From 75470578abf41b1632fb7f6f8afac646f438b82f Mon Sep 17 00:00:00 2001 From: Michael Lauer Date: Sat, 19 Aug 2006 17:34:42 +0000 Subject: tin: add 1.9.1, uses our libpcre now, no more patches necessary --- packages/tin/files/.mtn2git_empty | 0 packages/tin/files/configure.patch | 205 + packages/tin/files/m4.patch | 5630 ++++++++++++++++++++++++++ packages/tin/files/makecfg-buildcc.patch | 24 + packages/tin/tin-1.7.3/.mtn2git_empty | 0 packages/tin/tin-1.7.3/configure.patch | 205 - packages/tin/tin-1.7.3/m4.patch | 5630 -------------------------- packages/tin/tin-1.7.3/makecfg-buildcc.patch | 24 - packages/tin/tin_1.7.3.bb | 6 +- packages/tin/tin_1.9.1.bb | 23 + 10 files changed, 5886 insertions(+), 5861 deletions(-) create mode 100644 packages/tin/files/.mtn2git_empty create mode 100644 packages/tin/files/configure.patch create mode 100644 packages/tin/files/m4.patch create mode 100644 packages/tin/files/makecfg-buildcc.patch delete mode 100644 packages/tin/tin-1.7.3/.mtn2git_empty delete mode 100644 packages/tin/tin-1.7.3/configure.patch delete mode 100644 packages/tin/tin-1.7.3/m4.patch delete mode 100644 packages/tin/tin-1.7.3/makecfg-buildcc.patch create mode 100644 packages/tin/tin_1.9.1.bb (limited to 'packages/tin') diff --git a/packages/tin/files/.mtn2git_empty b/packages/tin/files/.mtn2git_empty new file mode 100644 index 0000000000..e69de29bb2 diff --git a/packages/tin/files/configure.patch b/packages/tin/files/configure.patch new file mode 100644 index 0000000000..4059fe086f --- /dev/null +++ b/packages/tin/files/configure.patch @@ -0,0 +1,205 @@ + +# +# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher +# + +--- tin-1.7.3/configure.in~configure ++++ tin-1.7.3/configure.in +@@ -34,8 +34,9 @@ + dnl + dnl Process this file with autoconf to produce a configure script. + +-AC_PREREQ(2.13.20020210) +-AC_INIT(include/tin.h) ++AC_PREREQ(2.57) ++AC_INIT ++AC_CONFIG_SRCDIR([include/tin.h]) + AC_CONFIG_HEADER(include/autoconf.h:include/autoconf.hin) + AC_PREFIX_DEFAULT(/usr/local) + +@@ -406,7 +407,7 @@ + CF_NCURSES_LIBS(ncursesw) + CF_NCURSES_VERSION + CF_XOPEN_CURSES +- test "$cf_cv_need_xopen_extension" = unknown && AC_ERROR(X/Open curses not found) ++ test "$cf_cv_need_xopen_extension" = unknown && AC_MSG_ERROR([X/Open curses not found]) + ;; + curses) #(vi + CF_CURSES_CPPFLAGS +@@ -432,25 +433,25 @@ + fi + + ## debugging libraries (do this after other libraries) +-AC_MSG_CHECKING(if you want dbmalloc library) ++AC_MSG_CHECKING([if you want dbmalloc library]) + debug_malloc=none +-AC_ARG_WITH(dbmalloc, ++AC_ARG_WITH([dbmalloc], + [ --with-dbmalloc use Conor Cahill's dbmalloc library], +- [AC_MSG_RESULT(yes) +- AC_CHECK_LIB(dbmalloc,debug_malloc, +- AC_CHECK_HEADER(dbmalloc.h,debug_malloc=DBMALLOC))], +- AC_MSG_RESULT(no)) ++ [AC_MSG_RESULT([yes]) ++ AC_CHECK_LIB([dbmalloc],[debug_malloc],[ ++ AC_CHECK_HEADER([dbmalloc.h],[debug_malloc=DBMALLOC])])], ++ AC_MSG_RESULT([no])) + +-AC_MSG_CHECKING(if you want dmalloc library) +-AC_ARG_WITH(dmalloc, ++AC_MSG_CHECKING([if you want dmalloc library]) ++AC_ARG_WITH([dmalloc], + [ --with-dmalloc use Gray Watson's dmalloc library], + [AC_MSG_RESULT(yes) +- AC_CHECK_LIB(dmalloc,dmalloc_debug, +- AC_CHECK_HEADER(dmalloc.h,debug_malloc=DMALLOC))], ++ AC_CHECK_LIB([dmalloc],[dmalloc_debug],[ ++ AC_CHECK_HEADER([dmalloc.h],[debug_malloc=DMALLOC])])], + AC_MSG_RESULT(no)) + +-AC_MSG_CHECKING(if you want debugging-trace) +-AC_ARG_WITH(trace, ++AC_MSG_CHECKING([if you want debugging-trace]) ++AC_ARG_WITH([trace], + [ --with-trace use debugging/traces], + [use_trace=yes], + [use_trace=no]) +@@ -667,7 +668,7 @@ + + ### checks for compiler characteristics + CF_MAKEFLAGS +-AC_LANG_C ++AC_LANG([C]) + AC_C_CONST + AC_C_INLINE + CF_CPP_EXPANDS +@@ -763,14 +764,13 @@ + + dnl test to see if quad_t is defined + AC_MSG_CHECKING(for quad_t) +-AC_TRY_COMPILE([ ++AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + #include + #if 0 + #include + #include + #endif /* 0 */ +-],[quad_t x; x = 0], +-ac_cv_quad_t=yes, ac_cv_quad_t=no) ++]], [[quad_t x; x = 0]])],[ac_cv_quad_t=yes],[ac_cv_quad_t=no]) + AC_MSG_RESULT($ac_cv_quad_t) + if test $ac_cv_quad_t = yes; then + AC_DEFINE(HAVE_QUAD_T) +@@ -778,10 +778,9 @@ + + dnl test to see if long long is defined + AC_MSG_CHECKING(for long long) +-AC_TRY_COMPILE([ ++AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + #include +-],[long long x; x = 0], +-ac_cv_long_long=yes, ac_cv_long_long=no) ++]], [[long long x; x = 0]])],[ac_cv_long_long=yes],[ac_cv_long_long=no]) + AC_MSG_RESULT($ac_cv_long_long) + if test $ac_cv_long_long = yes; then + AC_DEFINE(HAVE_LONG_LONG) +@@ -789,7 +788,7 @@ + + dnl test to see if nl_item is defined + AC_MSG_CHECKING(for nl_item) +-AC_TRY_COMPILE([ ++AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + #ifdef HAVE_LANGINFO_H + #include + #else +@@ -797,8 +796,7 @@ + #include + #endif + #endif +-],[nl_item x; x = 0], +-ac_cv_nl_item=yes, ac_cv_nl_item=no) ++]], [[nl_item x; x = 0]])],[ac_cv_nl_item=yes],[ac_cv_nl_item=no]) + AC_MSG_RESULT($ac_cv_nl_item) + if test $ac_cv_nl_item = yes; then + AC_DEFINE(HAVE_NL_ITEM) +@@ -845,14 +843,13 @@ + cf_save_LIBS="$LIBS" + cf_try_icuuc="no" + LIBS="$LIBS -licuuc" +- AC_TRY_LINK([#include ], [ ++ AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ + int32_t needed, ustr = NULL; + UErrorCode status; +- needed = unorm_normalize(ustr, -1, UNORM_DEFAULT, 0, NULL, 0, &status);], [ ++ needed = unorm_normalize(ustr, -1, UNORM_DEFAULT, 0, NULL, 0, &status);]])],[ + AC_DEFINE(HAVE_LIBICUUC) +- cf_try_icuuc="yes"], +- LIBS=$cf_save_LIBS +- ) ++ cf_try_icuuc="yes"],[LIBS=$cf_save_LIBS ++ ]) + AC_MSG_RESULT($cf_try_icuuc) + ]) + ]) +@@ -866,15 +863,13 @@ + AC_MSG_CHECKING(if we should include termcap.h) + cf_save_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -I$srcdir/include" +- AC_TRY_COMPILE([ ++ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + #define HAVE_TERMCAP_H 1 +-#include ],[ ++#include ]], [[ + #ifdef NCURSES_VERSION + make an error + #endif +-], +- [cf_result=yes], +- [cf_result=no]) ++]])],[cf_result=yes],[cf_result=no]) + AC_MSG_RESULT($cf_result) + CFLAGS="$cf_save_CFLAGS" + test $cf_result = yes && AC_DEFINE(HAVE_TERMCAP_H) +@@ -889,8 +884,7 @@ + cf_tc_externs="$cf_tc_funcs tgoto tigetstr tputs tigetflag" + elif test ".$cf_cv_termlib" = .termcap ; then + # BSD 'tputs()' may need 'PC' to be set. +- AC_TRY_LINK([],[extern char PC; PC = 0], +- [AC_DEFINE(HAVE_EXTERN_TCAP_PC)]) ++ AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[extern char PC; PC = 0]])],[AC_DEFINE(HAVE_EXTERN_TCAP_PC)],[]) + cf_tc_funcs="tgetint tgetnum tparam tparm" + cf_tc_externs="$cf_tc_funcs tgoto tgetstr tputs tgetent tgetflag" + fi +@@ -1172,7 +1166,7 @@ + + CF_CHECK_HEADERS(iconv.h) + AC_MSG_CHECKING(for iconv_open() //TRANSLIT extension) +-AC_TRY_RUN([ ++AC_RUN_IFELSE([AC_LANG_SOURCE([[ + #ifdef HAVE_ICONV_H + # include + #endif /* HAVE_ICONV_H */ +@@ -1185,11 +1179,8 @@ + if ((cd = iconv_open("US-ASCII//TRANSLIT", "ISO-8859-1")) == (iconv_t) (-1)) + exit(1); + exit(0); +-}], +- AC_DEFINE(HAVE_ICONV_OPEN_TRANSLIT) AC_MSG_RESULT(yes), +- AC_MSG_RESULT(no), +- AC_MSG_RESULT(unknown) +-) ++}]])],[AC_DEFINE(HAVE_ICONV_OPEN_TRANSLIT) AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)],[AC_MSG_RESULT(unknown) ++]) + + + # tin has mkdirs.sh instead of mkinstalldirs, overwrite the result of test +@@ -1223,6 +1214,7 @@ + CF_DEFINE_STRING(TIN_LDFLAGS, "$LDFLAGS") + CF_DEFINE_STRING(TIN_LIBS, "$LIBS") + +-AC_OUTPUT($PCRE_MAKEFILE ++AC_CONFIG_FILES([$PCRE_MAKEFILE + $SUB_MAKEFILE +- src/Makefile) ++ src/Makefile]) ++AC_OUTPUT diff --git a/packages/tin/files/m4.patch b/packages/tin/files/m4.patch new file mode 100644 index 0000000000..9277f6c1b3 --- /dev/null +++ b/packages/tin/files/m4.patch @@ -0,0 +1,5630 @@ + +# +# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher +# + +--- /dev/null ++++ tin-1.7.3/m4/codeset.m4 +@@ -0,0 +1,23 @@ ++# codeset.m4 serial AM1 (gettext-0.10.40) ++dnl Copyright (C) 2000-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Bruno Haible. ++ ++AC_DEFUN([AM_LANGINFO_CODESET], ++[ ++ AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset, ++ [AC_TRY_LINK([#include ], ++ [char* cs = nl_langinfo(CODESET);], ++ am_cv_langinfo_codeset=yes, ++ am_cv_langinfo_codeset=no) ++ ]) ++ if test $am_cv_langinfo_codeset = yes; then ++ AC_DEFINE(HAVE_LANGINFO_CODESET, 1, ++ [Define if you have and nl_langinfo(CODESET).]) ++ fi ++]) +--- /dev/null ++++ tin-1.7.3/m4/gettext.m4 +@@ -0,0 +1,587 @@ ++# gettext.m4 serial 17 (gettext-0.11.5) ++dnl Copyright (C) 1995-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++dnl ++dnl This file can can be used in projects which are not available under ++dnl the GNU General Public License or the GNU Library General Public ++dnl License but which still want to provide support for the GNU gettext ++dnl functionality. ++dnl Please note that the actual code of the GNU gettext library is covered ++dnl by the GNU Library General Public License, and the rest of the GNU ++dnl gettext package package is covered by the GNU General Public License. ++dnl They are *not* in the public domain. ++ ++dnl Authors: ++dnl Ulrich Drepper , 1995-2000. ++dnl Bruno Haible , 2000-2002. ++ ++dnl Macro to add for using GNU gettext. ++ ++dnl Usage: AM_GNU_GETTEXT([INTLSYMBOL], [NEEDSYMBOL], [INTLDIR]). ++dnl INTLSYMBOL can be one of 'external', 'no-libtool', 'use-libtool'. The ++dnl default (if it is not specified or empty) is 'no-libtool'. ++dnl INTLSYMBOL should be 'external' for packages with no intl directory, ++dnl and 'no-libtool' or 'use-libtool' for packages with an intl directory. ++dnl If INTLSYMBOL is 'use-libtool', then a libtool library ++dnl $(top_builddir)/intl/libintl.la will be created (shared and/or static, ++dnl depending on --{enable,disable}-{shared,static} and on the presence of ++dnl AM-DISABLE-SHARED). If INTLSYMBOL is 'no-libtool', a static library ++dnl $(top_builddir)/intl/libintl.a will be created. ++dnl If NEEDSYMBOL is specified and is 'need-ngettext', then GNU gettext ++dnl implementations (in libc or libintl) without the ngettext() function ++dnl will be ignored. If NEEDSYMBOL is specified and is ++dnl 'need-formatstring-macros', then GNU gettext implementations that don't ++dnl support the ISO C 99 formatstring macros will be ignored. ++dnl INTLDIR is used to find the intl libraries. If empty, ++dnl the value `$(top_builddir)/intl/' is used. ++dnl ++dnl The result of the configuration is one of three cases: ++dnl 1) GNU gettext, as included in the intl subdirectory, will be compiled ++dnl and used. ++dnl Catalog format: GNU --> install in $(datadir) ++dnl Catalog extension: .mo after installation, .gmo in source tree ++dnl 2) GNU gettext has been found in the system's C library. ++dnl Catalog format: GNU --> install in $(datadir) ++dnl Catalog extension: .mo after installation, .gmo in source tree ++dnl 3) No internationalization, always use English msgid. ++dnl Catalog format: none ++dnl Catalog extension: none ++dnl If INTLSYMBOL is 'external', only cases 2 and 3 can occur. ++dnl The use of .gmo is historical (it was needed to avoid overwriting the ++dnl GNU format catalogs when building on a platform with an X/Open gettext), ++dnl but we keep it in order not to force irrelevant filename changes on the ++dnl maintainers. ++dnl ++AC_DEFUN([AM_GNU_GETTEXT], ++[ ++ dnl Argument checking. ++ ifelse([$1], [], , [ifelse([$1], [external], , [ifelse([$1], [no-libtool], , [ifelse([$1], [use-libtool], , ++ [errprint([ERROR: invalid first argument to AM_GNU_GETTEXT ++])])])])]) ++ ifelse([$2], [], , [ifelse([$2], [need-ngettext], , [ifelse([$2], [need-formatstring-macros], , ++ [errprint([ERROR: invalid second argument to AM_GNU_GETTEXT ++])])])]) ++ define(gt_included_intl, ifelse([$1], [external], [no], [yes])) ++ define(gt_libtool_suffix_prefix, ifelse([$1], [use-libtool], [l], [])) ++ ++ AC_REQUIRE([AM_PO_SUBDIRS])dnl ++ ifelse(gt_included_intl, yes, [ ++ AC_REQUIRE([AM_INTL_SUBDIR])dnl ++ ]) ++ ++ dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ AC_REQUIRE([AC_LIB_RPATH]) ++ ++ dnl Sometimes libintl requires libiconv, so first search for libiconv. ++ dnl Ideally we would do this search only after the ++ dnl if test "$USE_NLS" = "yes"; then ++ dnl if test "$gt_cv_func_gnugettext_libc" != "yes"; then ++ dnl tests. But if configure.in invokes AM_ICONV after AM_GNU_GETTEXT ++ dnl the configure script would need to contain the same shell code ++ dnl again, outside any 'if'. There are two solutions: ++ dnl - Invoke AM_ICONV_LINKFLAGS_BODY here, outside any 'if'. ++ dnl - Control the expansions in more detail using AC_PROVIDE_IFELSE. ++ dnl Since AC_PROVIDE_IFELSE is only in autoconf >= 2.52 and not ++ dnl documented, we avoid it. ++ ifelse(gt_included_intl, yes, , [ ++ AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) ++ ]) ++ ++ AC_MSG_CHECKING([whether NLS is requested]) ++ dnl Default is enabled NLS ++ AC_ARG_ENABLE(nls, ++ [ --disable-nls do not use Native Language Support], ++ USE_NLS=$enableval, USE_NLS=yes) ++ AC_MSG_RESULT($USE_NLS) ++ AC_SUBST(USE_NLS) ++ ++ ifelse(gt_included_intl, yes, [ ++ BUILD_INCLUDED_LIBINTL=no ++ USE_INCLUDED_LIBINTL=no ++ ]) ++ LIBINTL= ++ LTLIBINTL= ++ POSUB= ++ ++ dnl If we use NLS figure out what method ++ if test "$USE_NLS" = "yes"; then ++ gt_use_preinstalled_gnugettext=no ++ ifelse(gt_included_intl, yes, [ ++ AC_MSG_CHECKING([whether included gettext is requested]) ++ AC_ARG_WITH(included-gettext, ++ [ --with-included-gettext use the GNU gettext library included here], ++ nls_cv_force_use_gnu_gettext=$withval, ++ nls_cv_force_use_gnu_gettext=no) ++ AC_MSG_RESULT($nls_cv_force_use_gnu_gettext) ++ ++ nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext" ++ if test "$nls_cv_force_use_gnu_gettext" != "yes"; then ++ ]) ++ dnl User does not insist on using GNU NLS library. Figure out what ++ dnl to use. If GNU gettext is available we use this. Else we have ++ dnl to fall back to GNU NLS library. ++ ++ dnl Add a version number to the cache macros. ++ define([gt_api_version], ifelse([$2], [need-formatstring-macros], 3, ifelse([$2], [need-ngettext], 2, 1))) ++ define([gt_cv_func_gnugettext_libc], [gt_cv_func_gnugettext]gt_api_version[_libc]) ++ define([gt_cv_func_gnugettext_libintl], [gt_cv_func_gnugettext]gt_api_version[_libintl]) ++ ++ AC_CACHE_CHECK([for GNU gettext in libc], gt_cv_func_gnugettext_libc, ++ [AC_TRY_LINK([#include ++]ifelse([$2], [need-formatstring-macros], ++[#ifndef __GNU_GETTEXT_SUPPORTED_REVISION ++#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1) ++#endif ++changequote(,)dnl ++typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; ++changequote([,])dnl ++], [])[extern int _nl_msg_cat_cntr; ++extern int *_nl_domain_bindings;], ++ [bindtextdomain ("", ""); ++return (int) gettext ("")]ifelse([$2], [need-ngettext], [ + (int) ngettext ("", "", 0)], [])[ + _nl_msg_cat_cntr + *_nl_domain_bindings], ++ gt_cv_func_gnugettext_libc=yes, ++ gt_cv_func_gnugettext_libc=no)]) ++ ++ if test "$gt_cv_func_gnugettext_libc" != "yes"; then ++ dnl Sometimes libintl requires libiconv, so first search for libiconv. ++ ifelse(gt_included_intl, yes, , [ ++ AM_ICONV_LINK ++ ]) ++ dnl Search for libintl and define LIBINTL, LTLIBINTL and INCINTL ++ dnl accordingly. Don't use AC_LIB_LINKFLAGS_BODY([intl],[iconv]) ++ dnl because that would add "-liconv" to LIBINTL and LTLIBINTL ++ dnl even if libiconv doesn't exist. ++ AC_LIB_LINKFLAGS_BODY([intl]) ++ AC_CACHE_CHECK([for GNU gettext in libintl], ++ gt_cv_func_gnugettext_libintl, ++ [gt_save_CPPFLAGS="$CPPFLAGS" ++ CPPFLAGS="$CPPFLAGS $INCINTL" ++ gt_save_LIBS="$LIBS" ++ LIBS="$LIBS $LIBINTL" ++ dnl Now see whether libintl exists and does not depend on libiconv. ++ AC_TRY_LINK([#include ++]ifelse([$2], [need-formatstring-macros], ++[#ifndef __GNU_GETTEXT_SUPPORTED_REVISION ++#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1) ++#endif ++changequote(,)dnl ++typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; ++changequote([,])dnl ++], [])[extern int _nl_msg_cat_cntr; ++extern ++#ifdef __cplusplus ++"C" ++#endif ++const char *_nl_expand_alias ();], ++ [bindtextdomain ("", ""); ++return (int) gettext ("")]ifelse([$2], [need-ngettext], [ + (int) ngettext ("", "", 0)], [])[ + _nl_msg_cat_cntr + *_nl_expand_alias (0)], ++ gt_cv_func_gnugettext_libintl=yes, ++ gt_cv_func_gnugettext_libintl=no) ++ dnl Now see whether libintl exists and depends on libiconv. ++ if test "$gt_cv_func_gnugettext_libintl" != yes && test -n "$LIBICONV"; then ++ LIBS="$LIBS $LIBICONV" ++ AC_TRY_LINK([#include ++]ifelse([$2], [need-formatstring-macros], ++[#ifndef __GNU_GETTEXT_SUPPORTED_REVISION ++#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1) ++#endif ++changequote(,)dnl ++typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; ++changequote([,])dnl ++], [])[extern int _nl_msg_cat_cntr; ++extern ++#ifdef __cplusplus ++"C" ++#endif ++const char *_nl_expand_alias ();], ++ [bindtextdomain ("", ""); ++return (int) gettext ("")]ifelse([$2], [need-ngettext], [ + (int) ngettext ("", "", 0)], [])[ + _nl_msg_cat_cntr + *_nl_expand_alias (0)], ++ [LIBINTL="$LIBINTL $LIBICONV" ++ LTLIBINTL="$LTLIBINTL $LTLIBICONV" ++ gt_cv_func_gnugettext_libintl=yes ++ ]) ++ fi ++ CPPFLAGS="$gt_save_CPPFLAGS" ++ LIBS="$gt_save_LIBS"]) ++ fi ++ ++ dnl If an already present or preinstalled GNU gettext() is found, ++ dnl use it. But if this macro is used in GNU gettext, and GNU ++ dnl gettext is already preinstalled in libintl, we update this ++ dnl libintl. (Cf. the install rule in intl/Makefile.in.) ++ if test "$gt_cv_func_gnugettext_libc" = "yes" \ ++ || { test "$gt_cv_func_gnugettext_libintl" = "yes" \ ++ && test "$PACKAGE" != gettext; }; then ++ gt_use_preinstalled_gnugettext=yes ++ else ++ dnl Reset the values set by searching for libintl. ++ LIBINTL= ++ LTLIBINTL= ++ INCINTL= ++ fi ++ ++ ifelse(gt_included_intl, yes, [ ++ if test "$gt_use_preinstalled_gnugettext" != "yes"; then ++ dnl GNU gettext is not found in the C library. ++ dnl Fall back on included GNU gettext library. ++ nls_cv_use_gnu_gettext=yes ++ fi ++ fi ++ ++ if test "$nls_cv_use_gnu_gettext" = "yes"; then ++ dnl Mark actions used to generate GNU NLS library. ++ INTLOBJS="\$(GETTOBJS)" ++ BUILD_INCLUDED_LIBINTL=yes ++ USE_INCLUDED_LIBINTL=yes ++ LIBINTL="ifelse([$3],[],\${top_builddir}/intl,[$3])/libintl.[]gt_libtool_suffix_prefix[]a $LIBICONV" ++ LTLIBINTL="ifelse([$3],[],\${top_builddir}/intl,[$3])/libintl.[]gt_libtool_suffix_prefix[]a $LTLIBICONV" ++ LIBS=`echo " $LIBS " | sed -e 's/ -lintl / /' -e 's/^ //' -e 's/ $//'` ++ fi ++ ++ if test "$gt_use_preinstalled_gnugettext" = "yes" \ ++ || test "$nls_cv_use_gnu_gettext" = "yes"; then ++ dnl Mark actions to use GNU gettext tools. ++ CATOBJEXT=.gmo ++ fi ++ ]) ++ ++ if test "$gt_use_preinstalled_gnugettext" = "yes" \ ++ || test "$nls_cv_use_gnu_gettext" = "yes"; then ++ AC_DEFINE(ENABLE_NLS, 1, ++ [Define to 1 if translation of program messages to the user's native language ++ is requested.]) ++ else ++ USE_NLS=no ++ fi ++ fi ++ ++ if test "$USE_NLS" = "yes"; then ++ ++ if test "$gt_use_preinstalled_gnugettext" = "yes"; then ++ if test "$gt_cv_func_gnugettext_libintl" = "yes"; then ++ AC_MSG_CHECKING([how to link with libintl]) ++ AC_MSG_RESULT([$LIBINTL]) ++ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCINTL]) ++ fi ++ ++ dnl For backward compatibility. Some packages may be using this. ++ AC_DEFINE(HAVE_GETTEXT, 1, ++ [Define if the GNU gettext() function is already present or preinstalled.]) ++ AC_DEFINE(HAVE_DCGETTEXT, 1, ++ [Define if the GNU dcgettext() function is already present or preinstalled.]) ++ fi ++ ++ dnl We need to process the po/ directory. ++ POSUB=po ++ fi ++ ++ ifelse(gt_included_intl, yes, [ ++ dnl If this is used in GNU gettext we have to set BUILD_INCLUDED_LIBINTL ++ dnl to 'yes' because some of the testsuite requires it. ++ if test "$PACKAGE" = gettext; then ++ BUILD_INCLUDED_LIBINTL=yes ++ fi ++ ++ dnl Make all variables we use known to autoconf. ++ AC_SUBST(BUILD_INCLUDED_LIBINTL) ++ AC_SUBST(USE_INCLUDED_LIBINTL) ++ AC_SUBST(CATOBJEXT) ++ AC_SUBST(INTLOBJS) ++ ++ dnl For backward compatibility. Some configure.ins may be using this. ++ nls_cv_header_intl= ++ nls_cv_header_libgt= ++ ++ dnl For backward compatibility. Some Makefiles may be using this. ++ DATADIRNAME=share ++ AC_SUBST(DATADIRNAME) ++ ++ dnl For backward compatibility. Some Makefiles may be using this. ++ INSTOBJEXT=.mo ++ AC_SUBST(INSTOBJEXT) ++ ++ dnl For backward compatibility. Some Makefiles may be using this. ++ GENCAT=gencat ++ AC_SUBST(GENCAT) ++ ++ dnl Enable libtool support if the surrounding package wishes it. ++ INTL_LIBTOOL_SUFFIX_PREFIX=gt_libtool_suffix_prefix ++ AC_SUBST(INTL_LIBTOOL_SUFFIX_PREFIX) ++ ]) ++ ++ dnl For backward compatibility. Some Makefiles may be using this. ++ INTLLIBS="$LIBINTL" ++ AC_SUBST(INTLLIBS) ++ ++ dnl Make all documented variables known to autoconf. ++ AC_SUBST(LIBINTL) ++ AC_SUBST(LTLIBINTL) ++ AC_SUBST(POSUB) ++]) ++ ++ ++dnl Checks for all prerequisites of the po subdirectory, ++dnl except for USE_NLS. ++AC_DEFUN([AM_PO_SUBDIRS], ++[ ++ AC_REQUIRE([AC_PROG_MAKE_SET])dnl ++ AC_REQUIRE([AC_PROG_INSTALL])dnl ++ AC_REQUIRE([AM_MKINSTALLDIRS])dnl ++ ++ dnl Perform the following tests also if --disable-nls has been given, ++ dnl because they are needed for "make dist" to work. ++ ++ dnl Search for GNU msgfmt in the PATH. ++ dnl The first test excludes Solaris msgfmt and early GNU msgfmt versions. ++ dnl The second test excludes FreeBSD msgfmt. ++ AM_PATH_PROG_WITH_TEST(MSGFMT, msgfmt, ++ [$ac_dir/$ac_word --statistics /dev/null >/dev/null 2>&1 && ++ (if $ac_dir/$ac_word --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], ++ :) ++ AC_PATH_PROG(GMSGFMT, gmsgfmt, $MSGFMT) ++ ++ dnl Search for GNU xgettext 0.11 or newer in the PATH. ++ dnl The first test excludes Solaris xgettext and early GNU xgettext versions. ++ dnl The second test excludes FreeBSD xgettext. ++ AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext, ++ [$ac_dir/$ac_word --omit-header --copyright-holder= /dev/null >/dev/null 2>&1 && ++ (if $ac_dir/$ac_word --omit-header --copyright-holder= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], ++ :) ++ dnl Remove leftover from FreeBSD xgettext call. ++ rm -f messages.po ++ ++ dnl Search for GNU msgmerge 0.11 or newer in the PATH. ++ AM_PATH_PROG_WITH_TEST(MSGMERGE, msgmerge, ++ [$ac_dir/$ac_word --update -q /dev/null /dev/null >/dev/null 2>&1], :) ++ ++ dnl This could go away some day; the PATH_PROG_WITH_TEST already does it. ++ dnl Test whether we really found GNU msgfmt. ++ if test "$GMSGFMT" != ":"; then ++ dnl If it is no GNU msgfmt we define it as : so that the ++ dnl Makefiles still can work. ++ if $GMSGFMT --statistics /dev/null >/dev/null 2>&1 && ++ (if $GMSGFMT --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then ++ : ; ++ else ++ GMSGFMT=`echo "$GMSGFMT" | sed -e 's,^.*/,,'` ++ AC_MSG_RESULT( ++ [found $GMSGFMT program is not GNU msgfmt; ignore it]) ++ GMSGFMT=":" ++ fi ++ fi ++ ++ dnl This could go away some day; the PATH_PROG_WITH_TEST already does it. ++ dnl Test whether we really found GNU xgettext. ++ if test "$XGETTEXT" != ":"; then ++ dnl If it is no GNU xgettext we define it as : so that the ++ dnl Makefiles still can work. ++ if $XGETTEXT --omit-header --copyright-holder= /dev/null >/dev/null 2>&1 && ++ (if $XGETTEXT --omit-header --copyright-holder= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then ++ : ; ++ else ++ AC_MSG_RESULT( ++ [found xgettext program is not GNU xgettext; ignore it]) ++ XGETTEXT=":" ++ fi ++ dnl Remove leftover from FreeBSD xgettext call. ++ rm -f messages.po ++ fi ++ ++ AC_OUTPUT_COMMANDS([ ++ for ac_file in $CONFIG_FILES; do ++ # Support "outfile[:infile[:infile...]]" ++ case "$ac_file" in ++ *:*) ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; ++ esac ++ # PO directories have a Makefile.in generated from Makefile.in.in. ++ case "$ac_file" in */Makefile.in) ++ # Adjust a relative srcdir. ++ ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'` ++ ac_dir_suffix="/`echo "$ac_dir"|sed 's%^\./%%'`" ++ ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'` ++ # In autoconf-2.13 it is called $ac_given_srcdir. ++ # In autoconf-2.50 it is called $srcdir. ++ test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir" ++ case "$ac_given_srcdir" in ++ .) top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;; ++ /*) top_srcdir="$ac_given_srcdir" ;; ++ *) top_srcdir="$ac_dots$ac_given_srcdir" ;; ++ esac ++ if test -f "$ac_given_srcdir/$ac_dir/POTFILES.in"; then ++ rm -f "$ac_dir/POTFILES" ++ test -n "$as_me" && echo "$as_me: creating $ac_dir/POTFILES" || echo "creating $ac_dir/POTFILES" ++ cat "$ac_given_srcdir/$ac_dir/POTFILES.in" | sed -e "/^#/d" -e "/^[ ]*\$/d" -e "s,.*, $top_srcdir/& \\\\," | sed -e "\$s/\(.*\) \\\\/\1/" > "$ac_dir/POTFILES" ++ # ALL_LINGUAS, POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES depend ++ # on $ac_dir but don't depend on user-specified configuration ++ # parameters. ++ if test -f "$ac_given_srcdir/$ac_dir/LINGUAS"; then ++ # The LINGUAS file contains the set of available languages. ++ if test -n "$ALL_LINGUAS"; then ++ test -n "$as_me" && echo "$as_me: setting ALL_LINGUAS in configure.in is obsolete" || echo "setting ALL_LINGUAS in configure.in is obsolete" ++ fi ++ ALL_LINGUAS_=`sed -e "/^#/d" "$ac_given_srcdir/$ac_dir/LINGUAS"` ++ # Hide the ALL_LINGUAS assigment from automake. ++ eval 'ALL_LINGUAS''=$ALL_LINGUAS_' ++ fi ++ case "$ac_given_srcdir" in ++ .) srcdirpre= ;; ++ *) srcdirpre='$(srcdir)/' ;; ++ esac ++ POFILES= ++ GMOFILES= ++ UPDATEPOFILES= ++ DUMMYPOFILES= ++ for lang in $ALL_LINGUAS; do ++ POFILES="$POFILES $srcdirpre$lang.po" ++ GMOFILES="$GMOFILES $srcdirpre$lang.gmo" ++ UPDATEPOFILES="$UPDATEPOFILES $lang.po-update" ++ DUMMYPOFILES="$DUMMYPOFILES $lang.nop" ++ done ++ # CATALOGS depends on both $ac_dir and the user's LINGUAS ++ # environment variable. ++ INST_LINGUAS= ++ if test -n "$ALL_LINGUAS"; then ++ for presentlang in $ALL_LINGUAS; do ++ useit=no ++ if test "%UNSET%" != "$LINGUAS"; then ++ desiredlanguages="$LINGUAS" ++ else ++ desiredlanguages="$ALL_LINGUAS" ++ fi ++ for desiredlang in $desiredlanguages; do ++ # Use the presentlang catalog if desiredlang is ++ # a. equal to presentlang, or ++ # b. a variant of presentlang (because in this case, ++ # presentlang can be used as a fallback for messages ++ # which are not translated in the desiredlang catalog). ++ case "$desiredlang" in ++ "$presentlang"*) useit=yes;; ++ esac ++ done ++ if test $useit = yes; then ++ INST_LINGUAS="$INST_LINGUAS $presentlang" ++ fi ++ done ++ fi ++ CATALOGS= ++ if test -n "$INST_LINGUAS"; then ++ for lang in $INST_LINGUAS; do ++ CATALOGS="$CATALOGS $lang.gmo" ++ done ++ fi ++ test -n "$as_me" && echo "$as_me: creating $ac_dir/Makefile" || echo "creating $ac_dir/Makefile" ++ sed -e "/^POTFILES =/r $ac_dir/POTFILES" -e "/^# Makevars/r $ac_given_srcdir/$ac_dir/Makevars" -e "s|@POFILES@|$POFILES|g" -e "s|@GMOFILES@|$GMOFILES|g" -e "s|@UPDATEPOFILES@|$UPDATEPOFILES|g" -e "s|@DUMMYPOFILES@|$DUMMYPOFILES|g" -e "s|@CATALOGS@|$CATALOGS|g" "$ac_dir/Makefile.in" > "$ac_dir/Makefile" ++ for f in "$ac_given_srcdir/$ac_dir"/Rules-*; do ++ if test -f "$f"; then ++ case "$f" in ++ *.orig | *.bak | *~) ;; ++ *) cat "$f" >> "$ac_dir/Makefile" ;; ++ esac ++ fi ++ done ++ fi ++ ;; ++ esac ++ done], ++ [# Capture the value of obsolete ALL_LINGUAS because we need it to compute ++ # POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES, CATALOGS. But hide it ++ # from automake. ++ eval 'ALL_LINGUAS''="$ALL_LINGUAS"' ++ # Capture the value of LINGUAS because we need it to compute CATALOGS. ++ LINGUAS="${LINGUAS-%UNSET%}" ++ ]) ++]) ++ ++ ++dnl Checks for all prerequisites of the intl subdirectory, ++dnl except for INTL_LIBTOOL_SUFFIX_PREFIX (and possibly LIBTOOL), INTLOBJS, ++dnl USE_INCLUDED_LIBINTL, BUILD_INCLUDED_LIBINTL. ++AC_DEFUN([AM_INTL_SUBDIR], ++[ ++ AC_REQUIRE([AC_PROG_INSTALL])dnl ++ AC_REQUIRE([AM_MKINSTALLDIRS])dnl ++ AC_REQUIRE([AC_PROG_CC])dnl ++ AC_REQUIRE([AC_CANONICAL_HOST])dnl ++ AC_REQUIRE([AC_PROG_RANLIB])dnl ++ AC_REQUIRE([AC_ISC_POSIX])dnl ++ AC_REQUIRE([AC_HEADER_STDC])dnl ++ AC_REQUIRE([AC_C_CONST])dnl ++ AC_REQUIRE([AC_C_INLINE])dnl ++ AC_REQUIRE([AC_TYPE_OFF_T])dnl ++ AC_REQUIRE([AC_TYPE_SIZE_T])dnl ++ AC_REQUIRE([AC_FUNC_ALLOCA])dnl ++ AC_REQUIRE([AC_FUNC_MMAP])dnl ++ AC_REQUIRE([jm_GLIBC21])dnl ++ AC_REQUIRE([gt_INTDIV0])dnl ++ AC_REQUIRE([jm_AC_TYPE_UINTMAX_T])dnl ++ AC_REQUIRE([gt_HEADER_INTTYPES_H])dnl ++ AC_REQUIRE([gt_INTTYPES_PRI])dnl ++ ++ AC_CHECK_HEADERS([argz.h limits.h locale.h nl_types.h malloc.h stddef.h \ ++stdlib.h string.h unistd.h sys/param.h]) ++ AC_CHECK_FUNCS([feof_unlocked fgets_unlocked getc_unlocked getcwd getegid \ ++geteuid getgid getuid mempcpy munmap putenv setenv setlocale stpcpy \ ++strcasecmp strdup strtoul tsearch __argz_count __argz_stringify __argz_next]) ++ ++ AM_ICONV ++ AM_LANGINFO_CODESET ++ if test $ac_cv_header_locale_h = yes; then ++ AM_LC_MESSAGES ++ fi ++ ++ dnl intl/plural.c is generated from intl/plural.y. It requires bison, ++ dnl because plural.y uses bison specific features. It requires at least ++ dnl bison-1.26 because earlier versions generate a plural.c that doesn't ++ dnl compile. ++ dnl bison is only needed for the maintainer (who touches plural.y). But in ++ dnl order to avoid separate Makefiles or --enable-maintainer-mode, we put ++ dnl the rule in general Makefile. Now, some people carelessly touch the ++ dnl files or have a broken "make" program, hence the plural.c rule will ++ dnl sometimes fire. To avoid an error, defines BISON to ":" if it is not ++ dnl present or too old. ++ AC_CHECK_PROGS([INTLBISON], [bison]) ++ if test -z "$INTLBISON"; then ++ ac_verc_fail=yes ++ else ++ dnl Found it, now check the version. ++ AC_MSG_CHECKING([version of bison]) ++changequote(<<,>>)dnl ++ ac_prog_version=`$INTLBISON --version 2>&1 | sed -n 's/^.*GNU Bison.* \([0-9]*\.[0-9.]*\).*$/\1/p'` ++ case $ac_prog_version in ++ '') ac_prog_version="v. ?.??, bad"; ac_verc_fail=yes;; ++ 1.2[6-9]* | 1.[3-9][0-9]* | [2-9].*) ++changequote([,])dnl ++ ac_prog_version="$ac_prog_version, ok"; ac_verc_fail=no;; ++ *) ac_prog_version="$ac_prog_version, bad"; ac_verc_fail=yes;; ++ esac ++ AC_MSG_RESULT([$ac_prog_version]) ++ fi ++ if test $ac_verc_fail = yes; then ++ INTLBISON=: ++ fi ++]) ++ ++ ++AC_DEFUN([AM_MKINSTALLDIRS], ++[ ++ dnl If the AC_CONFIG_AUX_DIR macro for autoconf is used we possibly ++ dnl find the mkinstalldirs script in another subdir but $(top_srcdir). ++ dnl Try to locate is. ++ MKINSTALLDIRS= ++ if test -n "$ac_aux_dir"; then ++ MKINSTALLDIRS="$ac_aux_dir/mkinstalldirs" ++ fi ++ if test -z "$MKINSTALLDIRS"; then ++ MKINSTALLDIRS="\$(top_srcdir)/mkinstalldirs" ++ fi ++ AC_SUBST(MKINSTALLDIRS) ++]) ++ ++ ++dnl Usage: AM_GNU_GETTEXT_VERSION([gettext-version]) ++AC_DEFUN([AM_GNU_GETTEXT_VERSION], []) +--- /dev/null ++++ tin-1.7.3/m4/glibc21.m4 +@@ -0,0 +1,32 @@ ++# glibc21.m4 serial 2 (fileutils-4.1.3, gettext-0.10.40) ++dnl Copyright (C) 2000-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++# Test for the GNU C Library, version 2.1 or newer. ++# From Bruno Haible. ++ ++AC_DEFUN([jm_GLIBC21], ++ [ ++ AC_CACHE_CHECK(whether we are using the GNU C Library 2.1 or newer, ++ ac_cv_gnu_library_2_1, ++ [AC_EGREP_CPP([Lucky GNU user], ++ [ ++#include ++#ifdef __GNU_LIBRARY__ ++ #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2) ++ Lucky GNU user ++ #endif ++#endif ++ ], ++ ac_cv_gnu_library_2_1=yes, ++ ac_cv_gnu_library_2_1=no) ++ ] ++ ) ++ AC_SUBST(GLIBC21) ++ GLIBC21="$ac_cv_gnu_library_2_1" ++ ] ++) +--- /dev/null ++++ tin-1.7.3/m4/iconv.m4 +@@ -0,0 +1,103 @@ ++# iconv.m4 serial AM4 (gettext-0.11.3) ++dnl Copyright (C) 2000-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Bruno Haible. ++ ++AC_DEFUN([AM_ICONV_LINKFLAGS_BODY], ++[ ++ dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ AC_REQUIRE([AC_LIB_RPATH]) ++ ++ dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV ++ dnl accordingly. ++ AC_LIB_LINKFLAGS_BODY([iconv]) ++]) ++ ++AC_DEFUN([AM_ICONV_LINK], ++[ ++ dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and ++ dnl those with the standalone portable GNU libiconv installed). ++ ++ dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV ++ dnl accordingly. ++ AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) ++ ++ dnl Add $INCICONV to CPPFLAGS before performing the following checks, ++ dnl because if the user has installed libiconv and not disabled its use ++ dnl via --without-libiconv-prefix, he wants to use it. The first ++ dnl AC_TRY_LINK will then fail, the second AC_TRY_LINK will succeed. ++ am_save_CPPFLAGS="$CPPFLAGS" ++ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV]) ++ ++ AC_CACHE_CHECK(for iconv, am_cv_func_iconv, [ ++ am_cv_func_iconv="no, consider installing GNU libiconv" ++ am_cv_lib_iconv=no ++ AC_TRY_LINK([#include ++#include ], ++ [iconv_t cd = iconv_open("",""); ++ iconv(cd,NULL,NULL,NULL,NULL); ++ iconv_close(cd);], ++ am_cv_func_iconv=yes) ++ if test "$am_cv_func_iconv" != yes; then ++ am_save_LIBS="$LIBS" ++ LIBS="$LIBS $LIBICONV" ++ AC_TRY_LINK([#include ++#include ], ++ [iconv_t cd = iconv_open("",""); ++ iconv(cd,NULL,NULL,NULL,NULL); ++ iconv_close(cd);], ++ am_cv_lib_iconv=yes ++ am_cv_func_iconv=yes) ++ LIBS="$am_save_LIBS" ++ fi ++ ]) ++ if test "$am_cv_func_iconv" = yes; then ++ AC_DEFINE(HAVE_ICONV, 1, [Define if you have the iconv() function.]) ++ fi ++ if test "$am_cv_lib_iconv" = yes; then ++ AC_MSG_CHECKING([how to link with libiconv]) ++ AC_MSG_RESULT([$LIBICONV]) ++ else ++ dnl If $LIBICONV didn't lead to a usable library, we don't need $INCICONV ++ dnl either. ++ CPPFLAGS="$am_save_CPPFLAGS" ++ LIBICONV= ++ LTLIBICONV= ++ fi ++ AC_SUBST(LIBICONV) ++ AC_SUBST(LTLIBICONV) ++]) ++ ++AC_DEFUN([AM_ICONV], ++[ ++ AM_ICONV_LINK ++ if test "$am_cv_func_iconv" = yes; then ++ AC_MSG_CHECKING([for iconv declaration]) ++ AC_CACHE_VAL(am_cv_proto_iconv, [ ++ AC_TRY_COMPILE([ ++#include ++#include ++extern ++#ifdef __cplusplus ++"C" ++#endif ++#if defined(__STDC__) || defined(__cplusplus) ++size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft); ++#else ++size_t iconv(); ++#endif ++], [], am_cv_proto_iconv_arg1="", am_cv_proto_iconv_arg1="const") ++ am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"]) ++ am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'` ++ AC_MSG_RESULT([$]{ac_t:- ++ }[$]am_cv_proto_iconv) ++ AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg1, ++ [Define as const if the declaration of iconv() needs const.]) ++ fi ++]) +--- /dev/null ++++ tin-1.7.3/m4/intdiv0.m4 +@@ -0,0 +1,72 @@ ++# intdiv0.m4 serial 1 (gettext-0.11.3) ++dnl Copyright (C) 2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Bruno Haible. ++ ++AC_DEFUN([gt_INTDIV0], ++[ ++ AC_REQUIRE([AC_PROG_CC])dnl ++ AC_REQUIRE([AC_CANONICAL_HOST])dnl ++ ++ AC_CACHE_CHECK([whether integer division by zero raises SIGFPE], ++ gt_cv_int_divbyzero_sigfpe, ++ [ ++ AC_TRY_RUN([ ++#include ++#include ++ ++static void ++#ifdef __cplusplus ++sigfpe_handler (int sig) ++#else ++sigfpe_handler (sig) int sig; ++#endif ++{ ++ /* Exit with code 0 if SIGFPE, with code 1 if any other signal. */ ++ exit (sig != SIGFPE); ++} ++ ++int x = 1; ++int y = 0; ++int z; ++int nan; ++ ++int main () ++{ ++ signal (SIGFPE, sigfpe_handler); ++/* IRIX and AIX (when "xlc -qcheck" is used) yield signal SIGTRAP. */ ++#if (defined (__sgi) || defined (_AIX)) && defined (SIGTRAP) ++ signal (SIGTRAP, sigfpe_handler); ++#endif ++/* Linux/SPARC yields signal SIGILL. */ ++#if defined (__sparc__) && defined (__linux__) ++ signal (SIGILL, sigfpe_handler); ++#endif ++ ++ z = x / y; ++ nan = y / y; ++ exit (1); ++} ++], gt_cv_int_divbyzero_sigfpe=yes, gt_cv_int_divbyzero_sigfpe=no, ++ [ ++ # Guess based on the CPU. ++ case "$host_cpu" in ++ alpha* | i[34567]86 | m68k | s390*) ++ gt_cv_int_divbyzero_sigfpe="guessing yes";; ++ *) ++ gt_cv_int_divbyzero_sigfpe="guessing no";; ++ esac ++ ]) ++ ]) ++ case "$gt_cv_int_divbyzero_sigfpe" in ++ *yes) value=1;; ++ *) value=0;; ++ esac ++ AC_DEFINE_UNQUOTED(INTDIV0_RAISES_SIGFPE, $value, ++ [Define if integer division by zero raises signal SIGFPE.]) ++]) +--- /dev/null ++++ tin-1.7.3/m4/inttypes_h.m4 +@@ -0,0 +1,28 @@ ++# inttypes_h.m4 serial 4 (gettext-0.11.4) ++dnl Copyright (C) 1997-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Paul Eggert. ++ ++# Define HAVE_INTTYPES_H_WITH_UINTMAX if exists, ++# doesn't clash with , and declares uintmax_t. ++ ++AC_DEFUN([jm_AC_HEADER_INTTYPES_H], ++[ ++ AC_CACHE_CHECK([for inttypes.h], jm_ac_cv_header_inttypes_h, ++ [AC_TRY_COMPILE( ++ [#include ++#include ], ++ [uintmax_t i = (uintmax_t) -1;], ++ jm_ac_cv_header_inttypes_h=yes, ++ jm_ac_cv_header_inttypes_h=no)]) ++ if test $jm_ac_cv_header_inttypes_h = yes; then ++ AC_DEFINE_UNQUOTED(HAVE_INTTYPES_H_WITH_UINTMAX, 1, ++[Define if exists, doesn't clash with , ++ and declares uintmax_t. ]) ++ fi ++]) +--- /dev/null ++++ tin-1.7.3/m4/inttypes.m4 +@@ -0,0 +1,27 @@ ++# inttypes.m4 serial 1 (gettext-0.11.4) ++dnl Copyright (C) 1997-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Paul Eggert. ++ ++# Define HAVE_INTTYPES_H if exists and doesn't clash with ++# . ++ ++AC_DEFUN([gt_HEADER_INTTYPES_H], ++[ ++ AC_CACHE_CHECK([for inttypes.h], gt_cv_header_inttypes_h, ++ [ ++ AC_TRY_COMPILE( ++ [#include ++#include ], ++ [], gt_cv_header_inttypes_h=yes, gt_cv_header_inttypes_h=no) ++ ]) ++ if test $gt_cv_header_inttypes_h = yes; then ++ AC_DEFINE_UNQUOTED(HAVE_INTTYPES_H, 1, ++ [Define if exists and doesn't clash with .]) ++ fi ++]) +--- /dev/null ++++ tin-1.7.3/m4/inttypes-pri.m4 +@@ -0,0 +1,32 @@ ++# inttypes-pri.m4 serial 1 (gettext-0.11.4) ++dnl Copyright (C) 1997-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Bruno Haible. ++ ++# Define PRI_MACROS_BROKEN if exists and defines the PRI* ++# macros to non-string values. This is the case on AIX 4.3.3. ++ ++AC_DEFUN([gt_INTTYPES_PRI], ++[ ++ AC_REQUIRE([gt_HEADER_INTTYPES_H]) ++ if test $gt_cv_header_inttypes_h = yes; then ++ AC_CACHE_CHECK([whether the inttypes.h PRIxNN macros are broken], ++ gt_cv_inttypes_pri_broken, ++ [ ++ AC_TRY_COMPILE([#include ++#ifdef PRId32 ++char *p = PRId32; ++#endif ++], [], gt_cv_inttypes_pri_broken=no, gt_cv_inttypes_pri_broken=yes) ++ ]) ++ fi ++ if test "$gt_cv_inttypes_pri_broken" = yes; then ++ AC_DEFINE_UNQUOTED(PRI_MACROS_BROKEN, 1, ++ [Define if exists and defines unusable PRI* macros.]) ++ fi ++]) +--- /dev/null ++++ tin-1.7.3/m4/isc-posix.m4 +@@ -0,0 +1,26 @@ ++# isc-posix.m4 serial 2 (gettext-0.11.2) ++dnl Copyright (C) 1995-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++# This file is not needed with autoconf-2.53 and newer. Remove it in 2005. ++ ++# This test replaces the one in autoconf. ++# Currently this macro should have the same name as the autoconf macro ++# because gettext's gettext.m4 (distributed in the automake package) ++# still uses it. Otherwise, the use in gettext.m4 makes autoheader ++# give these diagnostics: ++# configure.in:556: AC_TRY_COMPILE was called before AC_ISC_POSIX ++# configure.in:556: AC_TRY_RUN was called before AC_ISC_POSIX ++ ++undefine([AC_ISC_POSIX]) ++ ++AC_DEFUN([AC_ISC_POSIX], ++ [ ++ dnl This test replaces the obsolescent AC_ISC_POSIX kludge. ++ AC_CHECK_LIB(cposix, strerror, [LIBS="$LIBS -lcposix"]) ++ ] ++) +--- /dev/null ++++ tin-1.7.3/m4/lcmessage.m4 +@@ -0,0 +1,32 @@ ++# lcmessage.m4 serial 3 (gettext-0.11.3) ++dnl Copyright (C) 1995-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++dnl ++dnl This file can can be used in projects which are not available under ++dnl the GNU General Public License or the GNU Library General Public ++dnl License but which still want to provide support for the GNU gettext ++dnl functionality. ++dnl Please note that the actual code of the GNU gettext library is covered ++dnl by the GNU Library General Public License, and the rest of the GNU ++dnl gettext package package is covered by the GNU General Public License. ++dnl They are *not* in the public domain. ++ ++dnl Authors: ++dnl Ulrich Drepper , 1995. ++ ++# Check whether LC_MESSAGES is available in . ++ ++AC_DEFUN([AM_LC_MESSAGES], ++[ ++ AC_CACHE_CHECK([for LC_MESSAGES], am_cv_val_LC_MESSAGES, ++ [AC_TRY_LINK([#include ], [return LC_MESSAGES], ++ am_cv_val_LC_MESSAGES=yes, am_cv_val_LC_MESSAGES=no)]) ++ if test $am_cv_val_LC_MESSAGES = yes; then ++ AC_DEFINE(HAVE_LC_MESSAGES, 1, ++ [Define if your file defines LC_MESSAGES.]) ++ fi ++]) +--- /dev/null ++++ tin-1.7.3/m4/lib-ld.m4 +@@ -0,0 +1,97 @@ ++# lib-ld.m4 serial 1 (gettext-0.11) ++dnl Copyright (C) 1996-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl Subroutines of libtool.m4, ++dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision ++dnl with libtool.m4. ++ ++dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no. ++AC_DEFUN([AC_LIB_PROG_LD_GNU], ++[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], acl_cv_prog_gnu_ld, ++[# I'd rather use --version here, but apparently some GNU ld's only accept -v. ++if $LD -v 2>&1 &5; then ++ acl_cv_prog_gnu_ld=yes ++else ++ acl_cv_prog_gnu_ld=no ++fi]) ++with_gnu_ld=$acl_cv_prog_gnu_ld ++]) ++ ++dnl From libtool-1.4. Sets the variable LD. ++AC_DEFUN([AC_LIB_PROG_LD], ++[AC_ARG_WITH(gnu-ld, ++[ --with-gnu-ld assume the C compiler uses GNU ld [default=no]], ++test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no) ++AC_REQUIRE([AC_PROG_CC])dnl ++AC_REQUIRE([AC_CANONICAL_HOST])dnl ++ac_prog=ld ++if test "$GCC" = yes; then ++ # Check if gcc -print-prog-name=ld gives a path. ++ AC_MSG_CHECKING([for ld used by GCC]) ++ case $host in ++ *-*-mingw*) ++ # gcc leaves a trailing carriage return which upsets mingw ++ ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; ++ *) ++ ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; ++ esac ++ case $ac_prog in ++ # Accept absolute paths. ++ [[\\/]* | [A-Za-z]:[\\/]*)] ++ [re_direlt='/[^/][^/]*/\.\./'] ++ # Canonicalize the path of ld ++ ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'` ++ while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do ++ ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"` ++ done ++ test -z "$LD" && LD="$ac_prog" ++ ;; ++ "") ++ # If it fails, then pretend we aren't using GCC. ++ ac_prog=ld ++ ;; ++ *) ++ # If it is relative, then search for the first ld in PATH. ++ with_gnu_ld=unknown ++ ;; ++ esac ++elif test "$with_gnu_ld" = yes; then ++ AC_MSG_CHECKING([for GNU ld]) ++else ++ AC_MSG_CHECKING([for non-GNU ld]) ++fi ++AC_CACHE_VAL(acl_cv_path_LD, ++[if test -z "$LD"; then ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}" ++ for ac_dir in $PATH; do ++ test -z "$ac_dir" && ac_dir=. ++ if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then ++ acl_cv_path_LD="$ac_dir/$ac_prog" ++ # Check to see if the program is GNU ld. I'd rather use --version, ++ # but apparently some GNU ld's only accept -v. ++ # Break only if it was the GNU/non-GNU ld that we prefer. ++ if "$acl_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then ++ test "$with_gnu_ld" != no && break ++ else ++ test "$with_gnu_ld" != yes && break ++ fi ++ fi ++ done ++ IFS="$ac_save_ifs" ++else ++ acl_cv_path_LD="$LD" # Let the user override the test with a path. ++fi]) ++LD="$acl_cv_path_LD" ++if test -n "$LD"; then ++ AC_MSG_RESULT($LD) ++else ++ AC_MSG_RESULT(no) ++fi ++test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH]) ++AC_LIB_PROG_LD_GNU ++]) +--- /dev/null ++++ tin-1.7.3/m4/lib-link.m4 +@@ -0,0 +1,554 @@ ++# lib-link.m4 serial 3 (gettext-0.11.3) ++dnl Copyright (C) 2001-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Bruno Haible. ++ ++dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and ++dnl the libraries corresponding to explicit and implicit dependencies. ++dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and ++dnl augments the CPPFLAGS variable. ++AC_DEFUN([AC_LIB_LINKFLAGS], ++[ ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ AC_REQUIRE([AC_LIB_RPATH]) ++ define([Name],[translit([$1],[./-], [___])]) ++ define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) ++ AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [ ++ AC_LIB_LINKFLAGS_BODY([$1], [$2]) ++ ac_cv_lib[]Name[]_libs="$LIB[]NAME" ++ ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME" ++ ac_cv_lib[]Name[]_cppflags="$INC[]NAME" ++ ]) ++ LIB[]NAME="$ac_cv_lib[]Name[]_libs" ++ LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs" ++ INC[]NAME="$ac_cv_lib[]Name[]_cppflags" ++ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME) ++ AC_SUBST([LIB]NAME) ++ AC_SUBST([LTLIB]NAME) ++ dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the ++ dnl results of this search when this library appears as a dependency. ++ HAVE_LIB[]NAME=yes ++ undefine([Name]) ++ undefine([NAME]) ++]) ++ ++dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode) ++dnl searches for libname and the libraries corresponding to explicit and ++dnl implicit dependencies, together with the specified include files and ++dnl the ability to compile and link the specified testcode. If found, it ++dnl sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} and ++dnl LTLIB${NAME} variables and augments the CPPFLAGS variable, and ++dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs ++dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty. ++AC_DEFUN([AC_LIB_HAVE_LINKFLAGS], ++[ ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ AC_REQUIRE([AC_LIB_RPATH]) ++ define([Name],[translit([$1],[./-], [___])]) ++ define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) ++ ++ dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME ++ dnl accordingly. ++ AC_LIB_LINKFLAGS_BODY([$1], [$2]) ++ ++ dnl Add $INC[]NAME to CPPFLAGS before performing the following checks, ++ dnl because if the user has installed lib[]Name and not disabled its use ++ dnl via --without-lib[]Name-prefix, he wants to use it. ++ ac_save_CPPFLAGS="$CPPFLAGS" ++ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME) ++ ++ AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [ ++ ac_save_LIBS="$LIBS" ++ LIBS="$LIBS $LIB[]NAME" ++ AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no]) ++ LIBS="$ac_save_LIBS" ++ ]) ++ if test "$ac_cv_lib[]Name" = yes; then ++ HAVE_LIB[]NAME=yes ++ AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the $1 library.]) ++ AC_MSG_CHECKING([how to link with lib[]$1]) ++ AC_MSG_RESULT([$LIB[]NAME]) ++ else ++ HAVE_LIB[]NAME=no ++ dnl If $LIB[]NAME didn't lead to a usable library, we don't need ++ dnl $INC[]NAME either. ++ CPPFLAGS="$ac_save_CPPFLAGS" ++ LIB[]NAME= ++ LTLIB[]NAME= ++ fi ++ AC_SUBST([HAVE_LIB]NAME) ++ AC_SUBST([LIB]NAME) ++ AC_SUBST([LTLIB]NAME) ++ undefine([Name]) ++ undefine([NAME]) ++]) ++ ++dnl Determine the platform dependent parameters needed to use rpath: ++dnl libext, shlibext, hardcode_libdir_flag_spec, hardcode_libdir_separator, ++dnl hardcode_direct, hardcode_minus_L, ++dnl sys_lib_search_path_spec, sys_lib_dlsearch_path_spec. ++AC_DEFUN([AC_LIB_RPATH], ++[ ++ AC_REQUIRE([AC_PROG_CC]) dnl we use $CC, $GCC, $LDFLAGS ++ AC_REQUIRE([AC_LIB_PROG_LD]) dnl we use $LD, $with_gnu_ld ++ AC_REQUIRE([AC_CANONICAL_HOST]) dnl we use $host ++ AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir ++ AC_CACHE_CHECK([for shared library run path origin], acl_cv_rpath, [ ++ CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \ ++ ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh ++ . ./conftest.sh ++ rm -f ./conftest.sh ++ acl_cv_rpath=done ++ ]) ++ wl="$acl_cv_wl" ++ libext="$acl_cv_libext" ++ shlibext="$acl_cv_shlibext" ++ hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec" ++ hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator" ++ hardcode_direct="$acl_cv_hardcode_direct" ++ hardcode_minus_L="$acl_cv_hardcode_minus_L" ++ sys_lib_search_path_spec="$acl_cv_sys_lib_search_path_spec" ++ sys_lib_dlsearch_path_spec="$acl_cv_sys_lib_dlsearch_path_spec" ++ dnl Determine whether the user wants rpath handling at all. ++ AC_ARG_ENABLE(rpath, ++ [ --disable-rpath do not hardcode runtime library paths], ++ :, enable_rpath=yes) ++]) ++ ++dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and ++dnl the libraries corresponding to explicit and implicit dependencies. ++dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables. ++AC_DEFUN([AC_LIB_LINKFLAGS_BODY], ++[ ++ define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) ++ dnl By default, look in $includedir and $libdir. ++ use_additional=yes ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ ]) ++ AC_ARG_WITH([lib$1-prefix], ++[ --with-lib$1-prefix[=DIR] search for lib$1 in DIR/include and DIR/lib ++ --without-lib$1-prefix don't search for lib$1 in includedir and libdir], ++[ ++ if test "X$withval" = "Xno"; then ++ use_additional=no ++ else ++ if test "X$withval" = "X"; then ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ ]) ++ else ++ additional_includedir="$withval/include" ++ additional_libdir="$withval/lib" ++ fi ++ fi ++]) ++ dnl Search the library and its dependencies in $additional_libdir and ++ dnl $LDFLAGS. Using breadth-first-seach. ++ LIB[]NAME= ++ LTLIB[]NAME= ++ INC[]NAME= ++ rpathdirs= ++ ltrpathdirs= ++ names_already_handled= ++ names_next_round='$1 $2' ++ while test -n "$names_next_round"; do ++ names_this_round="$names_next_round" ++ names_next_round= ++ for name in $names_this_round; do ++ already_handled= ++ for n in $names_already_handled; do ++ if test "$n" = "$name"; then ++ already_handled=yes ++ break ++ fi ++ done ++ if test -z "$already_handled"; then ++ names_already_handled="$names_already_handled $name" ++ dnl See if it was already located by an earlier AC_LIB_LINKFLAGS ++ dnl or AC_LIB_HAVE_LINKFLAGS call. ++ uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'` ++ eval value=\"\$HAVE_LIB$uppername\" ++ if test -n "$value"; then ++ if test "$value" = yes; then ++ eval value=\"\$LIB$uppername\" ++ test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value" ++ eval value=\"\$LTLIB$uppername\" ++ test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value" ++ else ++ dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined ++ dnl that this library doesn't exist. So just drop it. ++ : ++ fi ++ else ++ dnl Search the library lib$name in $additional_libdir and $LDFLAGS ++ dnl and the already constructed $LIBNAME/$LTLIBNAME. ++ found_dir= ++ found_la= ++ found_so= ++ found_a= ++ if test $use_additional = yes; then ++ if test -n "$shlibext" && test -f "$additional_libdir/lib$name.$shlibext"; then ++ found_dir="$additional_libdir" ++ found_so="$additional_libdir/lib$name.$shlibext" ++ if test -f "$additional_libdir/lib$name.la"; then ++ found_la="$additional_libdir/lib$name.la" ++ fi ++ else ++ if test -f "$additional_libdir/lib$name.$libext"; then ++ found_dir="$additional_libdir" ++ found_a="$additional_libdir/lib$name.$libext" ++ if test -f "$additional_libdir/lib$name.la"; then ++ found_la="$additional_libdir/lib$name.la" ++ fi ++ fi ++ fi ++ fi ++ if test "X$found_dir" = "X"; then ++ for x in $LDFLAGS $LTLIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ case "$x" in ++ -L*) ++ dir=`echo "X$x" | sed -e 's/^X-L//'` ++ if test -n "$shlibext" && test -f "$dir/lib$name.$shlibext"; then ++ found_dir="$dir" ++ found_so="$dir/lib$name.$shlibext" ++ if test -f "$dir/lib$name.la"; then ++ found_la="$dir/lib$name.la" ++ fi ++ else ++ if test -f "$dir/lib$name.$libext"; then ++ found_dir="$dir" ++ found_a="$dir/lib$name.$libext" ++ if test -f "$dir/lib$name.la"; then ++ found_la="$dir/lib$name.la" ++ fi ++ fi ++ fi ++ ;; ++ esac ++ if test "X$found_dir" != "X"; then ++ break ++ fi ++ done ++ fi ++ if test "X$found_dir" != "X"; then ++ dnl Found the library. ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name" ++ if test "X$found_so" != "X"; then ++ dnl Linking with a shared library. We attempt to hardcode its ++ dnl directory into the executable's runpath, unless it's the ++ dnl standard /usr/lib. ++ if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/lib"; then ++ dnl No hardcoding is needed. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ else ++ dnl Use an explicit option to hardcode DIR into the resulting ++ dnl binary. ++ dnl Potentially add DIR to ltrpathdirs. ++ dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. ++ haveit= ++ for x in $ltrpathdirs; do ++ if test "X$x" = "X$found_dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ ltrpathdirs="$ltrpathdirs $found_dir" ++ fi ++ dnl The hardcoding into $LIBNAME is system dependent. ++ if test "$hardcode_direct" = yes; then ++ dnl Using DIR/libNAME.so during linking hardcodes DIR into the ++ dnl resulting binary. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ else ++ if test -n "$hardcode_libdir_flag_spec" && test "$hardcode_minus_L" = no; then ++ dnl Use an explicit option to hardcode DIR into the resulting ++ dnl binary. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ dnl Potentially add DIR to rpathdirs. ++ dnl The rpathdirs will be appended to $LIBNAME at the end. ++ haveit= ++ for x in $rpathdirs; do ++ if test "X$x" = "X$found_dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ rpathdirs="$rpathdirs $found_dir" ++ fi ++ else ++ dnl Rely on "-L$found_dir". ++ dnl But don't add it if it's already contained in the LDFLAGS ++ dnl or the already constructed $LIBNAME ++ haveit= ++ for x in $LDFLAGS $LIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$found_dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir" ++ fi ++ if test "$hardcode_minus_L" != no; then ++ dnl FIXME: Not sure whether we should use ++ dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" ++ dnl here. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ else ++ dnl We cannot use $hardcode_runpath_var and LD_RUN_PATH ++ dnl here, because this doesn't fit in flags passed to the ++ dnl compiler. So give up. No hardcoding. This affects only ++ dnl very old systems. ++ dnl FIXME: Not sure whether we should use ++ dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" ++ dnl here. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" ++ fi ++ fi ++ fi ++ fi ++ else ++ if test "X$found_a" != "X"; then ++ dnl Linking with a static library. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a" ++ else ++ dnl We shouldn't come here, but anyway it's good to have a ++ dnl fallback. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name" ++ fi ++ fi ++ dnl Assume the include files are nearby. ++ additional_includedir= ++ case "$found_dir" in ++ */lib | */lib/) ++ basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e 's,/lib/*$,,'` ++ additional_includedir="$basedir/include" ++ ;; ++ esac ++ if test "X$additional_includedir" != "X"; then ++ dnl Potentially add $additional_includedir to $INCNAME. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/include, ++ dnl 2. if it's /usr/local/include and we are using GCC on Linux, ++ dnl 3. if it's already present in $CPPFLAGS or the already ++ dnl constructed $INCNAME, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_includedir" != "X/usr/include"; then ++ haveit= ++ if test "X$additional_includedir" = "X/usr/local/include"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux*) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ for x in $CPPFLAGS $INC[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-I$additional_includedir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test -d "$additional_includedir"; then ++ dnl Really add $additional_includedir to $INCNAME. ++ INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir" ++ fi ++ fi ++ fi ++ fi ++ fi ++ dnl Look for dependencies. ++ if test -n "$found_la"; then ++ dnl Read the .la file. It defines the variables ++ dnl dlname, library_names, old_library, dependency_libs, current, ++ dnl age, revision, installed, dlopen, dlpreopen, libdir. ++ save_libdir="$libdir" ++ case "$found_la" in ++ */* | *\\*) . "$found_la" ;; ++ *) . "./$found_la" ;; ++ esac ++ libdir="$save_libdir" ++ dnl We use only dependency_libs. ++ for dep in $dependency_libs; do ++ case "$dep" in ++ -L*) ++ additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'` ++ dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/lib, ++ dnl 2. if it's /usr/local/lib and we are using GCC on Linux, ++ dnl 3. if it's already present in $LDFLAGS or the already ++ dnl constructed $LIBNAME, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_libdir" != "X/usr/lib"; then ++ haveit= ++ if test "X$additional_libdir" = "X/usr/local/lib"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux*) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ haveit= ++ for x in $LDFLAGS $LIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$additional_libdir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test -d "$additional_libdir"; then ++ dnl Really add $additional_libdir to $LIBNAME. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir" ++ fi ++ fi ++ haveit= ++ for x in $LDFLAGS $LTLIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$additional_libdir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test -d "$additional_libdir"; then ++ dnl Really add $additional_libdir to $LTLIBNAME. ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir" ++ fi ++ fi ++ fi ++ fi ++ ;; ++ -R*) ++ dir=`echo "X$dep" | sed -e 's/^X-R//'` ++ if test "$enable_rpath" != no; then ++ dnl Potentially add DIR to rpathdirs. ++ dnl The rpathdirs will be appended to $LIBNAME at the end. ++ haveit= ++ for x in $rpathdirs; do ++ if test "X$x" = "X$dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ rpathdirs="$rpathdirs $dir" ++ fi ++ dnl Potentially add DIR to ltrpathdirs. ++ dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. ++ haveit= ++ for x in $ltrpathdirs; do ++ if test "X$x" = "X$dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ ltrpathdirs="$ltrpathdirs $dir" ++ fi ++ fi ++ ;; ++ -l*) ++ dnl Handle this in the next round. ++ names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'` ++ ;; ++ *.la) ++ dnl Handle this in the next round. Throw away the .la's ++ dnl directory; it is already contained in a preceding -L ++ dnl option. ++ names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'` ++ ;; ++ *) ++ dnl Most likely an immediate library name. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep" ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep" ++ ;; ++ esac ++ done ++ fi ++ else ++ dnl Didn't find the library; assume it is in the system directories ++ dnl known to the linker and runtime loader. (All the system ++ dnl directories known to the linker should also be known to the ++ dnl runtime loader, otherwise the system is severely misconfigured.) ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name" ++ fi ++ fi ++ fi ++ done ++ done ++ if test "X$rpathdirs" != "X"; then ++ if test -n "$hardcode_libdir_separator"; then ++ dnl Weird platform: only the last -rpath option counts, the user must ++ dnl pass all path elements in one option. We can arrange that for a ++ dnl single library, but not when more than one $LIBNAMEs are used. ++ alldirs= ++ for found_dir in $rpathdirs; do ++ alldirs="${alldirs}${alldirs:+$hardcode_libdir_separator}$found_dir" ++ done ++ dnl Note: hardcode_libdir_flag_spec uses $libdir and $wl. ++ acl_save_libdir="$libdir" ++ libdir="$alldirs" ++ eval flag=\"$hardcode_libdir_flag_spec\" ++ libdir="$acl_save_libdir" ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" ++ else ++ dnl The -rpath options are cumulative. ++ for found_dir in $rpathdirs; do ++ acl_save_libdir="$libdir" ++ libdir="$found_dir" ++ eval flag=\"$hardcode_libdir_flag_spec\" ++ libdir="$acl_save_libdir" ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" ++ done ++ fi ++ fi ++ if test "X$ltrpathdirs" != "X"; then ++ dnl When using libtool, the option that works for both libraries and ++ dnl executables is -R. The -R options are cumulative. ++ for found_dir in $ltrpathdirs; do ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir" ++ done ++ fi ++]) ++ ++dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR, ++dnl unless already present in VAR. ++dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes ++dnl contains two or three consecutive elements that belong together. ++AC_DEFUN([AC_LIB_APPENDTOVAR], ++[ ++ for element in [$2]; do ++ haveit= ++ for x in $[$1]; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X$element"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ [$1]="${[$1]}${[$1]:+ }$element" ++ fi ++ done ++]) +--- /dev/null ++++ tin-1.7.3/m4/lib-prefix.m4 +@@ -0,0 +1,148 @@ ++# lib-prefix.m4 serial 1 (gettext-0.11) ++dnl Copyright (C) 2001-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Bruno Haible. ++ ++dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed ++dnl to access previously installed libraries. The basic assumption is that ++dnl a user will want packages to use other packages he previously installed ++dnl with the same --prefix option. ++dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate ++dnl libraries, but is otherwise very convenient. ++AC_DEFUN([AC_LIB_PREFIX], ++[ ++ AC_BEFORE([$0], [AC_LIB_LINKFLAGS]) ++ AC_REQUIRE([AC_PROG_CC]) ++ AC_REQUIRE([AC_CANONICAL_HOST]) ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ dnl By default, look in $includedir and $libdir. ++ use_additional=yes ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ ]) ++ AC_ARG_WITH([lib-prefix], ++[ --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib ++ --without-lib-prefix don't search for libraries in includedir and libdir], ++[ ++ if test "X$withval" = "Xno"; then ++ use_additional=no ++ else ++ if test "X$withval" = "X"; then ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ ]) ++ else ++ additional_includedir="$withval/include" ++ additional_libdir="$withval/lib" ++ fi ++ fi ++]) ++ if test $use_additional = yes; then ++ dnl Potentially add $additional_includedir to $CPPFLAGS. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/include, ++ dnl 2. if it's already present in $CPPFLAGS, ++ dnl 3. if it's /usr/local/include and we are using GCC on Linux, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_includedir" != "X/usr/include"; then ++ haveit= ++ for x in $CPPFLAGS; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-I$additional_includedir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test "X$additional_includedir" = "X/usr/local/include"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux*) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ if test -d "$additional_includedir"; then ++ dnl Really add $additional_includedir to $CPPFLAGS. ++ CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir" ++ fi ++ fi ++ fi ++ fi ++ dnl Potentially add $additional_libdir to $LDFLAGS. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/lib, ++ dnl 2. if it's already present in $LDFLAGS, ++ dnl 3. if it's /usr/local/lib and we are using GCC on Linux, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_libdir" != "X/usr/lib"; then ++ haveit= ++ for x in $LDFLAGS; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$additional_libdir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test "X$additional_libdir" = "X/usr/local/lib"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux*) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ if test -d "$additional_libdir"; then ++ dnl Really add $additional_libdir to $LDFLAGS. ++ LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir" ++ fi ++ fi ++ fi ++ fi ++ fi ++]) ++ ++dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix, ++dnl acl_final_exec_prefix, containing the values to which $prefix and ++dnl $exec_prefix will expand at the end of the configure script. ++AC_DEFUN([AC_LIB_PREPARE_PREFIX], ++[ ++ dnl Unfortunately, prefix and exec_prefix get only finally determined ++ dnl at the end of configure. ++ if test "X$prefix" = "XNONE"; then ++ acl_final_prefix="$ac_default_prefix" ++ else ++ acl_final_prefix="$prefix" ++ fi ++ if test "X$exec_prefix" = "XNONE"; then ++ acl_final_exec_prefix='${prefix}' ++ else ++ acl_final_exec_prefix="$exec_prefix" ++ fi ++ acl_save_prefix="$prefix" ++ prefix="$acl_final_prefix" ++ eval acl_final_exec_prefix=\"$acl_final_exec_prefix\" ++ prefix="$acl_save_prefix" ++]) ++ ++dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the ++dnl variables prefix and exec_prefix bound to the values they will have ++dnl at the end of the configure script. ++AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX], ++[ ++ acl_save_prefix="$prefix" ++ prefix="$acl_final_prefix" ++ acl_save_exec_prefix="$exec_prefix" ++ exec_prefix="$acl_final_exec_prefix" ++ $1 ++ exec_prefix="$acl_save_exec_prefix" ++ prefix="$acl_save_prefix" ++]) +--- /dev/null ++++ tin-1.7.3/m4/progtest.m4 +@@ -0,0 +1,59 @@ ++# progtest.m4 serial 2 (gettext-0.10.40) ++dnl Copyright (C) 1996-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++dnl ++dnl This file can can be used in projects which are not available under ++dnl the GNU General Public License or the GNU Library General Public ++dnl License but which still want to provide support for the GNU gettext ++dnl functionality. ++dnl Please note that the actual code of the GNU gettext library is covered ++dnl by the GNU Library General Public License, and the rest of the GNU ++dnl gettext package package is covered by the GNU General Public License. ++dnl They are *not* in the public domain. ++ ++dnl Authors: ++dnl Ulrich Drepper , 1996. ++ ++# Search path for a program which passes the given test. ++ ++dnl AM_PATH_PROG_WITH_TEST(VARIABLE, PROG-TO-CHECK-FOR, ++dnl TEST-PERFORMED-ON-FOUND_PROGRAM [, VALUE-IF-NOT-FOUND [, PATH]]) ++AC_DEFUN([AM_PATH_PROG_WITH_TEST], ++[# Extract the first word of "$2", so it can be a program name with args. ++set dummy $2; ac_word=[$]2 ++AC_MSG_CHECKING([for $ac_word]) ++AC_CACHE_VAL(ac_cv_path_$1, ++[case "[$]$1" in ++ /*) ++ ac_cv_path_$1="[$]$1" # Let the user override the test with a path. ++ ;; ++ *) ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" ++ for ac_dir in ifelse([$5], , $PATH, [$5]); do ++ test -z "$ac_dir" && ac_dir=. ++ if test -f $ac_dir/$ac_word; then ++ if [$3]; then ++ ac_cv_path_$1="$ac_dir/$ac_word" ++ break ++ fi ++ fi ++ done ++ IFS="$ac_save_ifs" ++dnl If no 4th arg is given, leave the cache variable unset, ++dnl so AC_PATH_PROGS will keep looking. ++ifelse([$4], , , [ test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4" ++])dnl ++ ;; ++esac])dnl ++$1="$ac_cv_path_$1" ++if test ifelse([$4], , [-n "[$]$1"], ["[$]$1" != "$4"]); then ++ AC_MSG_RESULT([$]$1) ++else ++ AC_MSG_RESULT(no) ++fi ++AC_SUBST($1)dnl ++]) +--- /dev/null ++++ tin-1.7.3/m4/stdint_h.m4 +@@ -0,0 +1,28 @@ ++# stdint_h.m4 serial 2 (gettext-0.11.4) ++dnl Copyright (C) 1997-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Paul Eggert. ++ ++# Define HAVE_STDINT_H_WITH_UINTMAX if exists, ++# doesn't clash with , and declares uintmax_t. ++ ++AC_DEFUN([jm_AC_HEADER_STDINT_H], ++[ ++ AC_CACHE_CHECK([for stdint.h], jm_ac_cv_header_stdint_h, ++ [AC_TRY_COMPILE( ++ [#include ++#include ], ++ [uintmax_t i = (uintmax_t) -1;], ++ jm_ac_cv_header_stdint_h=yes, ++ jm_ac_cv_header_stdint_h=no)]) ++ if test $jm_ac_cv_header_stdint_h = yes; then ++ AC_DEFINE_UNQUOTED(HAVE_STDINT_H_WITH_UINTMAX, 1, ++[Define if exists, doesn't clash with , ++ and declares uintmax_t. ]) ++ fi ++]) +--- /dev/null ++++ tin-1.7.3/m4/uintmax_t.m4 +@@ -0,0 +1,29 @@ ++# uintmax_t.m4 serial 6 (gettext-0.11) ++dnl Copyright (C) 1997-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Paul Eggert. ++ ++AC_PREREQ(2.13) ++ ++# Define uintmax_t to `unsigned long' or `unsigned long long' ++# if does not exist. ++ ++AC_DEFUN([jm_AC_TYPE_UINTMAX_T], ++[ ++ AC_REQUIRE([jm_AC_HEADER_INTTYPES_H]) ++ AC_REQUIRE([jm_AC_HEADER_STDINT_H]) ++ if test $jm_ac_cv_header_inttypes_h = no && test $jm_ac_cv_header_stdint_h = no; then ++ AC_REQUIRE([jm_AC_TYPE_UNSIGNED_LONG_LONG]) ++ test $ac_cv_type_unsigned_long_long = yes \ ++ && ac_type='unsigned long long' \ ++ || ac_type='unsigned long' ++ AC_DEFINE_UNQUOTED(uintmax_t, $ac_type, ++ [Define to unsigned long or unsigned long long ++ if and don't define.]) ++ fi ++]) +--- /dev/null ++++ tin-1.7.3/m4/ulonglong.m4 +@@ -0,0 +1,23 @@ ++# ulonglong.m4 serial 2 (fileutils-4.0.32, gettext-0.10.40) ++dnl Copyright (C) 1999-2002 Free Software Foundation, Inc. ++dnl This file is free software, distributed under the terms of the GNU ++dnl General Public License. As a special exception to the GNU General ++dnl Public License, this file may be distributed as part of a program ++dnl that contains a configuration script generated by Autoconf, under ++dnl the same distribution terms as the rest of that program. ++ ++dnl From Paul Eggert. ++ ++AC_DEFUN([jm_AC_TYPE_UNSIGNED_LONG_LONG], ++[ ++ AC_CACHE_CHECK([for unsigned long long], ac_cv_type_unsigned_long_long, ++ [AC_TRY_LINK([unsigned long long ull = 1; int i = 63;], ++ [unsigned long long ullmax = (unsigned long long) -1; ++ return ull << i | ull >> i | ullmax / ull | ullmax % ull;], ++ ac_cv_type_unsigned_long_long=yes, ++ ac_cv_type_unsigned_long_long=no)]) ++ if test $ac_cv_type_unsigned_long_long = yes; then ++ AC_DEFINE(HAVE_UNSIGNED_LONG_LONG, 1, ++ [Define if you have the unsigned long long type.]) ++ fi ++]) +--- /dev/null ++++ tin-1.7.3/acinclude.m4 +@@ -0,0 +1,3671 @@ ++dnl --------------------------------------------------------------------------- ++dnl AM_MULTIBYTE_ABLE version: 5 updated: 2003/01/16 16:21:27 ++dnl ----------------- ++ ++dnl check for required multibyte/widechar functions ++dnl Urs Janssen 20021006 ++dnl Usage: AM_MULTIBYTE_ABLE ++AC_DEFUN([AM_MULTIBYTE_ABLE], ++[ ++ AC_CACHE_CHECK([for wide char and multibyte support], am_cv_multibyte_able, ++ [AC_TRY_LINK([#include ++#ifdef HAVE_STDLIB_H ++# include ++#endif /* HAVE_STDLIB_H */ ++#ifdef HAVE_WCHAR_H ++# include ++#endif /* HAVE_WCHAR_H */ ++#ifdef HAVE_WCTYPE_H ++# include ++#endif /* HAVE_WCTYPE_H */ ++], ++ [char icb[5] = {0xa4, 0xa4, 0xa4, 0xe5, 0x00}; ++ char ocb[5]; ++ wchar_t wcb[5]; ++ wchar_t wcb2[5]; ++ wchar_t format[3]; ++ ++ putwc(0, 0); ++ fputwc(0, 0); ++ fwide(0, 0); ++ mbtowc(wcb, icb, MB_CUR_MAX); ++ mbstowcs(wcb, icb, 5); ++ iswprint((wint_t) wcb[0]); ++ wcslen(wcb); ++ wcsnlen(wcb, 4); ++ wcwidth((wint_t) wcb[0]); ++ wcswidth(wcb, 5); ++ wcstombs(ocb, wcb, 5); ++ mbstowcs(format, "%s", 2); ++ swprintf(wcb, 5, format, "test"); ++ wcsncat(wcb2, wcb, 5);], ++ am_cv_multibyte_able=yes, ++ [cf_save_LIBS="$LIBS" ++ LIBS="-lutf8 $LIBS" ++ AC_TRY_LINK([#include ], ++ [char icb[5] = {0xa4, 0xa4, 0xa4, 0xe5, 0x00}; ++ char ocb[5]; ++ wchar_t wcb[5]; ++ wchar_t wcb2[5]; ++ wchar_t format[3]; ++ ++ putwc(0, 0); ++ fputwc(0, 0); ++ fwide(0, 0); ++ mbtowc(wcb, icb, MB_CUR_MAX); ++ mbstowcs(wcb, icb, 5); ++ iswprint((wint_t) wcb[0]); ++ wcslen(wcb); ++ wcsnlen(wcb, 4); ++ wcwidth((wint_t) wcb[0]); ++ wcswidth(wcb, 5); ++ wcstombs(ocb, wcb, 5); ++ mbstowcs(format, "%s", 2); ++ swprintf(wcb, 5, format, "test"); ++ wcsncat(wcb2, wcb, 5);], ++ [am_cv_multibyte_able=yes ++ have_libutf8_h=yes], ++ [am_cv_multibyte_able=no ++ LIBS="$cf_save_LIBS"]) ++ ]) ++ ]) ++ if test $am_cv_multibyte_able = yes; then ++ AC_DEFINE(MULTIBYTE_ABLE, 1, ++ [Define if you have swprintf() and co.]) ++ if test $have_libutf8_h = yes; then ++ AC_DEFINE(HAVE_LIBUTF8_H) ++ fi ++ fi ++]) ++dnl --------------------------------------------------------------------------- ++dnl CF_ADD_CFLAGS version: 5 updated: 2002/12/01 00:12:15 ++dnl ------------- ++dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS ++dnl The second parameter if given makes this macro verbose. ++AC_DEFUN([CF_ADD_CFLAGS], ++[ ++cf_new_cflags= ++cf_new_cppflags= ++for cf_add_cflags in $1 ++do ++ case $cf_add_cflags in #(vi ++ -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi ++ case "$CPPFLAGS" in ++ *$cf_add_cflags) #(vi ++ ;; ++ *) #(vi ++ cf_new_cppflags="$cf_new_cppflags $cf_add_cflags" ++ ;; ++ esac ++ ;; ++ *) ++ cf_new_cflags="$cf_new_cflags $cf_add_cflags" ++ ;; ++ esac ++done ++ ++if test -n "$cf_new_cflags" ; then ++ ifelse($2,,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)]) ++ CFLAGS="$CFLAGS $cf_new_cflags" ++fi ++ ++if test -n "$cf_new_cppflags" ; then ++ ifelse($2,,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)]) ++ CPPFLAGS="$cf_new_cppflags $CPPFLAGS" ++fi ++ ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_ADD_INCDIR version: 4 updated: 2002/12/21 14:25:52 ++dnl ------------- ++dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's ++dnl redundant. We don't normally need to add -I/usr/local/include for gcc, ++dnl but old versions (and some misinstalled ones) need that. To make things ++dnl worse, gcc 3.x gives error messages if -I/usr/local/include is added to ++dnl the include-path). ++AC_DEFUN([CF_ADD_INCDIR], ++[ ++for cf_add_incdir in $1 ++do ++ while true ++ do ++ case $cf_add_incdir in ++ /usr/include) # (vi ++ ;; ++ /usr/local/include) # (vi ++ if test "$GCC" = yes ++ then ++ cf_save_CPPFLAGS="$CPPFLAGS" ++ CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" ++ AC_TRY_COMPILE([#include ], ++ [printf("Hello")], ++ [], ++ [CPPFLAGS="$cf_save_CPPFLAGS"]) ++ fi ++ ;; ++ *) # (vi ++ CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" ++ ;; ++ esac ++ cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` ++ test "$cf_top_incdir" = "$cf_add_incdir" && break ++ cf_add_incdir="$cf_top_incdir" ++ done ++done ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34 ++dnl ---------------- ++dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES' ++dnl in the sharutils 4.2 distribution. ++AC_DEFUN([CF_ANSI_CC_CHECK], ++[ ++AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[ ++cf_cv_ansi_cc=no ++cf_save_CFLAGS="$CFLAGS" ++cf_save_CPPFLAGS="$CPPFLAGS" ++# Don't try gcc -ansi; that turns off useful extensions and ++# breaks some systems' header files. ++# AIX -qlanglvl=ansi ++# Ultrix and OSF/1 -std1 ++# HP-UX -Aa -D_HPUX_SOURCE ++# SVR4 -Xc ++# UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes) ++for cf_arg in "-DCC_HAS_PROTOS" \ ++ "" \ ++ -qlanglvl=ansi \ ++ -std1 \ ++ -Ae \ ++ "-Aa -D_HPUX_SOURCE" \ ++ -Xc ++do ++ CF_ADD_CFLAGS($cf_arg) ++ AC_TRY_COMPILE( ++[ ++#ifndef CC_HAS_PROTOS ++#if !defined(__STDC__) || (__STDC__ != 1) ++choke me ++#endif ++#endif ++],[ ++ int test (int i, double x); ++ struct s1 {int (*f) (int a);}; ++ struct s2 {int (*f) (double a);};], ++ [cf_cv_ansi_cc="$cf_arg"; break]) ++done ++CFLAGS="$cf_save_CFLAGS" ++CPPFLAGS="$cf_save_CPPFLAGS" ++]) ++ ++if test "$cf_cv_ansi_cc" != "no"; then ++if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then ++ CF_ADD_CFLAGS($cf_cv_ansi_cc) ++else ++ AC_DEFINE(CC_HAS_PROTOS) ++fi ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_ANSI_CC_REQD version: 3 updated: 1997/09/06 13:40:44 ++dnl --------------- ++dnl For programs that must use an ANSI compiler, obtain compiler options that ++dnl will make it recognize prototypes. We'll do preprocessor checks in other ++dnl macros, since tools such as unproto can fake prototypes, but only part of ++dnl the preprocessor. ++AC_DEFUN([CF_ANSI_CC_REQD], ++[AC_REQUIRE([CF_ANSI_CC_CHECK]) ++if test "$cf_cv_ansi_cc" = "no"; then ++ AC_ERROR( ++[Your compiler does not appear to recognize prototypes. ++You have the following choices: ++ a. adjust your compiler options ++ b. get an up-to-date compiler ++ c. use a wrapper such as unproto]) ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31 ++dnl -------------- ++dnl Allow user to disable a normally-on option. ++AC_DEFUN([CF_ARG_DISABLE], ++[CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31 ++dnl ------------- ++dnl Allow user to enable a normally-off option. ++AC_DEFUN([CF_ARG_ENABLE], ++[CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_ARG_OPTION version: 3 updated: 1997/10/18 14:42:41 ++dnl ------------- ++dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus ++dnl values. ++dnl ++dnl Parameters: ++dnl $1 = option name ++dnl $2 = help-string ++dnl $3 = action to perform if option is not default ++dnl $4 = action if perform if option is default ++dnl $5 = default option value (either 'yes' or 'no') ++AC_DEFUN([CF_ARG_OPTION], ++[AC_ARG_ENABLE($1,[$2],[test "$enableval" != ifelse($5,no,yes,no) && enableval=ifelse($5,no,no,yes) ++ if test "$enableval" != "$5" ; then ++ifelse($3,,[ :]dnl ++,[ $3]) ifelse($4,,,[ ++ else ++ $4]) ++ fi],[enableval=$5 ifelse($4,,,[ ++ $4 ++])dnl ++ ])])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_ARG_WITH version: 3 updated: 2000/07/20 00:41:18 ++dnl ----------- ++dnl Restricted form of AC_ARG_WITH that requires user to specify a value ++dnl $1 = option name ++dnl $2 = help message ++dnl $3 = variable to set with the --with value ++dnl $4 = default value, if any, must be constant. ++dnl $5 = default value shown for --help if $4 is empty. ++AC_DEFUN([CF_ARG_WITH], ++[AC_ARG_WITH($1,[$2 ](default: ifelse($4,,ifelse($5,,empty,$5),$4)),, ++ifelse($4,,[withval="${$3}"],[withval="${$3-$4}"]))dnl ++ifelse($4,,[test -n "$withval" && \ ++],[test -z "$withval" && withval=no ++])dnl ++case "$withval" in #(vi ++yes) ++ AC_ERROR(expected a value for --with-$1) ++ ;; #(vi ++no) withval="" ++ ;; ++esac ++$3="$withval" ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_BUNDLED_INTL version: 6 updated: 2003/06/06 00:48:41 ++dnl --------------- ++dnl Top-level macro for configuring an application with a bundled copy of ++dnl the intl and po directories for gettext. ++dnl ++dnl $1 specifies either Makefile or makefile, defaulting to the former. ++dnl $2 if nonempty sets the option to --enable-nls rather than to --disable-nls ++dnl ++dnl Sets variables which can be used to substitute in makefiles: ++dnl INTLDIR_MAKE - to make ./intl directory ++dnl MSG_DIR_MAKE - to make ./po directory ++dnl SUB_MAKEFILE - list of makefiles in ./intl, ./po directories ++dnl Defines ++dnl HAVE_LIBGETTEXT_H if we're using ./intl ++dnl ++AC_DEFUN([CF_BUNDLED_INTL],[ ++cf_makefile=ifelse($1,,Makefile,$1) ++ ++dnl Set of available languages (based on source distribution). Note that ++dnl setting $LINGUAS overrides $ALL_LINGUAS. Some environments set $LINGUAS ++dnl rather than $LC_ALL ++test -z "$ALL_LINGUAS" && ALL_LINGUAS=`test -d $srcdir/po && cd $srcdir/po && echo *.po|sed -e 's/\.po//g' -e 's/*//'` ++ ++AM_GNU_GETTEXT(,,,[$2]) ++ ++INTLDIR_MAKE= ++MSG_DIR_MAKE= ++SUB_MAKEFILE= ++ ++dnl this updates SUB_MAKEFILE and MSG_DIR_MAKE: ++CF_OUR_MESSAGES($1) ++ ++if test "$USE_INCLUDED_LIBINTL" = yes ; then ++ if test "$nls_cv_force_use_gnu_gettext" = yes ; then ++ SUB_MAKEFILE="$SUB_MAKEFILE intl/$cf_makefile" ++ elif test "$nls_cv_use_gnu_gettext" = yes ; then ++ SUB_MAKEFILE="$SUB_MAKEFILE intl/$cf_makefile" ++ else ++ INTLDIR_MAKE="#" ++ fi ++ if test -z "$INTLDIR_MAKE"; then ++ AC_DEFINE(HAVE_LIBGETTEXT_H) ++ fi ++else ++ INTLDIR_MAKE="#" ++ if test "$USE_NLS" = yes ; then ++ AC_CHECK_HEADERS(libintl.h) ++ fi ++fi ++ ++if test -z "$INTLDIR_MAKE" ; then ++ CPPFLAGS="-I../intl $CPPFLAGS" ++fi ++ ++dnl FIXME: we use this in lynx (the alternative is a spurious dependency upon ++dnl GNU make) ++if test "$BUILD_INCLUDED_LIBINTL" = yes ; then ++ GT_YES="#" ++ GT_NO= ++else ++ GT_YES= ++ GT_NO="#" ++fi ++ ++AC_SUBST(INTLDIR_MAKE) ++AC_SUBST(MSG_DIR_MAKE) ++AC_SUBST(GT_YES) ++AC_SUBST(GT_NO) ++ ++dnl FIXME: the underlying AM_GNU_GETTEXT macro either needs some fixes or a ++dnl little documentation. It doesn't define anything so that we can ifdef our ++dnl own code, except ENABLE_NLS, which is too vague to be of any use. ++ ++if test "$USE_INCLUDED_LIBINTL" = yes ; then ++ if test "$nls_cv_force_use_gnu_gettext" = yes ; then ++ AC_DEFINE(HAVE_GETTEXT) ++ elif test "$nls_cv_use_gnu_gettext" = yes ; then ++ AC_DEFINE(HAVE_GETTEXT) ++ fi ++ if test -n "$nls_cv_header_intl" ; then ++ AC_DEFINE(HAVE_LIBINTL_H) ++ fi ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_BUNDLED_PCRE version: 3 updated: 2002/04/17 21:09:56 ++dnl --------------- ++dnl Top-level macro for configuring an application with a bundled copy of ++dnl the pcre library. ++dnl ++dnl $1 specifies the top of the directory containing PCRE's include, lib dirs. ++AC_DEFUN([CF_BUNDLED_PCRE], ++[ ++cf_pcre_home=$1 ++PCREDIR_MAKE= ++PCREDIR_LIBS= ++PCREDIR_CPPFLAGS= ++case .$cf_pcre_home in #(vi ++.no) #(vi ++ # setup to compile the bundled PCRE: ++ . $srcdir/pcre/version.sh ++ AC_SUBST(PCRE_MAJOR) ++ AC_SUBST(PCRE_MINOR) ++ AC_SUBST(PCRE_DATE) ++ AC_SUBST(PCRE_DEFINES) ++ ;; ++.yes) #(vi ++ PCREDIR_MAKE='#' ++ PCREDIR_LIBS="-lpcre" ++ ;; ++.*) ++ CF_PATH_SYNTAX(cf_pcre_home) ++ PCREDIR_MAKE='#' ++ PCREDIR_LIBS="-L${cf_pcre_home}/lib -lpcre" ++ PCREDIR_CPPFLAGS="-I${cf_pcre_home}/include" ++ ;; ++esac ++AC_SUBST(PCREDIR_MAKE) ++AC_SUBST(PCREDIR_LIBS) ++AC_SUBST(PCREDIR_CPPFLAGS) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CHECK_1_DECL version: 5 updated: 2001/07/22 21:09:16 ++dnl --------------- ++dnl Check for missing declarations in the system headers (adapted from vile). ++dnl ++dnl CHECK_DECL_FLAG and CHECK_DECL_HDRS must be set in configure.in ++AC_DEFUN([CF_CHECK_1_DECL], ++[ ++AC_MSG_CHECKING([for missing "$1" extern]) ++AC_CACHE_VAL([cf_cv_func_$1],[ ++CF_MSG_LOG([for missing "$1" external]) ++cf_save_CFLAGS="$CFLAGS" ++CFLAGS="$CFLAGS $CHECK_DECL_FLAG" ++AC_TRY_LINK([ ++$CHECK_DECL_HDRS ++ ++#undef $1 ++struct zowie { int a; double b; struct zowie *c; char d; }; ++extern struct zowie *$1(); ++], ++[ ++], ++[if test -n "$CHECK_DECL_HDRS" ; then ++# try to work around system headers which are infested with non-standard syntax ++CF_UPPER(cf_1_up,$1) ++AC_TRY_COMPILE([ ++#define DECL_${cf_1_up} ++$CHECK_DECL_HDRS ++],[long x = 0], ++[eval 'cf_cv_func_'$1'=yes'], ++[eval 'cf_cv_func_'$1'=no']) ++else ++eval 'cf_cv_func_'$1'=yes' ++fi ++], ++[eval 'cf_cv_func_'$1'=no']) ++CFLAGS="$cf_save_CFLAGS" ++]) ++eval 'cf_result=$cf_cv_func_'$1 ++AC_MSG_RESULT($cf_result) ++test $cf_result = yes && AC_DEFINE_UNQUOTED(DECL_$2) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CHECK_CACHE version: 7 updated: 2001/12/19 00:50:10 ++dnl -------------- ++dnl Check if we're accidentally using a cache from a different machine. ++dnl Derive the system name, as a check for reusing the autoconf cache. ++dnl ++dnl If we've packaged config.guess and config.sub, run that (since it does a ++dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow ++dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM ++dnl which is useful in cross-compiles. ++AC_DEFUN([CF_CHECK_CACHE], ++[ ++if test -f $srcdir/config.guess ; then ++ ifelse([$1],,[AC_CANONICAL_HOST],[$1]) ++ system_name="$host_os" ++else ++ system_name="`(uname -s -r) 2>/dev/null`" ++ if test -z "$system_name" ; then ++ system_name="`(hostname) 2>/dev/null`" ++ fi ++fi ++test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name") ++AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"]) ++ ++test -z "$system_name" && system_name="$cf_cv_system_name" ++test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name) ++ ++if test ".$system_name" != ".$cf_cv_system_name" ; then ++ AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)) ++ AC_ERROR("Please remove config.cache and try again.") ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CHECK_CFLAGS version: 2 updated: 2001/12/30 19:09:58 ++dnl --------------- ++dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from ++dnl a build-configuration such as imake. These have the pitfall that they ++dnl often contain compiler-specific options which we cannot use, mixed with ++dnl preprocessor options that we usually can. ++AC_DEFUN([CF_CHECK_CFLAGS], ++[ ++CF_VERBOSE(checking additions to CFLAGS) ++cf_check_cflags="$CFLAGS" ++cf_check_cppflags="$CPPFLAGS" ++CF_ADD_CFLAGS($1,yes) ++if test "$cf_check_cflags" != "$CFLAGS" ; then ++AC_TRY_LINK([#include ],[printf("Hello world");],, ++ [CF_VERBOSE(test-compile failed. Undoing change to \$CFLAGS) ++ if test "$cf_check_cppflags" != "$CPPFLAGS" ; then ++ CF_VERBOSE(but keeping change to \$CPPFLAGS) ++ fi ++ CFLAGS="$cf_check_flags"]) ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CHECK_DECL version: 2 updated: 1997/08/28 23:57:55 ++dnl ------------- ++AC_DEFUN([CF_CHECK_DECL], ++[for ac_func in $1 ++do ++CF_UPPER(ac_tr_func,$ac_func) ++CF_CHECK_1_DECL(${ac_func}, ${ac_tr_func})dnl ++done ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CHECK_ERRNO version: 9 updated: 2001/12/30 18:03:23 ++dnl -------------- ++dnl Check for data that is usually declared in or , e.g., ++dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it ++dnl ourselves. ++dnl ++dnl $1 = the name to check ++AC_DEFUN([CF_CHECK_ERRNO], ++[ ++AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[ ++ AC_TRY_COMPILE([ ++#ifdef HAVE_STDLIB_H ++#include ++#endif ++#include ++#include ++#include ], ++ [long x = (long) $1], ++ [cf_cv_dcl_$1=yes], ++ [cf_cv_dcl_$1=no]) ++]) ++ ++if test "$cf_cv_dcl_$1" = no ; then ++ CF_UPPER(cf_result,decl_$1) ++ AC_DEFINE_UNQUOTED($cf_result) ++fi ++ ++# It's possible (for near-UNIX clones) that the data doesn't exist ++CF_CHECK_EXTERN_DATA($1,int) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23 ++dnl -------------------- ++dnl Check for existence of external data in the current set of libraries. If ++dnl we can modify it, it's real enough. ++dnl $1 = the name to check ++dnl $2 = its type ++AC_DEFUN([CF_CHECK_EXTERN_DATA], ++[ ++AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[ ++ AC_TRY_LINK([ ++#undef $1 ++extern $2 $1; ++], ++ [$1 = 2], ++ [cf_cv_have_$1=yes], ++ [cf_cv_have_$1=no]) ++]) ++ ++if test "$cf_cv_have_$1" = yes ; then ++ CF_UPPER(cf_result,have_$1) ++ AC_DEFINE_UNQUOTED($cf_result) ++fi ++ ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CHECK_HEADERS version: 3 updated: 2000/11/03 11:14:19 ++dnl ---------------- ++dnl AC_CHECK_HEADERS(sys/socket.h) fails on OS/2 EMX because it demands that ++dnl be included first. ++dnl ++dnl Also and and , but we normally do ++dnl not do our own tests via AC_CHECK_HEADERS for those. ++AC_DEFUN([CF_CHECK_HEADERS],[ ++for cf_hdr in $1 ++do ++ AC_MSG_CHECKING(for $cf_hdr) ++ AC_TRY_CPP([ ++#include ++#include <$cf_hdr> ++],[cf_found=yes],[cf_found=no]) ++AC_MSG_RESULT($cf_found) ++if test $cf_found = yes ; then ++ CF_UPPER(cf_tr_hdr,$cf_hdr) ++ AC_DEFINE_UNQUOTED(HAVE_${cf_tr_hdr}) ++fi ++done ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CHECK_IPV6 version: 2 updated: 2000/04/13 21:38:04 ++dnl ------------- ++dnl Check for IPV6 configuration. ++AC_DEFUN([CF_CHECK_IPV6],[ ++CF_FIND_IPV6_TYPE ++CF_FIND_IPV6_LIBS ++ ++CF_FUNC_GETADDRINFO ++ ++if test "$cf_cv_getaddrinfo" != "yes"; then ++ if test "$cf_cv_ipv6type" != "linux"; then ++ AC_MSG_ERROR( ++[You must get working getaddrinfo() function, ++or you can specify "--disable-ipv6"]) ++ else ++ AC_MSG_WARN( ++[The getaddrinfo() implementation on your system seems be buggy. ++You should upgrade your system library to the newest version ++of GNU C library (aka glibc).]) ++ fi ++fi ++ ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CHECK_NESTED_PARAMS version: 2 updated: 1997/08/28 23:57:55 ++dnl ---------------------- ++dnl Check if the compiler allows nested parameter lists (some don't) ++AC_DEFUN([CF_CHECK_NESTED_PARAMS], ++[ ++AC_MSG_CHECKING([if nested parameters work]) ++AC_CACHE_VAL(cf_cv_nested_params,[ ++ AC_TRY_COMPILE([], ++ [extern void (*sigdisp(int sig, void (*func)(int sig)))(int sig)], ++ [cf_cv_nested_params=yes], ++ [cf_cv_nested_params=no]) ++]) ++AC_MSG_RESULT($cf_cv_nested_params) ++test $cf_cv_nested_params = yes && AC_DEFINE(HAVE_NESTED_PARAMS) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_COLOR_CURSES version: 6 updated: 2002/10/27 18:21:42 ++dnl --------------- ++dnl Check if curses supports color. (Note that while SVr3 curses supports ++dnl color, it does this differently from SVr4 curses; more work would be needed ++dnl to accommodate SVr3). ++dnl ++AC_DEFUN([CF_COLOR_CURSES], ++[ ++AC_MSG_CHECKING(if curses supports color attributes) ++AC_CACHE_VAL(cf_cv_color_curses,[ ++ AC_TRY_LINK([ ++#include <${cf_cv_ncurses_header-curses.h}> ++], ++ [chtype x = COLOR_BLUE; ++ has_colors(); ++ start_color(); ++#ifndef NCURSES_BROKEN ++ wbkgd(curscr, getbkgd(stdscr)); /* X/Open XPG4 aka SVr4 Curses */ ++#endif ++ ], ++ [cf_cv_color_curses=yes], ++ [cf_cv_color_curses=no]) ++ ]) ++AC_MSG_RESULT($cf_cv_color_curses) ++if test $cf_cv_color_curses = yes ; then ++ AC_DEFINE(COLOR_CURSES) ++ test ".$cf_cv_ncurses_broken" != .yes && AC_DEFINE(HAVE_GETBKGD) ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_COMPTYPE version: 2 updated: 1997/08/28 23:57:55 ++dnl ----------- ++dnl Check if the compiler uses 'void *' for qsort's compare function parameters ++dnl (i.e., it's an ANSI prototype). ++AC_DEFUN([CF_COMPTYPE], ++[ ++AC_MSG_CHECKING([for ANSI qsort]) ++AC_CACHE_VAL(cf_cv_comptype,[ ++ AC_TRY_COMPILE([ ++#ifdef HAVE_STDLIB_H ++#include ++#endif], ++ [extern int compare(const void *, const void *); ++ char *foo = "string"; ++ qsort(foo, sizeof(foo)/sizeof(*foo), sizeof(*foo), compare)], ++ [cf_cv_comptype=yes], ++ [cf_cv_comptype=no]) ++]) ++AC_MSG_RESULT($cf_cv_comptype) ++if test $cf_cv_comptype = yes; then ++ AC_DEFINE(HAVE_COMPTYPE_VOID) ++else ++ AC_DEFINE(HAVE_COMPTYPE_CHAR) ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_COREFILE version: 2 updated: 1997/08/28 23:57:55 ++dnl ----------- ++dnl Check if the application can dump core (for debugging). ++AC_DEFUN([CF_COREFILE], ++[ ++AC_MSG_CHECKING([if application can dump core]) ++AC_CACHE_VAL(cf_cv_corefile,[ ++ AC_TRY_RUN([ ++#include ++#include ++#include ++int found() ++{ ++ struct stat sb; ++ return ((stat("core", &sb) == 0 /* UNIX */ ++ || stat("conftest.core", &sb) == 0 /* FreeBSD */ ++ ) ++ && ((sb.st_mode & S_IFMT) == S_IFREG)); ++} ++int main() ++{ ++#ifdef __amiga__ ++/* Nicholas d'Alterio (nagd@ic.ac.uk) reports that the check for ability to ++ * core dump causes the machine to crash - reason unknown (gcc 2.7.2) ++ */ ++ exit(1); ++#else ++ int pid, status; ++ if (found()) ++ unlink("core"); ++ if (found()) ++ exit(1); ++ if ((pid = fork()) != 0) { ++ while (wait(&status) <= 0) ++ ; ++ } else { ++ abort(); /* this will dump core, if anything will */ ++ } ++ if (found()) { ++ unlink("core"); ++ exit(0); ++ } ++ exit(1); ++#endif ++}], ++ [cf_cv_corefile=yes], ++ [cf_cv_corefile=no], ++ [cf_cv_corefile=unknown])]) ++AC_MSG_RESULT($cf_cv_corefile) ++test $cf_cv_corefile = yes && AC_DEFINE(HAVE_COREFILE) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CPP_CONCATS version: 2 updated: 1997/08/28 23:57:55 ++dnl -------------- ++dnl Test for ANSI token expansion (used in 'assert'). ++AC_DEFUN([CF_CPP_CONCATS], ++[ ++AC_MSG_CHECKING([for ansi token concatenation]) ++AC_CACHE_VAL(cf_cv_cpp_concats,[ ++ AC_TRY_COMPILE([ ++#define concat(a,b) a ## b], ++ [char *firstlast = "y", *s = concat(first,last)], ++ [cf_cv_cpp_concats=yes], ++ [cf_cv_cpp_concats=no]) ++]) ++AC_MSG_RESULT($cf_cv_cpp_concats) ++test $cf_cv_cpp_concats = yes && AC_DEFINE(CPP_DOES_CONCAT) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CPP_EXPANDS version: 2 updated: 1997/08/28 23:57:55 ++dnl -------------- ++dnl Test for ANSI token expansion (used in 'assert'). ++AC_DEFUN([CF_CPP_EXPANDS], ++[ ++AC_MSG_CHECKING([for ansi token expansion/substitution]) ++AC_CACHE_VAL(cf_cv_cpp_expands,[ ++ AC_TRY_COMPILE([ ++#define string(n) #n], ++ [char *s = string(token)], ++ [cf_cv_cpp_expands=yes], ++ [cf_cv_cpp_expands=no]) ++]) ++AC_MSG_RESULT($cf_cv_cpp_expands) ++test $cf_cv_cpp_expands = yes && AC_DEFINE(CPP_DOES_EXPAND) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CURSES_CPPFLAGS version: 7 updated: 2003/06/06 00:48:41 ++dnl ------------------ ++dnl Look for the curses headers. ++AC_DEFUN([CF_CURSES_CPPFLAGS],[ ++ ++AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[ ++cf_cv_curses_incdir=no ++case $host_os in #(vi ++hpux10.*|hpux11.*) #(vi ++ test -d /usr/include/curses_colr && \ ++ cf_cv_curses_incdir="-I/usr/include/curses_colr" ++ ;; ++sunos3*|sunos4*) ++ test -d /usr/5lib && \ ++ test -d /usr/5include && \ ++ cf_cv_curses_incdir="-I/usr/5include" ++ ;; ++esac ++]) ++test "$cf_cv_curses_incdir" != no && CPPFLAGS="$cf_cv_curses_incdir $CPPFLAGS" ++ ++AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[ ++cf_cv_ncurses_header=none ++for cf_header in \ ++ curses.h \ ++ ncurses.h \ ++ ncurses/curses.h \ ++ ncurses/ncurses.h ++do ++AC_TRY_COMPILE([#include <${cf_header}>], ++ [initscr(); tgoto("?", 0,0)], ++ [cf_cv_ncurses_header=$cf_header; break],[]) ++done ++]) ++ ++if test "$cf_cv_ncurses_header" = none ; then ++ AC_MSG_ERROR(No curses header-files found) ++fi ++ ++# cheat, to get the right #define's for HAVE_NCURSES_H, etc. ++AC_CHECK_HEADERS($cf_cv_ncurses_header) ++ ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CURSES_LIBS version: 22 updated: 2002/10/27 18:21:42 ++dnl -------------- ++dnl Look for the curses libraries. Older curses implementations may require ++dnl termcap/termlib to be linked as well. Call CF_CURSES_CPPFLAGS first. ++AC_DEFUN([CF_CURSES_LIBS],[ ++ ++AC_MSG_CHECKING(if we have identified curses libraries) ++AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], ++ [initscr(); tgoto("?", 0,0)], ++ cf_result=yes, ++ cf_result=no) ++AC_MSG_RESULT($cf_result) ++ ++if test "$cf_result" = no ; then ++case $host_os in #(vi ++freebsd*) #(vi ++ AC_CHECK_LIB(mytinfo,tgoto,[LIBS="-lmytinfo $LIBS"]) ++ ;; ++hpux10.*|hpux11.*) #(vi ++ AC_CHECK_LIB(cur_colr,initscr,[ ++ LIBS="-lcur_colr $LIBS" ++ ac_cv_func_initscr=yes ++ ],[ ++ AC_CHECK_LIB(Hcurses,initscr,[ ++ # HP's header uses __HP_CURSES, but user claims _HP_CURSES. ++ LIBS="-lHcurses $LIBS" ++ CPPFLAGS="-D__HP_CURSES -D_HP_CURSES $CPPFLAGS" ++ ac_cv_func_initscr=yes ++ ])]) ++ ;; ++linux*) # Suse Linux does not follow /usr/lib convention ++ LIBS="$LIBS -L/lib" ++ ;; ++sunos3*|sunos4*) ++ test -d /usr/5lib && \ ++ LIBS="$LIBS -L/usr/5lib -lcurses -ltermcap" ++ ac_cv_func_initscr=yes ++ ;; ++esac ++ ++if test ".$ac_cv_func_initscr" != .yes ; then ++ cf_save_LIBS="$LIBS" ++ cf_term_lib="" ++ cf_curs_lib="" ++ ++ if test ".${cf_cv_ncurses_version-no}" != .no ++ then ++ cf_check_list="ncurses curses cursesX" ++ else ++ cf_check_list="cursesX curses ncurses" ++ fi ++ ++ # Check for library containing tgoto. Do this before curses library ++ # because it may be needed to link the test-case for initscr. ++ AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[ ++ for cf_term_lib in $cf_check_list termcap termlib unknown ++ do ++ AC_CHECK_LIB($cf_term_lib,tgoto,[break]) ++ done ++ ]) ++ ++ # Check for library containing initscr ++ test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS" ++ for cf_curs_lib in $cf_check_list xcurses jcurses unknown ++ do ++ AC_CHECK_LIB($cf_curs_lib,initscr,[break]) ++ done ++ test $cf_curs_lib = unknown && AC_ERROR(no curses library found) ++ ++ LIBS="-l$cf_curs_lib $cf_save_LIBS" ++ if test "$cf_term_lib" = unknown ; then ++ AC_MSG_CHECKING(if we can link with $cf_curs_lib library) ++ AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], ++ [initscr()], ++ [cf_result=yes], ++ [cf_result=no]) ++ AC_MSG_RESULT($cf_result) ++ test $cf_result = no && AC_ERROR(Cannot link curses library) ++ elif test "$cf_curs_lib" = "$cf_term_lib" ; then ++ : ++ elif test "$cf_term_lib" != predefined ; then ++ AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries) ++ AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], ++ [initscr(); tgoto((char *)0, 0, 0);], ++ [cf_result=no], ++ [ ++ LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS" ++ AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], ++ [initscr()], ++ [cf_result=yes], ++ [cf_result=error]) ++ ]) ++ AC_MSG_RESULT($cf_result) ++ fi ++fi ++fi ++ ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CURSES_TERMCAP version: 10 updated: 2002/01/13 16:02:19 ++dnl ----------------- ++dnl Check if we should include to pick up prototypes for termcap ++dnl functions. On terminfo systems, these are normally declared in , ++dnl but may be in . We check for termcap.h as an alternate, but it ++dnl isn't standard (usually associated with GNU termcap). ++dnl ++dnl The 'tgoto()' function is declared in both terminfo and termcap. ++dnl ++dnl See CF_TYPE_OUTCHAR for more details. ++AC_DEFUN([CF_CURSES_TERMCAP], ++[ ++AC_REQUIRE([CF_CURSES_TERM_H]) ++AC_CACHE_CHECK(if we should include curses.h or termcap.h, cf_cv_need_curses_h,[ ++cf_save_CPPFLAGS="$CPPFLAGS" ++cf_cv_need_curses_h=no ++ ++for cf_t_opts in "" "NEED_TERMCAP_H" ++do ++for cf_c_opts in "" "NEED_CURSES_H" ++do ++ ++ CPPFLAGS="$cf_save_CPPFLAGS $CHECK_DECL_FLAG" ++ test -n "$cf_c_opts" && CPPFLAGS="$CPPFLAGS -D$cf_c_opts" ++ test -n "$cf_t_opts" && CPPFLAGS="$CPPFLAGS -D$cf_t_opts" ++ ++ AC_TRY_LINK([/* $cf_c_opts $cf_t_opts */ ++$CHECK_DECL_HDRS], ++ [char *x = (char *)tgoto("")], ++ [test "$cf_cv_need_curses_h" = no && { ++ cf_cv_need_curses_h=maybe ++ cf_ok_c_opts=$cf_c_opts ++ cf_ok_t_opts=$cf_t_opts ++ }], ++ [echo "Recompiling with corrected call (C:$cf_c_opts, T:$cf_t_opts)" >&AC_FD_CC ++ AC_TRY_LINK([ ++$CHECK_DECL_HDRS], ++ [char *x = (char *)tgoto("",0,0)], ++ [cf_cv_need_curses_h=yes ++ cf_ok_c_opts=$cf_c_opts ++ cf_ok_t_opts=$cf_t_opts])]) ++ ++ CPPFLAGS="$cf_save_CPPFLAGS" ++ test "$cf_cv_need_curses_h" = yes && break ++done ++ test "$cf_cv_need_curses_h" = yes && break ++done ++ ++if test "$cf_cv_need_curses_h" != no ; then ++ echo "Curses/termcap test = $cf_cv_need_curses_h (C:$cf_ok_c_opts, T:$cf_ok_t_opts)" >&AC_FD_CC ++ if test -n "$cf_ok_c_opts" ; then ++ if test -n "$cf_ok_t_opts" ; then ++ cf_cv_need_curses_h=both ++ else ++ cf_cv_need_curses_h=curses.h ++ fi ++ elif test -n "$cf_ok_t_opts" ; then ++ cf_cv_need_curses_h=termcap.h ++ elif test "$cf_cv_term_header" != no ; then ++ cf_cv_need_curses_h=term.h ++ else ++ cf_cv_need_curses_h=no ++ fi ++fi ++]) ++ ++case $cf_cv_need_curses_h in ++both) #(vi ++ AC_DEFINE_UNQUOTED(NEED_CURSES_H) ++ AC_DEFINE_UNQUOTED(NEED_TERMCAP_H) ++ ;; ++curses.h) #(vi ++ AC_DEFINE_UNQUOTED(NEED_CURSES_H) ++ ;; ++term.h) #(vi ++ AC_DEFINE_UNQUOTED(NEED_TERM_H) ++ ;; ++termcap.h) #(vi ++ AC_DEFINE_UNQUOTED(NEED_TERMCAP_H) ++ ;; ++esac ++ ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_CURSES_TERM_H version: 4 updated: 2002/01/12 17:08:23 ++dnl ---------------- ++dnl SVr4 curses should have term.h as well (where it puts the definitions of ++dnl the low-level interface). This may not be true in old/broken implementations, ++dnl as well as in misconfigured systems (e.g., gcc configured for Solaris 2.4 ++dnl running with Solaris 2.5.1). ++AC_DEFUN([CF_CURSES_TERM_H], ++[ ++AC_CACHE_CHECK(for term.h, cf_cv_term_header,[ ++for cf_header in \ ++ ncurses/term.h \ ++ term.h ++do ++ AC_TRY_COMPILE([ ++#include <${cf_cv_ncurses_header-curses.h}> ++#include <${cf_header}>], ++ [WINDOW *x], ++ [cf_cv_term_header=$cf_header], ++ [cf_cv_term_header=no]) ++done ++]) ++ ++case $cf_cv_term_header in #(vi ++term.h) #(vi ++ AC_DEFINE(HAVE_TERM_H) ++ ;; ++ncurses/term.h) ++ AC_DEFINE(HAVE_NCURSES_TERM_H) ++ ;; ++esac ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_DEFAULT_SHELL version: 5 updated: 2002/12/04 00:06:27 ++dnl ---------------- ++dnl Look for a Bourne-shell compatible program from a list that we know about: ++dnl ash Almquist Shell (sh based) ++dnl bash Bourne Again Shell (sh, ksh based) ++dnl dash Debian Almquist Shell (sh based) ++dnl jsh Job Control Bourne Shell (sh based) ++dnl keysh Key Shell (ksh based) ++dnl ksh Korn Shell (sh based) ++dnl pdksh Public-domain ksh ++dnl sh Bourne Shell or POSIX Shell ++dnl zsh Z Shell (sh, ksh based) ++dnl On BSD systems look for a C Shell compatible program: ++dnl csh C Shell ++dnl tcsh TENEX C Shell (csh based) ++AC_DEFUN([CF_DEFAULT_SHELL], ++[ ++AC_MSG_CHECKING(for the default shell program) ++cf_shell_progs="ifelse($1,,sh,[$1])" ++if test -z "$cf_shell_progs" ; then ++ cf_shell_progs="sh ksh bash zsh pdksh jsh keysh ash dash" ++ # TIN preferred default shell for BSD systems is csh. Others are sh. ++ AC_TRY_COMPILE([ ++#include ],[ ++#if (defined(BSD) && (BSD >= 199103)) ++#else ++make an error ++#endif ++],[$cf_shell_progs="csh tcsh $cf_shell_progs"]) ++fi ++CF_MSG_LOG(paths of shell programs: $cf_shell_progs) ++if test -s /etc/shells && test `egrep -c -v '^(#| | |$)' /etc/shells` -gt 0; then ++ CF_MSG_LOG(/etc/shells) ++ for cf_prog in $cf_shell_progs ++ do ++ case $cf_prog in ++ /*) ++ cf_pattern="^"$cf_prog"$" ++ ;; ++ */*) ++ AC_MSG_ERROR(Program name must be absolute or filename: $cf_prog) ++ ;; ++ *) ++ cf_pattern="/"$cf_prog"$" ++ ;; ++ esac ++ cf_path=`egrep $cf_pattern /etc/shells 2>/dev/null` ++ if test -n "$cf_path" ++ then ++ for cf_shell in $cf_path ++ do ++ if test -f "$cf_shell" ++ then ++ DEFAULT_SHELL="$cf_shell" ++ break ++ fi ++ done ++ fi ++ if test -n "$DEFAULT_SHELL" ++ then ++ break ++ fi ++ done ++ AC_MSG_RESULT($DEFAULT_SHELL) ++else ++ CF_MSG_LOG($PATH) ++AC_PATH_PROGS(DEFAULT_SHELL, ++ $cf_shell_progs,, ++ $PATH:/bin:/usr/bin:/usr/xpg4/bin:/bin/posix:/usr/bin/posix:/usr/old/bin:/usr/local/bin) ++fi ++if test -z "$DEFAULT_SHELL" ; then ++ AC_MSG_WARN( ++Cannot find the default shell you specified: $cf_shell_progs) ++ if test -f /bin/false ; then ++ AC_MSG_WARN(Using /bin/false instead) ++ DEFAULT_SHELL=/bin/false ++ else ++ AC_MSG_ERROR(Cannot use /bin/false because it does not exist) ++ fi ++fi ++AC_DEFINE_UNQUOTED(DEFAULT_SHELL,"$DEFAULT_SHELL") ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_DEFINE_STRING version: 2 updated: 2001/07/22 21:09:16 ++dnl ---------------- ++dnl Define a string which may contain escaped quotes or backslashes ++dnl $1 = symbol to define ++dnl $2 = the information we want to quote ++AC_DEFUN([CF_DEFINE_STRING], ++[ ++cf_define=`echo $2|sed -e 's/\\\\/\\\\134/g' -e 's/^[[ ]]\\+//' -e 's/[[ ]]\\+$//' -e 's/"/\\\\042/g'` ++AC_DEFINE_UNQUOTED($1, "$cf_define") ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52 ++dnl ---------- ++dnl "dirname" is not portable, so we fake it with a shell script. ++AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_DISABLE_ECHO version: 10 updated: 2003/04/17 22:27:11 ++dnl --------------- ++dnl You can always use "make -n" to see the actual options, but it's hard to ++dnl pick out/analyze warning messages when the compile-line is long. ++dnl ++dnl Sets: ++dnl ECHO_LT - symbol to control if libtool is verbose ++dnl ECHO_LD - symbol to prefix "cc -o" lines ++dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o) ++dnl SHOW_CC - symbol to put before explicit "cc -c" lines ++dnl ECHO_CC - symbol to put before any "cc" line ++dnl ++AC_DEFUN([CF_DISABLE_ECHO],[ ++AC_MSG_CHECKING(if you want to see long compiling messages) ++CF_ARG_DISABLE(echo, ++ [ --disable-echo display "compiling" commands], ++ [ ++ ECHO_LT='--silent' ++ ECHO_LD='@echo linking [$]@;' ++ RULE_CC=' @echo compiling [$]<' ++ SHOW_CC=' @echo compiling [$]@' ++ ECHO_CC='@' ++],[ ++ ECHO_LT='' ++ ECHO_LD='' ++ RULE_CC='# compiling' ++ SHOW_CC='# compiling' ++ ECHO_CC='' ++]) ++AC_MSG_RESULT($enableval) ++AC_SUBST(ECHO_LT) ++AC_SUBST(ECHO_LD) ++AC_SUBST(RULE_CC) ++AC_SUBST(SHOW_CC) ++AC_SUBST(ECHO_CC) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39 ++dnl -------- ++dnl Check if 'errno' is declared in ++AC_DEFUN([CF_ERRNO], ++[ ++CF_CHECK_ERRNO(errno) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_FIND_IPV6_LIBS version: 6 updated: 2002/11/09 09:05:18 ++dnl ----------------- ++dnl Based on the IPV6 stack type, look for the corresponding library. ++AC_DEFUN([CF_FIND_IPV6_LIBS],[ ++AC_REQUIRE([CF_FIND_IPV6_TYPE]) ++ ++cf_ipv6lib=none ++cf_ipv6dir=none ++ ++AC_MSG_CHECKING(for IPv6 library if required) ++case $cf_cv_ipv6type in #(vi ++solaris) #(vi ++ ;; ++inria) #(vi ++ ;; ++kame) #(vi ++ dnl http://www.kame.net/ ++ cf_ipv6lib=inet6 ++ cf_ipv6dir=v6 ++ ;; ++linux-glibc) #(vi ++ ;; ++linux-libinet6) #(vi ++ dnl http://www.v6.linux.or.jp/ ++ cf_ipv6lib=inet6 ++ cf_ipv6dir=inet6 ++ ;; ++toshiba) #(vi ++ cf_ipv6lib=inet6 ++ cf_ipv6dir=v6 ++ ;; ++v6d) #(vi ++ cf_ipv6lib=v6 ++ cf_ipv6dir=v6 ++ ;; ++zeta) ++ cf_ipv6lib=inet6 ++ cf_ipv6dir=v6 ++ ;; ++esac ++AC_MSG_RESULT($cf_ipv6lib) ++ ++if test "$cf_ipv6lib" != "none"; then ++ ++ AC_TRY_LINK([ ++#include ++#include ++#include ++#include ], ++ [getaddrinfo(0, 0, 0, 0)],,[ ++ CF_HEADER_PATH(cf_search,$cf_ipv6dir) ++ for cf_incdir in $cf_search ++ do ++ cf_header=$cf_incdir/netinet/ip6.h ++ if test -f $cf_header ++ then ++ CPPFLAGS="$CPPFLAGS -I$cf_incdir" ++ test -n "$verbose" && echo " ... found $cf_header" 1>&AC_FD_MSG ++ break ++ fi ++ test -n "$verbose" && echo " ... tested $cf_header" 1>&AC_FD_MSG ++ done ++ ]) ++ ++ CF_FIND_LIBRARY([$cf_ipv6lib],[$cf_ipv6dir],[ ++#include ++#include ++#include ++#include ], ++ [getaddrinfo(0, 0, 0, 0)], ++ [getaddrinfo], ++ noexit) ++ if test $cf_found_library = no ; then ++ AC_MSG_ERROR( ++[No $cf_ipv6lib library found, cannot continue. You must fetch lib$cf_ipv6lib.a ++from an appropriate IPv6 kit and compile beforehand.]) ++ fi ++fi ++ ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_FIND_IPV6_TYPE version: 5 updated: 2001/10/11 20:46:17 ++dnl ----------------- ++AC_DEFUN([CF_FIND_IPV6_TYPE],[ ++AC_CACHE_CHECK(ipv6 stack type, cf_cv_ipv6type, [ ++cf_cv_ipv6type=unknown ++for i in solaris inria kame linux-glibc linux-libinet6 toshiba v6d zeta ++do ++ case $i in #(vi ++ solaris) #(vi ++ if test "SunOS" = "`uname -s`" ++ then ++ if test -f /usr/include/netinet/ip6.h ++ then ++ cf_cv_ipv6type=$i ++ fi ++ fi ++ ;; ++ inria) #(vi ++ dnl http://www.kame.net/ ++ AC_EGREP_CPP(yes, [ ++#include ++#ifdef IPV6_INRIA_VERSION ++yes ++#endif], [cf_cv_ipv6type=$i]) ++ ;; ++ kame) #(vi ++ dnl http://www.kame.net/ ++ AC_EGREP_CPP(yes, [ ++#include ++#ifdef __KAME__ ++yes ++#endif], [cf_cv_ipv6type=$i]) ++ ;; ++ linux-glibc) #(vi ++ dnl http://www.v6.linux.or.jp/ ++ AC_EGREP_CPP(yes, [ ++#include ++#if defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1 ++yes ++#endif], [cf_cv_ipv6type=$i]) ++ ;; ++ linux-libinet6) #(vi ++ dnl http://www.v6.linux.or.jp/ ++ if test -d /usr/inet6 ++ then ++ cf_cv_ipv6type=$i ++ elif test -f /usr/include/netinet/ip6.h ++ then ++ cf_cv_ipv6type=$i ++ fi ++ ;; ++ toshiba) #(vi ++ AC_EGREP_CPP(yes, [ ++#include ++#ifdef _TOSHIBA_INET6 ++yes ++#endif], [cf_cv_ipv6type=$i]) ++ ;; ++ v6d) #(vi ++ AC_EGREP_CPP(yes, [ ++#include ++#ifdef __V6D__ ++yes ++#endif], [cf_cv_ipv6type=$i]) ++ ;; ++ zeta) ++ AC_EGREP_CPP(yes, [ ++#include ++#ifdef _ZETA_MINAMI_INET6 ++yes ++#endif], [cf_cv_ipv6type=$i]) ++ ;; ++ esac ++ if test "$cf_cv_ipv6type" != "unknown"; then ++ break ++ fi ++done ++]) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_FIND_LIBRARY version: 7 updated: 2000/04/13 21:38:04 ++dnl --------------- ++dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We ++dnl prefer a standard location, and use -L options only if we do not find the ++dnl library in the standard library location(s). ++dnl $1 = library name ++dnl $2 = library class, usually the same as library name ++dnl $3 = includes ++dnl $4 = code fragment to compile/link ++dnl $5 = corresponding function-name ++dnl $6 = flag, nonnull if failure causes an error-exit ++dnl ++dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had ++dnl to use a -L option. ++AC_DEFUN([CF_FIND_LIBRARY], ++[ ++ eval 'cf_cv_have_lib_'$1'=no' ++ cf_libdir="" ++ AC_CHECK_FUNC($5, ++ eval 'cf_cv_have_lib_'$1'=yes',[ ++ cf_save_LIBS="$LIBS" ++ AC_MSG_CHECKING(for $5 in -l$1) ++ LIBS="-l$1 $LIBS" ++ AC_TRY_LINK([$3],[$4], ++ [AC_MSG_RESULT(yes) ++ eval 'cf_cv_have_lib_'$1'=yes' ++ ], ++ [AC_MSG_RESULT(no) ++ CF_LIBRARY_PATH(cf_search,$2) ++ for cf_libdir in $cf_search ++ do ++ AC_MSG_CHECKING(for -l$1 in $cf_libdir) ++ LIBS="-L$cf_libdir -l$1 $cf_save_LIBS" ++ AC_TRY_LINK([$3],[$4], ++ [AC_MSG_RESULT(yes) ++ eval 'cf_cv_have_lib_'$1'=yes' ++ break], ++ [AC_MSG_RESULT(no) ++ LIBS="$cf_save_LIBS"]) ++ done ++ ]) ++ ]) ++eval 'cf_found_library=[$]cf_cv_have_lib_'$1 ++ifelse($6,,[ ++if test $cf_found_library = no ; then ++ AC_ERROR(Cannot link $1 library) ++fi ++]) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_FIX_SLASHES version: 2 updated: 2001/05/27 21:36:02 ++dnl -------------- ++dnl OS/2 and Cygwin ports may pick up backslashes in pathnames, which are not ++dnl usable in quoted strings. Fix them. ++dnl $1=fixed($2) ++AC_DEFUN([CF_FIX_SLASHES], ++[ ++case $cf_cv_system_name in #(vi ++os2*|cygwin*) ++ $1=`echo "[$]$1" | sed -e 's%\\\\%/%g'` ++ ;; ++esac ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_FUNC_FORK version: 2 updated: 1997/08/28 23:57:55 ++dnl ------------ ++dnl Check if 'fork()' is available, and working. Amiga (and possibly other ++dnl machines) have a non-working 'fork()' entrypoint. ++AC_DEFUN([CF_FUNC_FORK], ++[AC_MSG_CHECKING([for fork]) ++AC_CACHE_VAL(cf_cv_func_fork,[ ++AC_TRY_RUN([ ++int main() ++{ ++ if (fork() < 0) ++ exit(1); ++ exit(0); ++}], [cf_cv_func_fork=yes], ++ [cf_cv_func_fork=no], ++ [cf_cv_func_fork=unknown]) ++])dnl ++AC_MSG_RESULT($cf_cv_func_fork) ++test $cf_cv_func_fork = yes && AC_DEFINE(HAVE_FORK) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_FUNC_GETADDRINFO version: 5 updated: 2000/09/28 06:18:08 ++dnl ------------------- ++dnl Look for a working version of getaddrinfo(), for IPV6 support. ++AC_DEFUN([CF_FUNC_GETADDRINFO],[ ++AC_CACHE_CHECK(working getaddrinfo, cf_cv_getaddrinfo,[ ++AC_TRY_RUN([ ++#include ++#include ++#include ++#include ++#include ++ ++#define expect(a,b) if (strcmp(a,b) != 0) goto bad ++ ++int main() ++{ ++ int passive, gaierr, inet4 = 0, inet6 = 0; ++ struct addrinfo hints, *ai, *aitop; ++ char straddr[INET6_ADDRSTRLEN], strport[16]; ++ ++ for (passive = 0; passive <= 1; passive++) { ++ memset(&hints, 0, sizeof(hints)); ++ hints.ai_family = AF_UNSPEC; ++ hints.ai_flags = passive ? AI_PASSIVE : 0; ++ hints.ai_socktype = SOCK_STREAM; ++ if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) { ++ (void)gai_strerror(gaierr); ++ goto bad; ++ } ++ for (ai = aitop; ai; ai = ai->ai_next) { ++ if (ai->ai_addr == NULL || ++ ai->ai_addrlen == 0 || ++ getnameinfo(ai->ai_addr, ai->ai_addrlen, ++ straddr, sizeof(straddr), strport, sizeof(strport), ++ NI_NUMERICHOST|NI_NUMERICSERV) != 0) { ++ goto bad; ++ } ++ switch (ai->ai_family) { ++ case AF_INET: ++ expect(strport, "54321"); ++ if (passive) { ++ expect(straddr, "0.0.0.0"); ++ } else { ++ expect(straddr, "127.0.0.1"); ++ } ++ inet4++; ++ break; ++ case AF_INET6: ++ expect(strport, "54321"); ++ if (passive) { ++ expect(straddr, "::"); ++ } else { ++ expect(straddr, "::1"); ++ } ++ inet6++; ++ break; ++ case AF_UNSPEC: ++ goto bad; ++ break; ++ default: ++ /* another family support? */ ++ break; ++ } ++ } ++ } ++ ++ if (!(inet4 == 0 || inet4 == 2)) ++ goto bad; ++ if (!(inet6 == 0 || inet6 == 2)) ++ goto bad; ++ ++ if (aitop) ++ freeaddrinfo(aitop); ++ exit(0); ++ ++ bad: ++ if (aitop) ++ freeaddrinfo(aitop); ++ exit(1); ++} ++], ++[cf_cv_getaddrinfo=yes], ++[cf_cv_getaddrinfo=no], ++[cf_cv_getaddrinfo=unknown]) ++]) ++if test "$cf_cv_getaddrinfo" = yes ; then ++ AC_DEFINE(HAVE_GAI_STRERROR) ++ AC_DEFINE(HAVE_GETADDRINFO) ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_FUNC_MEMMOVE version: 5 updated: 2000/08/12 23:18:52 ++dnl --------------- ++dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither ++dnl is found, add our own version of memmove to the list of objects. ++AC_DEFUN([CF_FUNC_MEMMOVE], ++[ ++AC_CHECK_FUNC(memmove,,[ ++AC_CHECK_FUNC(bcopy,[ ++ AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[ ++ AC_TRY_RUN([ ++int main() { ++ static char data[] = "abcdefghijklmnopqrstuwwxyz"; ++ char temp[40]; ++ bcopy(data, temp, sizeof(data)); ++ bcopy(temp+10, temp, 15); ++ bcopy(temp+5, temp+15, 10); ++ exit (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz")); ++} ++ ], ++ [cf_cv_good_bcopy=yes], ++ [cf_cv_good_bcopy=no], ++ [cf_cv_good_bcopy=unknown]) ++ ]) ++ ],[cf_cv_good_bcopy=no]) ++ if test "$cf_cv_good_bcopy" = yes ; then ++ AC_DEFINE(USE_OK_BCOPY) ++ else ++ AC_DEFINE(USE_MY_MEMMOVE) ++ fi ++])])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_FUNC_SYSTEM version: 3 updated: 1997/10/22 22:02:10 ++dnl -------------- ++dnl Check if the 'system()' function returns a usable status, or if not, try ++dnl to use the status returned by a SIGCHLD. ++AC_DEFUN([CF_FUNC_SYSTEM], ++[ ++AC_REQUIRE([CF_UNION_WAIT]) ++AC_MSG_CHECKING(if the system function returns usable child-status) ++AC_CACHE_VAL(cf_cv_system_status,[ ++ AC_TRY_RUN([ ++#include ++#include ++#if HAVE_SYS_WAIT_H ++#include ++#endif ++ ++RETSIGTYPE signal_handler (int sig) ++{ ++#if HAVE_TYPE_UNIONWAIT ++ union wait wait_status; ++#else ++ int wait_status = 1; ++#endif ++ int system_status; ++ wait (&wait_status); ++ system_status = WEXITSTATUS(wait_status); /* should be nonzero */ ++ exit(system_status != 23); ++} ++ ++int main() ++{ ++ /* this looks weird, but apparently the SIGCHLD gets there first on ++ * machines where 'system()' doesn't return a usable code, so ... ++ */ ++ signal (SIGCHLD, signal_handler); ++ system("exit 23"); ++ exit(1); ++} ++], ++ [cf_cv_system_status=no], ++ [AC_TRY_RUN( ++ [int main() { exit(system("exit 23") != (23 << 8)); }], ++ [cf_cv_system_status=yes], ++ [cf_cv_system_status=unknown], ++ [cf_cv_system_status=unknown])], ++ [cf_cv_system_status=unknown]) ++]) ++AC_MSG_RESULT($cf_cv_system_status) ++test $cf_cv_system_status = no && AC_DEFINE(USE_SYSTEM_STATUS) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_GCC_VERSION version: 2 updated: 2003/05/24 15:01:41 ++dnl -------------- ++dnl Find version of gcc ++AC_DEFUN([CF_GCC_VERSION],[ ++AC_REQUIRE([AC_PROG_CC]) ++GCC_VERSION=none ++if test "$GCC" = yes ; then ++ AC_MSG_CHECKING(version of $CC) ++ GCC_VERSION="`${CC} --version|head -1 | sed -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`" ++ test -z "$GCC_VERSION" && GCC_VERSION=unknown ++ AC_MSG_RESULT($GCC_VERSION) ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_GCC_WARNINGS version: 14 updated: 2003/05/24 15:03:15 ++dnl --------------- ++dnl Check if the compiler supports useful warning options. There's a few that ++dnl we don't use, simply because they're too noisy: ++dnl ++dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x) ++dnl -Wredundant-decls (system headers make this too noisy) ++dnl -Wtraditional (combines too many unrelated messages, only a few useful) ++dnl -Wwrite-strings (too noisy, but should review occasionally). This ++dnl is enabled for ncurses using "--enable-const". ++dnl -pedantic ++dnl ++AC_DEFUN([CF_GCC_WARNINGS], ++[ ++AC_REQUIRE([CF_GCC_VERSION]) ++if ( test "$GCC" = yes || test "$GXX" = yes ) ++then ++ cat > conftest.$ac_ext <],[ ++#ifndef _XOPEN_SOURCE ++make an error ++#endif], ++ [cf_cv_gnu_source=no], ++ [cf_save="$CPPFLAGS" ++ CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" ++ AC_TRY_COMPILE([#include ],[ ++#ifdef _XOPEN_SOURCE ++make an error ++#endif], ++ [cf_cv_gnu_source=no], ++ [cf_cv_gnu_source=yes]) ++ CPPFLAGS="$cf_save" ++ ]) ++]) ++test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_HEADER_PATH version: 8 updated: 2002/11/10 14:46:59 ++dnl -------------- ++dnl Construct a search-list for a nonstandard header-file ++AC_DEFUN([CF_HEADER_PATH], ++[CF_SUBDIR_PATH($1,$2,include) ++test "$includedir" != NONE && \ ++test "$includedir" != "/usr/include" && \ ++test -d "$includedir" && { ++ test -d $includedir && $1="[$]$1 $includedir" ++ test -d $includedir/$2 && $1="[$]$1 $includedir/$2" ++} ++ ++test "$oldincludedir" != NONE && \ ++test "$oldincludedir" != "/usr/include" && \ ++test -d "$oldincludedir" && { ++ test -d $oldincludedir && $1="[$]$1 $oldincludedir" ++ test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2" ++} ++ ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_LIBRARY_PATH version: 7 updated: 2002/11/10 14:46:59 ++dnl --------------- ++dnl Construct a search-list for a nonstandard library-file ++AC_DEFUN([CF_LIBRARY_PATH], ++[CF_SUBDIR_PATH($1,$2,lib)])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48 ++dnl ------------- ++dnl Compute the library-prefix for the given host system ++dnl $1 = variable to set ++AC_DEFUN([CF_LIB_PREFIX], ++[ ++ case $cf_cv_system_name in ++ OS/2*) LIB_PREFIX='' ;; ++ os2*) LIB_PREFIX='' ;; ++ *) LIB_PREFIX='lib' ;; ++ esac ++ifelse($1,,,[$1=$LIB_PREFIX]) ++ AC_SUBST(LIB_PREFIX) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_LOCKFILE version: 2 updated: 2001/05/26 12:41:02 ++dnl ----------- ++dnl Check for functions that we can use for file-locking. Simply checking for ++dnl existence is not sufficient, since fcntl, for example, uses definitions ++dnl that are not in every version of the header. ++AC_DEFUN([CF_LOCKFILE], ++[ ++AC_CHECK_HEADERS(unistd.h fcntl.h sys/file.h) ++AC_CHECK_FUNC(fcntl) ++AC_CHECK_FUNC(lockf) ++AC_CHECK_FUNC(flock,,,[ ++ CF_RECHECK_FUNC(flock,bsd,cf_cv_lockfile,[AC_MSG_WARN(no lock function found)])]) ++ ++AC_CACHE_CHECK(for file-locking functions,cf_cv_lockfile,[ ++cf_cv_lockfile= ++for cf_lock in fcntl lockf flock ++do ++if eval 'test ${ac_cv_func_'$cf_lock'+set} = set'; then ++ case $cf_lock in #(vi ++ fcntl) #(vi ++ AC_TRY_COMPILE([ ++#include ++#ifdef HAVE_UNISTD_H ++#include ++#endif ++#ifdef HAVE_FCNTL_H ++#include ++#endif ++],[ ++ struct flock flk; ++ int block = 1; ++ int fd = 0; ++ int rc; ++ ++ flk.l_type = F_WRLCK; ++ flk.l_whence = SEEK_SET; ++ flk.l_start = 0; ++ flk.l_len = 0; ++ rc = fcntl(fd, block ? F_SETLKW : F_SETLK, &flk) ++ && fcntl(fd, F_GETLK, &flk) ++ && fcntl(fd, F_SETLK, &flk); ++ ],,continue) ++ ;; ++ lockf) #(vi ++ AC_TRY_COMPILE([ ++#include ++#ifdef HAVE_UNISTD_H ++#include ++#endif ++#ifdef HAVE_FCNTL_H ++#include ++#endif ++],[ ++ int block = 1, fd = 0; ++ int ret = lockf(fd, block ? F_LOCK : F_TLOCK, 0L) ++ && lockf(fd, F_TEST, 0L) ++ && lockf(fd, F_ULOCK, 0L); ++ ],,[continue]) ++ ;; ++ flock) ++ AC_TRY_COMPILE([ ++#include ++#ifdef HAVE_UNISTD_H ++#include ++#endif ++#ifdef HAVE_FCNTL_H ++#include ++#endif ++#ifdef HAVE_SYS_FILE_H ++#include ++#endif ++],[ ++ int block = 1, fd = 0; ++ int ret = flock(fd, (LOCK_EX|LOCK_NB)) ++ && flock(fd, LOCK_UN) ++ && flock(fd, block ? LOCK_EX : (LOCK_EX | LOCK_NB)); ++ ],,[continue]) ++ ;; ++ esac ++ cf_cv_lockfile="$cf_cv_lockfile $cf_lock" ++fi ++done ++]) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_MAKEFLAGS version: 9 updated: 2001/12/30 18:17:27 ++dnl ------------ ++dnl Some 'make' programs support $(MAKEFLAGS), some $(MFLAGS), to pass 'make' ++dnl options to lower-levels. It's very useful for "make -n" -- if we have it. ++dnl (GNU 'make' does both, something POSIX 'make', which happens to make the ++dnl $(MAKEFLAGS) variable incompatible because it adds the assignments :-) ++AC_DEFUN([CF_MAKEFLAGS], ++[ ++AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[ ++ cf_cv_makeflags='' ++ for cf_option in '-$(MAKEFLAGS)' '$(MFLAGS)' ++ do ++ cat >cf_makeflags.tmp </dev/null` ++ case "$cf_result" in ++ .*k) ++ cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null` ++ case "$cf_result" in ++ .*CC=*) cf_cv_makeflags= ++ ;; ++ *) cf_cv_makeflags=$cf_option ++ ;; ++ esac ++ break ++ ;; ++ *) echo no match "$cf_result" ++ ;; ++ esac ++ done ++ rm -f cf_makeflags.tmp ++]) ++ ++AC_SUBST(cf_cv_makeflags) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_MSG_LOG version: 3 updated: 1997/09/07 14:05:52 ++dnl ---------- ++dnl Write a debug message to config.log, along with the line number in the ++dnl configure script. ++AC_DEFUN([CF_MSG_LOG],[ ++echo "(line __oline__) testing $* ..." 1>&AC_FD_CC ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_NCURSES_BROKEN version: 6 updated: 1998/04/27 20:32:34 ++dnl ----------------- ++dnl Check for pre-1.9.9g ncurses (among other problems, the most obvious is ++dnl that color combinations don't work). ++AC_DEFUN([CF_NCURSES_BROKEN], ++[ ++AC_REQUIRE([CF_NCURSES_VERSION]) ++if test "$cf_cv_ncurses_version" != no ; then ++AC_MSG_CHECKING(for obsolete/broken version of ncurses) ++AC_CACHE_VAL(cf_cv_ncurses_broken,[ ++AC_TRY_COMPILE([ ++#include <${cf_cv_ncurses_header-curses.h}>],[ ++#if defined(NCURSES_VERSION) && defined(wgetbkgd) ++ make an error ++#else ++ int x = 1 ++#endif ++], ++ [cf_cv_ncurses_broken=no], ++ [cf_cv_ncurses_broken=yes]) ++]) ++AC_MSG_RESULT($cf_cv_ncurses_broken) ++if test "$cf_cv_ncurses_broken" = yes ; then ++ AC_MSG_WARN(hmm... you should get an up-to-date version of ncurses) ++ AC_DEFINE(NCURSES_BROKEN) ++fi ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_NCURSES_CC_CHECK version: 3 updated: 2003/01/12 18:59:28 ++dnl ------------------- ++dnl Check if we can compile with ncurses' header file ++dnl $1 is the cache variable to set ++dnl $2 is the header-file to include ++dnl $3 is the root name (ncurses or ncursesw) ++AC_DEFUN([CF_NCURSES_CC_CHECK],[ ++ AC_TRY_COMPILE([ ++]ifelse($3,ncursesw,[ ++#define _XOPEN_SOURCE_EXTENDED ++#undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */ ++#define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */ ++])[ ++#include <$2>],[ ++#ifdef NCURSES_VERSION ++]ifelse($3,ncursesw,[ ++#ifndef WACS_BSSB ++ make an error ++#endif ++])[ ++printf("%s\n", NCURSES_VERSION); ++#else ++#ifdef __NCURSES_H ++printf("old\n"); ++#else ++ make an error ++#endif ++#endif ++ ] ++ ,[$1=$cf_header] ++ ,[$1=no]) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_NCURSES_CPPFLAGS version: 16 updated: 2002/12/29 18:30:46 ++dnl ------------------- ++dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting ++dnl the CPPFLAGS variable so we can include its header. ++dnl ++dnl The header files may be installed as either curses.h, or ncurses.h (would ++dnl be obsolete, except that some packagers prefer this name to distinguish it ++dnl from a "native" curses implementation). If not installed for overwrite, ++dnl the curses.h file would be in an ncurses subdirectory (e.g., ++dnl /usr/include/ncurses), but someone may have installed overwriting the ++dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd ++dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in ++dnl the header. ++dnl ++dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header ++dnl is already in the include-path, don't even bother with this, since we cannot ++dnl easily determine which file it is. In this case, it has to be . ++dnl ++dnl The optional parameter gives the root name of the library, in case it is ++dnl not installed as the default curses library. That is how the ++dnl wide-character version of ncurses is installed. ++AC_DEFUN([CF_NCURSES_CPPFLAGS], ++[AC_REQUIRE([CF_WITH_CURSES_DIR]) ++ ++cf_ncuhdr_root=ifelse($1,,ncurses,$1) ++ ++test -n "$cf_cv_curses_dir" && \ ++test "$cf_cv_curses_dir" != "no" && \ ++CPPFLAGS="-I$cf_cv_curses_dir/include -I$cf_cv_curses_dir/include/$cf_ncuhdr_root $CPPFLAGS" ++ ++AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[ ++ cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h" ++ ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h" ++ for cf_header in $cf_header_list ++ do ++ CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1) ++ test "$cf_cv_ncurses_h" != no && break ++ done ++]) ++ ++if test "$cf_cv_ncurses_h" != no ; then ++ cf_cv_ncurses_header=$cf_cv_ncurses_h ++else ++AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[ ++ test -n "$verbose" && echo ++ CF_HEADER_PATH(cf_search,$cf_ncuhdr_root) ++ test -n "$verbose" && echo search path $cf_search ++ cf_save2_CPPFLAGS="$CPPFLAGS" ++ for cf_incdir in $cf_search ++ do ++ CF_ADD_INCDIR($cf_incdir) ++ for cf_header in \ ++ ncurses.h \ ++ curses.h ++ do ++ CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1) ++ if test "$cf_cv_ncurses_h2" != no ; then ++ cf_cv_ncurses_h2=$cf_incdir/$cf_header ++ test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&AC_FD_MSG ++ break ++ fi ++ test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG ++ done ++ CPPFLAGS="$cf_save2_CPPFLAGS" ++ test "$cf_cv_ncurses_h2" != no && break ++ done ++ test "$cf_cv_ncurses_h2" = no && AC_ERROR(not found) ++ ]) ++ ++ CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2) ++ cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2` ++ if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then ++ cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header ++ fi ++ CF_ADD_INCDIR($cf_1st_incdir) ++ ++fi ++ ++AC_DEFINE(NCURSES) ++ ++case $cf_cv_ncurses_header in # (vi ++*ncurses.h) ++ AC_DEFINE(HAVE_NCURSES_H) ++ ;; ++esac ++ ++case $cf_cv_ncurses_header in # (vi ++ncurses/curses.h|ncurses/ncurses.h) ++ AC_DEFINE(HAVE_NCURSES_NCURSES_H) ++ ;; ++ncursesw/curses.h|ncursesw/ncurses.h) ++ AC_DEFINE(HAVE_NCURSESW_NCURSES_H) ++ ;; ++esac ++ ++CF_NCURSES_VERSION ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_NCURSES_LIBS version: 11 updated: 2002/12/22 14:22:25 ++dnl --------------- ++dnl Look for the ncurses library. This is a little complicated on Linux, ++dnl because it may be linked with the gpm (general purpose mouse) library. ++dnl Some distributions have gpm linked with (bsd) curses, which makes it ++dnl unusable with ncurses. However, we don't want to link with gpm unless ++dnl ncurses has a dependency, since gpm is normally set up as a shared library, ++dnl and the linker will record a dependency. ++dnl ++dnl The optional parameter gives the root name of the library, in case it is ++dnl not installed as the default curses library. That is how the ++dnl wide-character version of ncurses is installed. ++AC_DEFUN([CF_NCURSES_LIBS], ++[AC_REQUIRE([CF_NCURSES_CPPFLAGS]) ++ ++cf_nculib_root=ifelse($1,,ncurses,$1) ++ # This works, except for the special case where we find gpm, but ++ # ncurses is in a nonstandard location via $LIBS, and we really want ++ # to link gpm. ++cf_ncurses_LIBS="" ++cf_ncurses_SAVE="$LIBS" ++AC_CHECK_LIB(gpm,Gpm_Open, ++ [AC_CHECK_LIB(gpm,initscr, ++ [LIBS="$cf_ncurses_SAVE"], ++ [cf_ncurses_LIBS="-lgpm"])]) ++ ++case $host_os in #(vi ++freebsd*) ++ # This is only necessary if you are linking against an obsolete ++ # version of ncurses (but it should do no harm, since it's static). ++ AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"]) ++ ;; ++esac ++ ++LIBS="$cf_ncurses_LIBS $LIBS" ++ ++if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" ) ++then ++ LIBS="-L$cf_cv_curses_dir/lib -l$cf_nculib_root $LIBS" ++else ++ CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root, ++ [#include <${cf_cv_ncurses_header-curses.h}>], ++ [initscr()], ++ initscr) ++fi ++ ++if test -n "$cf_ncurses_LIBS" ; then ++ AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS) ++ cf_ncurses_SAVE="$LIBS" ++ for p in $cf_ncurses_LIBS ; do ++ q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"` ++ if test "$q" != "$LIBS" ; then ++ LIBS="$q" ++ fi ++ done ++ AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], ++ [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);], ++ [AC_MSG_RESULT(yes)], ++ [AC_MSG_RESULT(no) ++ LIBS="$cf_ncurses_SAVE"]) ++fi ++ ++CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root) ++AC_DEFINE_UNQUOTED($cf_nculib_ROOT) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_NCURSES_VERSION version: 10 updated: 2002/10/27 18:21:42 ++dnl ------------------ ++dnl Check for the version of ncurses, to aid in reporting bugs, etc. ++dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use ++dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi. ++AC_DEFUN([CF_NCURSES_VERSION], ++[ ++AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[ ++ cf_cv_ncurses_version=no ++ cf_tempfile=out$$ ++ rm -f $cf_tempfile ++ AC_TRY_RUN([ ++#include <${cf_cv_ncurses_header-curses.h}> ++#include ++int main() ++{ ++ FILE *fp = fopen("$cf_tempfile", "w"); ++#ifdef NCURSES_VERSION ++# ifdef NCURSES_VERSION_PATCH ++ fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH); ++# else ++ fprintf(fp, "%s\n", NCURSES_VERSION); ++# endif ++#else ++# ifdef __NCURSES_H ++ fprintf(fp, "old\n"); ++# else ++ make an error ++# endif ++#endif ++ exit(0); ++}],[ ++ cf_cv_ncurses_version=`cat $cf_tempfile`],,[ ++ ++ # This will not work if the preprocessor splits the line after the ++ # Autoconf token. The 'unproto' program does that. ++ cat > conftest.$ac_ext < ++#undef Autoconf ++#ifdef NCURSES_VERSION ++Autoconf NCURSES_VERSION ++#else ++#ifdef __NCURSES_H ++Autoconf "old" ++#endif ++; ++#endif ++EOF ++ cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out" ++ AC_TRY_EVAL(cf_try) ++ if test -f conftest.out ; then ++ cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'` ++ test -n "$cf_out" && cf_cv_ncurses_version="$cf_out" ++ rm -f conftest.out ++ fi ++]) ++ rm -f $cf_tempfile ++]) ++test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_NETLIBS version: 4 updated: 1999/12/23 15:20:39 ++dnl ---------- ++dnl After checking for functions in the default $LIBS, make a further check ++dnl for the functions that are netlib-related (these aren't always in the ++dnl libc, etc., and have to be handled specially because there are conflicting ++dnl and broken implementations. ++dnl Common library requirements (in order): ++dnl -lresolv -lsocket -lnsl ++dnl -lnsl -lsocket ++dnl -lsocket ++dnl -lbsd ++AC_DEFUN([CF_NETLIBS],[ ++cf_test_netlibs=no ++AC_MSG_CHECKING(for network libraries) ++AC_CACHE_VAL(cf_cv_netlibs,[ ++AC_MSG_RESULT(working...) ++cf_cv_netlibs="" ++cf_test_netlibs=yes ++AC_CHECK_FUNCS(gethostname,,[ ++ CF_RECHECK_FUNC(gethostname,nsl,cf_cv_netlibs,[ ++ CF_RECHECK_FUNC(gethostname,socket,cf_cv_netlibs)])]) ++# ++# FIXME: sequent needs this library (i.e., -lsocket -linet -lnsl), but ++# I don't know the entrypoints - 97/7/22 TD ++# AC_HAVE_LIBRARY(inet,cf_cv_netlibs="-linet $cf_cv_netlibs") ++AC_CHECK_LIB(inet, main, cf_cv_netlibs="-linet $cf_cv_netlibs") ++# ++if test "$ac_cv_func_lsocket" != no ; then ++AC_CHECK_FUNCS(socket,,[ ++ CF_RECHECK_FUNC(socket,socket,cf_cv_netlibs,[ ++ CF_RECHECK_FUNC(socket,bsd,cf_cv_netlibs)])]) ++fi ++# ++AC_CHECK_FUNCS(gethostbyname,,[ ++ CF_RECHECK_FUNC(gethostbyname,nsl,cf_cv_netlibs)]) ++# ++AC_CHECK_FUNCS(strcasecmp,,[ ++ CF_RECHECK_FUNC(strcasecmp,resolv,cf_cv_netlibs)]) ++]) ++LIBS="$LIBS $cf_cv_netlibs" ++test $cf_test_netlibs = no && echo "$cf_cv_netlibs" >&AC_FD_MSG ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_OUR_MESSAGES version: 4 updated: 2003/06/06 00:48:41 ++dnl --------------- ++dnl Check if we use the messages included with this program ++dnl ++dnl $1 specifies either Makefile or makefile, defaulting to the former. ++dnl ++dnl Sets variables which can be used to substitute in makefiles: ++dnl MSG_DIR_MAKE - to make ./po directory ++dnl SUB_MAKEFILE - makefile in ./po directory (see CF_BUNDLED_INTL) ++dnl ++AC_DEFUN([CF_OUR_MESSAGES], ++[ ++cf_makefile=ifelse($1,,Makefile,$1) ++ ++use_our_messages=no ++if test "$USE_NLS" = yes ; then ++if test -d $srcdir/po ; then ++AC_MSG_CHECKING(if we should use included message-library) ++ AC_ARG_ENABLE(included-msgs, ++ [ --enable-included-msgs use included messages, for i18n support], ++ [use_our_messages=$enableval], ++ [use_our_messages=yes]) ++fi ++AC_MSG_RESULT($use_our_messages) ++fi ++ ++MSG_DIR_MAKE="#" ++if test "$use_our_messages" = yes ++then ++ SUB_MAKEFILE="$SUB_MAKEFILE po/$cf_makefile.in:po/$cf_makefile.inn" ++ MSG_DIR_MAKE= ++fi ++ ++AC_SUBST(MSG_DIR_MAKE) ++AC_SUBST(SUB_MAKEFILE) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53 ++dnl ---------- ++dnl Provide a value for the $PATH and similar separator ++AC_DEFUN([CF_PATHSEP], ++[ ++ case $cf_cv_system_name in ++ os2*) PATHSEP=';' ;; ++ *) PATHSEP=':' ;; ++ esac ++ifelse($1,,,[$1=$PATHSEP]) ++ AC_SUBST(PATHSEP) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_PATH_EDITOR version: 5 updated: 2000/07/20 00:41:18 ++dnl -------------- ++dnl Look for the default editor (vi) ++AC_DEFUN([CF_PATH_EDITOR], ++[ ++AC_MSG_CHECKING(for default editor) ++CF_ARG_WITH(editor, ++ [ --with-editor=PROG specify editor], ++ [DEFAULT_EDITOR],,vi) ++if test -z "$DEFAULT_EDITOR" ; then ++ if test -n "$EDITOR" ; then ++ DEFAULT_EDITOR="$EDITOR" ++ elif test -n "$VISUAL" ; then ++ DEFAULT_EDITOR="$VISUAL" ++ else ++ AC_PATH_PROG(DEFAULT_EDITOR,vi,vi,$PATH:/usr/bin:/usr/ucb) ++ fi ++fi ++AC_MSG_RESULT($DEFAULT_EDITOR) ++AC_DEFINE_UNQUOTED(DEFAULT_EDITOR,"$DEFAULT_EDITOR") ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_PATH_MAILBOX version: 4 updated: 1998/04/01 11:39:13 ++dnl --------------- ++dnl Look for the directory that contains incoming mail. I would check for an ++dnl actual mail-file, to verify this, but that is not always easy to arrange. ++AC_DEFUN([CF_PATH_MAILBOX], ++[ ++AC_MSG_CHECKING(for incoming-mail directory) ++CF_ARG_WITH(mailbox, ++ [ --with-mailbox=DIR directory for incoming mailboxes], ++ [DEFAULT_MAILBOX]) ++if test -z "$DEFAULT_MAILBOX" ; then ++for cf_dir in \ ++ /var/spool/mail \ ++ /usr/spool/mail \ ++ /var/mail \ ++ /usr/mail \ ++ /mail ++ do ++ if test -d $cf_dir ; then ++ DEFAULT_MAILBOX=$cf_dir ++ break ++ fi ++ done ++fi ++if test -n "$DEFAULT_MAILBOX" ; then ++ AC_DEFINE_UNQUOTED(DEFAULT_MAILBOX,"$DEFAULT_MAILBOX") ++else ++ DEFAULT_MAILBOX=none ++fi ++AC_MSG_RESULT($DEFAULT_MAILBOX) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_PATH_MAILER version: 6 updated: 2001/05/27 21:36:02 ++dnl -------------- ++dnl Look for the program that sends outgoing mail. ++AC_DEFUN([CF_PATH_MAILER], ++[ ++AC_PATH_PROG(DEFAULT_MAILER,sendmail,,$PATH:/usr/sbin:/usr/lib) ++CF_ARG_WITH(mailer, ++ [ --with-mailer=PROG specify default mailer-program], ++ [DEFAULT_MAILER],,mailx) ++if test -z "$DEFAULT_MAILER" ; then ++AC_PATH_PROG(DEFAULT_MAILER,mailx,,$PATH:/usr/bin) ++fi ++if test -z "$DEFAULT_MAILER" ; then ++AC_PATH_PROG(DEFAULT_MAILER,mail,,$PATH:/usr/bin) ++fi ++AC_MSG_CHECKING(for default mailer) ++if test -n "$DEFAULT_MAILER" ; then ++ CF_FIX_SLASHES(ac_cv_path_DEFAULT_MAILER) ++ CF_FIX_SLASHES(DEFAULT_MAILER) ++ AC_DEFINE_UNQUOTED(DEFAULT_MAILER,"$DEFAULT_MAILER") ++else ++ DEFAULT_MAILER=none ++fi ++AC_MSG_RESULT($DEFAULT_MAILER) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_PATH_SYNTAX version: 9 updated: 2002/09/17 23:03:38 ++dnl -------------- ++dnl Check the argument to see that it looks like a pathname. Rewrite it if it ++dnl begins with one of the prefix/exec_prefix variables, and then again if the ++dnl result begins with 'NONE'. This is necessary to work around autoconf's ++dnl delayed evaluation of those symbols. ++AC_DEFUN([CF_PATH_SYNTAX],[ ++case ".[$]$1" in #(vi ++.\[$]\(*\)*|.\'*\'*) #(vi ++ ;; ++..|./*|.\\*) #(vi ++ ;; ++.[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX ++ ;; ++.\[$]{*prefix}*) #(vi ++ eval $1="[$]$1" ++ case ".[$]$1" in #(vi ++ .NONE/*) ++ $1=`echo [$]$1 | sed -e s%NONE%$ac_default_prefix%` ++ ;; ++ esac ++ ;; #(vi ++.NONE/*) ++ $1=`echo [$]$1 | sed -e s%NONE%$ac_default_prefix%` ++ ;; ++*) ++ ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2) ++ ;; ++esac ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_PDCURSES_X11 version: 6 updated: 2002/10/27 18:21:42 ++dnl --------------- ++dnl Configure for PDCurses' X11 library ++AC_DEFUN([CF_PDCURSES_X11],[ ++AC_REQUIRE([CF_X_ATHENA]) ++LDFLAGS="$LDFLAGS $X_LIBS" ++CF_CHECK_CFLAGS($X_CFLAGS) ++AC_CHECK_LIB(X11,XOpenDisplay, ++ [LIBS="-lX11 $LIBS"],, ++ [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS]) ++AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[ ++LIBS="-lXCurses $LIBS" ++AC_TRY_LINK([ ++#include ++char *XCursesProgramName = "test"; ++],[XCursesExit();], ++[cf_cv_lib_XCurses=yes], ++[cf_cv_lib_XCurses=no]) ++]) ++if test $cf_cv_lib_XCurses = yes ; then ++ AC_DEFINE(UNIX) ++ AC_DEFINE(XCURSES) ++ AC_DEFINE(HAVE_XCURSES) ++else ++ AC_ERROR(Cannot link with XCurses) ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_POSIX_JC version: 3 updated: 2001/05/27 21:36:02 ++dnl ----------- ++dnl Check if we have POSIX-style job control (i.e., sigaction), or if we must ++dnl use the signal functions. Use AC_CHECK_FUNCS(sigaction) first. ++AC_DEFUN([CF_POSIX_JC],[ ++ ++AC_REQUIRE([AC_TYPE_SIGNAL]) ++AC_REQUIRE([CF_SIG_ARGS]) ++ ++if test "$ac_cv_func_sigaction" = yes; then ++ ++AC_CACHE_CHECK(whether sigaction needs _POSIX_SOURCE,cf_cv_sigact_bad,[ ++AC_TRY_COMPILE([ ++#include ++#include ],[struct sigaction act], ++ [cf_cv_sigact_bad=no],[cf_cv_sigact_bad=yes]) ++]) ++ ++test "$cf_cv_sigact_bad" = yes && AC_DEFINE(SVR4_ACTION) ++ ++AC_CACHE_CHECK(if we have sigaction/related functions,cf_cv_sigaction_funcs,[ ++AC_TRY_LINK([ ++#ifdef SVR4_ACTION ++#define _POSIX_SOURCE ++#endif ++#include ++#include ],[ ++ RETSIGTYPE (*func)(SIG_ARGS) = SIG_IGN; ++ struct sigaction sa, osa; ++ sa.sa_handler = func; ++ sa.sa_flags = 0; ++ sigemptyset (&sa.sa_mask); ++ sigaction (SIGBUS,&sa,&osa);], ++ [cf_cv_sigaction_funcs=yes], ++ [cf_cv_sigaction_funcs=no])]) ++ ++test "$cf_cv_sigaction_funcs" = yes && AC_DEFINE(HAVE_POSIX_JC) ++ ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_PROG_EXT version: 8 updated: 2002/12/21 19:25:52 ++dnl ----------- ++dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX. ++AC_DEFUN([CF_PROG_EXT], ++[ ++AC_REQUIRE([CF_CHECK_CACHE]) ++PROG_EXT= ++case $cf_cv_system_name in ++os2*) ++ # We make sure -Zexe is not used -- it would interfere with @PROG_EXT@ ++ CFLAGS="$CFLAGS -Zmt" ++ CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__" ++ CXXFLAGS="$CXXFLAGS -Zmt" ++ LDFLAGS=`echo "$LDFLAGS -Zmt -Zcrtdll" | sed -e "s%-Zexe%%g"` ++ PROG_EXT=".exe" ++ ;; ++cygwin*) ++ PROG_EXT=".exe" ++ ;; ++esac ++AC_SUBST(PROG_EXT) ++test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT") ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_PROG_SUM_R version: 2 updated: 1997/08/28 23:57:55 ++dnl ------------- ++dnl See if sum can take -r ++AC_DEFUN([CF_PROG_SUM_R], ++[ ++if test $ac_cv_path_PATH_SUM ++then ++AC_MSG_CHECKING([if $ac_cv_path_PATH_SUM takes -r]) ++AC_CACHE_VAL(ac_cv_prog_sum_r,[ ++if AC_TRY_COMMAND($ac_cv_path_PATH_SUM -r config.log 1>&AC_FD_CC) ++then ++ ac_cv_prog_sum_r=yes ++else ++ ac_cv_prog_sum_r=no ++fi ++]) ++if test $ac_cv_prog_sum_r = yes; then ++ AC_DEFINE(SUM_TAKES_DASH_R) ++ AC_DEFINE_UNQUOTED(PATH_SUM_R, "$ac_cv_path_PATH_SUM -r") ++else ++ AC_DEFINE_UNQUOTED(PATH_SUM_R, "$ac_cv_path_PATH_SUM") ++fi ++AC_MSG_RESULT($ac_cv_prog_sum_r) ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_PROG_YACC version: 2 updated: 1997/12/16 11:20:41 ++dnl ------------ ++dnl A better version of AC_PROC_YACC, verifies that we'll only choose bison if ++dnl we'll be able to compile with it. Bison uses alloca, which isn't all that ++dnl portable. ++AC_DEFUN([CF_PROG_YACC], ++[ ++AC_REQUIRE([AC_PROG_CC]) ++AC_CACHE_VAL(cf_cv_prog_YACC,[ ++if test -n "$YACC" ; then ++ cf_cv_prog_YACC="$YACC" # Let the user override the test. ++else ++cat >conftest.y < ++],[ ++ struct passwd foo; ++ char bar = foo.pw_gecos], ++ [cf_cv_pw_gecos=yes], ++ [cf_cv_pw_gecos=no])]) ++test $cf_cv_pw_gecos = no && AC_DEFINE(DONT_HAVE_PW_GECOS) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_RECHECK_FUNC version: 3 updated: 2000/10/18 19:29:13 ++dnl --------------- ++dnl Re-check on a function to see if we can pick it up by adding a library. ++dnl $1 = function to check ++dnl $2 = library to check in ++dnl $3 = environment to update (e.g., $LIBS) ++dnl $4 = what to do if this fails ++dnl ++dnl This uses 'unset' if the shell happens to support it, but leaves the ++dnl configuration variable set to 'unknown' if not. This is a little better ++dnl than the normal autoconf test, which gives misleading results if a test ++dnl for the function is made (e.g., with AC_CHECK_FUNC) after this macro is ++dnl used (autoconf does not distinguish between a null token and one that is ++dnl set to 'no'). ++AC_DEFUN([CF_RECHECK_FUNC],[ ++AC_CHECK_LIB($2,$1,[ ++ CF_UPPER(cf_tr_func,$1) ++ AC_DEFINE_UNQUOTED(HAVE_$cf_tr_func) ++ ac_cv_func_$1=yes ++ if test "$cf_used_lib_$2" != yes ; then cf_used_lib_$2=yes; $3="-l$2 [$]$3"; fi],[ ++ ac_cv_func_$1=unknown ++ unset ac_cv_func_$1 2>/dev/null ++ $4], ++ [[$]$3]) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_SET_GID_UID version: 2 updated: 1997/08/28 23:57:55 ++dnl -------------- ++dnl Check for the functions that set effective/real uid/gid. This has to ++dnl follow the AC_CHECK_FUNCS call. ++AC_DEFUN([CF_SET_GID_UID], ++[ ++AC_MSG_CHECKING([for setuid-like functions]) ++AC_CACHE_VAL(cf_cv_setuid_funcs,[ ++if test -n "${ac_cv_func_setuid}${ac_cv_func_seteuid}${ac_cv_func_setreuid}"; then ++ cf_cv_setuid_funcs=yes ++else ++ cf_cv_setuid_funcs=no ++fi ++]) ++AC_MSG_RESULT($cf_cv_setuid_funcs) ++test $cf_cv_setuid_funcs = yes && AC_DEFINE(HAVE_SET_GID_UID) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_SIG_ARGS version: 2 updated: 1997/08/28 23:57:55 ++dnl ----------- ++dnl Check for systems that have signal-handlers prototyped with one argument ++dnl versus those with more than one argument, define the symbol SIG_ARGS to ++dnl match. (If it's empty, that's ok too). ++AC_DEFUN([CF_SIG_ARGS], ++[ ++AC_MSG_CHECKING([declaration of signal arguments]) ++AC_CACHE_VAL(cf_cv_sig_args,[ ++cf_cv_sig_args= ++for cf_test in "int sig" "int sig, ..." ++do ++ AC_TRY_COMPILE([ ++#include ], ++ [extern RETSIGTYPE catch($cf_test); signal(SIGINT, catch)], ++ [cf_cv_sig_args="$cf_test";break]) ++done ++]) ++AC_MSG_RESULT($cf_cv_sig_args) ++AC_DEFINE_UNQUOTED(SIG_ARGS,$cf_cv_sig_args) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_SIG_CONST version: 2 updated: 1997/08/28 23:57:55 ++dnl ------------ ++dnl Check for systems where the special signal constants aren't prototyped ++dnl (there's a lot of them, and the compiler can generate a lot of warning ++dnl messages that make it hard to pick out genuine errors). ++AC_DEFUN([CF_SIG_CONST], ++[ ++AC_REQUIRE([CF_SIG_ARGS]) ++AC_MSG_CHECKING([for redefinable signal constants]) ++AC_CACHE_VAL(cf_cv_sig_const,[ ++cf_cv_sig_const=no ++if test -n "$cf_cv_sig_args"; then ++ cf_test=`echo $cf_cv_sig_args|sed -e s/sig//` ++ AC_TRY_RUN([ ++#define NEW_DFL ((RETSIGTYPE (*)($cf_test))0) ++#define NEW_IGN ((RETSIGTYPE (*)($cf_test))1) ++#define NEW_ERR ((RETSIGTYPE (*)($cf_test))-1) ++ ++#include ++ ++int main() ++{ ++ if (NEW_DFL != SIG_DFL ++ || NEW_IGN != SIG_IGN ++ || NEW_ERR != SIG_ERR ++ /* at least one system won't let me redefine these! */ ++#undef SIG_DFL ++#undef SIG_IGN ++#undef SIG_ERR ++#define SIG_DFL NEW_DFL ++#define SIG_IGN NEW_IGN ++#define SIG_ERR NEW_ERR ++ || NEW_DFL != SIG_DFL) ++ exit(1); ++ signal(SIGINT, SIG_DFL); ++ exit(0); ++}], ++ [cf_cv_sig_const=yes], ++ [cf_cv_sig_const=no], ++ [cf_cv_sig_const=unknown]) ++fi ++]) ++AC_MSG_RESULT($cf_cv_sig_const) ++test "$cf_cv_sig_const" = yes && AC_DEFINE(DECL_SIG_CONST) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16 ++dnl ------------- ++dnl Check for definitions & structures needed for window size-changing ++dnl FIXME: check that this works with "snake" (HP-UX 10.x) ++AC_DEFUN([CF_SIZECHANGE], ++[ ++AC_REQUIRE([CF_STRUCT_TERMIOS]) ++AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[ ++ cf_cv_sizechange=unknown ++ cf_save_CPPFLAGS="$CPPFLAGS" ++ ++for cf_opts in "" "NEED_PTEM_H" ++do ++ ++ CPPFLAGS="$cf_save_CPPFLAGS" ++ test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts" ++ AC_TRY_COMPILE([#include ++#ifdef HAVE_TERMIOS_H ++#include ++#else ++#ifdef HAVE_TERMIO_H ++#include ++#endif ++#endif ++#ifdef NEED_PTEM_H ++/* This is a workaround for SCO: they neglected to define struct winsize in ++ * termios.h -- it's only in termio.h and ptem.h ++ */ ++#include ++#include ++#endif ++#if !defined(sun) || !defined(HAVE_TERMIOS_H) ++#include ++#endif ++],[ ++#ifdef TIOCGSIZE ++ struct ttysize win; /* FIXME: what system is this? */ ++ int y = win.ts_lines; ++ int x = win.ts_cols; ++#else ++#ifdef TIOCGWINSZ ++ struct winsize win; ++ int y = win.ws_row; ++ int x = win.ws_col; ++#else ++ no TIOCGSIZE or TIOCGWINSZ ++#endif /* TIOCGWINSZ */ ++#endif /* TIOCGSIZE */ ++ ], ++ [cf_cv_sizechange=yes], ++ [cf_cv_sizechange=no]) ++ ++ CPPFLAGS="$cf_save_CPPFLAGS" ++ if test "$cf_cv_sizechange" = yes ; then ++ echo "size-change succeeded ($cf_opts)" >&AC_FD_CC ++ test -n "$cf_opts" && cf_cv_sizechange="$cf_opts" ++ break ++ fi ++done ++]) ++if test "$cf_cv_sizechange" != no ; then ++ AC_DEFINE(HAVE_SIZECHANGE) ++ case $cf_cv_sizechange in #(vi ++ NEED*) ++ AC_DEFINE_UNQUOTED($cf_cv_sizechange ) ++ ;; ++ esac ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_SOCKS version: 3 updated: 2001/01/01 09:54:40 ++dnl -------- ++dnl Check for socks library ++dnl $1 = the [optional] directory in which the library may be found ++AC_DEFUN([CF_SOCKS],[ ++case "$1" in #(vi ++no|yes) #(vi ++ ;; ++*) ++ if test -d $1 ; then ++ if test -d $1/include ; then ++ CPPFLAGS="$CPPFLAGS -I$1/include" ++ LIBS="$LIBS -L$1/lib" ++ else ++ LIBS="$LIBS -L$1" ++ test -d $1/../include && CPPFLAGS="$CPPFLAGS -I$1/../include" ++ fi ++ else ++ AC_MSG_WARN(expected a directory: $1) ++ fi ++ ;; ++esac ++LIBS="$LIBS -lsocks" ++AC_DEFINE(SOCKS) ++AC_DEFINE(accept,Raccept) ++AC_DEFINE(bind,Rbind) ++AC_DEFINE(connect,Rconnect) ++AC_DEFINE(getpeername,Rgetpeername) ++AC_DEFINE(getsockname,Rgetsockname) ++AC_DEFINE(listen,Rlisten) ++AC_DEFINE(recvfrom,Rrecvfrom) ++AC_DEFINE(select,Rselect) ++AC_TRY_LINK([ ++#include ],[ ++ accept((char *)0)],, ++ [AC_ERROR(Cannot link with socks library)]) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_SOCKS5 version: 7 updated: 2001/01/01 09:54:40 ++dnl --------- ++dnl Check for socks5 configuration ++dnl $1 = the [optional] directory in which the library may be found ++AC_DEFUN([CF_SOCKS5],[ ++case "$1" in #(vi ++no|yes) #(vi ++ ;; ++*) ++ if test -d $1 ; then ++ if test -d $1/include ; then ++ CPPFLAGS="$CPPFLAGS -I$1/include" ++ LIBS="$LIBS -L$1/lib" ++ else ++ LIBS="$LIBS -L$1" ++ test -d $1/../include && CPPFLAGS="$CPPFLAGS -I$1/../include" ++ fi ++ else ++ AC_MSG_WARN(expected a directory: $1) ++ fi ++ ;; ++esac ++LIBS="$LIBS -lsocks5" ++AC_DEFINE(USE_SOCKS5) ++AC_DEFINE(SOCKS) ++AC_MSG_CHECKING(if the socks library uses socks4 prefix) ++cf_use_socks4=error ++AC_TRY_LINK([ ++#include ],[ ++ Rinit((char *)0)], ++ [AC_DEFINE(USE_SOCKS4_PREFIX) ++ cf_use_socks4=yes], ++ [AC_TRY_LINK([#include ], ++ [SOCKSinit((char *)0)], ++ [cf_use_socks4=no], ++ [AC_ERROR(Cannot link with socks5 library)])]) ++AC_MSG_RESULT($cf_use_socks4) ++if test "$cf_use_socks4" = "yes" ; then ++ AC_DEFINE(accept,Raccept) ++ AC_DEFINE(bind,Rbind) ++ AC_DEFINE(connect,Rconnect) ++ AC_DEFINE(getpeername,Rgetpeername) ++ AC_DEFINE(getsockname,Rgetsockname) ++ AC_DEFINE(listen,Rlisten) ++ AC_DEFINE(recvfrom,Rrecvfrom) ++ AC_DEFINE(select,Rselect) ++else ++ AC_DEFINE(accept,SOCKSaccept) ++ AC_DEFINE(getpeername,SOCKSgetpeername) ++ AC_DEFINE(getsockname,SOCKSgetsockname) ++ AC_DEFINE(recvfrom,SOCKSrecvfrom) ++fi ++AC_MSG_CHECKING(if socks5p.h is available) ++AC_TRY_COMPILE([ ++#define INCLUDE_PROTOTYPES ++#include ],[ ++ init((char *)0)], ++ [cf_use_socks5p_h=yes], ++ [cf_use_socks5p_h=no]) ++AC_MSG_RESULT($cf_use_socks5p_h) ++test "$cf_use_socks5p_h" = yes && AC_DEFINE(INCLUDE_PROTOTYPES) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_STRERROR version: 2 updated: 2001/07/11 09:34:49 ++dnl ----------- ++dnl Check for strerror(), or it is not found, for the related data. POSIX ++dnl requires strerror(), so only old systems such as SunOS lack it. ++AC_DEFUN([CF_STRERROR],[ ++AC_CHECK_FUNCS(strerror, AC_DEFINE(HAVE_STRERROR),[CF_SYS_ERRLIST]) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_STRUCT_TERMIOS version: 5 updated: 2000/11/04 12:22:46 ++dnl ----------------- ++dnl Some machines require _POSIX_SOURCE to completely define struct termios. ++dnl If so, define SVR4_TERMIO ++AC_DEFUN([CF_STRUCT_TERMIOS],[ ++AC_CHECK_HEADERS( \ ++termio.h \ ++termios.h \ ++unistd.h \ ++) ++if test "$ISC" = yes ; then ++ AC_CHECK_HEADERS( sys/termio.h ) ++fi ++if test "$ac_cv_header_termios_h" = yes ; then ++ case "$CFLAGS $CPPFLAGS" in ++ *-D_POSIX_SOURCE*) ++ termios_bad=dunno ;; ++ *) termios_bad=maybe ;; ++ esac ++ if test "$termios_bad" = maybe ; then ++ AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE) ++ AC_TRY_COMPILE([#include ], ++ [struct termios foo; int x = foo.c_iflag], ++ termios_bad=no, [ ++ AC_TRY_COMPILE([ ++#define _POSIX_SOURCE ++#include ], ++ [struct termios foo; int x = foo.c_iflag], ++ termios_bad=unknown, ++ termios_bad=yes AC_DEFINE(SVR4_TERMIO)) ++ ]) ++ AC_MSG_RESULT($termios_bad) ++ fi ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_SUBDIR_PATH version: 3 updated: 2002/12/29 18:30:46 ++dnl -------------- ++dnl Construct a search-list for a nonstandard header/lib-file ++dnl $1 = the variable to return as result ++dnl $2 = the package name ++dnl $3 = the subdirectory, e.g., bin, include or lib ++AC_DEFUN([CF_SUBDIR_PATH], ++[$1="" ++ ++test -d [$]HOME && { ++ test -n "$verbose" && echo " ... testing $3-directories under [$]HOME" ++ test -d [$]HOME/$3 && $1="[$]$1 [$]HOME/$3" ++ test -d [$]HOME/$3/$2 && $1="[$]$1 [$]HOME/$3/$2" ++ test -d [$]HOME/$3/$2/$3 && $1="[$]$1 [$]HOME/$3/$2/$3" ++} ++ ++# For other stuff under the home directory, it should be sufficient to put ++# a symbolic link for $HOME/$2 to the actual package location: ++test -d [$]HOME/$2 && { ++ test -n "$verbose" && echo " ... testing $3-directories under [$]HOME/$2" ++ test -d [$]HOME/$2/$3 && $1="[$]$1 [$]HOME/$2/$3" ++ test -d [$]HOME/$2/$3/$2 && $1="[$]$1 [$]HOME/$2/$3/$2" ++} ++ ++test "$prefix" != /usr/local && \ ++test -d /usr/local && { ++ test -n "$verbose" && echo " ... testing $3-directories under /usr/local" ++ test -d /usr/local/$3 && $1="[$]$1 /usr/local/$3" ++ test -d /usr/local/$3/$2 && $1="[$]$1 /usr/local/$3/$2" ++ test -d /usr/local/$3/$2/$3 && $1="[$]$1 /usr/local/$3/$2/$3" ++ test -d /usr/local/$2/$3 && $1="[$]$1 /usr/local/$2/$3" ++ test -d /usr/local/$2/$3/$2 && $1="[$]$1 /usr/local/$2/$3/$2" ++} ++ ++test "$prefix" != NONE && \ ++test -d $prefix && { ++ test -n "$verbose" && echo " ... testing $3-directories under $prefix" ++ test -d $prefix/$3 && $1="[$]$1 $prefix/$3" ++ test -d $prefix/$3/$2 && $1="[$]$1 $prefix/$3/$2" ++ test -d $prefix/$3/$2/$3 && $1="[$]$1 $prefix/$3/$2/$3" ++ test -d $prefix/$2/$3 && $1="[$]$1 $prefix/$2/$3" ++ test -d $prefix/$2/$3/$2 && $1="[$]$1 $prefix/$2/$3/$2" ++} ++ ++test "$prefix" != /opt && \ ++test -d /opt && { ++ test -n "$verbose" && echo " ... testing $3-directories under /opt" ++ test -d /opt/$3 && $1="[$]$1 /opt/$3" ++ test -d /opt/$3/$2 && $1="[$]$1 /opt/$3/$2" ++ test -d /opt/$3/$2/$3 && $1="[$]$1 /opt/$3/$2/$3" ++ test -d /opt/$2/$3 && $1="[$]$1 /opt/$2/$3" ++ test -d /opt/$2/$3/$2 && $1="[$]$1 /opt/$2/$3/$2" ++} ++ ++test "$prefix" != /usr && \ ++test -d /usr && { ++ test -n "$verbose" && echo " ... testing $3-directories under /usr" ++ test -d /usr/$3 && $1="[$]$1 /usr/$3" ++ test -d /usr/$3/$2 && $1="[$]$1 /usr/$3/$2" ++ test -d /usr/$3/$2/$3 && $1="[$]$1 /usr/$3/$2/$3" ++ test -d /usr/$2/$3 && $1="[$]$1 /usr/$2/$3" ++} ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_SYS_ERRLIST version: 6 updated: 2001/12/30 13:03:23 ++dnl -------------- ++dnl Check for declaration of sys_nerr and sys_errlist in one of stdio.h and ++dnl errno.h. Declaration of sys_errlist on BSD4.4 interferes with our ++dnl declaration. Reported by Keith Bostic. ++AC_DEFUN([CF_SYS_ERRLIST], ++[ ++ CF_CHECK_ERRNO(sys_nerr) ++ CF_CHECK_ERRNO(sys_errlist) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_SYS_SELECT_TIMEVAL version: 4 updated: 1997/12/16 11:22:31 ++dnl --------------------- ++dnl Check if there is a conflict between and . ++dnl This is known to be a problem with SCO. ++AC_DEFUN([CF_SYS_SELECT_TIMEVAL], ++[ ++AC_MSG_CHECKING(if sys/time.h conflicts with sys/select.h) ++AC_CACHE_VAL(cf_cv_sys_select_timeval,[ ++for cf_opts in no yes ++do ++AC_TRY_COMPILE([ ++#define yes 1 ++#define no 0 ++#if $cf_opts ++#define timeval fake_timeval ++#endif ++#include ++#ifdef TIME_WITH_SYS_TIME ++# include ++# include ++#else ++# ifdef HAVE_SYS_TIME_H ++# include ++# else ++# include ++# endif ++#endif ++#undef timeval ++#ifdef HAVE_SYS_SELECT_H ++# include ++#endif ++],[struct timeval foo], ++ [cf_cv_sys_select_timeval=$cf_opts ++ break], ++ [cf_cv_sys_select_timeval=no]) ++done ++]) ++AC_MSG_RESULT($cf_cv_sys_select_timeval) ++test $cf_cv_sys_select_timeval = yes && AC_DEFINE(NEED_TIMEVAL_FIX) ++]) ++dnl --------------------------------------------------------------------------- ++dnl CF_TERMCAP_LIBS version: 10 updated: 2001/10/18 20:42:39 ++dnl --------------- ++dnl Look for termcap libraries, or the equivalent in terminfo. ++AC_DEFUN([CF_TERMCAP_LIBS], ++[ ++AC_CACHE_VAL(cf_cv_termlib,[ ++cf_cv_termlib=none ++AC_TRY_LINK([],[char *x=(char*)tgoto("",0,0)], ++[AC_TRY_LINK([],[int x=tigetstr("")], ++ [cf_cv_termlib=terminfo], ++ [cf_cv_termlib=termcap]) ++ CF_VERBOSE(using functions in predefined $cf_cv_termlib LIBS) ++],[ ++ifelse([$1],,,[ ++case "$1" in # (vi ++ncurses*) ++ CF_NCURSES_CPPFLAGS($1) ++ CF_NCURSES_LIBS($1) ++ cf_cv_termlib=terminfo ++ ;; ++esac ++]) ++if test "$cf_cv_termlib" = none; then ++ # FreeBSD's linker gives bogus results for AC_CHECK_LIB, saying that ++ # tgetstr lives in -lcurses when it is only an unsatisfied extern. ++ cf_save_LIBS="$LIBS" ++ for cf_lib in curses ncurses termlib termcap ++ do ++ LIBS="-l$cf_lib $cf_save_LIBS" ++ for cf_func in tigetstr tgetstr ++ do ++ AC_MSG_CHECKING(for $cf_func in -l$cf_lib) ++ AC_TRY_LINK([],[int x=$cf_func("")],[cf_result=yes],[cf_result=no]) ++ AC_MSG_RESULT($cf_result) ++ if test "$cf_result" = yes ; then ++ if test "$cf_func" = tigetstr ; then ++ cf_cv_termlib=terminfo ++ else ++ cf_cv_termlib=termcap ++ fi ++ break ++ fi ++ done ++ test "$cf_result" = yes && break ++ done ++ test "$cf_result" = no && LIBS="$cf_save_LIBS" ++fi ++if test "$cf_cv_termlib" = none; then ++ # allow curses library for broken AIX system. ++ AC_CHECK_LIB(curses, initscr, [LIBS="$LIBS -lcurses" cf_cv_termlib=termcap]) ++ AC_CHECK_LIB(termcap, tgoto, [LIBS="$LIBS -ltermcap" cf_cv_termlib=termcap]) ++fi ++]) ++if test "$cf_cv_termlib" = none; then ++ AC_MSG_WARN([Cannot find -ltermlib, -lcurses, or -ltermcap]) ++fi ++])])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_TERMIOS version: 2 updated: 1997/08/28 23:57:55 ++dnl ---------- ++dnl See if we can link with the termios functions tcsetattr/tcgetattr ++AC_DEFUN([CF_TERMIOS], ++[ ++AC_MSG_CHECKING([for nonconflicting termios.h]) ++AC_CACHE_VAL(cf_cv_use_termios_h,[ ++ AC_TRY_LINK([ ++#ifdef HAVE_IOCTL_H ++# include ++#else ++# ifdef HAVE_SYS_IOCTL_H ++# include ++# endif ++#endif ++ ++#if !defined(sun) || !defined(NL0) ++#include ++#endif ++],[ ++ struct termios save_tty; ++ (void) tcsetattr (0, TCSANOW, &save_tty); ++ (void) tcgetattr (0, &save_tty)], ++ [cf_cv_use_termios_h=yes], ++ [cf_cv_use_termios_h=no]) ++]) ++AC_MSG_RESULT($cf_cv_use_termios_h) ++if test $cf_cv_use_termios_h = yes; then ++ AC_DEFINE(HAVE_TERMIOS_H) ++ AC_DEFINE(HAVE_TCGETATTR) ++ AC_DEFINE(HAVE_TCSETATTR) ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_TIOCGWINSZ version: 3 updated: 1997/11/29 01:04:53 ++dnl ------------- ++dnl On some systems ioctl(fd, TIOCGWINSZ, &size) will always return {0,0} until ++dnl ioctl(fd, TIOCSWINSZ, &size) is called to explicitly set the size of the ++dnl screen. ++dnl ++dnl Attempt to determine if we're on such a system by running a test-program. ++dnl This won't work, of course, if the configure script is run in batch mode, ++dnl since we've got to have access to the terminal. ++dnl ++dnl CHECK_DECL_FLAG and CHECK_DECL_HDRS must be set in configure.in ++AC_DEFUN([CF_TIOCGWINSZ], ++[ ++AC_MSG_CHECKING([for working TIOCGWINSZ]) ++AC_CACHE_VAL(cf_cv_use_tiocgwinsz,[ ++ cf_save_CFLAGS="$CFLAGS" ++ CFLAGS="$CFLAGS -D__CPROTO__ $CHECK_DECL_FLAG" ++ AC_TRY_RUN([ ++$CHECK_DECL_HDRS ++int main() ++{ ++ int fd; ++ for (fd = 0; fd <= 2; fd++) { /* try in/out/err in case redirected */ ++#ifdef TIOCGSIZE ++ struct ttysize size; ++ if (ioctl (0, TIOCGSIZE, &size) == 0 ++ && size.ts_lines > 0 ++ && size.ts_cols > 0) ++ exit(0); ++#else ++ struct winsize size; ++ if (ioctl(0, TIOCGWINSZ, &size) == 0 ++ && size.ws_row > 0 ++ && size.ws_col > 0) ++ exit(0); ++#endif ++ } ++ exit(0); /* we cannot guarantee this is run interactively */ ++}], ++ [cf_cv_use_tiocgwinsz=yes], ++ [cf_cv_use_tiocgwinsz=no], ++ [cf_cv_use_tiocgwinsz=unknown]) ++ rm -f autoconf.h ++ CFLAGS="$cf_save_CFLAGS"]) ++AC_MSG_RESULT($cf_cv_use_tiocgwinsz) ++test $cf_cv_use_tiocgwinsz != yes && AC_DEFINE(DONT_HAVE_SIGWINCH) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_TM_GMTOFF version: 2 updated: 1997/08/28 23:57:55 ++dnl ------------ ++dnl Check if the tm-struct defines the '.tm_gmtoff' member (useful in decoding ++dnl dates). ++AC_DEFUN([CF_TM_GMTOFF], ++[ ++AC_MSG_CHECKING([for tm.tm_gmtoff]) ++AC_CACHE_VAL(cf_cv_tm_gmtoff,[ ++ AC_TRY_COMPILE([ ++#ifdef TIME_WITH_SYS_TIME ++# include ++# include ++#else ++# ifdef HAVE_SYS_TIME_H ++# include ++# else ++# include ++# endif ++#endif ++],[ ++ struct tm foo; ++ long bar = foo.tm_gmtoff], ++ [cf_cv_tm_gmtoff=yes], ++ [cf_cv_tm_gmtoff=no])]) ++AC_MSG_RESULT($cf_cv_tm_gmtoff) ++test $cf_cv_tm_gmtoff = no && AC_DEFINE(DONT_HAVE_TM_GMTOFF) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_TYPE_OUTCHAR version: 13 updated: 2002/10/09 20:00:37 ++dnl --------------- ++dnl Check for return and param type of 3rd -- OutChar() -- param of tputs(). ++dnl ++dnl For this check, and for CF_CURSES_TERMCAP, the $CHECK_DECL_HDRS variable ++dnl must point to a header file containing this (or equivalent): ++dnl ++dnl #ifdef NEED_CURSES_H ++dnl # ifdef HAVE_NCURSES_NCURSES_H ++dnl # include ++dnl # else ++dnl # ifdef HAVE_NCURSES_H ++dnl # include ++dnl # else ++dnl # include ++dnl # endif ++dnl # endif ++dnl #endif ++dnl ++dnl #ifdef HAVE_NCURSES_TERM_H ++dnl # include ++dnl #else ++dnl # ifdef HAVE_TERM_H ++dnl # include ++dnl # endif ++dnl #endif ++dnl ++dnl #if NEED_TERMCAP_H ++dnl # include ++dnl #endif ++dnl ++AC_DEFUN([CF_TYPE_OUTCHAR], ++[ ++AC_REQUIRE([CF_CURSES_TERMCAP]) ++ ++AC_CACHE_CHECK(declaration of tputs 3rd param, cf_cv_type_outchar,[ ++ ++cf_cv_type_outchar="int OutChar(int)" ++cf_cv_found=no ++cf_save_CPPFLAGS="$CPPFLAGS" ++CPPFLAGS="$CPPFLAGS $CHECK_DECL_FLAG" ++ ++for P in int void; do ++for Q in int void; do ++for R in int char; do ++for S in "" const; do ++ CF_MSG_LOG(loop variables [P:[$]P, Q:[$]Q, R:[$]R, S:[$]S]) ++ AC_TRY_COMPILE([$CHECK_DECL_HDRS], ++ [extern $Q OutChar($R); ++ extern $P tputs ($S char *string, int nlines, $Q (*_f)($R)); ++ tputs("", 1, OutChar)], ++ [cf_cv_type_outchar="$Q OutChar($R)" ++ cf_cv_found=yes ++ break]) ++done ++ test $cf_cv_found = yes && break ++done ++ test $cf_cv_found = yes && break ++done ++ test $cf_cv_found = yes && break ++done ++]) ++ ++case $cf_cv_type_outchar in ++int*) ++ AC_DEFINE(OUTC_RETURN) ++ ;; ++esac ++case $cf_cv_type_outchar in ++*char*) ++ AC_DEFINE(OUTC_ARGS,char c) ++ ;; ++esac ++ ++CPPFLAGS="$cf_save_CPPFLAGS" ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52 ++dnl ----------------- ++dnl ++AC_DEFUN([CF_TYPE_SIGACTION], ++[ ++AC_MSG_CHECKING([for type sigaction_t]) ++AC_CACHE_VAL(cf_cv_type_sigaction,[ ++ AC_TRY_COMPILE([ ++#include ], ++ [sigaction_t x], ++ [cf_cv_type_sigaction=yes], ++ [cf_cv_type_sigaction=no])]) ++AC_MSG_RESULT($cf_cv_type_sigaction) ++test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_UNION_WAIT version: 5 updated: 1997/11/23 14:49:44 ++dnl ------------- ++dnl Check to see if the BSD-style union wait is declared. Some platforms may ++dnl use this, though it is deprecated in favor of the 'int' type in Posix. ++dnl Some vendors provide a bogus implementation that declares union wait, but ++dnl uses the 'int' type instead; we try to spot these by checking for the ++dnl associated macros. ++dnl ++dnl Ahem. Some implementers cast the status value to an int*, as an attempt to ++dnl use the macros for either union wait or int. So we do a check compile to ++dnl see if the macros are defined and apply to an int. ++dnl ++dnl Sets: $cf_cv_type_unionwait ++dnl Defines: HAVE_TYPE_UNIONWAIT ++AC_DEFUN([CF_UNION_WAIT], ++[ ++AC_REQUIRE([CF_WAIT_HEADERS]) ++AC_MSG_CHECKING([for union wait]) ++AC_CACHE_VAL(cf_cv_type_unionwait,[ ++ AC_TRY_LINK($cf_wait_headers, ++ [int x; ++ int y = WEXITSTATUS(x); ++ int z = WTERMSIG(x); ++ wait(&x); ++ ], ++ [cf_cv_type_unionwait=no ++ echo compiles ok w/o union wait 1>&AC_FD_CC ++ ],[ ++ AC_TRY_LINK($cf_wait_headers, ++ [union wait x; ++#ifdef WEXITSTATUS ++ int y = WEXITSTATUS(x); ++#endif ++#ifdef WTERMSIG ++ int z = WTERMSIG(x); ++#endif ++ wait(&x); ++ ], ++ [cf_cv_type_unionwait=yes ++ echo compiles ok with union wait and possibly macros too 1>&AC_FD_CC ++ ], ++ [cf_cv_type_unionwait=no])])]) ++AC_MSG_RESULT($cf_cv_type_unionwait) ++test $cf_cv_type_unionwait = yes && AC_DEFINE(HAVE_TYPE_UNIONWAIT) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59 ++dnl -------- ++dnl Make an uppercase version of a variable ++dnl $1=uppercase($2) ++AC_DEFUN([CF_UPPER], ++[ ++$1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_VERBOSE version: 2 updated: 1997/09/05 10:45:14 ++dnl ---------- ++dnl Use AC_VERBOSE w/o the warnings ++AC_DEFUN([CF_VERBOSE], ++[test -n "$verbose" && echo " $1" 1>&AC_FD_MSG ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_WAIT_HEADERS version: 2 updated: 1997/10/21 19:45:33 ++dnl --------------- ++dnl Build up an expression $cf_wait_headers with the header files needed to ++dnl compile against the prototypes for 'wait()', 'waitpid()', etc. Assume it's ++dnl Posix, which uses and , but allow SVr4 variation ++dnl with . ++AC_DEFUN([CF_WAIT_HEADERS], ++[ ++AC_HAVE_HEADERS(sys/wait.h) ++cf_wait_headers="#include ++" ++if test $ac_cv_header_sys_wait_h = yes; then ++cf_wait_headers="$cf_wait_headers ++#include ++" ++else ++AC_HAVE_HEADERS(wait.h) ++AC_HAVE_HEADERS(waitstatus.h) ++if test $ac_cv_header_wait_h = yes; then ++cf_wait_headers="$cf_wait_headers ++#include ++" ++fi ++if test $ac_cv_header_waitstatus_h = yes; then ++cf_wait_headers="$cf_wait_headers ++#include ++" ++fi ++fi ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_WITH_CURSES_DIR version: 2 updated: 2002/11/10 14:46:59 ++dnl ------------------ ++dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses ++dnl libraries. ++AC_DEFUN([CF_WITH_CURSES_DIR],[ ++AC_ARG_WITH(curses-dir, ++ [ --with-curses-dir=DIR directory in which (n)curses is installed], ++ [CF_PATH_SYNTAX(withval) ++ cf_cv_curses_dir=$withval], ++ [cf_cv_curses_dir=no]) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_WITH_DFTENV version: 3 updated: 1998/04/01 11:39:13 ++dnl -------------- ++dnl Wrapper for AC_ARG_WITH to inherit/override an environment variable's ++dnl "#define" in the compile. ++dnl $1 = option name ++dnl $2 = help-message ++dnl $3 = name of variable to inherit/override ++dnl $4 = default value of variable, if any ++AC_DEFUN([CF_WITH_DFTENV], ++[AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),, ++ifelse($4,,[withval="${$3}"],[withval="${$3-$4}"]))dnl ++case "$withval" in #(vi ++yes|no) ++ AC_ERROR(expected a value for --with-$1) ++ ;; ++esac ++$3="$withval" ++AC_DEFINE_UNQUOTED($3,"[$]$3")dnl ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_WITH_PATH version: 6 updated: 1998/10/11 00:40:17 ++dnl ------------ ++dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just ++dnl defaulting to yes/no. ++dnl ++dnl $1 = option name ++dnl $2 = help-text ++dnl $3 = environment variable to set ++dnl $4 = default value, shown in the help-message, must be a constant ++dnl $5 = default value, if it's an expression & cannot be in the help-message ++dnl ++AC_DEFUN([CF_WITH_PATH], ++[AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),, ++ifelse($4,,[withval="${$3}"],[withval="${$3-ifelse($5,,$4,$5)}"]))dnl ++CF_PATH_SYNTAX(withval) ++eval $3="$withval" ++AC_SUBST($3)dnl ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_WITH_PROGRAM version: 5 updated: 2001/07/22 23:07:22 ++dnl --------------- ++dnl Wrapper for AC_PATH_PROG, with command-line option. ++dnl Params: ++dnl $1 = program name ++dnl $2 = help-string (I'd use format, but someone's disable it in autoconf) ++dnl $3 = caller-supplied default if no --with option is given. If this is ++dnl blank, the macro uses AC_PATH_PROG. ++AC_DEFUN([CF_WITH_PROGRAM], ++[dnl ++define([cf_path_name], PATH_[]translit($1, [a-z], [A-Z]))dnl ++define([cf_have_name], HAVE_[]translit($1, [a-z], [A-Z]))dnl ++AC_ARG_WITH($1,[$2],ifelse($3,, ++[case "$withval" in #(vi ++ yes[)] ++ AC_ERROR(expected a value for --with-$1) ++ ;; #(vi ++ no[)] ++ ;; #(vi ++ *[)] ++ # user supplied option-value for "--with-$1=path" ++ AC_MSG_CHECKING(for $1) ++ ac_cv_path_]cf_path_name[="$withval" ++ AC_DEFINE_UNQUOTED(cf_path_name,"$withval")dnl ++ AC_DEFINE(cf_have_name)dnl ++ AC_MSG_RESULT($withval) ++ ;; ++ esac],[$3]),[ ++ # user did not specify "--with-$1"; do automatic check ++ AC_PATH_PROG(cf_path_name,$1) ++ if test -n "$cf_path_name"; then ++ AC_DEFINE_UNQUOTED(cf_path_name,"$cf_path_name")dnl ++ AC_DEFINE(cf_have_name)dnl ++ fi ++])dnl ++undefine([cf_path_name])undefine([cf_have_name])])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_WITH_VALUE version: 3 updated: 1998/04/01 11:39:13 ++dnl ------------- ++dnl Wrapper for AC_ARG_WITH to ensure that if the user supplies a value, it is ++dnl not simply defaulting to yes/no. Empty strings are ok if the macro is ++dnl invoked without a default value ++dnl $1 = option name ++dnl $2 = help-message ++dnl $3 = variable to inherit/override ++dnl $4 = default value, if any. ++AC_DEFUN([CF_WITH_VALUE], ++[CF_ARG_WITH($1,[$2],[$3],[$4]) ++ AC_DEFINE_UNQUOTED($3,"$withval")dnl ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_XOPEN_CURSES version: 6 updated: 2002/11/12 06:55:30 ++dnl --------------- ++dnl Test if we should define X/Open source for curses, needed on Digital Unix ++dnl 4.x, to see the extended functions, but breaks on IRIX 6.x. ++AC_DEFUN([CF_XOPEN_CURSES], ++[ ++AC_CACHE_CHECK(if we must define _XOPEN_SOURCE_EXTENDED,cf_cv_need_xopen_extension,[ ++AC_TRY_LINK([ ++#include ++#include <${cf_cv_ncurses_header-curses.h}>],[ ++ long x = winnstr(stdscr, "", 0)], ++ [cf_cv_need_xopen_extension=no], ++ [AC_TRY_LINK([ ++#define _XOPEN_SOURCE_EXTENDED ++#include ++#include <${cf_cv_ncurses_header-curses.h}>],[ ++ long x = winnstr(stdscr, "", 0)], ++ [cf_cv_need_xopen_extension=yes], ++ [cf_cv_need_xopen_extension=unknown])])]) ++test $cf_cv_need_xopen_extension = yes && CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE_EXTENDED" ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_X_ATHENA version: 11 updated: 2002/12/26 20:56:10 ++dnl ----------- ++dnl Check for Xaw (Athena) libraries ++dnl ++AC_DEFUN([CF_X_ATHENA], ++[AC_REQUIRE([CF_X_TOOLKIT]) ++cf_x_athena=${cf_x_athena-Xaw} ++ ++AC_ARG_WITH(Xaw3d, ++ [ --with-Xaw3d link with Xaw 3d library], ++ [cf_x_athena=Xaw3d]) ++ ++AC_ARG_WITH(neXtaw, ++ [ --with-neXtaw link with neXT Athena library], ++ [cf_x_athena=neXtaw]) ++ ++AC_ARG_WITH(XawPlus, ++ [ --with-XawPlus link with Athena-Plus library], ++ [cf_x_athena=XawPlus]) ++ ++AC_CHECK_LIB(Xext,XextCreateExtension, ++ [LIBS="-lXext $LIBS"]) ++ ++cf_x_athena_lib="" ++ ++CF_X_ATHENA_CPPFLAGS($cf_x_athena) ++CF_X_ATHENA_LIBS($cf_x_athena) ++])dnl ++dnl --------------------------------------------------------------------------- ++dnl CF_X_ATHENA_CPPFLAGS version: 2 updated: 2002/10/09 20:00:37 ++dnl -------------------- ++dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of ++dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw. ++AC_DEFUN([CF_X_ATHENA_CPPFLAGS], ++[ ++cf_x_athena_root=ifelse($1,,Xaw,$1) ++cf_x_athena_include="" ++ ++for cf_path in default \ ++ /usr/contrib/X11R6 \ ++ /usr/contrib/X11R5 \ ++ /usr/lib/X11R5 \ ++ /usr/local ++do ++ if test -z "$cf_x_athena_include" ; then ++ cf_save="$CPPFLAGS" ++ cf_test=X11/$cf_x_athena_root/SimpleMenu.h ++ if test $cf_path != default ; then ++ CPPFLAGS="-I$cf_path/include $cf_save" ++ AC_MSG_CHECKING(for $cf_test in $cf_path) ++ else ++ AC_MSG_CHECKING(for $cf_test) ++ fi ++ AC_TRY_COMPILE([ ++#include ++#include <$cf_test>],[], ++ [cf_result=yes], ++ [cf_result=no]) ++ AC_MSG_RESULT($cf_result) ++ if test "$cf_result" = yes ; then ++ cf_x_athena_include=$cf_path ++ break ++ else ++ CPPFLAGS="$cf_save" ++ fi ++ fi ++done ++ ++if test -z "$cf_x_athena_include" ; then ++ AC_MSG_WARN( ++[Unable to successfully find Athena header files with test program]) ++elif test "$cf_x_athena_include" != default ; then ++ CPPFLAGS="$CPPFLAGS -I$cf_x_athena_include" ++fi ++]) ++dnl --------------------------------------------------------------------------- ++dnl CF_X_ATHENA_LIBS version: 3 updated: 2003/02/16 15:24:54 ++dnl ---------------- ++dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of ++dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw. ++AC_DEFUN([CF_X_ATHENA_LIBS], ++[AC_REQUIRE([CF_X_TOOLKIT]) ++cf_x_athena_root=ifelse($1,,Xaw,$1) ++cf_x_athena_lib="" ++ ++for cf_path in default \ ++ /usr/contrib/X11R6 \ ++ /usr/contrib/X11R5 \ ++ /usr/lib/X11R5 \ ++ /usr/local ++do ++ for cf_lib in \ ++ "-l$cf_x_athena_root -lXmu" \ ++ "-l$cf_x_athena_root -lXpm -lXmu" \ ++ "-l${cf_x_athena_root}_s -lXmu_s" ++ do ++ if test -z "$cf_x_athena_lib" ; then ++ cf_save="$LIBS" ++ cf_test=XawSimpleMenuAddGlobalActions ++ if test $cf_path != default ; then ++ LIBS="-L$cf_path/lib $cf_lib $LIBS" ++ AC_MSG_CHECKING(for $cf_lib in $cf_path) ++ else ++ LIBS="$cf_lib $LIBS" ++ AC_MSG_CHECKING(for $cf_test in $cf_lib) ++ fi ++ cf_SAVE="$LIBS" ++ LIBS="$X_PRE_LIBS $LIBS $X_EXTRA_LIBS" ++ AC_TRY_LINK([],[$cf_test()], ++ [cf_result=yes], ++ [cf_result=no]) ++ AC_MSG_RESULT($cf_result) ++ if test "$cf_result" = yes ; then ++ cf_x_athena_lib="$cf_lib" ++ LIBS="$cf_SAVE" ++ break ++ else ++ LIBS="$cf_save" ++ fi ++ fi ++ done ++done ++ ++if test -z "$cf_x_athena_lib" ; then ++ AC_ERROR( ++[Unable to successfully link Athena library (-l$cf_x_athena_root) with test program]) ++fi ++ ++CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena) ++AC_DEFINE_UNQUOTED($cf_x_athena_LIBS) ++]) ++dnl --------------------------------------------------------------------------- ++dnl CF_X_TOOLKIT version: 9 updated: 2001/12/30 19:09:58 ++dnl ------------ ++dnl Check for X Toolkit libraries ++dnl ++AC_DEFUN([CF_X_TOOLKIT], ++[ ++AC_REQUIRE([CF_CHECK_CACHE]) ++# We need to check for -lsocket and -lnsl here in order to work around an ++# autoconf bug. autoconf-2.12 is not checking for these prior to checking for ++# the X11R6 -lSM and -lICE libraries. The resultant failures cascade... ++# (tested on Solaris 2.5 w/ X11R6) ++SYSTEM_NAME=`echo "$cf_cv_system_name"|tr ' ' -` ++cf_have_X_LIBS=no ++case $SYSTEM_NAME in ++irix[[56]]*) ;; ++clix*) ++ # FIXME: modify the library lookup in autoconf to ++ # allow _s.a suffix ahead of .a ++ AC_CHECK_LIB(c_s,open, ++ [LIBS="-lc_s $LIBS" ++ AC_CHECK_LIB(bsd,gethostname, ++ [LIBS="-lbsd $LIBS" ++ AC_CHECK_LIB(nsl_s,gethostname, ++ [LIBS="-lnsl_s $LIBS" ++ AC_CHECK_LIB(X11_s,XOpenDisplay, ++ [LIBS="-lX11_s $LIBS" ++ AC_CHECK_LIB(Xt_s,XtAppInitialize, ++ [LIBS="-lXt_s $LIBS" ++ cf_have_X_LIBS=Xt ++ ]) ]) ]) ]) ]) ++ ;; ++*) ++ AC_CHECK_LIB(socket,socket) ++ AC_CHECK_LIB(nsl,gethostname) ++ ;; ++esac ++ ++if test $cf_have_X_LIBS = no ; then ++ AC_PATH_XTRA ++ LDFLAGS="$LDFLAGS $X_LIBS" ++ CF_CHECK_CFLAGS($X_CFLAGS) ++ AC_CHECK_LIB(X11,XOpenDisplay, ++ [LIBS="-lX11 $LIBS"],, ++ [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS]) ++ AC_CHECK_LIB(Xt, XtAppInitialize, ++ [AC_DEFINE(HAVE_LIBXT) ++ cf_have_X_LIBS=Xt ++ LIBS="-lXt $X_PRE_LIBS $LIBS"],, ++ [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS]) ++else ++ LDFLAGS="$LDFLAGS $X_LIBS" ++ CF_CHECK_CFLAGS($X_CFLAGS) ++fi ++ ++if test $cf_have_X_LIBS = no ; then ++ AC_WARN( ++[Unable to successfully link X Toolkit library (-lXt) with ++test program. You will have to check and add the proper libraries by hand ++to makefile.]) ++fi ++])dnl diff --git a/packages/tin/files/makecfg-buildcc.patch b/packages/tin/files/makecfg-buildcc.patch new file mode 100644 index 0000000000..2b3dba44f9 --- /dev/null +++ b/packages/tin/files/makecfg-buildcc.patch @@ -0,0 +1,24 @@ + +# +# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher +# + +--- tin-1.7.3/src/Makefile.in~makecfg-buildcc ++++ tin-1.7.3/src/Makefile.in +@@ -462,7 +462,7 @@ + ./makecfg $(SRCDIR)/tincfg.tbl tincfg.h + + makecfg$(EXEEXT): $(OBJDIR)/makecfg.o +- $(LD) $(LDFLAGS) -o $@ $(OBJDIR)/makecfg.o @LIBS@ ++ $(BUILD_CC) $(BUILD_LDFLAGS) -o $@ $(OBJDIR)/makecfg.o + + $(OBJDIR)/active.o: $(SRCDIR)/active.c $(TIN_DEP) + $(OBJDIR)/art.o: $(SRCDIR)/art.c $(TIN_DEP) \ +@@ -519,6 +519,7 @@ + $(OBJDIR)/main.o: $(SRCDIR)/main.c $(TIN_DEP) \ + $(INCDIR)/version.h + $(OBJDIR)/makecfg.o: $(SRCDIR)/makecfg.c $(TIN_DEP) ++ $(BUILD_CC) $(BUILD_CFLAGS) -c -I../include -I../pcre -o $@ $(SRCDIR)/makecfg.c + $(OBJDIR)/memory.o: $(SRCDIR)/memory.c $(TIN_DEP) \ + $(INCDIR)/rfc2046.h + $(OBJDIR)/mimetypes.o: $(SRCDIR)/mimetypes.c $(TIN_DEP) diff --git a/packages/tin/tin-1.7.3/.mtn2git_empty b/packages/tin/tin-1.7.3/.mtn2git_empty deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/packages/tin/tin-1.7.3/configure.patch b/packages/tin/tin-1.7.3/configure.patch deleted file mode 100644 index 4059fe086f..0000000000 --- a/packages/tin/tin-1.7.3/configure.patch +++ /dev/null @@ -1,205 +0,0 @@ - -# -# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher -# - ---- tin-1.7.3/configure.in~configure -+++ tin-1.7.3/configure.in -@@ -34,8 +34,9 @@ - dnl - dnl Process this file with autoconf to produce a configure script. - --AC_PREREQ(2.13.20020210) --AC_INIT(include/tin.h) -+AC_PREREQ(2.57) -+AC_INIT -+AC_CONFIG_SRCDIR([include/tin.h]) - AC_CONFIG_HEADER(include/autoconf.h:include/autoconf.hin) - AC_PREFIX_DEFAULT(/usr/local) - -@@ -406,7 +407,7 @@ - CF_NCURSES_LIBS(ncursesw) - CF_NCURSES_VERSION - CF_XOPEN_CURSES -- test "$cf_cv_need_xopen_extension" = unknown && AC_ERROR(X/Open curses not found) -+ test "$cf_cv_need_xopen_extension" = unknown && AC_MSG_ERROR([X/Open curses not found]) - ;; - curses) #(vi - CF_CURSES_CPPFLAGS -@@ -432,25 +433,25 @@ - fi - - ## debugging libraries (do this after other libraries) --AC_MSG_CHECKING(if you want dbmalloc library) -+AC_MSG_CHECKING([if you want dbmalloc library]) - debug_malloc=none --AC_ARG_WITH(dbmalloc, -+AC_ARG_WITH([dbmalloc], - [ --with-dbmalloc use Conor Cahill's dbmalloc library], -- [AC_MSG_RESULT(yes) -- AC_CHECK_LIB(dbmalloc,debug_malloc, -- AC_CHECK_HEADER(dbmalloc.h,debug_malloc=DBMALLOC))], -- AC_MSG_RESULT(no)) -+ [AC_MSG_RESULT([yes]) -+ AC_CHECK_LIB([dbmalloc],[debug_malloc],[ -+ AC_CHECK_HEADER([dbmalloc.h],[debug_malloc=DBMALLOC])])], -+ AC_MSG_RESULT([no])) - --AC_MSG_CHECKING(if you want dmalloc library) --AC_ARG_WITH(dmalloc, -+AC_MSG_CHECKING([if you want dmalloc library]) -+AC_ARG_WITH([dmalloc], - [ --with-dmalloc use Gray Watson's dmalloc library], - [AC_MSG_RESULT(yes) -- AC_CHECK_LIB(dmalloc,dmalloc_debug, -- AC_CHECK_HEADER(dmalloc.h,debug_malloc=DMALLOC))], -+ AC_CHECK_LIB([dmalloc],[dmalloc_debug],[ -+ AC_CHECK_HEADER([dmalloc.h],[debug_malloc=DMALLOC])])], - AC_MSG_RESULT(no)) - --AC_MSG_CHECKING(if you want debugging-trace) --AC_ARG_WITH(trace, -+AC_MSG_CHECKING([if you want debugging-trace]) -+AC_ARG_WITH([trace], - [ --with-trace use debugging/traces], - [use_trace=yes], - [use_trace=no]) -@@ -667,7 +668,7 @@ - - ### checks for compiler characteristics - CF_MAKEFLAGS --AC_LANG_C -+AC_LANG([C]) - AC_C_CONST - AC_C_INLINE - CF_CPP_EXPANDS -@@ -763,14 +764,13 @@ - - dnl test to see if quad_t is defined - AC_MSG_CHECKING(for quad_t) --AC_TRY_COMPILE([ -+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ - #include - #if 0 - #include - #include - #endif /* 0 */ --],[quad_t x; x = 0], --ac_cv_quad_t=yes, ac_cv_quad_t=no) -+]], [[quad_t x; x = 0]])],[ac_cv_quad_t=yes],[ac_cv_quad_t=no]) - AC_MSG_RESULT($ac_cv_quad_t) - if test $ac_cv_quad_t = yes; then - AC_DEFINE(HAVE_QUAD_T) -@@ -778,10 +778,9 @@ - - dnl test to see if long long is defined - AC_MSG_CHECKING(for long long) --AC_TRY_COMPILE([ -+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ - #include --],[long long x; x = 0], --ac_cv_long_long=yes, ac_cv_long_long=no) -+]], [[long long x; x = 0]])],[ac_cv_long_long=yes],[ac_cv_long_long=no]) - AC_MSG_RESULT($ac_cv_long_long) - if test $ac_cv_long_long = yes; then - AC_DEFINE(HAVE_LONG_LONG) -@@ -789,7 +788,7 @@ - - dnl test to see if nl_item is defined - AC_MSG_CHECKING(for nl_item) --AC_TRY_COMPILE([ -+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ - #ifdef HAVE_LANGINFO_H - #include - #else -@@ -797,8 +796,7 @@ - #include - #endif - #endif --],[nl_item x; x = 0], --ac_cv_nl_item=yes, ac_cv_nl_item=no) -+]], [[nl_item x; x = 0]])],[ac_cv_nl_item=yes],[ac_cv_nl_item=no]) - AC_MSG_RESULT($ac_cv_nl_item) - if test $ac_cv_nl_item = yes; then - AC_DEFINE(HAVE_NL_ITEM) -@@ -845,14 +843,13 @@ - cf_save_LIBS="$LIBS" - cf_try_icuuc="no" - LIBS="$LIBS -licuuc" -- AC_TRY_LINK([#include ], [ -+ AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ - int32_t needed, ustr = NULL; - UErrorCode status; -- needed = unorm_normalize(ustr, -1, UNORM_DEFAULT, 0, NULL, 0, &status);], [ -+ needed = unorm_normalize(ustr, -1, UNORM_DEFAULT, 0, NULL, 0, &status);]])],[ - AC_DEFINE(HAVE_LIBICUUC) -- cf_try_icuuc="yes"], -- LIBS=$cf_save_LIBS -- ) -+ cf_try_icuuc="yes"],[LIBS=$cf_save_LIBS -+ ]) - AC_MSG_RESULT($cf_try_icuuc) - ]) - ]) -@@ -866,15 +863,13 @@ - AC_MSG_CHECKING(if we should include termcap.h) - cf_save_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS -I$srcdir/include" -- AC_TRY_COMPILE([ -+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ - #define HAVE_TERMCAP_H 1 --#include ],[ -+#include ]], [[ - #ifdef NCURSES_VERSION - make an error - #endif --], -- [cf_result=yes], -- [cf_result=no]) -+]])],[cf_result=yes],[cf_result=no]) - AC_MSG_RESULT($cf_result) - CFLAGS="$cf_save_CFLAGS" - test $cf_result = yes && AC_DEFINE(HAVE_TERMCAP_H) -@@ -889,8 +884,7 @@ - cf_tc_externs="$cf_tc_funcs tgoto tigetstr tputs tigetflag" - elif test ".$cf_cv_termlib" = .termcap ; then - # BSD 'tputs()' may need 'PC' to be set. -- AC_TRY_LINK([],[extern char PC; PC = 0], -- [AC_DEFINE(HAVE_EXTERN_TCAP_PC)]) -+ AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[extern char PC; PC = 0]])],[AC_DEFINE(HAVE_EXTERN_TCAP_PC)],[]) - cf_tc_funcs="tgetint tgetnum tparam tparm" - cf_tc_externs="$cf_tc_funcs tgoto tgetstr tputs tgetent tgetflag" - fi -@@ -1172,7 +1166,7 @@ - - CF_CHECK_HEADERS(iconv.h) - AC_MSG_CHECKING(for iconv_open() //TRANSLIT extension) --AC_TRY_RUN([ -+AC_RUN_IFELSE([AC_LANG_SOURCE([[ - #ifdef HAVE_ICONV_H - # include - #endif /* HAVE_ICONV_H */ -@@ -1185,11 +1179,8 @@ - if ((cd = iconv_open("US-ASCII//TRANSLIT", "ISO-8859-1")) == (iconv_t) (-1)) - exit(1); - exit(0); --}], -- AC_DEFINE(HAVE_ICONV_OPEN_TRANSLIT) AC_MSG_RESULT(yes), -- AC_MSG_RESULT(no), -- AC_MSG_RESULT(unknown) --) -+}]])],[AC_DEFINE(HAVE_ICONV_OPEN_TRANSLIT) AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)],[AC_MSG_RESULT(unknown) -+]) - - - # tin has mkdirs.sh instead of mkinstalldirs, overwrite the result of test -@@ -1223,6 +1214,7 @@ - CF_DEFINE_STRING(TIN_LDFLAGS, "$LDFLAGS") - CF_DEFINE_STRING(TIN_LIBS, "$LIBS") - --AC_OUTPUT($PCRE_MAKEFILE -+AC_CONFIG_FILES([$PCRE_MAKEFILE - $SUB_MAKEFILE -- src/Makefile) -+ src/Makefile]) -+AC_OUTPUT diff --git a/packages/tin/tin-1.7.3/m4.patch b/packages/tin/tin-1.7.3/m4.patch deleted file mode 100644 index 9277f6c1b3..0000000000 --- a/packages/tin/tin-1.7.3/m4.patch +++ /dev/null @@ -1,5630 +0,0 @@ - -# -# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher -# - ---- /dev/null -+++ tin-1.7.3/m4/codeset.m4 -@@ -0,0 +1,23 @@ -+# codeset.m4 serial AM1 (gettext-0.10.40) -+dnl Copyright (C) 2000-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Bruno Haible. -+ -+AC_DEFUN([AM_LANGINFO_CODESET], -+[ -+ AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset, -+ [AC_TRY_LINK([#include ], -+ [char* cs = nl_langinfo(CODESET);], -+ am_cv_langinfo_codeset=yes, -+ am_cv_langinfo_codeset=no) -+ ]) -+ if test $am_cv_langinfo_codeset = yes; then -+ AC_DEFINE(HAVE_LANGINFO_CODESET, 1, -+ [Define if you have and nl_langinfo(CODESET).]) -+ fi -+]) ---- /dev/null -+++ tin-1.7.3/m4/gettext.m4 -@@ -0,0 +1,587 @@ -+# gettext.m4 serial 17 (gettext-0.11.5) -+dnl Copyright (C) 1995-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+dnl -+dnl This file can can be used in projects which are not available under -+dnl the GNU General Public License or the GNU Library General Public -+dnl License but which still want to provide support for the GNU gettext -+dnl functionality. -+dnl Please note that the actual code of the GNU gettext library is covered -+dnl by the GNU Library General Public License, and the rest of the GNU -+dnl gettext package package is covered by the GNU General Public License. -+dnl They are *not* in the public domain. -+ -+dnl Authors: -+dnl Ulrich Drepper , 1995-2000. -+dnl Bruno Haible , 2000-2002. -+ -+dnl Macro to add for using GNU gettext. -+ -+dnl Usage: AM_GNU_GETTEXT([INTLSYMBOL], [NEEDSYMBOL], [INTLDIR]). -+dnl INTLSYMBOL can be one of 'external', 'no-libtool', 'use-libtool'. The -+dnl default (if it is not specified or empty) is 'no-libtool'. -+dnl INTLSYMBOL should be 'external' for packages with no intl directory, -+dnl and 'no-libtool' or 'use-libtool' for packages with an intl directory. -+dnl If INTLSYMBOL is 'use-libtool', then a libtool library -+dnl $(top_builddir)/intl/libintl.la will be created (shared and/or static, -+dnl depending on --{enable,disable}-{shared,static} and on the presence of -+dnl AM-DISABLE-SHARED). If INTLSYMBOL is 'no-libtool', a static library -+dnl $(top_builddir)/intl/libintl.a will be created. -+dnl If NEEDSYMBOL is specified and is 'need-ngettext', then GNU gettext -+dnl implementations (in libc or libintl) without the ngettext() function -+dnl will be ignored. If NEEDSYMBOL is specified and is -+dnl 'need-formatstring-macros', then GNU gettext implementations that don't -+dnl support the ISO C 99 formatstring macros will be ignored. -+dnl INTLDIR is used to find the intl libraries. If empty, -+dnl the value `$(top_builddir)/intl/' is used. -+dnl -+dnl The result of the configuration is one of three cases: -+dnl 1) GNU gettext, as included in the intl subdirectory, will be compiled -+dnl and used. -+dnl Catalog format: GNU --> install in $(datadir) -+dnl Catalog extension: .mo after installation, .gmo in source tree -+dnl 2) GNU gettext has been found in the system's C library. -+dnl Catalog format: GNU --> install in $(datadir) -+dnl Catalog extension: .mo after installation, .gmo in source tree -+dnl 3) No internationalization, always use English msgid. -+dnl Catalog format: none -+dnl Catalog extension: none -+dnl If INTLSYMBOL is 'external', only cases 2 and 3 can occur. -+dnl The use of .gmo is historical (it was needed to avoid overwriting the -+dnl GNU format catalogs when building on a platform with an X/Open gettext), -+dnl but we keep it in order not to force irrelevant filename changes on the -+dnl maintainers. -+dnl -+AC_DEFUN([AM_GNU_GETTEXT], -+[ -+ dnl Argument checking. -+ ifelse([$1], [], , [ifelse([$1], [external], , [ifelse([$1], [no-libtool], , [ifelse([$1], [use-libtool], , -+ [errprint([ERROR: invalid first argument to AM_GNU_GETTEXT -+])])])])]) -+ ifelse([$2], [], , [ifelse([$2], [need-ngettext], , [ifelse([$2], [need-formatstring-macros], , -+ [errprint([ERROR: invalid second argument to AM_GNU_GETTEXT -+])])])]) -+ define(gt_included_intl, ifelse([$1], [external], [no], [yes])) -+ define(gt_libtool_suffix_prefix, ifelse([$1], [use-libtool], [l], [])) -+ -+ AC_REQUIRE([AM_PO_SUBDIRS])dnl -+ ifelse(gt_included_intl, yes, [ -+ AC_REQUIRE([AM_INTL_SUBDIR])dnl -+ ]) -+ -+ dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. -+ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) -+ AC_REQUIRE([AC_LIB_RPATH]) -+ -+ dnl Sometimes libintl requires libiconv, so first search for libiconv. -+ dnl Ideally we would do this search only after the -+ dnl if test "$USE_NLS" = "yes"; then -+ dnl if test "$gt_cv_func_gnugettext_libc" != "yes"; then -+ dnl tests. But if configure.in invokes AM_ICONV after AM_GNU_GETTEXT -+ dnl the configure script would need to contain the same shell code -+ dnl again, outside any 'if'. There are two solutions: -+ dnl - Invoke AM_ICONV_LINKFLAGS_BODY here, outside any 'if'. -+ dnl - Control the expansions in more detail using AC_PROVIDE_IFELSE. -+ dnl Since AC_PROVIDE_IFELSE is only in autoconf >= 2.52 and not -+ dnl documented, we avoid it. -+ ifelse(gt_included_intl, yes, , [ -+ AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) -+ ]) -+ -+ AC_MSG_CHECKING([whether NLS is requested]) -+ dnl Default is enabled NLS -+ AC_ARG_ENABLE(nls, -+ [ --disable-nls do not use Native Language Support], -+ USE_NLS=$enableval, USE_NLS=yes) -+ AC_MSG_RESULT($USE_NLS) -+ AC_SUBST(USE_NLS) -+ -+ ifelse(gt_included_intl, yes, [ -+ BUILD_INCLUDED_LIBINTL=no -+ USE_INCLUDED_LIBINTL=no -+ ]) -+ LIBINTL= -+ LTLIBINTL= -+ POSUB= -+ -+ dnl If we use NLS figure out what method -+ if test "$USE_NLS" = "yes"; then -+ gt_use_preinstalled_gnugettext=no -+ ifelse(gt_included_intl, yes, [ -+ AC_MSG_CHECKING([whether included gettext is requested]) -+ AC_ARG_WITH(included-gettext, -+ [ --with-included-gettext use the GNU gettext library included here], -+ nls_cv_force_use_gnu_gettext=$withval, -+ nls_cv_force_use_gnu_gettext=no) -+ AC_MSG_RESULT($nls_cv_force_use_gnu_gettext) -+ -+ nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext" -+ if test "$nls_cv_force_use_gnu_gettext" != "yes"; then -+ ]) -+ dnl User does not insist on using GNU NLS library. Figure out what -+ dnl to use. If GNU gettext is available we use this. Else we have -+ dnl to fall back to GNU NLS library. -+ -+ dnl Add a version number to the cache macros. -+ define([gt_api_version], ifelse([$2], [need-formatstring-macros], 3, ifelse([$2], [need-ngettext], 2, 1))) -+ define([gt_cv_func_gnugettext_libc], [gt_cv_func_gnugettext]gt_api_version[_libc]) -+ define([gt_cv_func_gnugettext_libintl], [gt_cv_func_gnugettext]gt_api_version[_libintl]) -+ -+ AC_CACHE_CHECK([for GNU gettext in libc], gt_cv_func_gnugettext_libc, -+ [AC_TRY_LINK([#include -+]ifelse([$2], [need-formatstring-macros], -+[#ifndef __GNU_GETTEXT_SUPPORTED_REVISION -+#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1) -+#endif -+changequote(,)dnl -+typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; -+changequote([,])dnl -+], [])[extern int _nl_msg_cat_cntr; -+extern int *_nl_domain_bindings;], -+ [bindtextdomain ("", ""); -+return (int) gettext ("")]ifelse([$2], [need-ngettext], [ + (int) ngettext ("", "", 0)], [])[ + _nl_msg_cat_cntr + *_nl_domain_bindings], -+ gt_cv_func_gnugettext_libc=yes, -+ gt_cv_func_gnugettext_libc=no)]) -+ -+ if test "$gt_cv_func_gnugettext_libc" != "yes"; then -+ dnl Sometimes libintl requires libiconv, so first search for libiconv. -+ ifelse(gt_included_intl, yes, , [ -+ AM_ICONV_LINK -+ ]) -+ dnl Search for libintl and define LIBINTL, LTLIBINTL and INCINTL -+ dnl accordingly. Don't use AC_LIB_LINKFLAGS_BODY([intl],[iconv]) -+ dnl because that would add "-liconv" to LIBINTL and LTLIBINTL -+ dnl even if libiconv doesn't exist. -+ AC_LIB_LINKFLAGS_BODY([intl]) -+ AC_CACHE_CHECK([for GNU gettext in libintl], -+ gt_cv_func_gnugettext_libintl, -+ [gt_save_CPPFLAGS="$CPPFLAGS" -+ CPPFLAGS="$CPPFLAGS $INCINTL" -+ gt_save_LIBS="$LIBS" -+ LIBS="$LIBS $LIBINTL" -+ dnl Now see whether libintl exists and does not depend on libiconv. -+ AC_TRY_LINK([#include -+]ifelse([$2], [need-formatstring-macros], -+[#ifndef __GNU_GETTEXT_SUPPORTED_REVISION -+#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1) -+#endif -+changequote(,)dnl -+typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; -+changequote([,])dnl -+], [])[extern int _nl_msg_cat_cntr; -+extern -+#ifdef __cplusplus -+"C" -+#endif -+const char *_nl_expand_alias ();], -+ [bindtextdomain ("", ""); -+return (int) gettext ("")]ifelse([$2], [need-ngettext], [ + (int) ngettext ("", "", 0)], [])[ + _nl_msg_cat_cntr + *_nl_expand_alias (0)], -+ gt_cv_func_gnugettext_libintl=yes, -+ gt_cv_func_gnugettext_libintl=no) -+ dnl Now see whether libintl exists and depends on libiconv. -+ if test "$gt_cv_func_gnugettext_libintl" != yes && test -n "$LIBICONV"; then -+ LIBS="$LIBS $LIBICONV" -+ AC_TRY_LINK([#include -+]ifelse([$2], [need-formatstring-macros], -+[#ifndef __GNU_GETTEXT_SUPPORTED_REVISION -+#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1) -+#endif -+changequote(,)dnl -+typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; -+changequote([,])dnl -+], [])[extern int _nl_msg_cat_cntr; -+extern -+#ifdef __cplusplus -+"C" -+#endif -+const char *_nl_expand_alias ();], -+ [bindtextdomain ("", ""); -+return (int) gettext ("")]ifelse([$2], [need-ngettext], [ + (int) ngettext ("", "", 0)], [])[ + _nl_msg_cat_cntr + *_nl_expand_alias (0)], -+ [LIBINTL="$LIBINTL $LIBICONV" -+ LTLIBINTL="$LTLIBINTL $LTLIBICONV" -+ gt_cv_func_gnugettext_libintl=yes -+ ]) -+ fi -+ CPPFLAGS="$gt_save_CPPFLAGS" -+ LIBS="$gt_save_LIBS"]) -+ fi -+ -+ dnl If an already present or preinstalled GNU gettext() is found, -+ dnl use it. But if this macro is used in GNU gettext, and GNU -+ dnl gettext is already preinstalled in libintl, we update this -+ dnl libintl. (Cf. the install rule in intl/Makefile.in.) -+ if test "$gt_cv_func_gnugettext_libc" = "yes" \ -+ || { test "$gt_cv_func_gnugettext_libintl" = "yes" \ -+ && test "$PACKAGE" != gettext; }; then -+ gt_use_preinstalled_gnugettext=yes -+ else -+ dnl Reset the values set by searching for libintl. -+ LIBINTL= -+ LTLIBINTL= -+ INCINTL= -+ fi -+ -+ ifelse(gt_included_intl, yes, [ -+ if test "$gt_use_preinstalled_gnugettext" != "yes"; then -+ dnl GNU gettext is not found in the C library. -+ dnl Fall back on included GNU gettext library. -+ nls_cv_use_gnu_gettext=yes -+ fi -+ fi -+ -+ if test "$nls_cv_use_gnu_gettext" = "yes"; then -+ dnl Mark actions used to generate GNU NLS library. -+ INTLOBJS="\$(GETTOBJS)" -+ BUILD_INCLUDED_LIBINTL=yes -+ USE_INCLUDED_LIBINTL=yes -+ LIBINTL="ifelse([$3],[],\${top_builddir}/intl,[$3])/libintl.[]gt_libtool_suffix_prefix[]a $LIBICONV" -+ LTLIBINTL="ifelse([$3],[],\${top_builddir}/intl,[$3])/libintl.[]gt_libtool_suffix_prefix[]a $LTLIBICONV" -+ LIBS=`echo " $LIBS " | sed -e 's/ -lintl / /' -e 's/^ //' -e 's/ $//'` -+ fi -+ -+ if test "$gt_use_preinstalled_gnugettext" = "yes" \ -+ || test "$nls_cv_use_gnu_gettext" = "yes"; then -+ dnl Mark actions to use GNU gettext tools. -+ CATOBJEXT=.gmo -+ fi -+ ]) -+ -+ if test "$gt_use_preinstalled_gnugettext" = "yes" \ -+ || test "$nls_cv_use_gnu_gettext" = "yes"; then -+ AC_DEFINE(ENABLE_NLS, 1, -+ [Define to 1 if translation of program messages to the user's native language -+ is requested.]) -+ else -+ USE_NLS=no -+ fi -+ fi -+ -+ if test "$USE_NLS" = "yes"; then -+ -+ if test "$gt_use_preinstalled_gnugettext" = "yes"; then -+ if test "$gt_cv_func_gnugettext_libintl" = "yes"; then -+ AC_MSG_CHECKING([how to link with libintl]) -+ AC_MSG_RESULT([$LIBINTL]) -+ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCINTL]) -+ fi -+ -+ dnl For backward compatibility. Some packages may be using this. -+ AC_DEFINE(HAVE_GETTEXT, 1, -+ [Define if the GNU gettext() function is already present or preinstalled.]) -+ AC_DEFINE(HAVE_DCGETTEXT, 1, -+ [Define if the GNU dcgettext() function is already present or preinstalled.]) -+ fi -+ -+ dnl We need to process the po/ directory. -+ POSUB=po -+ fi -+ -+ ifelse(gt_included_intl, yes, [ -+ dnl If this is used in GNU gettext we have to set BUILD_INCLUDED_LIBINTL -+ dnl to 'yes' because some of the testsuite requires it. -+ if test "$PACKAGE" = gettext; then -+ BUILD_INCLUDED_LIBINTL=yes -+ fi -+ -+ dnl Make all variables we use known to autoconf. -+ AC_SUBST(BUILD_INCLUDED_LIBINTL) -+ AC_SUBST(USE_INCLUDED_LIBINTL) -+ AC_SUBST(CATOBJEXT) -+ AC_SUBST(INTLOBJS) -+ -+ dnl For backward compatibility. Some configure.ins may be using this. -+ nls_cv_header_intl= -+ nls_cv_header_libgt= -+ -+ dnl For backward compatibility. Some Makefiles may be using this. -+ DATADIRNAME=share -+ AC_SUBST(DATADIRNAME) -+ -+ dnl For backward compatibility. Some Makefiles may be using this. -+ INSTOBJEXT=.mo -+ AC_SUBST(INSTOBJEXT) -+ -+ dnl For backward compatibility. Some Makefiles may be using this. -+ GENCAT=gencat -+ AC_SUBST(GENCAT) -+ -+ dnl Enable libtool support if the surrounding package wishes it. -+ INTL_LIBTOOL_SUFFIX_PREFIX=gt_libtool_suffix_prefix -+ AC_SUBST(INTL_LIBTOOL_SUFFIX_PREFIX) -+ ]) -+ -+ dnl For backward compatibility. Some Makefiles may be using this. -+ INTLLIBS="$LIBINTL" -+ AC_SUBST(INTLLIBS) -+ -+ dnl Make all documented variables known to autoconf. -+ AC_SUBST(LIBINTL) -+ AC_SUBST(LTLIBINTL) -+ AC_SUBST(POSUB) -+]) -+ -+ -+dnl Checks for all prerequisites of the po subdirectory, -+dnl except for USE_NLS. -+AC_DEFUN([AM_PO_SUBDIRS], -+[ -+ AC_REQUIRE([AC_PROG_MAKE_SET])dnl -+ AC_REQUIRE([AC_PROG_INSTALL])dnl -+ AC_REQUIRE([AM_MKINSTALLDIRS])dnl -+ -+ dnl Perform the following tests also if --disable-nls has been given, -+ dnl because they are needed for "make dist" to work. -+ -+ dnl Search for GNU msgfmt in the PATH. -+ dnl The first test excludes Solaris msgfmt and early GNU msgfmt versions. -+ dnl The second test excludes FreeBSD msgfmt. -+ AM_PATH_PROG_WITH_TEST(MSGFMT, msgfmt, -+ [$ac_dir/$ac_word --statistics /dev/null >/dev/null 2>&1 && -+ (if $ac_dir/$ac_word --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], -+ :) -+ AC_PATH_PROG(GMSGFMT, gmsgfmt, $MSGFMT) -+ -+ dnl Search for GNU xgettext 0.11 or newer in the PATH. -+ dnl The first test excludes Solaris xgettext and early GNU xgettext versions. -+ dnl The second test excludes FreeBSD xgettext. -+ AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext, -+ [$ac_dir/$ac_word --omit-header --copyright-holder= /dev/null >/dev/null 2>&1 && -+ (if $ac_dir/$ac_word --omit-header --copyright-holder= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], -+ :) -+ dnl Remove leftover from FreeBSD xgettext call. -+ rm -f messages.po -+ -+ dnl Search for GNU msgmerge 0.11 or newer in the PATH. -+ AM_PATH_PROG_WITH_TEST(MSGMERGE, msgmerge, -+ [$ac_dir/$ac_word --update -q /dev/null /dev/null >/dev/null 2>&1], :) -+ -+ dnl This could go away some day; the PATH_PROG_WITH_TEST already does it. -+ dnl Test whether we really found GNU msgfmt. -+ if test "$GMSGFMT" != ":"; then -+ dnl If it is no GNU msgfmt we define it as : so that the -+ dnl Makefiles still can work. -+ if $GMSGFMT --statistics /dev/null >/dev/null 2>&1 && -+ (if $GMSGFMT --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then -+ : ; -+ else -+ GMSGFMT=`echo "$GMSGFMT" | sed -e 's,^.*/,,'` -+ AC_MSG_RESULT( -+ [found $GMSGFMT program is not GNU msgfmt; ignore it]) -+ GMSGFMT=":" -+ fi -+ fi -+ -+ dnl This could go away some day; the PATH_PROG_WITH_TEST already does it. -+ dnl Test whether we really found GNU xgettext. -+ if test "$XGETTEXT" != ":"; then -+ dnl If it is no GNU xgettext we define it as : so that the -+ dnl Makefiles still can work. -+ if $XGETTEXT --omit-header --copyright-holder= /dev/null >/dev/null 2>&1 && -+ (if $XGETTEXT --omit-header --copyright-holder= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then -+ : ; -+ else -+ AC_MSG_RESULT( -+ [found xgettext program is not GNU xgettext; ignore it]) -+ XGETTEXT=":" -+ fi -+ dnl Remove leftover from FreeBSD xgettext call. -+ rm -f messages.po -+ fi -+ -+ AC_OUTPUT_COMMANDS([ -+ for ac_file in $CONFIG_FILES; do -+ # Support "outfile[:infile[:infile...]]" -+ case "$ac_file" in -+ *:*) ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; -+ esac -+ # PO directories have a Makefile.in generated from Makefile.in.in. -+ case "$ac_file" in */Makefile.in) -+ # Adjust a relative srcdir. -+ ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'` -+ ac_dir_suffix="/`echo "$ac_dir"|sed 's%^\./%%'`" -+ ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'` -+ # In autoconf-2.13 it is called $ac_given_srcdir. -+ # In autoconf-2.50 it is called $srcdir. -+ test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir" -+ case "$ac_given_srcdir" in -+ .) top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;; -+ /*) top_srcdir="$ac_given_srcdir" ;; -+ *) top_srcdir="$ac_dots$ac_given_srcdir" ;; -+ esac -+ if test -f "$ac_given_srcdir/$ac_dir/POTFILES.in"; then -+ rm -f "$ac_dir/POTFILES" -+ test -n "$as_me" && echo "$as_me: creating $ac_dir/POTFILES" || echo "creating $ac_dir/POTFILES" -+ cat "$ac_given_srcdir/$ac_dir/POTFILES.in" | sed -e "/^#/d" -e "/^[ ]*\$/d" -e "s,.*, $top_srcdir/& \\\\," | sed -e "\$s/\(.*\) \\\\/\1/" > "$ac_dir/POTFILES" -+ # ALL_LINGUAS, POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES depend -+ # on $ac_dir but don't depend on user-specified configuration -+ # parameters. -+ if test -f "$ac_given_srcdir/$ac_dir/LINGUAS"; then -+ # The LINGUAS file contains the set of available languages. -+ if test -n "$ALL_LINGUAS"; then -+ test -n "$as_me" && echo "$as_me: setting ALL_LINGUAS in configure.in is obsolete" || echo "setting ALL_LINGUAS in configure.in is obsolete" -+ fi -+ ALL_LINGUAS_=`sed -e "/^#/d" "$ac_given_srcdir/$ac_dir/LINGUAS"` -+ # Hide the ALL_LINGUAS assigment from automake. -+ eval 'ALL_LINGUAS''=$ALL_LINGUAS_' -+ fi -+ case "$ac_given_srcdir" in -+ .) srcdirpre= ;; -+ *) srcdirpre='$(srcdir)/' ;; -+ esac -+ POFILES= -+ GMOFILES= -+ UPDATEPOFILES= -+ DUMMYPOFILES= -+ for lang in $ALL_LINGUAS; do -+ POFILES="$POFILES $srcdirpre$lang.po" -+ GMOFILES="$GMOFILES $srcdirpre$lang.gmo" -+ UPDATEPOFILES="$UPDATEPOFILES $lang.po-update" -+ DUMMYPOFILES="$DUMMYPOFILES $lang.nop" -+ done -+ # CATALOGS depends on both $ac_dir and the user's LINGUAS -+ # environment variable. -+ INST_LINGUAS= -+ if test -n "$ALL_LINGUAS"; then -+ for presentlang in $ALL_LINGUAS; do -+ useit=no -+ if test "%UNSET%" != "$LINGUAS"; then -+ desiredlanguages="$LINGUAS" -+ else -+ desiredlanguages="$ALL_LINGUAS" -+ fi -+ for desiredlang in $desiredlanguages; do -+ # Use the presentlang catalog if desiredlang is -+ # a. equal to presentlang, or -+ # b. a variant of presentlang (because in this case, -+ # presentlang can be used as a fallback for messages -+ # which are not translated in the desiredlang catalog). -+ case "$desiredlang" in -+ "$presentlang"*) useit=yes;; -+ esac -+ done -+ if test $useit = yes; then -+ INST_LINGUAS="$INST_LINGUAS $presentlang" -+ fi -+ done -+ fi -+ CATALOGS= -+ if test -n "$INST_LINGUAS"; then -+ for lang in $INST_LINGUAS; do -+ CATALOGS="$CATALOGS $lang.gmo" -+ done -+ fi -+ test -n "$as_me" && echo "$as_me: creating $ac_dir/Makefile" || echo "creating $ac_dir/Makefile" -+ sed -e "/^POTFILES =/r $ac_dir/POTFILES" -e "/^# Makevars/r $ac_given_srcdir/$ac_dir/Makevars" -e "s|@POFILES@|$POFILES|g" -e "s|@GMOFILES@|$GMOFILES|g" -e "s|@UPDATEPOFILES@|$UPDATEPOFILES|g" -e "s|@DUMMYPOFILES@|$DUMMYPOFILES|g" -e "s|@CATALOGS@|$CATALOGS|g" "$ac_dir/Makefile.in" > "$ac_dir/Makefile" -+ for f in "$ac_given_srcdir/$ac_dir"/Rules-*; do -+ if test -f "$f"; then -+ case "$f" in -+ *.orig | *.bak | *~) ;; -+ *) cat "$f" >> "$ac_dir/Makefile" ;; -+ esac -+ fi -+ done -+ fi -+ ;; -+ esac -+ done], -+ [# Capture the value of obsolete ALL_LINGUAS because we need it to compute -+ # POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES, CATALOGS. But hide it -+ # from automake. -+ eval 'ALL_LINGUAS''="$ALL_LINGUAS"' -+ # Capture the value of LINGUAS because we need it to compute CATALOGS. -+ LINGUAS="${LINGUAS-%UNSET%}" -+ ]) -+]) -+ -+ -+dnl Checks for all prerequisites of the intl subdirectory, -+dnl except for INTL_LIBTOOL_SUFFIX_PREFIX (and possibly LIBTOOL), INTLOBJS, -+dnl USE_INCLUDED_LIBINTL, BUILD_INCLUDED_LIBINTL. -+AC_DEFUN([AM_INTL_SUBDIR], -+[ -+ AC_REQUIRE([AC_PROG_INSTALL])dnl -+ AC_REQUIRE([AM_MKINSTALLDIRS])dnl -+ AC_REQUIRE([AC_PROG_CC])dnl -+ AC_REQUIRE([AC_CANONICAL_HOST])dnl -+ AC_REQUIRE([AC_PROG_RANLIB])dnl -+ AC_REQUIRE([AC_ISC_POSIX])dnl -+ AC_REQUIRE([AC_HEADER_STDC])dnl -+ AC_REQUIRE([AC_C_CONST])dnl -+ AC_REQUIRE([AC_C_INLINE])dnl -+ AC_REQUIRE([AC_TYPE_OFF_T])dnl -+ AC_REQUIRE([AC_TYPE_SIZE_T])dnl -+ AC_REQUIRE([AC_FUNC_ALLOCA])dnl -+ AC_REQUIRE([AC_FUNC_MMAP])dnl -+ AC_REQUIRE([jm_GLIBC21])dnl -+ AC_REQUIRE([gt_INTDIV0])dnl -+ AC_REQUIRE([jm_AC_TYPE_UINTMAX_T])dnl -+ AC_REQUIRE([gt_HEADER_INTTYPES_H])dnl -+ AC_REQUIRE([gt_INTTYPES_PRI])dnl -+ -+ AC_CHECK_HEADERS([argz.h limits.h locale.h nl_types.h malloc.h stddef.h \ -+stdlib.h string.h unistd.h sys/param.h]) -+ AC_CHECK_FUNCS([feof_unlocked fgets_unlocked getc_unlocked getcwd getegid \ -+geteuid getgid getuid mempcpy munmap putenv setenv setlocale stpcpy \ -+strcasecmp strdup strtoul tsearch __argz_count __argz_stringify __argz_next]) -+ -+ AM_ICONV -+ AM_LANGINFO_CODESET -+ if test $ac_cv_header_locale_h = yes; then -+ AM_LC_MESSAGES -+ fi -+ -+ dnl intl/plural.c is generated from intl/plural.y. It requires bison, -+ dnl because plural.y uses bison specific features. It requires at least -+ dnl bison-1.26 because earlier versions generate a plural.c that doesn't -+ dnl compile. -+ dnl bison is only needed for the maintainer (who touches plural.y). But in -+ dnl order to avoid separate Makefiles or --enable-maintainer-mode, we put -+ dnl the rule in general Makefile. Now, some people carelessly touch the -+ dnl files or have a broken "make" program, hence the plural.c rule will -+ dnl sometimes fire. To avoid an error, defines BISON to ":" if it is not -+ dnl present or too old. -+ AC_CHECK_PROGS([INTLBISON], [bison]) -+ if test -z "$INTLBISON"; then -+ ac_verc_fail=yes -+ else -+ dnl Found it, now check the version. -+ AC_MSG_CHECKING([version of bison]) -+changequote(<<,>>)dnl -+ ac_prog_version=`$INTLBISON --version 2>&1 | sed -n 's/^.*GNU Bison.* \([0-9]*\.[0-9.]*\).*$/\1/p'` -+ case $ac_prog_version in -+ '') ac_prog_version="v. ?.??, bad"; ac_verc_fail=yes;; -+ 1.2[6-9]* | 1.[3-9][0-9]* | [2-9].*) -+changequote([,])dnl -+ ac_prog_version="$ac_prog_version, ok"; ac_verc_fail=no;; -+ *) ac_prog_version="$ac_prog_version, bad"; ac_verc_fail=yes;; -+ esac -+ AC_MSG_RESULT([$ac_prog_version]) -+ fi -+ if test $ac_verc_fail = yes; then -+ INTLBISON=: -+ fi -+]) -+ -+ -+AC_DEFUN([AM_MKINSTALLDIRS], -+[ -+ dnl If the AC_CONFIG_AUX_DIR macro for autoconf is used we possibly -+ dnl find the mkinstalldirs script in another subdir but $(top_srcdir). -+ dnl Try to locate is. -+ MKINSTALLDIRS= -+ if test -n "$ac_aux_dir"; then -+ MKINSTALLDIRS="$ac_aux_dir/mkinstalldirs" -+ fi -+ if test -z "$MKINSTALLDIRS"; then -+ MKINSTALLDIRS="\$(top_srcdir)/mkinstalldirs" -+ fi -+ AC_SUBST(MKINSTALLDIRS) -+]) -+ -+ -+dnl Usage: AM_GNU_GETTEXT_VERSION([gettext-version]) -+AC_DEFUN([AM_GNU_GETTEXT_VERSION], []) ---- /dev/null -+++ tin-1.7.3/m4/glibc21.m4 -@@ -0,0 +1,32 @@ -+# glibc21.m4 serial 2 (fileutils-4.1.3, gettext-0.10.40) -+dnl Copyright (C) 2000-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+# Test for the GNU C Library, version 2.1 or newer. -+# From Bruno Haible. -+ -+AC_DEFUN([jm_GLIBC21], -+ [ -+ AC_CACHE_CHECK(whether we are using the GNU C Library 2.1 or newer, -+ ac_cv_gnu_library_2_1, -+ [AC_EGREP_CPP([Lucky GNU user], -+ [ -+#include -+#ifdef __GNU_LIBRARY__ -+ #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2) -+ Lucky GNU user -+ #endif -+#endif -+ ], -+ ac_cv_gnu_library_2_1=yes, -+ ac_cv_gnu_library_2_1=no) -+ ] -+ ) -+ AC_SUBST(GLIBC21) -+ GLIBC21="$ac_cv_gnu_library_2_1" -+ ] -+) ---- /dev/null -+++ tin-1.7.3/m4/iconv.m4 -@@ -0,0 +1,103 @@ -+# iconv.m4 serial AM4 (gettext-0.11.3) -+dnl Copyright (C) 2000-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Bruno Haible. -+ -+AC_DEFUN([AM_ICONV_LINKFLAGS_BODY], -+[ -+ dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. -+ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) -+ AC_REQUIRE([AC_LIB_RPATH]) -+ -+ dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV -+ dnl accordingly. -+ AC_LIB_LINKFLAGS_BODY([iconv]) -+]) -+ -+AC_DEFUN([AM_ICONV_LINK], -+[ -+ dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and -+ dnl those with the standalone portable GNU libiconv installed). -+ -+ dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV -+ dnl accordingly. -+ AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) -+ -+ dnl Add $INCICONV to CPPFLAGS before performing the following checks, -+ dnl because if the user has installed libiconv and not disabled its use -+ dnl via --without-libiconv-prefix, he wants to use it. The first -+ dnl AC_TRY_LINK will then fail, the second AC_TRY_LINK will succeed. -+ am_save_CPPFLAGS="$CPPFLAGS" -+ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV]) -+ -+ AC_CACHE_CHECK(for iconv, am_cv_func_iconv, [ -+ am_cv_func_iconv="no, consider installing GNU libiconv" -+ am_cv_lib_iconv=no -+ AC_TRY_LINK([#include -+#include ], -+ [iconv_t cd = iconv_open("",""); -+ iconv(cd,NULL,NULL,NULL,NULL); -+ iconv_close(cd);], -+ am_cv_func_iconv=yes) -+ if test "$am_cv_func_iconv" != yes; then -+ am_save_LIBS="$LIBS" -+ LIBS="$LIBS $LIBICONV" -+ AC_TRY_LINK([#include -+#include ], -+ [iconv_t cd = iconv_open("",""); -+ iconv(cd,NULL,NULL,NULL,NULL); -+ iconv_close(cd);], -+ am_cv_lib_iconv=yes -+ am_cv_func_iconv=yes) -+ LIBS="$am_save_LIBS" -+ fi -+ ]) -+ if test "$am_cv_func_iconv" = yes; then -+ AC_DEFINE(HAVE_ICONV, 1, [Define if you have the iconv() function.]) -+ fi -+ if test "$am_cv_lib_iconv" = yes; then -+ AC_MSG_CHECKING([how to link with libiconv]) -+ AC_MSG_RESULT([$LIBICONV]) -+ else -+ dnl If $LIBICONV didn't lead to a usable library, we don't need $INCICONV -+ dnl either. -+ CPPFLAGS="$am_save_CPPFLAGS" -+ LIBICONV= -+ LTLIBICONV= -+ fi -+ AC_SUBST(LIBICONV) -+ AC_SUBST(LTLIBICONV) -+]) -+ -+AC_DEFUN([AM_ICONV], -+[ -+ AM_ICONV_LINK -+ if test "$am_cv_func_iconv" = yes; then -+ AC_MSG_CHECKING([for iconv declaration]) -+ AC_CACHE_VAL(am_cv_proto_iconv, [ -+ AC_TRY_COMPILE([ -+#include -+#include -+extern -+#ifdef __cplusplus -+"C" -+#endif -+#if defined(__STDC__) || defined(__cplusplus) -+size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft); -+#else -+size_t iconv(); -+#endif -+], [], am_cv_proto_iconv_arg1="", am_cv_proto_iconv_arg1="const") -+ am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"]) -+ am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'` -+ AC_MSG_RESULT([$]{ac_t:- -+ }[$]am_cv_proto_iconv) -+ AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg1, -+ [Define as const if the declaration of iconv() needs const.]) -+ fi -+]) ---- /dev/null -+++ tin-1.7.3/m4/intdiv0.m4 -@@ -0,0 +1,72 @@ -+# intdiv0.m4 serial 1 (gettext-0.11.3) -+dnl Copyright (C) 2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Bruno Haible. -+ -+AC_DEFUN([gt_INTDIV0], -+[ -+ AC_REQUIRE([AC_PROG_CC])dnl -+ AC_REQUIRE([AC_CANONICAL_HOST])dnl -+ -+ AC_CACHE_CHECK([whether integer division by zero raises SIGFPE], -+ gt_cv_int_divbyzero_sigfpe, -+ [ -+ AC_TRY_RUN([ -+#include -+#include -+ -+static void -+#ifdef __cplusplus -+sigfpe_handler (int sig) -+#else -+sigfpe_handler (sig) int sig; -+#endif -+{ -+ /* Exit with code 0 if SIGFPE, with code 1 if any other signal. */ -+ exit (sig != SIGFPE); -+} -+ -+int x = 1; -+int y = 0; -+int z; -+int nan; -+ -+int main () -+{ -+ signal (SIGFPE, sigfpe_handler); -+/* IRIX and AIX (when "xlc -qcheck" is used) yield signal SIGTRAP. */ -+#if (defined (__sgi) || defined (_AIX)) && defined (SIGTRAP) -+ signal (SIGTRAP, sigfpe_handler); -+#endif -+/* Linux/SPARC yields signal SIGILL. */ -+#if defined (__sparc__) && defined (__linux__) -+ signal (SIGILL, sigfpe_handler); -+#endif -+ -+ z = x / y; -+ nan = y / y; -+ exit (1); -+} -+], gt_cv_int_divbyzero_sigfpe=yes, gt_cv_int_divbyzero_sigfpe=no, -+ [ -+ # Guess based on the CPU. -+ case "$host_cpu" in -+ alpha* | i[34567]86 | m68k | s390*) -+ gt_cv_int_divbyzero_sigfpe="guessing yes";; -+ *) -+ gt_cv_int_divbyzero_sigfpe="guessing no";; -+ esac -+ ]) -+ ]) -+ case "$gt_cv_int_divbyzero_sigfpe" in -+ *yes) value=1;; -+ *) value=0;; -+ esac -+ AC_DEFINE_UNQUOTED(INTDIV0_RAISES_SIGFPE, $value, -+ [Define if integer division by zero raises signal SIGFPE.]) -+]) ---- /dev/null -+++ tin-1.7.3/m4/inttypes_h.m4 -@@ -0,0 +1,28 @@ -+# inttypes_h.m4 serial 4 (gettext-0.11.4) -+dnl Copyright (C) 1997-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Paul Eggert. -+ -+# Define HAVE_INTTYPES_H_WITH_UINTMAX if exists, -+# doesn't clash with , and declares uintmax_t. -+ -+AC_DEFUN([jm_AC_HEADER_INTTYPES_H], -+[ -+ AC_CACHE_CHECK([for inttypes.h], jm_ac_cv_header_inttypes_h, -+ [AC_TRY_COMPILE( -+ [#include -+#include ], -+ [uintmax_t i = (uintmax_t) -1;], -+ jm_ac_cv_header_inttypes_h=yes, -+ jm_ac_cv_header_inttypes_h=no)]) -+ if test $jm_ac_cv_header_inttypes_h = yes; then -+ AC_DEFINE_UNQUOTED(HAVE_INTTYPES_H_WITH_UINTMAX, 1, -+[Define if exists, doesn't clash with , -+ and declares uintmax_t. ]) -+ fi -+]) ---- /dev/null -+++ tin-1.7.3/m4/inttypes.m4 -@@ -0,0 +1,27 @@ -+# inttypes.m4 serial 1 (gettext-0.11.4) -+dnl Copyright (C) 1997-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Paul Eggert. -+ -+# Define HAVE_INTTYPES_H if exists and doesn't clash with -+# . -+ -+AC_DEFUN([gt_HEADER_INTTYPES_H], -+[ -+ AC_CACHE_CHECK([for inttypes.h], gt_cv_header_inttypes_h, -+ [ -+ AC_TRY_COMPILE( -+ [#include -+#include ], -+ [], gt_cv_header_inttypes_h=yes, gt_cv_header_inttypes_h=no) -+ ]) -+ if test $gt_cv_header_inttypes_h = yes; then -+ AC_DEFINE_UNQUOTED(HAVE_INTTYPES_H, 1, -+ [Define if exists and doesn't clash with .]) -+ fi -+]) ---- /dev/null -+++ tin-1.7.3/m4/inttypes-pri.m4 -@@ -0,0 +1,32 @@ -+# inttypes-pri.m4 serial 1 (gettext-0.11.4) -+dnl Copyright (C) 1997-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Bruno Haible. -+ -+# Define PRI_MACROS_BROKEN if exists and defines the PRI* -+# macros to non-string values. This is the case on AIX 4.3.3. -+ -+AC_DEFUN([gt_INTTYPES_PRI], -+[ -+ AC_REQUIRE([gt_HEADER_INTTYPES_H]) -+ if test $gt_cv_header_inttypes_h = yes; then -+ AC_CACHE_CHECK([whether the inttypes.h PRIxNN macros are broken], -+ gt_cv_inttypes_pri_broken, -+ [ -+ AC_TRY_COMPILE([#include -+#ifdef PRId32 -+char *p = PRId32; -+#endif -+], [], gt_cv_inttypes_pri_broken=no, gt_cv_inttypes_pri_broken=yes) -+ ]) -+ fi -+ if test "$gt_cv_inttypes_pri_broken" = yes; then -+ AC_DEFINE_UNQUOTED(PRI_MACROS_BROKEN, 1, -+ [Define if exists and defines unusable PRI* macros.]) -+ fi -+]) ---- /dev/null -+++ tin-1.7.3/m4/isc-posix.m4 -@@ -0,0 +1,26 @@ -+# isc-posix.m4 serial 2 (gettext-0.11.2) -+dnl Copyright (C) 1995-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+# This file is not needed with autoconf-2.53 and newer. Remove it in 2005. -+ -+# This test replaces the one in autoconf. -+# Currently this macro should have the same name as the autoconf macro -+# because gettext's gettext.m4 (distributed in the automake package) -+# still uses it. Otherwise, the use in gettext.m4 makes autoheader -+# give these diagnostics: -+# configure.in:556: AC_TRY_COMPILE was called before AC_ISC_POSIX -+# configure.in:556: AC_TRY_RUN was called before AC_ISC_POSIX -+ -+undefine([AC_ISC_POSIX]) -+ -+AC_DEFUN([AC_ISC_POSIX], -+ [ -+ dnl This test replaces the obsolescent AC_ISC_POSIX kludge. -+ AC_CHECK_LIB(cposix, strerror, [LIBS="$LIBS -lcposix"]) -+ ] -+) ---- /dev/null -+++ tin-1.7.3/m4/lcmessage.m4 -@@ -0,0 +1,32 @@ -+# lcmessage.m4 serial 3 (gettext-0.11.3) -+dnl Copyright (C) 1995-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+dnl -+dnl This file can can be used in projects which are not available under -+dnl the GNU General Public License or the GNU Library General Public -+dnl License but which still want to provide support for the GNU gettext -+dnl functionality. -+dnl Please note that the actual code of the GNU gettext library is covered -+dnl by the GNU Library General Public License, and the rest of the GNU -+dnl gettext package package is covered by the GNU General Public License. -+dnl They are *not* in the public domain. -+ -+dnl Authors: -+dnl Ulrich Drepper , 1995. -+ -+# Check whether LC_MESSAGES is available in . -+ -+AC_DEFUN([AM_LC_MESSAGES], -+[ -+ AC_CACHE_CHECK([for LC_MESSAGES], am_cv_val_LC_MESSAGES, -+ [AC_TRY_LINK([#include ], [return LC_MESSAGES], -+ am_cv_val_LC_MESSAGES=yes, am_cv_val_LC_MESSAGES=no)]) -+ if test $am_cv_val_LC_MESSAGES = yes; then -+ AC_DEFINE(HAVE_LC_MESSAGES, 1, -+ [Define if your file defines LC_MESSAGES.]) -+ fi -+]) ---- /dev/null -+++ tin-1.7.3/m4/lib-ld.m4 -@@ -0,0 +1,97 @@ -+# lib-ld.m4 serial 1 (gettext-0.11) -+dnl Copyright (C) 1996-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl Subroutines of libtool.m4, -+dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision -+dnl with libtool.m4. -+ -+dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no. -+AC_DEFUN([AC_LIB_PROG_LD_GNU], -+[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], acl_cv_prog_gnu_ld, -+[# I'd rather use --version here, but apparently some GNU ld's only accept -v. -+if $LD -v 2>&1 &5; then -+ acl_cv_prog_gnu_ld=yes -+else -+ acl_cv_prog_gnu_ld=no -+fi]) -+with_gnu_ld=$acl_cv_prog_gnu_ld -+]) -+ -+dnl From libtool-1.4. Sets the variable LD. -+AC_DEFUN([AC_LIB_PROG_LD], -+[AC_ARG_WITH(gnu-ld, -+[ --with-gnu-ld assume the C compiler uses GNU ld [default=no]], -+test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no) -+AC_REQUIRE([AC_PROG_CC])dnl -+AC_REQUIRE([AC_CANONICAL_HOST])dnl -+ac_prog=ld -+if test "$GCC" = yes; then -+ # Check if gcc -print-prog-name=ld gives a path. -+ AC_MSG_CHECKING([for ld used by GCC]) -+ case $host in -+ *-*-mingw*) -+ # gcc leaves a trailing carriage return which upsets mingw -+ ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; -+ *) -+ ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; -+ esac -+ case $ac_prog in -+ # Accept absolute paths. -+ [[\\/]* | [A-Za-z]:[\\/]*)] -+ [re_direlt='/[^/][^/]*/\.\./'] -+ # Canonicalize the path of ld -+ ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'` -+ while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do -+ ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"` -+ done -+ test -z "$LD" && LD="$ac_prog" -+ ;; -+ "") -+ # If it fails, then pretend we aren't using GCC. -+ ac_prog=ld -+ ;; -+ *) -+ # If it is relative, then search for the first ld in PATH. -+ with_gnu_ld=unknown -+ ;; -+ esac -+elif test "$with_gnu_ld" = yes; then -+ AC_MSG_CHECKING([for GNU ld]) -+else -+ AC_MSG_CHECKING([for non-GNU ld]) -+fi -+AC_CACHE_VAL(acl_cv_path_LD, -+[if test -z "$LD"; then -+ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}" -+ for ac_dir in $PATH; do -+ test -z "$ac_dir" && ac_dir=. -+ if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then -+ acl_cv_path_LD="$ac_dir/$ac_prog" -+ # Check to see if the program is GNU ld. I'd rather use --version, -+ # but apparently some GNU ld's only accept -v. -+ # Break only if it was the GNU/non-GNU ld that we prefer. -+ if "$acl_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then -+ test "$with_gnu_ld" != no && break -+ else -+ test "$with_gnu_ld" != yes && break -+ fi -+ fi -+ done -+ IFS="$ac_save_ifs" -+else -+ acl_cv_path_LD="$LD" # Let the user override the test with a path. -+fi]) -+LD="$acl_cv_path_LD" -+if test -n "$LD"; then -+ AC_MSG_RESULT($LD) -+else -+ AC_MSG_RESULT(no) -+fi -+test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH]) -+AC_LIB_PROG_LD_GNU -+]) ---- /dev/null -+++ tin-1.7.3/m4/lib-link.m4 -@@ -0,0 +1,554 @@ -+# lib-link.m4 serial 3 (gettext-0.11.3) -+dnl Copyright (C) 2001-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Bruno Haible. -+ -+dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and -+dnl the libraries corresponding to explicit and implicit dependencies. -+dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and -+dnl augments the CPPFLAGS variable. -+AC_DEFUN([AC_LIB_LINKFLAGS], -+[ -+ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) -+ AC_REQUIRE([AC_LIB_RPATH]) -+ define([Name],[translit([$1],[./-], [___])]) -+ define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], -+ [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) -+ AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [ -+ AC_LIB_LINKFLAGS_BODY([$1], [$2]) -+ ac_cv_lib[]Name[]_libs="$LIB[]NAME" -+ ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME" -+ ac_cv_lib[]Name[]_cppflags="$INC[]NAME" -+ ]) -+ LIB[]NAME="$ac_cv_lib[]Name[]_libs" -+ LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs" -+ INC[]NAME="$ac_cv_lib[]Name[]_cppflags" -+ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME) -+ AC_SUBST([LIB]NAME) -+ AC_SUBST([LTLIB]NAME) -+ dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the -+ dnl results of this search when this library appears as a dependency. -+ HAVE_LIB[]NAME=yes -+ undefine([Name]) -+ undefine([NAME]) -+]) -+ -+dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode) -+dnl searches for libname and the libraries corresponding to explicit and -+dnl implicit dependencies, together with the specified include files and -+dnl the ability to compile and link the specified testcode. If found, it -+dnl sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} and -+dnl LTLIB${NAME} variables and augments the CPPFLAGS variable, and -+dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs -+dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty. -+AC_DEFUN([AC_LIB_HAVE_LINKFLAGS], -+[ -+ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) -+ AC_REQUIRE([AC_LIB_RPATH]) -+ define([Name],[translit([$1],[./-], [___])]) -+ define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], -+ [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) -+ -+ dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME -+ dnl accordingly. -+ AC_LIB_LINKFLAGS_BODY([$1], [$2]) -+ -+ dnl Add $INC[]NAME to CPPFLAGS before performing the following checks, -+ dnl because if the user has installed lib[]Name and not disabled its use -+ dnl via --without-lib[]Name-prefix, he wants to use it. -+ ac_save_CPPFLAGS="$CPPFLAGS" -+ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME) -+ -+ AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [ -+ ac_save_LIBS="$LIBS" -+ LIBS="$LIBS $LIB[]NAME" -+ AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no]) -+ LIBS="$ac_save_LIBS" -+ ]) -+ if test "$ac_cv_lib[]Name" = yes; then -+ HAVE_LIB[]NAME=yes -+ AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the $1 library.]) -+ AC_MSG_CHECKING([how to link with lib[]$1]) -+ AC_MSG_RESULT([$LIB[]NAME]) -+ else -+ HAVE_LIB[]NAME=no -+ dnl If $LIB[]NAME didn't lead to a usable library, we don't need -+ dnl $INC[]NAME either. -+ CPPFLAGS="$ac_save_CPPFLAGS" -+ LIB[]NAME= -+ LTLIB[]NAME= -+ fi -+ AC_SUBST([HAVE_LIB]NAME) -+ AC_SUBST([LIB]NAME) -+ AC_SUBST([LTLIB]NAME) -+ undefine([Name]) -+ undefine([NAME]) -+]) -+ -+dnl Determine the platform dependent parameters needed to use rpath: -+dnl libext, shlibext, hardcode_libdir_flag_spec, hardcode_libdir_separator, -+dnl hardcode_direct, hardcode_minus_L, -+dnl sys_lib_search_path_spec, sys_lib_dlsearch_path_spec. -+AC_DEFUN([AC_LIB_RPATH], -+[ -+ AC_REQUIRE([AC_PROG_CC]) dnl we use $CC, $GCC, $LDFLAGS -+ AC_REQUIRE([AC_LIB_PROG_LD]) dnl we use $LD, $with_gnu_ld -+ AC_REQUIRE([AC_CANONICAL_HOST]) dnl we use $host -+ AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir -+ AC_CACHE_CHECK([for shared library run path origin], acl_cv_rpath, [ -+ CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \ -+ ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh -+ . ./conftest.sh -+ rm -f ./conftest.sh -+ acl_cv_rpath=done -+ ]) -+ wl="$acl_cv_wl" -+ libext="$acl_cv_libext" -+ shlibext="$acl_cv_shlibext" -+ hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec" -+ hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator" -+ hardcode_direct="$acl_cv_hardcode_direct" -+ hardcode_minus_L="$acl_cv_hardcode_minus_L" -+ sys_lib_search_path_spec="$acl_cv_sys_lib_search_path_spec" -+ sys_lib_dlsearch_path_spec="$acl_cv_sys_lib_dlsearch_path_spec" -+ dnl Determine whether the user wants rpath handling at all. -+ AC_ARG_ENABLE(rpath, -+ [ --disable-rpath do not hardcode runtime library paths], -+ :, enable_rpath=yes) -+]) -+ -+dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and -+dnl the libraries corresponding to explicit and implicit dependencies. -+dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables. -+AC_DEFUN([AC_LIB_LINKFLAGS_BODY], -+[ -+ define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], -+ [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) -+ dnl By default, look in $includedir and $libdir. -+ use_additional=yes -+ AC_LIB_WITH_FINAL_PREFIX([ -+ eval additional_includedir=\"$includedir\" -+ eval additional_libdir=\"$libdir\" -+ ]) -+ AC_ARG_WITH([lib$1-prefix], -+[ --with-lib$1-prefix[=DIR] search for lib$1 in DIR/include and DIR/lib -+ --without-lib$1-prefix don't search for lib$1 in includedir and libdir], -+[ -+ if test "X$withval" = "Xno"; then -+ use_additional=no -+ else -+ if test "X$withval" = "X"; then -+ AC_LIB_WITH_FINAL_PREFIX([ -+ eval additional_includedir=\"$includedir\" -+ eval additional_libdir=\"$libdir\" -+ ]) -+ else -+ additional_includedir="$withval/include" -+ additional_libdir="$withval/lib" -+ fi -+ fi -+]) -+ dnl Search the library and its dependencies in $additional_libdir and -+ dnl $LDFLAGS. Using breadth-first-seach. -+ LIB[]NAME= -+ LTLIB[]NAME= -+ INC[]NAME= -+ rpathdirs= -+ ltrpathdirs= -+ names_already_handled= -+ names_next_round='$1 $2' -+ while test -n "$names_next_round"; do -+ names_this_round="$names_next_round" -+ names_next_round= -+ for name in $names_this_round; do -+ already_handled= -+ for n in $names_already_handled; do -+ if test "$n" = "$name"; then -+ already_handled=yes -+ break -+ fi -+ done -+ if test -z "$already_handled"; then -+ names_already_handled="$names_already_handled $name" -+ dnl See if it was already located by an earlier AC_LIB_LINKFLAGS -+ dnl or AC_LIB_HAVE_LINKFLAGS call. -+ uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'` -+ eval value=\"\$HAVE_LIB$uppername\" -+ if test -n "$value"; then -+ if test "$value" = yes; then -+ eval value=\"\$LIB$uppername\" -+ test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value" -+ eval value=\"\$LTLIB$uppername\" -+ test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value" -+ else -+ dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined -+ dnl that this library doesn't exist. So just drop it. -+ : -+ fi -+ else -+ dnl Search the library lib$name in $additional_libdir and $LDFLAGS -+ dnl and the already constructed $LIBNAME/$LTLIBNAME. -+ found_dir= -+ found_la= -+ found_so= -+ found_a= -+ if test $use_additional = yes; then -+ if test -n "$shlibext" && test -f "$additional_libdir/lib$name.$shlibext"; then -+ found_dir="$additional_libdir" -+ found_so="$additional_libdir/lib$name.$shlibext" -+ if test -f "$additional_libdir/lib$name.la"; then -+ found_la="$additional_libdir/lib$name.la" -+ fi -+ else -+ if test -f "$additional_libdir/lib$name.$libext"; then -+ found_dir="$additional_libdir" -+ found_a="$additional_libdir/lib$name.$libext" -+ if test -f "$additional_libdir/lib$name.la"; then -+ found_la="$additional_libdir/lib$name.la" -+ fi -+ fi -+ fi -+ fi -+ if test "X$found_dir" = "X"; then -+ for x in $LDFLAGS $LTLIB[]NAME; do -+ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -+ case "$x" in -+ -L*) -+ dir=`echo "X$x" | sed -e 's/^X-L//'` -+ if test -n "$shlibext" && test -f "$dir/lib$name.$shlibext"; then -+ found_dir="$dir" -+ found_so="$dir/lib$name.$shlibext" -+ if test -f "$dir/lib$name.la"; then -+ found_la="$dir/lib$name.la" -+ fi -+ else -+ if test -f "$dir/lib$name.$libext"; then -+ found_dir="$dir" -+ found_a="$dir/lib$name.$libext" -+ if test -f "$dir/lib$name.la"; then -+ found_la="$dir/lib$name.la" -+ fi -+ fi -+ fi -+ ;; -+ esac -+ if test "X$found_dir" != "X"; then -+ break -+ fi -+ done -+ fi -+ if test "X$found_dir" != "X"; then -+ dnl Found the library. -+ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name" -+ if test "X$found_so" != "X"; then -+ dnl Linking with a shared library. We attempt to hardcode its -+ dnl directory into the executable's runpath, unless it's the -+ dnl standard /usr/lib. -+ if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/lib"; then -+ dnl No hardcoding is needed. -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" -+ else -+ dnl Use an explicit option to hardcode DIR into the resulting -+ dnl binary. -+ dnl Potentially add DIR to ltrpathdirs. -+ dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. -+ haveit= -+ for x in $ltrpathdirs; do -+ if test "X$x" = "X$found_dir"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ ltrpathdirs="$ltrpathdirs $found_dir" -+ fi -+ dnl The hardcoding into $LIBNAME is system dependent. -+ if test "$hardcode_direct" = yes; then -+ dnl Using DIR/libNAME.so during linking hardcodes DIR into the -+ dnl resulting binary. -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" -+ else -+ if test -n "$hardcode_libdir_flag_spec" && test "$hardcode_minus_L" = no; then -+ dnl Use an explicit option to hardcode DIR into the resulting -+ dnl binary. -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" -+ dnl Potentially add DIR to rpathdirs. -+ dnl The rpathdirs will be appended to $LIBNAME at the end. -+ haveit= -+ for x in $rpathdirs; do -+ if test "X$x" = "X$found_dir"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ rpathdirs="$rpathdirs $found_dir" -+ fi -+ else -+ dnl Rely on "-L$found_dir". -+ dnl But don't add it if it's already contained in the LDFLAGS -+ dnl or the already constructed $LIBNAME -+ haveit= -+ for x in $LDFLAGS $LIB[]NAME; do -+ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -+ if test "X$x" = "X-L$found_dir"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir" -+ fi -+ if test "$hardcode_minus_L" != no; then -+ dnl FIXME: Not sure whether we should use -+ dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" -+ dnl here. -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" -+ else -+ dnl We cannot use $hardcode_runpath_var and LD_RUN_PATH -+ dnl here, because this doesn't fit in flags passed to the -+ dnl compiler. So give up. No hardcoding. This affects only -+ dnl very old systems. -+ dnl FIXME: Not sure whether we should use -+ dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" -+ dnl here. -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" -+ fi -+ fi -+ fi -+ fi -+ else -+ if test "X$found_a" != "X"; then -+ dnl Linking with a static library. -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a" -+ else -+ dnl We shouldn't come here, but anyway it's good to have a -+ dnl fallback. -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name" -+ fi -+ fi -+ dnl Assume the include files are nearby. -+ additional_includedir= -+ case "$found_dir" in -+ */lib | */lib/) -+ basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e 's,/lib/*$,,'` -+ additional_includedir="$basedir/include" -+ ;; -+ esac -+ if test "X$additional_includedir" != "X"; then -+ dnl Potentially add $additional_includedir to $INCNAME. -+ dnl But don't add it -+ dnl 1. if it's the standard /usr/include, -+ dnl 2. if it's /usr/local/include and we are using GCC on Linux, -+ dnl 3. if it's already present in $CPPFLAGS or the already -+ dnl constructed $INCNAME, -+ dnl 4. if it doesn't exist as a directory. -+ if test "X$additional_includedir" != "X/usr/include"; then -+ haveit= -+ if test "X$additional_includedir" = "X/usr/local/include"; then -+ if test -n "$GCC"; then -+ case $host_os in -+ linux*) haveit=yes;; -+ esac -+ fi -+ fi -+ if test -z "$haveit"; then -+ for x in $CPPFLAGS $INC[]NAME; do -+ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -+ if test "X$x" = "X-I$additional_includedir"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ if test -d "$additional_includedir"; then -+ dnl Really add $additional_includedir to $INCNAME. -+ INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir" -+ fi -+ fi -+ fi -+ fi -+ fi -+ dnl Look for dependencies. -+ if test -n "$found_la"; then -+ dnl Read the .la file. It defines the variables -+ dnl dlname, library_names, old_library, dependency_libs, current, -+ dnl age, revision, installed, dlopen, dlpreopen, libdir. -+ save_libdir="$libdir" -+ case "$found_la" in -+ */* | *\\*) . "$found_la" ;; -+ *) . "./$found_la" ;; -+ esac -+ libdir="$save_libdir" -+ dnl We use only dependency_libs. -+ for dep in $dependency_libs; do -+ case "$dep" in -+ -L*) -+ additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'` -+ dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME. -+ dnl But don't add it -+ dnl 1. if it's the standard /usr/lib, -+ dnl 2. if it's /usr/local/lib and we are using GCC on Linux, -+ dnl 3. if it's already present in $LDFLAGS or the already -+ dnl constructed $LIBNAME, -+ dnl 4. if it doesn't exist as a directory. -+ if test "X$additional_libdir" != "X/usr/lib"; then -+ haveit= -+ if test "X$additional_libdir" = "X/usr/local/lib"; then -+ if test -n "$GCC"; then -+ case $host_os in -+ linux*) haveit=yes;; -+ esac -+ fi -+ fi -+ if test -z "$haveit"; then -+ haveit= -+ for x in $LDFLAGS $LIB[]NAME; do -+ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -+ if test "X$x" = "X-L$additional_libdir"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ if test -d "$additional_libdir"; then -+ dnl Really add $additional_libdir to $LIBNAME. -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir" -+ fi -+ fi -+ haveit= -+ for x in $LDFLAGS $LTLIB[]NAME; do -+ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -+ if test "X$x" = "X-L$additional_libdir"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ if test -d "$additional_libdir"; then -+ dnl Really add $additional_libdir to $LTLIBNAME. -+ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir" -+ fi -+ fi -+ fi -+ fi -+ ;; -+ -R*) -+ dir=`echo "X$dep" | sed -e 's/^X-R//'` -+ if test "$enable_rpath" != no; then -+ dnl Potentially add DIR to rpathdirs. -+ dnl The rpathdirs will be appended to $LIBNAME at the end. -+ haveit= -+ for x in $rpathdirs; do -+ if test "X$x" = "X$dir"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ rpathdirs="$rpathdirs $dir" -+ fi -+ dnl Potentially add DIR to ltrpathdirs. -+ dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. -+ haveit= -+ for x in $ltrpathdirs; do -+ if test "X$x" = "X$dir"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ ltrpathdirs="$ltrpathdirs $dir" -+ fi -+ fi -+ ;; -+ -l*) -+ dnl Handle this in the next round. -+ names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'` -+ ;; -+ *.la) -+ dnl Handle this in the next round. Throw away the .la's -+ dnl directory; it is already contained in a preceding -L -+ dnl option. -+ names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'` -+ ;; -+ *) -+ dnl Most likely an immediate library name. -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep" -+ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep" -+ ;; -+ esac -+ done -+ fi -+ else -+ dnl Didn't find the library; assume it is in the system directories -+ dnl known to the linker and runtime loader. (All the system -+ dnl directories known to the linker should also be known to the -+ dnl runtime loader, otherwise the system is severely misconfigured.) -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" -+ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name" -+ fi -+ fi -+ fi -+ done -+ done -+ if test "X$rpathdirs" != "X"; then -+ if test -n "$hardcode_libdir_separator"; then -+ dnl Weird platform: only the last -rpath option counts, the user must -+ dnl pass all path elements in one option. We can arrange that for a -+ dnl single library, but not when more than one $LIBNAMEs are used. -+ alldirs= -+ for found_dir in $rpathdirs; do -+ alldirs="${alldirs}${alldirs:+$hardcode_libdir_separator}$found_dir" -+ done -+ dnl Note: hardcode_libdir_flag_spec uses $libdir and $wl. -+ acl_save_libdir="$libdir" -+ libdir="$alldirs" -+ eval flag=\"$hardcode_libdir_flag_spec\" -+ libdir="$acl_save_libdir" -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" -+ else -+ dnl The -rpath options are cumulative. -+ for found_dir in $rpathdirs; do -+ acl_save_libdir="$libdir" -+ libdir="$found_dir" -+ eval flag=\"$hardcode_libdir_flag_spec\" -+ libdir="$acl_save_libdir" -+ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" -+ done -+ fi -+ fi -+ if test "X$ltrpathdirs" != "X"; then -+ dnl When using libtool, the option that works for both libraries and -+ dnl executables is -R. The -R options are cumulative. -+ for found_dir in $ltrpathdirs; do -+ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir" -+ done -+ fi -+]) -+ -+dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR, -+dnl unless already present in VAR. -+dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes -+dnl contains two or three consecutive elements that belong together. -+AC_DEFUN([AC_LIB_APPENDTOVAR], -+[ -+ for element in [$2]; do -+ haveit= -+ for x in $[$1]; do -+ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -+ if test "X$x" = "X$element"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ [$1]="${[$1]}${[$1]:+ }$element" -+ fi -+ done -+]) ---- /dev/null -+++ tin-1.7.3/m4/lib-prefix.m4 -@@ -0,0 +1,148 @@ -+# lib-prefix.m4 serial 1 (gettext-0.11) -+dnl Copyright (C) 2001-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Bruno Haible. -+ -+dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed -+dnl to access previously installed libraries. The basic assumption is that -+dnl a user will want packages to use other packages he previously installed -+dnl with the same --prefix option. -+dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate -+dnl libraries, but is otherwise very convenient. -+AC_DEFUN([AC_LIB_PREFIX], -+[ -+ AC_BEFORE([$0], [AC_LIB_LINKFLAGS]) -+ AC_REQUIRE([AC_PROG_CC]) -+ AC_REQUIRE([AC_CANONICAL_HOST]) -+ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) -+ dnl By default, look in $includedir and $libdir. -+ use_additional=yes -+ AC_LIB_WITH_FINAL_PREFIX([ -+ eval additional_includedir=\"$includedir\" -+ eval additional_libdir=\"$libdir\" -+ ]) -+ AC_ARG_WITH([lib-prefix], -+[ --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib -+ --without-lib-prefix don't search for libraries in includedir and libdir], -+[ -+ if test "X$withval" = "Xno"; then -+ use_additional=no -+ else -+ if test "X$withval" = "X"; then -+ AC_LIB_WITH_FINAL_PREFIX([ -+ eval additional_includedir=\"$includedir\" -+ eval additional_libdir=\"$libdir\" -+ ]) -+ else -+ additional_includedir="$withval/include" -+ additional_libdir="$withval/lib" -+ fi -+ fi -+]) -+ if test $use_additional = yes; then -+ dnl Potentially add $additional_includedir to $CPPFLAGS. -+ dnl But don't add it -+ dnl 1. if it's the standard /usr/include, -+ dnl 2. if it's already present in $CPPFLAGS, -+ dnl 3. if it's /usr/local/include and we are using GCC on Linux, -+ dnl 4. if it doesn't exist as a directory. -+ if test "X$additional_includedir" != "X/usr/include"; then -+ haveit= -+ for x in $CPPFLAGS; do -+ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -+ if test "X$x" = "X-I$additional_includedir"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ if test "X$additional_includedir" = "X/usr/local/include"; then -+ if test -n "$GCC"; then -+ case $host_os in -+ linux*) haveit=yes;; -+ esac -+ fi -+ fi -+ if test -z "$haveit"; then -+ if test -d "$additional_includedir"; then -+ dnl Really add $additional_includedir to $CPPFLAGS. -+ CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir" -+ fi -+ fi -+ fi -+ fi -+ dnl Potentially add $additional_libdir to $LDFLAGS. -+ dnl But don't add it -+ dnl 1. if it's the standard /usr/lib, -+ dnl 2. if it's already present in $LDFLAGS, -+ dnl 3. if it's /usr/local/lib and we are using GCC on Linux, -+ dnl 4. if it doesn't exist as a directory. -+ if test "X$additional_libdir" != "X/usr/lib"; then -+ haveit= -+ for x in $LDFLAGS; do -+ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -+ if test "X$x" = "X-L$additional_libdir"; then -+ haveit=yes -+ break -+ fi -+ done -+ if test -z "$haveit"; then -+ if test "X$additional_libdir" = "X/usr/local/lib"; then -+ if test -n "$GCC"; then -+ case $host_os in -+ linux*) haveit=yes;; -+ esac -+ fi -+ fi -+ if test -z "$haveit"; then -+ if test -d "$additional_libdir"; then -+ dnl Really add $additional_libdir to $LDFLAGS. -+ LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir" -+ fi -+ fi -+ fi -+ fi -+ fi -+]) -+ -+dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix, -+dnl acl_final_exec_prefix, containing the values to which $prefix and -+dnl $exec_prefix will expand at the end of the configure script. -+AC_DEFUN([AC_LIB_PREPARE_PREFIX], -+[ -+ dnl Unfortunately, prefix and exec_prefix get only finally determined -+ dnl at the end of configure. -+ if test "X$prefix" = "XNONE"; then -+ acl_final_prefix="$ac_default_prefix" -+ else -+ acl_final_prefix="$prefix" -+ fi -+ if test "X$exec_prefix" = "XNONE"; then -+ acl_final_exec_prefix='${prefix}' -+ else -+ acl_final_exec_prefix="$exec_prefix" -+ fi -+ acl_save_prefix="$prefix" -+ prefix="$acl_final_prefix" -+ eval acl_final_exec_prefix=\"$acl_final_exec_prefix\" -+ prefix="$acl_save_prefix" -+]) -+ -+dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the -+dnl variables prefix and exec_prefix bound to the values they will have -+dnl at the end of the configure script. -+AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX], -+[ -+ acl_save_prefix="$prefix" -+ prefix="$acl_final_prefix" -+ acl_save_exec_prefix="$exec_prefix" -+ exec_prefix="$acl_final_exec_prefix" -+ $1 -+ exec_prefix="$acl_save_exec_prefix" -+ prefix="$acl_save_prefix" -+]) ---- /dev/null -+++ tin-1.7.3/m4/progtest.m4 -@@ -0,0 +1,59 @@ -+# progtest.m4 serial 2 (gettext-0.10.40) -+dnl Copyright (C) 1996-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+dnl -+dnl This file can can be used in projects which are not available under -+dnl the GNU General Public License or the GNU Library General Public -+dnl License but which still want to provide support for the GNU gettext -+dnl functionality. -+dnl Please note that the actual code of the GNU gettext library is covered -+dnl by the GNU Library General Public License, and the rest of the GNU -+dnl gettext package package is covered by the GNU General Public License. -+dnl They are *not* in the public domain. -+ -+dnl Authors: -+dnl Ulrich Drepper , 1996. -+ -+# Search path for a program which passes the given test. -+ -+dnl AM_PATH_PROG_WITH_TEST(VARIABLE, PROG-TO-CHECK-FOR, -+dnl TEST-PERFORMED-ON-FOUND_PROGRAM [, VALUE-IF-NOT-FOUND [, PATH]]) -+AC_DEFUN([AM_PATH_PROG_WITH_TEST], -+[# Extract the first word of "$2", so it can be a program name with args. -+set dummy $2; ac_word=[$]2 -+AC_MSG_CHECKING([for $ac_word]) -+AC_CACHE_VAL(ac_cv_path_$1, -+[case "[$]$1" in -+ /*) -+ ac_cv_path_$1="[$]$1" # Let the user override the test with a path. -+ ;; -+ *) -+ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" -+ for ac_dir in ifelse([$5], , $PATH, [$5]); do -+ test -z "$ac_dir" && ac_dir=. -+ if test -f $ac_dir/$ac_word; then -+ if [$3]; then -+ ac_cv_path_$1="$ac_dir/$ac_word" -+ break -+ fi -+ fi -+ done -+ IFS="$ac_save_ifs" -+dnl If no 4th arg is given, leave the cache variable unset, -+dnl so AC_PATH_PROGS will keep looking. -+ifelse([$4], , , [ test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4" -+])dnl -+ ;; -+esac])dnl -+$1="$ac_cv_path_$1" -+if test ifelse([$4], , [-n "[$]$1"], ["[$]$1" != "$4"]); then -+ AC_MSG_RESULT([$]$1) -+else -+ AC_MSG_RESULT(no) -+fi -+AC_SUBST($1)dnl -+]) ---- /dev/null -+++ tin-1.7.3/m4/stdint_h.m4 -@@ -0,0 +1,28 @@ -+# stdint_h.m4 serial 2 (gettext-0.11.4) -+dnl Copyright (C) 1997-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Paul Eggert. -+ -+# Define HAVE_STDINT_H_WITH_UINTMAX if exists, -+# doesn't clash with , and declares uintmax_t. -+ -+AC_DEFUN([jm_AC_HEADER_STDINT_H], -+[ -+ AC_CACHE_CHECK([for stdint.h], jm_ac_cv_header_stdint_h, -+ [AC_TRY_COMPILE( -+ [#include -+#include ], -+ [uintmax_t i = (uintmax_t) -1;], -+ jm_ac_cv_header_stdint_h=yes, -+ jm_ac_cv_header_stdint_h=no)]) -+ if test $jm_ac_cv_header_stdint_h = yes; then -+ AC_DEFINE_UNQUOTED(HAVE_STDINT_H_WITH_UINTMAX, 1, -+[Define if exists, doesn't clash with , -+ and declares uintmax_t. ]) -+ fi -+]) ---- /dev/null -+++ tin-1.7.3/m4/uintmax_t.m4 -@@ -0,0 +1,29 @@ -+# uintmax_t.m4 serial 6 (gettext-0.11) -+dnl Copyright (C) 1997-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Paul Eggert. -+ -+AC_PREREQ(2.13) -+ -+# Define uintmax_t to `unsigned long' or `unsigned long long' -+# if does not exist. -+ -+AC_DEFUN([jm_AC_TYPE_UINTMAX_T], -+[ -+ AC_REQUIRE([jm_AC_HEADER_INTTYPES_H]) -+ AC_REQUIRE([jm_AC_HEADER_STDINT_H]) -+ if test $jm_ac_cv_header_inttypes_h = no && test $jm_ac_cv_header_stdint_h = no; then -+ AC_REQUIRE([jm_AC_TYPE_UNSIGNED_LONG_LONG]) -+ test $ac_cv_type_unsigned_long_long = yes \ -+ && ac_type='unsigned long long' \ -+ || ac_type='unsigned long' -+ AC_DEFINE_UNQUOTED(uintmax_t, $ac_type, -+ [Define to unsigned long or unsigned long long -+ if and don't define.]) -+ fi -+]) ---- /dev/null -+++ tin-1.7.3/m4/ulonglong.m4 -@@ -0,0 +1,23 @@ -+# ulonglong.m4 serial 2 (fileutils-4.0.32, gettext-0.10.40) -+dnl Copyright (C) 1999-2002 Free Software Foundation, Inc. -+dnl This file is free software, distributed under the terms of the GNU -+dnl General Public License. As a special exception to the GNU General -+dnl Public License, this file may be distributed as part of a program -+dnl that contains a configuration script generated by Autoconf, under -+dnl the same distribution terms as the rest of that program. -+ -+dnl From Paul Eggert. -+ -+AC_DEFUN([jm_AC_TYPE_UNSIGNED_LONG_LONG], -+[ -+ AC_CACHE_CHECK([for unsigned long long], ac_cv_type_unsigned_long_long, -+ [AC_TRY_LINK([unsigned long long ull = 1; int i = 63;], -+ [unsigned long long ullmax = (unsigned long long) -1; -+ return ull << i | ull >> i | ullmax / ull | ullmax % ull;], -+ ac_cv_type_unsigned_long_long=yes, -+ ac_cv_type_unsigned_long_long=no)]) -+ if test $ac_cv_type_unsigned_long_long = yes; then -+ AC_DEFINE(HAVE_UNSIGNED_LONG_LONG, 1, -+ [Define if you have the unsigned long long type.]) -+ fi -+]) ---- /dev/null -+++ tin-1.7.3/acinclude.m4 -@@ -0,0 +1,3671 @@ -+dnl --------------------------------------------------------------------------- -+dnl AM_MULTIBYTE_ABLE version: 5 updated: 2003/01/16 16:21:27 -+dnl ----------------- -+ -+dnl check for required multibyte/widechar functions -+dnl Urs Janssen 20021006 -+dnl Usage: AM_MULTIBYTE_ABLE -+AC_DEFUN([AM_MULTIBYTE_ABLE], -+[ -+ AC_CACHE_CHECK([for wide char and multibyte support], am_cv_multibyte_able, -+ [AC_TRY_LINK([#include -+#ifdef HAVE_STDLIB_H -+# include -+#endif /* HAVE_STDLIB_H */ -+#ifdef HAVE_WCHAR_H -+# include -+#endif /* HAVE_WCHAR_H */ -+#ifdef HAVE_WCTYPE_H -+# include -+#endif /* HAVE_WCTYPE_H */ -+], -+ [char icb[5] = {0xa4, 0xa4, 0xa4, 0xe5, 0x00}; -+ char ocb[5]; -+ wchar_t wcb[5]; -+ wchar_t wcb2[5]; -+ wchar_t format[3]; -+ -+ putwc(0, 0); -+ fputwc(0, 0); -+ fwide(0, 0); -+ mbtowc(wcb, icb, MB_CUR_MAX); -+ mbstowcs(wcb, icb, 5); -+ iswprint((wint_t) wcb[0]); -+ wcslen(wcb); -+ wcsnlen(wcb, 4); -+ wcwidth((wint_t) wcb[0]); -+ wcswidth(wcb, 5); -+ wcstombs(ocb, wcb, 5); -+ mbstowcs(format, "%s", 2); -+ swprintf(wcb, 5, format, "test"); -+ wcsncat(wcb2, wcb, 5);], -+ am_cv_multibyte_able=yes, -+ [cf_save_LIBS="$LIBS" -+ LIBS="-lutf8 $LIBS" -+ AC_TRY_LINK([#include ], -+ [char icb[5] = {0xa4, 0xa4, 0xa4, 0xe5, 0x00}; -+ char ocb[5]; -+ wchar_t wcb[5]; -+ wchar_t wcb2[5]; -+ wchar_t format[3]; -+ -+ putwc(0, 0); -+ fputwc(0, 0); -+ fwide(0, 0); -+ mbtowc(wcb, icb, MB_CUR_MAX); -+ mbstowcs(wcb, icb, 5); -+ iswprint((wint_t) wcb[0]); -+ wcslen(wcb); -+ wcsnlen(wcb, 4); -+ wcwidth((wint_t) wcb[0]); -+ wcswidth(wcb, 5); -+ wcstombs(ocb, wcb, 5); -+ mbstowcs(format, "%s", 2); -+ swprintf(wcb, 5, format, "test"); -+ wcsncat(wcb2, wcb, 5);], -+ [am_cv_multibyte_able=yes -+ have_libutf8_h=yes], -+ [am_cv_multibyte_able=no -+ LIBS="$cf_save_LIBS"]) -+ ]) -+ ]) -+ if test $am_cv_multibyte_able = yes; then -+ AC_DEFINE(MULTIBYTE_ABLE, 1, -+ [Define if you have swprintf() and co.]) -+ if test $have_libutf8_h = yes; then -+ AC_DEFINE(HAVE_LIBUTF8_H) -+ fi -+ fi -+]) -+dnl --------------------------------------------------------------------------- -+dnl CF_ADD_CFLAGS version: 5 updated: 2002/12/01 00:12:15 -+dnl ------------- -+dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS -+dnl The second parameter if given makes this macro verbose. -+AC_DEFUN([CF_ADD_CFLAGS], -+[ -+cf_new_cflags= -+cf_new_cppflags= -+for cf_add_cflags in $1 -+do -+ case $cf_add_cflags in #(vi -+ -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi -+ case "$CPPFLAGS" in -+ *$cf_add_cflags) #(vi -+ ;; -+ *) #(vi -+ cf_new_cppflags="$cf_new_cppflags $cf_add_cflags" -+ ;; -+ esac -+ ;; -+ *) -+ cf_new_cflags="$cf_new_cflags $cf_add_cflags" -+ ;; -+ esac -+done -+ -+if test -n "$cf_new_cflags" ; then -+ ifelse($2,,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)]) -+ CFLAGS="$CFLAGS $cf_new_cflags" -+fi -+ -+if test -n "$cf_new_cppflags" ; then -+ ifelse($2,,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)]) -+ CPPFLAGS="$cf_new_cppflags $CPPFLAGS" -+fi -+ -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_ADD_INCDIR version: 4 updated: 2002/12/21 14:25:52 -+dnl ------------- -+dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's -+dnl redundant. We don't normally need to add -I/usr/local/include for gcc, -+dnl but old versions (and some misinstalled ones) need that. To make things -+dnl worse, gcc 3.x gives error messages if -I/usr/local/include is added to -+dnl the include-path). -+AC_DEFUN([CF_ADD_INCDIR], -+[ -+for cf_add_incdir in $1 -+do -+ while true -+ do -+ case $cf_add_incdir in -+ /usr/include) # (vi -+ ;; -+ /usr/local/include) # (vi -+ if test "$GCC" = yes -+ then -+ cf_save_CPPFLAGS="$CPPFLAGS" -+ CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" -+ AC_TRY_COMPILE([#include ], -+ [printf("Hello")], -+ [], -+ [CPPFLAGS="$cf_save_CPPFLAGS"]) -+ fi -+ ;; -+ *) # (vi -+ CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" -+ ;; -+ esac -+ cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` -+ test "$cf_top_incdir" = "$cf_add_incdir" && break -+ cf_add_incdir="$cf_top_incdir" -+ done -+done -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34 -+dnl ---------------- -+dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES' -+dnl in the sharutils 4.2 distribution. -+AC_DEFUN([CF_ANSI_CC_CHECK], -+[ -+AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[ -+cf_cv_ansi_cc=no -+cf_save_CFLAGS="$CFLAGS" -+cf_save_CPPFLAGS="$CPPFLAGS" -+# Don't try gcc -ansi; that turns off useful extensions and -+# breaks some systems' header files. -+# AIX -qlanglvl=ansi -+# Ultrix and OSF/1 -std1 -+# HP-UX -Aa -D_HPUX_SOURCE -+# SVR4 -Xc -+# UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes) -+for cf_arg in "-DCC_HAS_PROTOS" \ -+ "" \ -+ -qlanglvl=ansi \ -+ -std1 \ -+ -Ae \ -+ "-Aa -D_HPUX_SOURCE" \ -+ -Xc -+do -+ CF_ADD_CFLAGS($cf_arg) -+ AC_TRY_COMPILE( -+[ -+#ifndef CC_HAS_PROTOS -+#if !defined(__STDC__) || (__STDC__ != 1) -+choke me -+#endif -+#endif -+],[ -+ int test (int i, double x); -+ struct s1 {int (*f) (int a);}; -+ struct s2 {int (*f) (double a);};], -+ [cf_cv_ansi_cc="$cf_arg"; break]) -+done -+CFLAGS="$cf_save_CFLAGS" -+CPPFLAGS="$cf_save_CPPFLAGS" -+]) -+ -+if test "$cf_cv_ansi_cc" != "no"; then -+if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then -+ CF_ADD_CFLAGS($cf_cv_ansi_cc) -+else -+ AC_DEFINE(CC_HAS_PROTOS) -+fi -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_ANSI_CC_REQD version: 3 updated: 1997/09/06 13:40:44 -+dnl --------------- -+dnl For programs that must use an ANSI compiler, obtain compiler options that -+dnl will make it recognize prototypes. We'll do preprocessor checks in other -+dnl macros, since tools such as unproto can fake prototypes, but only part of -+dnl the preprocessor. -+AC_DEFUN([CF_ANSI_CC_REQD], -+[AC_REQUIRE([CF_ANSI_CC_CHECK]) -+if test "$cf_cv_ansi_cc" = "no"; then -+ AC_ERROR( -+[Your compiler does not appear to recognize prototypes. -+You have the following choices: -+ a. adjust your compiler options -+ b. get an up-to-date compiler -+ c. use a wrapper such as unproto]) -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_ARG_DISABLE version: 3 updated: 1999/03/30 17:24:31 -+dnl -------------- -+dnl Allow user to disable a normally-on option. -+AC_DEFUN([CF_ARG_DISABLE], -+[CF_ARG_OPTION($1,[$2],[$3],[$4],yes)])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31 -+dnl ------------- -+dnl Allow user to enable a normally-off option. -+AC_DEFUN([CF_ARG_ENABLE], -+[CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_ARG_OPTION version: 3 updated: 1997/10/18 14:42:41 -+dnl ------------- -+dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus -+dnl values. -+dnl -+dnl Parameters: -+dnl $1 = option name -+dnl $2 = help-string -+dnl $3 = action to perform if option is not default -+dnl $4 = action if perform if option is default -+dnl $5 = default option value (either 'yes' or 'no') -+AC_DEFUN([CF_ARG_OPTION], -+[AC_ARG_ENABLE($1,[$2],[test "$enableval" != ifelse($5,no,yes,no) && enableval=ifelse($5,no,no,yes) -+ if test "$enableval" != "$5" ; then -+ifelse($3,,[ :]dnl -+,[ $3]) ifelse($4,,,[ -+ else -+ $4]) -+ fi],[enableval=$5 ifelse($4,,,[ -+ $4 -+])dnl -+ ])])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_ARG_WITH version: 3 updated: 2000/07/20 00:41:18 -+dnl ----------- -+dnl Restricted form of AC_ARG_WITH that requires user to specify a value -+dnl $1 = option name -+dnl $2 = help message -+dnl $3 = variable to set with the --with value -+dnl $4 = default value, if any, must be constant. -+dnl $5 = default value shown for --help if $4 is empty. -+AC_DEFUN([CF_ARG_WITH], -+[AC_ARG_WITH($1,[$2 ](default: ifelse($4,,ifelse($5,,empty,$5),$4)),, -+ifelse($4,,[withval="${$3}"],[withval="${$3-$4}"]))dnl -+ifelse($4,,[test -n "$withval" && \ -+],[test -z "$withval" && withval=no -+])dnl -+case "$withval" in #(vi -+yes) -+ AC_ERROR(expected a value for --with-$1) -+ ;; #(vi -+no) withval="" -+ ;; -+esac -+$3="$withval" -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_BUNDLED_INTL version: 6 updated: 2003/06/06 00:48:41 -+dnl --------------- -+dnl Top-level macro for configuring an application with a bundled copy of -+dnl the intl and po directories for gettext. -+dnl -+dnl $1 specifies either Makefile or makefile, defaulting to the former. -+dnl $2 if nonempty sets the option to --enable-nls rather than to --disable-nls -+dnl -+dnl Sets variables which can be used to substitute in makefiles: -+dnl INTLDIR_MAKE - to make ./intl directory -+dnl MSG_DIR_MAKE - to make ./po directory -+dnl SUB_MAKEFILE - list of makefiles in ./intl, ./po directories -+dnl Defines -+dnl HAVE_LIBGETTEXT_H if we're using ./intl -+dnl -+AC_DEFUN([CF_BUNDLED_INTL],[ -+cf_makefile=ifelse($1,,Makefile,$1) -+ -+dnl Set of available languages (based on source distribution). Note that -+dnl setting $LINGUAS overrides $ALL_LINGUAS. Some environments set $LINGUAS -+dnl rather than $LC_ALL -+test -z "$ALL_LINGUAS" && ALL_LINGUAS=`test -d $srcdir/po && cd $srcdir/po && echo *.po|sed -e 's/\.po//g' -e 's/*//'` -+ -+AM_GNU_GETTEXT(,,,[$2]) -+ -+INTLDIR_MAKE= -+MSG_DIR_MAKE= -+SUB_MAKEFILE= -+ -+dnl this updates SUB_MAKEFILE and MSG_DIR_MAKE: -+CF_OUR_MESSAGES($1) -+ -+if test "$USE_INCLUDED_LIBINTL" = yes ; then -+ if test "$nls_cv_force_use_gnu_gettext" = yes ; then -+ SUB_MAKEFILE="$SUB_MAKEFILE intl/$cf_makefile" -+ elif test "$nls_cv_use_gnu_gettext" = yes ; then -+ SUB_MAKEFILE="$SUB_MAKEFILE intl/$cf_makefile" -+ else -+ INTLDIR_MAKE="#" -+ fi -+ if test -z "$INTLDIR_MAKE"; then -+ AC_DEFINE(HAVE_LIBGETTEXT_H) -+ fi -+else -+ INTLDIR_MAKE="#" -+ if test "$USE_NLS" = yes ; then -+ AC_CHECK_HEADERS(libintl.h) -+ fi -+fi -+ -+if test -z "$INTLDIR_MAKE" ; then -+ CPPFLAGS="-I../intl $CPPFLAGS" -+fi -+ -+dnl FIXME: we use this in lynx (the alternative is a spurious dependency upon -+dnl GNU make) -+if test "$BUILD_INCLUDED_LIBINTL" = yes ; then -+ GT_YES="#" -+ GT_NO= -+else -+ GT_YES= -+ GT_NO="#" -+fi -+ -+AC_SUBST(INTLDIR_MAKE) -+AC_SUBST(MSG_DIR_MAKE) -+AC_SUBST(GT_YES) -+AC_SUBST(GT_NO) -+ -+dnl FIXME: the underlying AM_GNU_GETTEXT macro either needs some fixes or a -+dnl little documentation. It doesn't define anything so that we can ifdef our -+dnl own code, except ENABLE_NLS, which is too vague to be of any use. -+ -+if test "$USE_INCLUDED_LIBINTL" = yes ; then -+ if test "$nls_cv_force_use_gnu_gettext" = yes ; then -+ AC_DEFINE(HAVE_GETTEXT) -+ elif test "$nls_cv_use_gnu_gettext" = yes ; then -+ AC_DEFINE(HAVE_GETTEXT) -+ fi -+ if test -n "$nls_cv_header_intl" ; then -+ AC_DEFINE(HAVE_LIBINTL_H) -+ fi -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_BUNDLED_PCRE version: 3 updated: 2002/04/17 21:09:56 -+dnl --------------- -+dnl Top-level macro for configuring an application with a bundled copy of -+dnl the pcre library. -+dnl -+dnl $1 specifies the top of the directory containing PCRE's include, lib dirs. -+AC_DEFUN([CF_BUNDLED_PCRE], -+[ -+cf_pcre_home=$1 -+PCREDIR_MAKE= -+PCREDIR_LIBS= -+PCREDIR_CPPFLAGS= -+case .$cf_pcre_home in #(vi -+.no) #(vi -+ # setup to compile the bundled PCRE: -+ . $srcdir/pcre/version.sh -+ AC_SUBST(PCRE_MAJOR) -+ AC_SUBST(PCRE_MINOR) -+ AC_SUBST(PCRE_DATE) -+ AC_SUBST(PCRE_DEFINES) -+ ;; -+.yes) #(vi -+ PCREDIR_MAKE='#' -+ PCREDIR_LIBS="-lpcre" -+ ;; -+.*) -+ CF_PATH_SYNTAX(cf_pcre_home) -+ PCREDIR_MAKE='#' -+ PCREDIR_LIBS="-L${cf_pcre_home}/lib -lpcre" -+ PCREDIR_CPPFLAGS="-I${cf_pcre_home}/include" -+ ;; -+esac -+AC_SUBST(PCREDIR_MAKE) -+AC_SUBST(PCREDIR_LIBS) -+AC_SUBST(PCREDIR_CPPFLAGS) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CHECK_1_DECL version: 5 updated: 2001/07/22 21:09:16 -+dnl --------------- -+dnl Check for missing declarations in the system headers (adapted from vile). -+dnl -+dnl CHECK_DECL_FLAG and CHECK_DECL_HDRS must be set in configure.in -+AC_DEFUN([CF_CHECK_1_DECL], -+[ -+AC_MSG_CHECKING([for missing "$1" extern]) -+AC_CACHE_VAL([cf_cv_func_$1],[ -+CF_MSG_LOG([for missing "$1" external]) -+cf_save_CFLAGS="$CFLAGS" -+CFLAGS="$CFLAGS $CHECK_DECL_FLAG" -+AC_TRY_LINK([ -+$CHECK_DECL_HDRS -+ -+#undef $1 -+struct zowie { int a; double b; struct zowie *c; char d; }; -+extern struct zowie *$1(); -+], -+[ -+], -+[if test -n "$CHECK_DECL_HDRS" ; then -+# try to work around system headers which are infested with non-standard syntax -+CF_UPPER(cf_1_up,$1) -+AC_TRY_COMPILE([ -+#define DECL_${cf_1_up} -+$CHECK_DECL_HDRS -+],[long x = 0], -+[eval 'cf_cv_func_'$1'=yes'], -+[eval 'cf_cv_func_'$1'=no']) -+else -+eval 'cf_cv_func_'$1'=yes' -+fi -+], -+[eval 'cf_cv_func_'$1'=no']) -+CFLAGS="$cf_save_CFLAGS" -+]) -+eval 'cf_result=$cf_cv_func_'$1 -+AC_MSG_RESULT($cf_result) -+test $cf_result = yes && AC_DEFINE_UNQUOTED(DECL_$2) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CHECK_CACHE version: 7 updated: 2001/12/19 00:50:10 -+dnl -------------- -+dnl Check if we're accidentally using a cache from a different machine. -+dnl Derive the system name, as a check for reusing the autoconf cache. -+dnl -+dnl If we've packaged config.guess and config.sub, run that (since it does a -+dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow -+dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM -+dnl which is useful in cross-compiles. -+AC_DEFUN([CF_CHECK_CACHE], -+[ -+if test -f $srcdir/config.guess ; then -+ ifelse([$1],,[AC_CANONICAL_HOST],[$1]) -+ system_name="$host_os" -+else -+ system_name="`(uname -s -r) 2>/dev/null`" -+ if test -z "$system_name" ; then -+ system_name="`(hostname) 2>/dev/null`" -+ fi -+fi -+test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name") -+AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"]) -+ -+test -z "$system_name" && system_name="$cf_cv_system_name" -+test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name) -+ -+if test ".$system_name" != ".$cf_cv_system_name" ; then -+ AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)) -+ AC_ERROR("Please remove config.cache and try again.") -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CHECK_CFLAGS version: 2 updated: 2001/12/30 19:09:58 -+dnl --------------- -+dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from -+dnl a build-configuration such as imake. These have the pitfall that they -+dnl often contain compiler-specific options which we cannot use, mixed with -+dnl preprocessor options that we usually can. -+AC_DEFUN([CF_CHECK_CFLAGS], -+[ -+CF_VERBOSE(checking additions to CFLAGS) -+cf_check_cflags="$CFLAGS" -+cf_check_cppflags="$CPPFLAGS" -+CF_ADD_CFLAGS($1,yes) -+if test "$cf_check_cflags" != "$CFLAGS" ; then -+AC_TRY_LINK([#include ],[printf("Hello world");],, -+ [CF_VERBOSE(test-compile failed. Undoing change to \$CFLAGS) -+ if test "$cf_check_cppflags" != "$CPPFLAGS" ; then -+ CF_VERBOSE(but keeping change to \$CPPFLAGS) -+ fi -+ CFLAGS="$cf_check_flags"]) -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CHECK_DECL version: 2 updated: 1997/08/28 23:57:55 -+dnl ------------- -+AC_DEFUN([CF_CHECK_DECL], -+[for ac_func in $1 -+do -+CF_UPPER(ac_tr_func,$ac_func) -+CF_CHECK_1_DECL(${ac_func}, ${ac_tr_func})dnl -+done -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CHECK_ERRNO version: 9 updated: 2001/12/30 18:03:23 -+dnl -------------- -+dnl Check for data that is usually declared in or , e.g., -+dnl the 'errno' variable. Define a DECL_xxx symbol if we must declare it -+dnl ourselves. -+dnl -+dnl $1 = the name to check -+AC_DEFUN([CF_CHECK_ERRNO], -+[ -+AC_CACHE_CHECK(if external $1 is declared, cf_cv_dcl_$1,[ -+ AC_TRY_COMPILE([ -+#ifdef HAVE_STDLIB_H -+#include -+#endif -+#include -+#include -+#include ], -+ [long x = (long) $1], -+ [cf_cv_dcl_$1=yes], -+ [cf_cv_dcl_$1=no]) -+]) -+ -+if test "$cf_cv_dcl_$1" = no ; then -+ CF_UPPER(cf_result,decl_$1) -+ AC_DEFINE_UNQUOTED($cf_result) -+fi -+ -+# It's possible (for near-UNIX clones) that the data doesn't exist -+CF_CHECK_EXTERN_DATA($1,int) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CHECK_EXTERN_DATA version: 3 updated: 2001/12/30 18:03:23 -+dnl -------------------- -+dnl Check for existence of external data in the current set of libraries. If -+dnl we can modify it, it's real enough. -+dnl $1 = the name to check -+dnl $2 = its type -+AC_DEFUN([CF_CHECK_EXTERN_DATA], -+[ -+AC_CACHE_CHECK(if external $1 exists, cf_cv_have_$1,[ -+ AC_TRY_LINK([ -+#undef $1 -+extern $2 $1; -+], -+ [$1 = 2], -+ [cf_cv_have_$1=yes], -+ [cf_cv_have_$1=no]) -+]) -+ -+if test "$cf_cv_have_$1" = yes ; then -+ CF_UPPER(cf_result,have_$1) -+ AC_DEFINE_UNQUOTED($cf_result) -+fi -+ -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CHECK_HEADERS version: 3 updated: 2000/11/03 11:14:19 -+dnl ---------------- -+dnl AC_CHECK_HEADERS(sys/socket.h) fails on OS/2 EMX because it demands that -+dnl be included first. -+dnl -+dnl Also and and , but we normally do -+dnl not do our own tests via AC_CHECK_HEADERS for those. -+AC_DEFUN([CF_CHECK_HEADERS],[ -+for cf_hdr in $1 -+do -+ AC_MSG_CHECKING(for $cf_hdr) -+ AC_TRY_CPP([ -+#include -+#include <$cf_hdr> -+],[cf_found=yes],[cf_found=no]) -+AC_MSG_RESULT($cf_found) -+if test $cf_found = yes ; then -+ CF_UPPER(cf_tr_hdr,$cf_hdr) -+ AC_DEFINE_UNQUOTED(HAVE_${cf_tr_hdr}) -+fi -+done -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CHECK_IPV6 version: 2 updated: 2000/04/13 21:38:04 -+dnl ------------- -+dnl Check for IPV6 configuration. -+AC_DEFUN([CF_CHECK_IPV6],[ -+CF_FIND_IPV6_TYPE -+CF_FIND_IPV6_LIBS -+ -+CF_FUNC_GETADDRINFO -+ -+if test "$cf_cv_getaddrinfo" != "yes"; then -+ if test "$cf_cv_ipv6type" != "linux"; then -+ AC_MSG_ERROR( -+[You must get working getaddrinfo() function, -+or you can specify "--disable-ipv6"]) -+ else -+ AC_MSG_WARN( -+[The getaddrinfo() implementation on your system seems be buggy. -+You should upgrade your system library to the newest version -+of GNU C library (aka glibc).]) -+ fi -+fi -+ -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CHECK_NESTED_PARAMS version: 2 updated: 1997/08/28 23:57:55 -+dnl ---------------------- -+dnl Check if the compiler allows nested parameter lists (some don't) -+AC_DEFUN([CF_CHECK_NESTED_PARAMS], -+[ -+AC_MSG_CHECKING([if nested parameters work]) -+AC_CACHE_VAL(cf_cv_nested_params,[ -+ AC_TRY_COMPILE([], -+ [extern void (*sigdisp(int sig, void (*func)(int sig)))(int sig)], -+ [cf_cv_nested_params=yes], -+ [cf_cv_nested_params=no]) -+]) -+AC_MSG_RESULT($cf_cv_nested_params) -+test $cf_cv_nested_params = yes && AC_DEFINE(HAVE_NESTED_PARAMS) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_COLOR_CURSES version: 6 updated: 2002/10/27 18:21:42 -+dnl --------------- -+dnl Check if curses supports color. (Note that while SVr3 curses supports -+dnl color, it does this differently from SVr4 curses; more work would be needed -+dnl to accommodate SVr3). -+dnl -+AC_DEFUN([CF_COLOR_CURSES], -+[ -+AC_MSG_CHECKING(if curses supports color attributes) -+AC_CACHE_VAL(cf_cv_color_curses,[ -+ AC_TRY_LINK([ -+#include <${cf_cv_ncurses_header-curses.h}> -+], -+ [chtype x = COLOR_BLUE; -+ has_colors(); -+ start_color(); -+#ifndef NCURSES_BROKEN -+ wbkgd(curscr, getbkgd(stdscr)); /* X/Open XPG4 aka SVr4 Curses */ -+#endif -+ ], -+ [cf_cv_color_curses=yes], -+ [cf_cv_color_curses=no]) -+ ]) -+AC_MSG_RESULT($cf_cv_color_curses) -+if test $cf_cv_color_curses = yes ; then -+ AC_DEFINE(COLOR_CURSES) -+ test ".$cf_cv_ncurses_broken" != .yes && AC_DEFINE(HAVE_GETBKGD) -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_COMPTYPE version: 2 updated: 1997/08/28 23:57:55 -+dnl ----------- -+dnl Check if the compiler uses 'void *' for qsort's compare function parameters -+dnl (i.e., it's an ANSI prototype). -+AC_DEFUN([CF_COMPTYPE], -+[ -+AC_MSG_CHECKING([for ANSI qsort]) -+AC_CACHE_VAL(cf_cv_comptype,[ -+ AC_TRY_COMPILE([ -+#ifdef HAVE_STDLIB_H -+#include -+#endif], -+ [extern int compare(const void *, const void *); -+ char *foo = "string"; -+ qsort(foo, sizeof(foo)/sizeof(*foo), sizeof(*foo), compare)], -+ [cf_cv_comptype=yes], -+ [cf_cv_comptype=no]) -+]) -+AC_MSG_RESULT($cf_cv_comptype) -+if test $cf_cv_comptype = yes; then -+ AC_DEFINE(HAVE_COMPTYPE_VOID) -+else -+ AC_DEFINE(HAVE_COMPTYPE_CHAR) -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_COREFILE version: 2 updated: 1997/08/28 23:57:55 -+dnl ----------- -+dnl Check if the application can dump core (for debugging). -+AC_DEFUN([CF_COREFILE], -+[ -+AC_MSG_CHECKING([if application can dump core]) -+AC_CACHE_VAL(cf_cv_corefile,[ -+ AC_TRY_RUN([ -+#include -+#include -+#include -+int found() -+{ -+ struct stat sb; -+ return ((stat("core", &sb) == 0 /* UNIX */ -+ || stat("conftest.core", &sb) == 0 /* FreeBSD */ -+ ) -+ && ((sb.st_mode & S_IFMT) == S_IFREG)); -+} -+int main() -+{ -+#ifdef __amiga__ -+/* Nicholas d'Alterio (nagd@ic.ac.uk) reports that the check for ability to -+ * core dump causes the machine to crash - reason unknown (gcc 2.7.2) -+ */ -+ exit(1); -+#else -+ int pid, status; -+ if (found()) -+ unlink("core"); -+ if (found()) -+ exit(1); -+ if ((pid = fork()) != 0) { -+ while (wait(&status) <= 0) -+ ; -+ } else { -+ abort(); /* this will dump core, if anything will */ -+ } -+ if (found()) { -+ unlink("core"); -+ exit(0); -+ } -+ exit(1); -+#endif -+}], -+ [cf_cv_corefile=yes], -+ [cf_cv_corefile=no], -+ [cf_cv_corefile=unknown])]) -+AC_MSG_RESULT($cf_cv_corefile) -+test $cf_cv_corefile = yes && AC_DEFINE(HAVE_COREFILE) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CPP_CONCATS version: 2 updated: 1997/08/28 23:57:55 -+dnl -------------- -+dnl Test for ANSI token expansion (used in 'assert'). -+AC_DEFUN([CF_CPP_CONCATS], -+[ -+AC_MSG_CHECKING([for ansi token concatenation]) -+AC_CACHE_VAL(cf_cv_cpp_concats,[ -+ AC_TRY_COMPILE([ -+#define concat(a,b) a ## b], -+ [char *firstlast = "y", *s = concat(first,last)], -+ [cf_cv_cpp_concats=yes], -+ [cf_cv_cpp_concats=no]) -+]) -+AC_MSG_RESULT($cf_cv_cpp_concats) -+test $cf_cv_cpp_concats = yes && AC_DEFINE(CPP_DOES_CONCAT) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CPP_EXPANDS version: 2 updated: 1997/08/28 23:57:55 -+dnl -------------- -+dnl Test for ANSI token expansion (used in 'assert'). -+AC_DEFUN([CF_CPP_EXPANDS], -+[ -+AC_MSG_CHECKING([for ansi token expansion/substitution]) -+AC_CACHE_VAL(cf_cv_cpp_expands,[ -+ AC_TRY_COMPILE([ -+#define string(n) #n], -+ [char *s = string(token)], -+ [cf_cv_cpp_expands=yes], -+ [cf_cv_cpp_expands=no]) -+]) -+AC_MSG_RESULT($cf_cv_cpp_expands) -+test $cf_cv_cpp_expands = yes && AC_DEFINE(CPP_DOES_EXPAND) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CURSES_CPPFLAGS version: 7 updated: 2003/06/06 00:48:41 -+dnl ------------------ -+dnl Look for the curses headers. -+AC_DEFUN([CF_CURSES_CPPFLAGS],[ -+ -+AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[ -+cf_cv_curses_incdir=no -+case $host_os in #(vi -+hpux10.*|hpux11.*) #(vi -+ test -d /usr/include/curses_colr && \ -+ cf_cv_curses_incdir="-I/usr/include/curses_colr" -+ ;; -+sunos3*|sunos4*) -+ test -d /usr/5lib && \ -+ test -d /usr/5include && \ -+ cf_cv_curses_incdir="-I/usr/5include" -+ ;; -+esac -+]) -+test "$cf_cv_curses_incdir" != no && CPPFLAGS="$cf_cv_curses_incdir $CPPFLAGS" -+ -+AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[ -+cf_cv_ncurses_header=none -+for cf_header in \ -+ curses.h \ -+ ncurses.h \ -+ ncurses/curses.h \ -+ ncurses/ncurses.h -+do -+AC_TRY_COMPILE([#include <${cf_header}>], -+ [initscr(); tgoto("?", 0,0)], -+ [cf_cv_ncurses_header=$cf_header; break],[]) -+done -+]) -+ -+if test "$cf_cv_ncurses_header" = none ; then -+ AC_MSG_ERROR(No curses header-files found) -+fi -+ -+# cheat, to get the right #define's for HAVE_NCURSES_H, etc. -+AC_CHECK_HEADERS($cf_cv_ncurses_header) -+ -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CURSES_LIBS version: 22 updated: 2002/10/27 18:21:42 -+dnl -------------- -+dnl Look for the curses libraries. Older curses implementations may require -+dnl termcap/termlib to be linked as well. Call CF_CURSES_CPPFLAGS first. -+AC_DEFUN([CF_CURSES_LIBS],[ -+ -+AC_MSG_CHECKING(if we have identified curses libraries) -+AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], -+ [initscr(); tgoto("?", 0,0)], -+ cf_result=yes, -+ cf_result=no) -+AC_MSG_RESULT($cf_result) -+ -+if test "$cf_result" = no ; then -+case $host_os in #(vi -+freebsd*) #(vi -+ AC_CHECK_LIB(mytinfo,tgoto,[LIBS="-lmytinfo $LIBS"]) -+ ;; -+hpux10.*|hpux11.*) #(vi -+ AC_CHECK_LIB(cur_colr,initscr,[ -+ LIBS="-lcur_colr $LIBS" -+ ac_cv_func_initscr=yes -+ ],[ -+ AC_CHECK_LIB(Hcurses,initscr,[ -+ # HP's header uses __HP_CURSES, but user claims _HP_CURSES. -+ LIBS="-lHcurses $LIBS" -+ CPPFLAGS="-D__HP_CURSES -D_HP_CURSES $CPPFLAGS" -+ ac_cv_func_initscr=yes -+ ])]) -+ ;; -+linux*) # Suse Linux does not follow /usr/lib convention -+ LIBS="$LIBS -L/lib" -+ ;; -+sunos3*|sunos4*) -+ test -d /usr/5lib && \ -+ LIBS="$LIBS -L/usr/5lib -lcurses -ltermcap" -+ ac_cv_func_initscr=yes -+ ;; -+esac -+ -+if test ".$ac_cv_func_initscr" != .yes ; then -+ cf_save_LIBS="$LIBS" -+ cf_term_lib="" -+ cf_curs_lib="" -+ -+ if test ".${cf_cv_ncurses_version-no}" != .no -+ then -+ cf_check_list="ncurses curses cursesX" -+ else -+ cf_check_list="cursesX curses ncurses" -+ fi -+ -+ # Check for library containing tgoto. Do this before curses library -+ # because it may be needed to link the test-case for initscr. -+ AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[ -+ for cf_term_lib in $cf_check_list termcap termlib unknown -+ do -+ AC_CHECK_LIB($cf_term_lib,tgoto,[break]) -+ done -+ ]) -+ -+ # Check for library containing initscr -+ test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS" -+ for cf_curs_lib in $cf_check_list xcurses jcurses unknown -+ do -+ AC_CHECK_LIB($cf_curs_lib,initscr,[break]) -+ done -+ test $cf_curs_lib = unknown && AC_ERROR(no curses library found) -+ -+ LIBS="-l$cf_curs_lib $cf_save_LIBS" -+ if test "$cf_term_lib" = unknown ; then -+ AC_MSG_CHECKING(if we can link with $cf_curs_lib library) -+ AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], -+ [initscr()], -+ [cf_result=yes], -+ [cf_result=no]) -+ AC_MSG_RESULT($cf_result) -+ test $cf_result = no && AC_ERROR(Cannot link curses library) -+ elif test "$cf_curs_lib" = "$cf_term_lib" ; then -+ : -+ elif test "$cf_term_lib" != predefined ; then -+ AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries) -+ AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], -+ [initscr(); tgoto((char *)0, 0, 0);], -+ [cf_result=no], -+ [ -+ LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS" -+ AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], -+ [initscr()], -+ [cf_result=yes], -+ [cf_result=error]) -+ ]) -+ AC_MSG_RESULT($cf_result) -+ fi -+fi -+fi -+ -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CURSES_TERMCAP version: 10 updated: 2002/01/13 16:02:19 -+dnl ----------------- -+dnl Check if we should include to pick up prototypes for termcap -+dnl functions. On terminfo systems, these are normally declared in , -+dnl but may be in . We check for termcap.h as an alternate, but it -+dnl isn't standard (usually associated with GNU termcap). -+dnl -+dnl The 'tgoto()' function is declared in both terminfo and termcap. -+dnl -+dnl See CF_TYPE_OUTCHAR for more details. -+AC_DEFUN([CF_CURSES_TERMCAP], -+[ -+AC_REQUIRE([CF_CURSES_TERM_H]) -+AC_CACHE_CHECK(if we should include curses.h or termcap.h, cf_cv_need_curses_h,[ -+cf_save_CPPFLAGS="$CPPFLAGS" -+cf_cv_need_curses_h=no -+ -+for cf_t_opts in "" "NEED_TERMCAP_H" -+do -+for cf_c_opts in "" "NEED_CURSES_H" -+do -+ -+ CPPFLAGS="$cf_save_CPPFLAGS $CHECK_DECL_FLAG" -+ test -n "$cf_c_opts" && CPPFLAGS="$CPPFLAGS -D$cf_c_opts" -+ test -n "$cf_t_opts" && CPPFLAGS="$CPPFLAGS -D$cf_t_opts" -+ -+ AC_TRY_LINK([/* $cf_c_opts $cf_t_opts */ -+$CHECK_DECL_HDRS], -+ [char *x = (char *)tgoto("")], -+ [test "$cf_cv_need_curses_h" = no && { -+ cf_cv_need_curses_h=maybe -+ cf_ok_c_opts=$cf_c_opts -+ cf_ok_t_opts=$cf_t_opts -+ }], -+ [echo "Recompiling with corrected call (C:$cf_c_opts, T:$cf_t_opts)" >&AC_FD_CC -+ AC_TRY_LINK([ -+$CHECK_DECL_HDRS], -+ [char *x = (char *)tgoto("",0,0)], -+ [cf_cv_need_curses_h=yes -+ cf_ok_c_opts=$cf_c_opts -+ cf_ok_t_opts=$cf_t_opts])]) -+ -+ CPPFLAGS="$cf_save_CPPFLAGS" -+ test "$cf_cv_need_curses_h" = yes && break -+done -+ test "$cf_cv_need_curses_h" = yes && break -+done -+ -+if test "$cf_cv_need_curses_h" != no ; then -+ echo "Curses/termcap test = $cf_cv_need_curses_h (C:$cf_ok_c_opts, T:$cf_ok_t_opts)" >&AC_FD_CC -+ if test -n "$cf_ok_c_opts" ; then -+ if test -n "$cf_ok_t_opts" ; then -+ cf_cv_need_curses_h=both -+ else -+ cf_cv_need_curses_h=curses.h -+ fi -+ elif test -n "$cf_ok_t_opts" ; then -+ cf_cv_need_curses_h=termcap.h -+ elif test "$cf_cv_term_header" != no ; then -+ cf_cv_need_curses_h=term.h -+ else -+ cf_cv_need_curses_h=no -+ fi -+fi -+]) -+ -+case $cf_cv_need_curses_h in -+both) #(vi -+ AC_DEFINE_UNQUOTED(NEED_CURSES_H) -+ AC_DEFINE_UNQUOTED(NEED_TERMCAP_H) -+ ;; -+curses.h) #(vi -+ AC_DEFINE_UNQUOTED(NEED_CURSES_H) -+ ;; -+term.h) #(vi -+ AC_DEFINE_UNQUOTED(NEED_TERM_H) -+ ;; -+termcap.h) #(vi -+ AC_DEFINE_UNQUOTED(NEED_TERMCAP_H) -+ ;; -+esac -+ -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_CURSES_TERM_H version: 4 updated: 2002/01/12 17:08:23 -+dnl ---------------- -+dnl SVr4 curses should have term.h as well (where it puts the definitions of -+dnl the low-level interface). This may not be true in old/broken implementations, -+dnl as well as in misconfigured systems (e.g., gcc configured for Solaris 2.4 -+dnl running with Solaris 2.5.1). -+AC_DEFUN([CF_CURSES_TERM_H], -+[ -+AC_CACHE_CHECK(for term.h, cf_cv_term_header,[ -+for cf_header in \ -+ ncurses/term.h \ -+ term.h -+do -+ AC_TRY_COMPILE([ -+#include <${cf_cv_ncurses_header-curses.h}> -+#include <${cf_header}>], -+ [WINDOW *x], -+ [cf_cv_term_header=$cf_header], -+ [cf_cv_term_header=no]) -+done -+]) -+ -+case $cf_cv_term_header in #(vi -+term.h) #(vi -+ AC_DEFINE(HAVE_TERM_H) -+ ;; -+ncurses/term.h) -+ AC_DEFINE(HAVE_NCURSES_TERM_H) -+ ;; -+esac -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_DEFAULT_SHELL version: 5 updated: 2002/12/04 00:06:27 -+dnl ---------------- -+dnl Look for a Bourne-shell compatible program from a list that we know about: -+dnl ash Almquist Shell (sh based) -+dnl bash Bourne Again Shell (sh, ksh based) -+dnl dash Debian Almquist Shell (sh based) -+dnl jsh Job Control Bourne Shell (sh based) -+dnl keysh Key Shell (ksh based) -+dnl ksh Korn Shell (sh based) -+dnl pdksh Public-domain ksh -+dnl sh Bourne Shell or POSIX Shell -+dnl zsh Z Shell (sh, ksh based) -+dnl On BSD systems look for a C Shell compatible program: -+dnl csh C Shell -+dnl tcsh TENEX C Shell (csh based) -+AC_DEFUN([CF_DEFAULT_SHELL], -+[ -+AC_MSG_CHECKING(for the default shell program) -+cf_shell_progs="ifelse($1,,sh,[$1])" -+if test -z "$cf_shell_progs" ; then -+ cf_shell_progs="sh ksh bash zsh pdksh jsh keysh ash dash" -+ # TIN preferred default shell for BSD systems is csh. Others are sh. -+ AC_TRY_COMPILE([ -+#include ],[ -+#if (defined(BSD) && (BSD >= 199103)) -+#else -+make an error -+#endif -+],[$cf_shell_progs="csh tcsh $cf_shell_progs"]) -+fi -+CF_MSG_LOG(paths of shell programs: $cf_shell_progs) -+if test -s /etc/shells && test `egrep -c -v '^(#| | |$)' /etc/shells` -gt 0; then -+ CF_MSG_LOG(/etc/shells) -+ for cf_prog in $cf_shell_progs -+ do -+ case $cf_prog in -+ /*) -+ cf_pattern="^"$cf_prog"$" -+ ;; -+ */*) -+ AC_MSG_ERROR(Program name must be absolute or filename: $cf_prog) -+ ;; -+ *) -+ cf_pattern="/"$cf_prog"$" -+ ;; -+ esac -+ cf_path=`egrep $cf_pattern /etc/shells 2>/dev/null` -+ if test -n "$cf_path" -+ then -+ for cf_shell in $cf_path -+ do -+ if test -f "$cf_shell" -+ then -+ DEFAULT_SHELL="$cf_shell" -+ break -+ fi -+ done -+ fi -+ if test -n "$DEFAULT_SHELL" -+ then -+ break -+ fi -+ done -+ AC_MSG_RESULT($DEFAULT_SHELL) -+else -+ CF_MSG_LOG($PATH) -+AC_PATH_PROGS(DEFAULT_SHELL, -+ $cf_shell_progs,, -+ $PATH:/bin:/usr/bin:/usr/xpg4/bin:/bin/posix:/usr/bin/posix:/usr/old/bin:/usr/local/bin) -+fi -+if test -z "$DEFAULT_SHELL" ; then -+ AC_MSG_WARN( -+Cannot find the default shell you specified: $cf_shell_progs) -+ if test -f /bin/false ; then -+ AC_MSG_WARN(Using /bin/false instead) -+ DEFAULT_SHELL=/bin/false -+ else -+ AC_MSG_ERROR(Cannot use /bin/false because it does not exist) -+ fi -+fi -+AC_DEFINE_UNQUOTED(DEFAULT_SHELL,"$DEFAULT_SHELL") -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_DEFINE_STRING version: 2 updated: 2001/07/22 21:09:16 -+dnl ---------------- -+dnl Define a string which may contain escaped quotes or backslashes -+dnl $1 = symbol to define -+dnl $2 = the information we want to quote -+AC_DEFUN([CF_DEFINE_STRING], -+[ -+cf_define=`echo $2|sed -e 's/\\\\/\\\\134/g' -e 's/^[[ ]]\\+//' -e 's/[[ ]]\\+$//' -e 's/"/\\\\042/g'` -+AC_DEFINE_UNQUOTED($1, "$cf_define") -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52 -+dnl ---------- -+dnl "dirname" is not portable, so we fake it with a shell script. -+AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_DISABLE_ECHO version: 10 updated: 2003/04/17 22:27:11 -+dnl --------------- -+dnl You can always use "make -n" to see the actual options, but it's hard to -+dnl pick out/analyze warning messages when the compile-line is long. -+dnl -+dnl Sets: -+dnl ECHO_LT - symbol to control if libtool is verbose -+dnl ECHO_LD - symbol to prefix "cc -o" lines -+dnl RULE_CC - symbol to put before implicit "cc -c" lines (e.g., .c.o) -+dnl SHOW_CC - symbol to put before explicit "cc -c" lines -+dnl ECHO_CC - symbol to put before any "cc" line -+dnl -+AC_DEFUN([CF_DISABLE_ECHO],[ -+AC_MSG_CHECKING(if you want to see long compiling messages) -+CF_ARG_DISABLE(echo, -+ [ --disable-echo display "compiling" commands], -+ [ -+ ECHO_LT='--silent' -+ ECHO_LD='@echo linking [$]@;' -+ RULE_CC=' @echo compiling [$]<' -+ SHOW_CC=' @echo compiling [$]@' -+ ECHO_CC='@' -+],[ -+ ECHO_LT='' -+ ECHO_LD='' -+ RULE_CC='# compiling' -+ SHOW_CC='# compiling' -+ ECHO_CC='' -+]) -+AC_MSG_RESULT($enableval) -+AC_SUBST(ECHO_LT) -+AC_SUBST(ECHO_LD) -+AC_SUBST(RULE_CC) -+AC_SUBST(SHOW_CC) -+AC_SUBST(ECHO_CC) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_ERRNO version: 5 updated: 1997/11/30 12:44:39 -+dnl -------- -+dnl Check if 'errno' is declared in -+AC_DEFUN([CF_ERRNO], -+[ -+CF_CHECK_ERRNO(errno) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_FIND_IPV6_LIBS version: 6 updated: 2002/11/09 09:05:18 -+dnl ----------------- -+dnl Based on the IPV6 stack type, look for the corresponding library. -+AC_DEFUN([CF_FIND_IPV6_LIBS],[ -+AC_REQUIRE([CF_FIND_IPV6_TYPE]) -+ -+cf_ipv6lib=none -+cf_ipv6dir=none -+ -+AC_MSG_CHECKING(for IPv6 library if required) -+case $cf_cv_ipv6type in #(vi -+solaris) #(vi -+ ;; -+inria) #(vi -+ ;; -+kame) #(vi -+ dnl http://www.kame.net/ -+ cf_ipv6lib=inet6 -+ cf_ipv6dir=v6 -+ ;; -+linux-glibc) #(vi -+ ;; -+linux-libinet6) #(vi -+ dnl http://www.v6.linux.or.jp/ -+ cf_ipv6lib=inet6 -+ cf_ipv6dir=inet6 -+ ;; -+toshiba) #(vi -+ cf_ipv6lib=inet6 -+ cf_ipv6dir=v6 -+ ;; -+v6d) #(vi -+ cf_ipv6lib=v6 -+ cf_ipv6dir=v6 -+ ;; -+zeta) -+ cf_ipv6lib=inet6 -+ cf_ipv6dir=v6 -+ ;; -+esac -+AC_MSG_RESULT($cf_ipv6lib) -+ -+if test "$cf_ipv6lib" != "none"; then -+ -+ AC_TRY_LINK([ -+#include -+#include -+#include -+#include ], -+ [getaddrinfo(0, 0, 0, 0)],,[ -+ CF_HEADER_PATH(cf_search,$cf_ipv6dir) -+ for cf_incdir in $cf_search -+ do -+ cf_header=$cf_incdir/netinet/ip6.h -+ if test -f $cf_header -+ then -+ CPPFLAGS="$CPPFLAGS -I$cf_incdir" -+ test -n "$verbose" && echo " ... found $cf_header" 1>&AC_FD_MSG -+ break -+ fi -+ test -n "$verbose" && echo " ... tested $cf_header" 1>&AC_FD_MSG -+ done -+ ]) -+ -+ CF_FIND_LIBRARY([$cf_ipv6lib],[$cf_ipv6dir],[ -+#include -+#include -+#include -+#include ], -+ [getaddrinfo(0, 0, 0, 0)], -+ [getaddrinfo], -+ noexit) -+ if test $cf_found_library = no ; then -+ AC_MSG_ERROR( -+[No $cf_ipv6lib library found, cannot continue. You must fetch lib$cf_ipv6lib.a -+from an appropriate IPv6 kit and compile beforehand.]) -+ fi -+fi -+ -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_FIND_IPV6_TYPE version: 5 updated: 2001/10/11 20:46:17 -+dnl ----------------- -+AC_DEFUN([CF_FIND_IPV6_TYPE],[ -+AC_CACHE_CHECK(ipv6 stack type, cf_cv_ipv6type, [ -+cf_cv_ipv6type=unknown -+for i in solaris inria kame linux-glibc linux-libinet6 toshiba v6d zeta -+do -+ case $i in #(vi -+ solaris) #(vi -+ if test "SunOS" = "`uname -s`" -+ then -+ if test -f /usr/include/netinet/ip6.h -+ then -+ cf_cv_ipv6type=$i -+ fi -+ fi -+ ;; -+ inria) #(vi -+ dnl http://www.kame.net/ -+ AC_EGREP_CPP(yes, [ -+#include -+#ifdef IPV6_INRIA_VERSION -+yes -+#endif], [cf_cv_ipv6type=$i]) -+ ;; -+ kame) #(vi -+ dnl http://www.kame.net/ -+ AC_EGREP_CPP(yes, [ -+#include -+#ifdef __KAME__ -+yes -+#endif], [cf_cv_ipv6type=$i]) -+ ;; -+ linux-glibc) #(vi -+ dnl http://www.v6.linux.or.jp/ -+ AC_EGREP_CPP(yes, [ -+#include -+#if defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1 -+yes -+#endif], [cf_cv_ipv6type=$i]) -+ ;; -+ linux-libinet6) #(vi -+ dnl http://www.v6.linux.or.jp/ -+ if test -d /usr/inet6 -+ then -+ cf_cv_ipv6type=$i -+ elif test -f /usr/include/netinet/ip6.h -+ then -+ cf_cv_ipv6type=$i -+ fi -+ ;; -+ toshiba) #(vi -+ AC_EGREP_CPP(yes, [ -+#include -+#ifdef _TOSHIBA_INET6 -+yes -+#endif], [cf_cv_ipv6type=$i]) -+ ;; -+ v6d) #(vi -+ AC_EGREP_CPP(yes, [ -+#include -+#ifdef __V6D__ -+yes -+#endif], [cf_cv_ipv6type=$i]) -+ ;; -+ zeta) -+ AC_EGREP_CPP(yes, [ -+#include -+#ifdef _ZETA_MINAMI_INET6 -+yes -+#endif], [cf_cv_ipv6type=$i]) -+ ;; -+ esac -+ if test "$cf_cv_ipv6type" != "unknown"; then -+ break -+ fi -+done -+]) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_FIND_LIBRARY version: 7 updated: 2000/04/13 21:38:04 -+dnl --------------- -+dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We -+dnl prefer a standard location, and use -L options only if we do not find the -+dnl library in the standard library location(s). -+dnl $1 = library name -+dnl $2 = library class, usually the same as library name -+dnl $3 = includes -+dnl $4 = code fragment to compile/link -+dnl $5 = corresponding function-name -+dnl $6 = flag, nonnull if failure causes an error-exit -+dnl -+dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had -+dnl to use a -L option. -+AC_DEFUN([CF_FIND_LIBRARY], -+[ -+ eval 'cf_cv_have_lib_'$1'=no' -+ cf_libdir="" -+ AC_CHECK_FUNC($5, -+ eval 'cf_cv_have_lib_'$1'=yes',[ -+ cf_save_LIBS="$LIBS" -+ AC_MSG_CHECKING(for $5 in -l$1) -+ LIBS="-l$1 $LIBS" -+ AC_TRY_LINK([$3],[$4], -+ [AC_MSG_RESULT(yes) -+ eval 'cf_cv_have_lib_'$1'=yes' -+ ], -+ [AC_MSG_RESULT(no) -+ CF_LIBRARY_PATH(cf_search,$2) -+ for cf_libdir in $cf_search -+ do -+ AC_MSG_CHECKING(for -l$1 in $cf_libdir) -+ LIBS="-L$cf_libdir -l$1 $cf_save_LIBS" -+ AC_TRY_LINK([$3],[$4], -+ [AC_MSG_RESULT(yes) -+ eval 'cf_cv_have_lib_'$1'=yes' -+ break], -+ [AC_MSG_RESULT(no) -+ LIBS="$cf_save_LIBS"]) -+ done -+ ]) -+ ]) -+eval 'cf_found_library=[$]cf_cv_have_lib_'$1 -+ifelse($6,,[ -+if test $cf_found_library = no ; then -+ AC_ERROR(Cannot link $1 library) -+fi -+]) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_FIX_SLASHES version: 2 updated: 2001/05/27 21:36:02 -+dnl -------------- -+dnl OS/2 and Cygwin ports may pick up backslashes in pathnames, which are not -+dnl usable in quoted strings. Fix them. -+dnl $1=fixed($2) -+AC_DEFUN([CF_FIX_SLASHES], -+[ -+case $cf_cv_system_name in #(vi -+os2*|cygwin*) -+ $1=`echo "[$]$1" | sed -e 's%\\\\%/%g'` -+ ;; -+esac -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_FUNC_FORK version: 2 updated: 1997/08/28 23:57:55 -+dnl ------------ -+dnl Check if 'fork()' is available, and working. Amiga (and possibly other -+dnl machines) have a non-working 'fork()' entrypoint. -+AC_DEFUN([CF_FUNC_FORK], -+[AC_MSG_CHECKING([for fork]) -+AC_CACHE_VAL(cf_cv_func_fork,[ -+AC_TRY_RUN([ -+int main() -+{ -+ if (fork() < 0) -+ exit(1); -+ exit(0); -+}], [cf_cv_func_fork=yes], -+ [cf_cv_func_fork=no], -+ [cf_cv_func_fork=unknown]) -+])dnl -+AC_MSG_RESULT($cf_cv_func_fork) -+test $cf_cv_func_fork = yes && AC_DEFINE(HAVE_FORK) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_FUNC_GETADDRINFO version: 5 updated: 2000/09/28 06:18:08 -+dnl ------------------- -+dnl Look for a working version of getaddrinfo(), for IPV6 support. -+AC_DEFUN([CF_FUNC_GETADDRINFO],[ -+AC_CACHE_CHECK(working getaddrinfo, cf_cv_getaddrinfo,[ -+AC_TRY_RUN([ -+#include -+#include -+#include -+#include -+#include -+ -+#define expect(a,b) if (strcmp(a,b) != 0) goto bad -+ -+int main() -+{ -+ int passive, gaierr, inet4 = 0, inet6 = 0; -+ struct addrinfo hints, *ai, *aitop; -+ char straddr[INET6_ADDRSTRLEN], strport[16]; -+ -+ for (passive = 0; passive <= 1; passive++) { -+ memset(&hints, 0, sizeof(hints)); -+ hints.ai_family = AF_UNSPEC; -+ hints.ai_flags = passive ? AI_PASSIVE : 0; -+ hints.ai_socktype = SOCK_STREAM; -+ if ((gaierr = getaddrinfo(NULL, "54321", &hints, &aitop)) != 0) { -+ (void)gai_strerror(gaierr); -+ goto bad; -+ } -+ for (ai = aitop; ai; ai = ai->ai_next) { -+ if (ai->ai_addr == NULL || -+ ai->ai_addrlen == 0 || -+ getnameinfo(ai->ai_addr, ai->ai_addrlen, -+ straddr, sizeof(straddr), strport, sizeof(strport), -+ NI_NUMERICHOST|NI_NUMERICSERV) != 0) { -+ goto bad; -+ } -+ switch (ai->ai_family) { -+ case AF_INET: -+ expect(strport, "54321"); -+ if (passive) { -+ expect(straddr, "0.0.0.0"); -+ } else { -+ expect(straddr, "127.0.0.1"); -+ } -+ inet4++; -+ break; -+ case AF_INET6: -+ expect(strport, "54321"); -+ if (passive) { -+ expect(straddr, "::"); -+ } else { -+ expect(straddr, "::1"); -+ } -+ inet6++; -+ break; -+ case AF_UNSPEC: -+ goto bad; -+ break; -+ default: -+ /* another family support? */ -+ break; -+ } -+ } -+ } -+ -+ if (!(inet4 == 0 || inet4 == 2)) -+ goto bad; -+ if (!(inet6 == 0 || inet6 == 2)) -+ goto bad; -+ -+ if (aitop) -+ freeaddrinfo(aitop); -+ exit(0); -+ -+ bad: -+ if (aitop) -+ freeaddrinfo(aitop); -+ exit(1); -+} -+], -+[cf_cv_getaddrinfo=yes], -+[cf_cv_getaddrinfo=no], -+[cf_cv_getaddrinfo=unknown]) -+]) -+if test "$cf_cv_getaddrinfo" = yes ; then -+ AC_DEFINE(HAVE_GAI_STRERROR) -+ AC_DEFINE(HAVE_GETADDRINFO) -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_FUNC_MEMMOVE version: 5 updated: 2000/08/12 23:18:52 -+dnl --------------- -+dnl Check for memmove, or a bcopy that can handle overlapping copy. If neither -+dnl is found, add our own version of memmove to the list of objects. -+AC_DEFUN([CF_FUNC_MEMMOVE], -+[ -+AC_CHECK_FUNC(memmove,,[ -+AC_CHECK_FUNC(bcopy,[ -+ AC_CACHE_CHECK(if bcopy does overlapping moves,cf_cv_good_bcopy,[ -+ AC_TRY_RUN([ -+int main() { -+ static char data[] = "abcdefghijklmnopqrstuwwxyz"; -+ char temp[40]; -+ bcopy(data, temp, sizeof(data)); -+ bcopy(temp+10, temp, 15); -+ bcopy(temp+5, temp+15, 10); -+ exit (strcmp(temp, "klmnopqrstuwwxypqrstuwwxyz")); -+} -+ ], -+ [cf_cv_good_bcopy=yes], -+ [cf_cv_good_bcopy=no], -+ [cf_cv_good_bcopy=unknown]) -+ ]) -+ ],[cf_cv_good_bcopy=no]) -+ if test "$cf_cv_good_bcopy" = yes ; then -+ AC_DEFINE(USE_OK_BCOPY) -+ else -+ AC_DEFINE(USE_MY_MEMMOVE) -+ fi -+])])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_FUNC_SYSTEM version: 3 updated: 1997/10/22 22:02:10 -+dnl -------------- -+dnl Check if the 'system()' function returns a usable status, or if not, try -+dnl to use the status returned by a SIGCHLD. -+AC_DEFUN([CF_FUNC_SYSTEM], -+[ -+AC_REQUIRE([CF_UNION_WAIT]) -+AC_MSG_CHECKING(if the system function returns usable child-status) -+AC_CACHE_VAL(cf_cv_system_status,[ -+ AC_TRY_RUN([ -+#include -+#include -+#if HAVE_SYS_WAIT_H -+#include -+#endif -+ -+RETSIGTYPE signal_handler (int sig) -+{ -+#if HAVE_TYPE_UNIONWAIT -+ union wait wait_status; -+#else -+ int wait_status = 1; -+#endif -+ int system_status; -+ wait (&wait_status); -+ system_status = WEXITSTATUS(wait_status); /* should be nonzero */ -+ exit(system_status != 23); -+} -+ -+int main() -+{ -+ /* this looks weird, but apparently the SIGCHLD gets there first on -+ * machines where 'system()' doesn't return a usable code, so ... -+ */ -+ signal (SIGCHLD, signal_handler); -+ system("exit 23"); -+ exit(1); -+} -+], -+ [cf_cv_system_status=no], -+ [AC_TRY_RUN( -+ [int main() { exit(system("exit 23") != (23 << 8)); }], -+ [cf_cv_system_status=yes], -+ [cf_cv_system_status=unknown], -+ [cf_cv_system_status=unknown])], -+ [cf_cv_system_status=unknown]) -+]) -+AC_MSG_RESULT($cf_cv_system_status) -+test $cf_cv_system_status = no && AC_DEFINE(USE_SYSTEM_STATUS) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_GCC_VERSION version: 2 updated: 2003/05/24 15:01:41 -+dnl -------------- -+dnl Find version of gcc -+AC_DEFUN([CF_GCC_VERSION],[ -+AC_REQUIRE([AC_PROG_CC]) -+GCC_VERSION=none -+if test "$GCC" = yes ; then -+ AC_MSG_CHECKING(version of $CC) -+ GCC_VERSION="`${CC} --version|head -1 | sed -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`" -+ test -z "$GCC_VERSION" && GCC_VERSION=unknown -+ AC_MSG_RESULT($GCC_VERSION) -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_GCC_WARNINGS version: 14 updated: 2003/05/24 15:03:15 -+dnl --------------- -+dnl Check if the compiler supports useful warning options. There's a few that -+dnl we don't use, simply because they're too noisy: -+dnl -+dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x) -+dnl -Wredundant-decls (system headers make this too noisy) -+dnl -Wtraditional (combines too many unrelated messages, only a few useful) -+dnl -Wwrite-strings (too noisy, but should review occasionally). This -+dnl is enabled for ncurses using "--enable-const". -+dnl -pedantic -+dnl -+AC_DEFUN([CF_GCC_WARNINGS], -+[ -+AC_REQUIRE([CF_GCC_VERSION]) -+if ( test "$GCC" = yes || test "$GXX" = yes ) -+then -+ cat > conftest.$ac_ext <],[ -+#ifndef _XOPEN_SOURCE -+make an error -+#endif], -+ [cf_cv_gnu_source=no], -+ [cf_save="$CPPFLAGS" -+ CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" -+ AC_TRY_COMPILE([#include ],[ -+#ifdef _XOPEN_SOURCE -+make an error -+#endif], -+ [cf_cv_gnu_source=no], -+ [cf_cv_gnu_source=yes]) -+ CPPFLAGS="$cf_save" -+ ]) -+]) -+test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_HEADER_PATH version: 8 updated: 2002/11/10 14:46:59 -+dnl -------------- -+dnl Construct a search-list for a nonstandard header-file -+AC_DEFUN([CF_HEADER_PATH], -+[CF_SUBDIR_PATH($1,$2,include) -+test "$includedir" != NONE && \ -+test "$includedir" != "/usr/include" && \ -+test -d "$includedir" && { -+ test -d $includedir && $1="[$]$1 $includedir" -+ test -d $includedir/$2 && $1="[$]$1 $includedir/$2" -+} -+ -+test "$oldincludedir" != NONE && \ -+test "$oldincludedir" != "/usr/include" && \ -+test -d "$oldincludedir" && { -+ test -d $oldincludedir && $1="[$]$1 $oldincludedir" -+ test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2" -+} -+ -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_LIBRARY_PATH version: 7 updated: 2002/11/10 14:46:59 -+dnl --------------- -+dnl Construct a search-list for a nonstandard library-file -+AC_DEFUN([CF_LIBRARY_PATH], -+[CF_SUBDIR_PATH($1,$2,lib)])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_LIB_PREFIX version: 7 updated: 2001/01/12 01:23:48 -+dnl ------------- -+dnl Compute the library-prefix for the given host system -+dnl $1 = variable to set -+AC_DEFUN([CF_LIB_PREFIX], -+[ -+ case $cf_cv_system_name in -+ OS/2*) LIB_PREFIX='' ;; -+ os2*) LIB_PREFIX='' ;; -+ *) LIB_PREFIX='lib' ;; -+ esac -+ifelse($1,,,[$1=$LIB_PREFIX]) -+ AC_SUBST(LIB_PREFIX) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_LOCKFILE version: 2 updated: 2001/05/26 12:41:02 -+dnl ----------- -+dnl Check for functions that we can use for file-locking. Simply checking for -+dnl existence is not sufficient, since fcntl, for example, uses definitions -+dnl that are not in every version of the header. -+AC_DEFUN([CF_LOCKFILE], -+[ -+AC_CHECK_HEADERS(unistd.h fcntl.h sys/file.h) -+AC_CHECK_FUNC(fcntl) -+AC_CHECK_FUNC(lockf) -+AC_CHECK_FUNC(flock,,,[ -+ CF_RECHECK_FUNC(flock,bsd,cf_cv_lockfile,[AC_MSG_WARN(no lock function found)])]) -+ -+AC_CACHE_CHECK(for file-locking functions,cf_cv_lockfile,[ -+cf_cv_lockfile= -+for cf_lock in fcntl lockf flock -+do -+if eval 'test ${ac_cv_func_'$cf_lock'+set} = set'; then -+ case $cf_lock in #(vi -+ fcntl) #(vi -+ AC_TRY_COMPILE([ -+#include -+#ifdef HAVE_UNISTD_H -+#include -+#endif -+#ifdef HAVE_FCNTL_H -+#include -+#endif -+],[ -+ struct flock flk; -+ int block = 1; -+ int fd = 0; -+ int rc; -+ -+ flk.l_type = F_WRLCK; -+ flk.l_whence = SEEK_SET; -+ flk.l_start = 0; -+ flk.l_len = 0; -+ rc = fcntl(fd, block ? F_SETLKW : F_SETLK, &flk) -+ && fcntl(fd, F_GETLK, &flk) -+ && fcntl(fd, F_SETLK, &flk); -+ ],,continue) -+ ;; -+ lockf) #(vi -+ AC_TRY_COMPILE([ -+#include -+#ifdef HAVE_UNISTD_H -+#include -+#endif -+#ifdef HAVE_FCNTL_H -+#include -+#endif -+],[ -+ int block = 1, fd = 0; -+ int ret = lockf(fd, block ? F_LOCK : F_TLOCK, 0L) -+ && lockf(fd, F_TEST, 0L) -+ && lockf(fd, F_ULOCK, 0L); -+ ],,[continue]) -+ ;; -+ flock) -+ AC_TRY_COMPILE([ -+#include -+#ifdef HAVE_UNISTD_H -+#include -+#endif -+#ifdef HAVE_FCNTL_H -+#include -+#endif -+#ifdef HAVE_SYS_FILE_H -+#include -+#endif -+],[ -+ int block = 1, fd = 0; -+ int ret = flock(fd, (LOCK_EX|LOCK_NB)) -+ && flock(fd, LOCK_UN) -+ && flock(fd, block ? LOCK_EX : (LOCK_EX | LOCK_NB)); -+ ],,[continue]) -+ ;; -+ esac -+ cf_cv_lockfile="$cf_cv_lockfile $cf_lock" -+fi -+done -+]) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_MAKEFLAGS version: 9 updated: 2001/12/30 18:17:27 -+dnl ------------ -+dnl Some 'make' programs support $(MAKEFLAGS), some $(MFLAGS), to pass 'make' -+dnl options to lower-levels. It's very useful for "make -n" -- if we have it. -+dnl (GNU 'make' does both, something POSIX 'make', which happens to make the -+dnl $(MAKEFLAGS) variable incompatible because it adds the assignments :-) -+AC_DEFUN([CF_MAKEFLAGS], -+[ -+AC_CACHE_CHECK(for makeflags variable, cf_cv_makeflags,[ -+ cf_cv_makeflags='' -+ for cf_option in '-$(MAKEFLAGS)' '$(MFLAGS)' -+ do -+ cat >cf_makeflags.tmp </dev/null` -+ case "$cf_result" in -+ .*k) -+ cf_result=`${MAKE-make} -k -f cf_makeflags.tmp CC=cc 2>/dev/null` -+ case "$cf_result" in -+ .*CC=*) cf_cv_makeflags= -+ ;; -+ *) cf_cv_makeflags=$cf_option -+ ;; -+ esac -+ break -+ ;; -+ *) echo no match "$cf_result" -+ ;; -+ esac -+ done -+ rm -f cf_makeflags.tmp -+]) -+ -+AC_SUBST(cf_cv_makeflags) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_MSG_LOG version: 3 updated: 1997/09/07 14:05:52 -+dnl ---------- -+dnl Write a debug message to config.log, along with the line number in the -+dnl configure script. -+AC_DEFUN([CF_MSG_LOG],[ -+echo "(line __oline__) testing $* ..." 1>&AC_FD_CC -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_NCURSES_BROKEN version: 6 updated: 1998/04/27 20:32:34 -+dnl ----------------- -+dnl Check for pre-1.9.9g ncurses (among other problems, the most obvious is -+dnl that color combinations don't work). -+AC_DEFUN([CF_NCURSES_BROKEN], -+[ -+AC_REQUIRE([CF_NCURSES_VERSION]) -+if test "$cf_cv_ncurses_version" != no ; then -+AC_MSG_CHECKING(for obsolete/broken version of ncurses) -+AC_CACHE_VAL(cf_cv_ncurses_broken,[ -+AC_TRY_COMPILE([ -+#include <${cf_cv_ncurses_header-curses.h}>],[ -+#if defined(NCURSES_VERSION) && defined(wgetbkgd) -+ make an error -+#else -+ int x = 1 -+#endif -+], -+ [cf_cv_ncurses_broken=no], -+ [cf_cv_ncurses_broken=yes]) -+]) -+AC_MSG_RESULT($cf_cv_ncurses_broken) -+if test "$cf_cv_ncurses_broken" = yes ; then -+ AC_MSG_WARN(hmm... you should get an up-to-date version of ncurses) -+ AC_DEFINE(NCURSES_BROKEN) -+fi -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_NCURSES_CC_CHECK version: 3 updated: 2003/01/12 18:59:28 -+dnl ------------------- -+dnl Check if we can compile with ncurses' header file -+dnl $1 is the cache variable to set -+dnl $2 is the header-file to include -+dnl $3 is the root name (ncurses or ncursesw) -+AC_DEFUN([CF_NCURSES_CC_CHECK],[ -+ AC_TRY_COMPILE([ -+]ifelse($3,ncursesw,[ -+#define _XOPEN_SOURCE_EXTENDED -+#undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */ -+#define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */ -+])[ -+#include <$2>],[ -+#ifdef NCURSES_VERSION -+]ifelse($3,ncursesw,[ -+#ifndef WACS_BSSB -+ make an error -+#endif -+])[ -+printf("%s\n", NCURSES_VERSION); -+#else -+#ifdef __NCURSES_H -+printf("old\n"); -+#else -+ make an error -+#endif -+#endif -+ ] -+ ,[$1=$cf_header] -+ ,[$1=no]) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_NCURSES_CPPFLAGS version: 16 updated: 2002/12/29 18:30:46 -+dnl ------------------- -+dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting -+dnl the CPPFLAGS variable so we can include its header. -+dnl -+dnl The header files may be installed as either curses.h, or ncurses.h (would -+dnl be obsolete, except that some packagers prefer this name to distinguish it -+dnl from a "native" curses implementation). If not installed for overwrite, -+dnl the curses.h file would be in an ncurses subdirectory (e.g., -+dnl /usr/include/ncurses), but someone may have installed overwriting the -+dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd -+dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in -+dnl the header. -+dnl -+dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header -+dnl is already in the include-path, don't even bother with this, since we cannot -+dnl easily determine which file it is. In this case, it has to be . -+dnl -+dnl The optional parameter gives the root name of the library, in case it is -+dnl not installed as the default curses library. That is how the -+dnl wide-character version of ncurses is installed. -+AC_DEFUN([CF_NCURSES_CPPFLAGS], -+[AC_REQUIRE([CF_WITH_CURSES_DIR]) -+ -+cf_ncuhdr_root=ifelse($1,,ncurses,$1) -+ -+test -n "$cf_cv_curses_dir" && \ -+test "$cf_cv_curses_dir" != "no" && \ -+CPPFLAGS="-I$cf_cv_curses_dir/include -I$cf_cv_curses_dir/include/$cf_ncuhdr_root $CPPFLAGS" -+ -+AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[ -+ cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h" -+ ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h" -+ for cf_header in $cf_header_list -+ do -+ CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1) -+ test "$cf_cv_ncurses_h" != no && break -+ done -+]) -+ -+if test "$cf_cv_ncurses_h" != no ; then -+ cf_cv_ncurses_header=$cf_cv_ncurses_h -+else -+AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[ -+ test -n "$verbose" && echo -+ CF_HEADER_PATH(cf_search,$cf_ncuhdr_root) -+ test -n "$verbose" && echo search path $cf_search -+ cf_save2_CPPFLAGS="$CPPFLAGS" -+ for cf_incdir in $cf_search -+ do -+ CF_ADD_INCDIR($cf_incdir) -+ for cf_header in \ -+ ncurses.h \ -+ curses.h -+ do -+ CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1) -+ if test "$cf_cv_ncurses_h2" != no ; then -+ cf_cv_ncurses_h2=$cf_incdir/$cf_header -+ test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&AC_FD_MSG -+ break -+ fi -+ test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG -+ done -+ CPPFLAGS="$cf_save2_CPPFLAGS" -+ test "$cf_cv_ncurses_h2" != no && break -+ done -+ test "$cf_cv_ncurses_h2" = no && AC_ERROR(not found) -+ ]) -+ -+ CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2) -+ cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2` -+ if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then -+ cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header -+ fi -+ CF_ADD_INCDIR($cf_1st_incdir) -+ -+fi -+ -+AC_DEFINE(NCURSES) -+ -+case $cf_cv_ncurses_header in # (vi -+*ncurses.h) -+ AC_DEFINE(HAVE_NCURSES_H) -+ ;; -+esac -+ -+case $cf_cv_ncurses_header in # (vi -+ncurses/curses.h|ncurses/ncurses.h) -+ AC_DEFINE(HAVE_NCURSES_NCURSES_H) -+ ;; -+ncursesw/curses.h|ncursesw/ncurses.h) -+ AC_DEFINE(HAVE_NCURSESW_NCURSES_H) -+ ;; -+esac -+ -+CF_NCURSES_VERSION -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_NCURSES_LIBS version: 11 updated: 2002/12/22 14:22:25 -+dnl --------------- -+dnl Look for the ncurses library. This is a little complicated on Linux, -+dnl because it may be linked with the gpm (general purpose mouse) library. -+dnl Some distributions have gpm linked with (bsd) curses, which makes it -+dnl unusable with ncurses. However, we don't want to link with gpm unless -+dnl ncurses has a dependency, since gpm is normally set up as a shared library, -+dnl and the linker will record a dependency. -+dnl -+dnl The optional parameter gives the root name of the library, in case it is -+dnl not installed as the default curses library. That is how the -+dnl wide-character version of ncurses is installed. -+AC_DEFUN([CF_NCURSES_LIBS], -+[AC_REQUIRE([CF_NCURSES_CPPFLAGS]) -+ -+cf_nculib_root=ifelse($1,,ncurses,$1) -+ # This works, except for the special case where we find gpm, but -+ # ncurses is in a nonstandard location via $LIBS, and we really want -+ # to link gpm. -+cf_ncurses_LIBS="" -+cf_ncurses_SAVE="$LIBS" -+AC_CHECK_LIB(gpm,Gpm_Open, -+ [AC_CHECK_LIB(gpm,initscr, -+ [LIBS="$cf_ncurses_SAVE"], -+ [cf_ncurses_LIBS="-lgpm"])]) -+ -+case $host_os in #(vi -+freebsd*) -+ # This is only necessary if you are linking against an obsolete -+ # version of ncurses (but it should do no harm, since it's static). -+ AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"]) -+ ;; -+esac -+ -+LIBS="$cf_ncurses_LIBS $LIBS" -+ -+if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" ) -+then -+ LIBS="-L$cf_cv_curses_dir/lib -l$cf_nculib_root $LIBS" -+else -+ CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root, -+ [#include <${cf_cv_ncurses_header-curses.h}>], -+ [initscr()], -+ initscr) -+fi -+ -+if test -n "$cf_ncurses_LIBS" ; then -+ AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS) -+ cf_ncurses_SAVE="$LIBS" -+ for p in $cf_ncurses_LIBS ; do -+ q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"` -+ if test "$q" != "$LIBS" ; then -+ LIBS="$q" -+ fi -+ done -+ AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], -+ [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);], -+ [AC_MSG_RESULT(yes)], -+ [AC_MSG_RESULT(no) -+ LIBS="$cf_ncurses_SAVE"]) -+fi -+ -+CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root) -+AC_DEFINE_UNQUOTED($cf_nculib_ROOT) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_NCURSES_VERSION version: 10 updated: 2002/10/27 18:21:42 -+dnl ------------------ -+dnl Check for the version of ncurses, to aid in reporting bugs, etc. -+dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use -+dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi. -+AC_DEFUN([CF_NCURSES_VERSION], -+[ -+AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[ -+ cf_cv_ncurses_version=no -+ cf_tempfile=out$$ -+ rm -f $cf_tempfile -+ AC_TRY_RUN([ -+#include <${cf_cv_ncurses_header-curses.h}> -+#include -+int main() -+{ -+ FILE *fp = fopen("$cf_tempfile", "w"); -+#ifdef NCURSES_VERSION -+# ifdef NCURSES_VERSION_PATCH -+ fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH); -+# else -+ fprintf(fp, "%s\n", NCURSES_VERSION); -+# endif -+#else -+# ifdef __NCURSES_H -+ fprintf(fp, "old\n"); -+# else -+ make an error -+# endif -+#endif -+ exit(0); -+}],[ -+ cf_cv_ncurses_version=`cat $cf_tempfile`],,[ -+ -+ # This will not work if the preprocessor splits the line after the -+ # Autoconf token. The 'unproto' program does that. -+ cat > conftest.$ac_ext < -+#undef Autoconf -+#ifdef NCURSES_VERSION -+Autoconf NCURSES_VERSION -+#else -+#ifdef __NCURSES_H -+Autoconf "old" -+#endif -+; -+#endif -+EOF -+ cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out" -+ AC_TRY_EVAL(cf_try) -+ if test -f conftest.out ; then -+ cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'` -+ test -n "$cf_out" && cf_cv_ncurses_version="$cf_out" -+ rm -f conftest.out -+ fi -+]) -+ rm -f $cf_tempfile -+]) -+test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_NETLIBS version: 4 updated: 1999/12/23 15:20:39 -+dnl ---------- -+dnl After checking for functions in the default $LIBS, make a further check -+dnl for the functions that are netlib-related (these aren't always in the -+dnl libc, etc., and have to be handled specially because there are conflicting -+dnl and broken implementations. -+dnl Common library requirements (in order): -+dnl -lresolv -lsocket -lnsl -+dnl -lnsl -lsocket -+dnl -lsocket -+dnl -lbsd -+AC_DEFUN([CF_NETLIBS],[ -+cf_test_netlibs=no -+AC_MSG_CHECKING(for network libraries) -+AC_CACHE_VAL(cf_cv_netlibs,[ -+AC_MSG_RESULT(working...) -+cf_cv_netlibs="" -+cf_test_netlibs=yes -+AC_CHECK_FUNCS(gethostname,,[ -+ CF_RECHECK_FUNC(gethostname,nsl,cf_cv_netlibs,[ -+ CF_RECHECK_FUNC(gethostname,socket,cf_cv_netlibs)])]) -+# -+# FIXME: sequent needs this library (i.e., -lsocket -linet -lnsl), but -+# I don't know the entrypoints - 97/7/22 TD -+# AC_HAVE_LIBRARY(inet,cf_cv_netlibs="-linet $cf_cv_netlibs") -+AC_CHECK_LIB(inet, main, cf_cv_netlibs="-linet $cf_cv_netlibs") -+# -+if test "$ac_cv_func_lsocket" != no ; then -+AC_CHECK_FUNCS(socket,,[ -+ CF_RECHECK_FUNC(socket,socket,cf_cv_netlibs,[ -+ CF_RECHECK_FUNC(socket,bsd,cf_cv_netlibs)])]) -+fi -+# -+AC_CHECK_FUNCS(gethostbyname,,[ -+ CF_RECHECK_FUNC(gethostbyname,nsl,cf_cv_netlibs)]) -+# -+AC_CHECK_FUNCS(strcasecmp,,[ -+ CF_RECHECK_FUNC(strcasecmp,resolv,cf_cv_netlibs)]) -+]) -+LIBS="$LIBS $cf_cv_netlibs" -+test $cf_test_netlibs = no && echo "$cf_cv_netlibs" >&AC_FD_MSG -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_OUR_MESSAGES version: 4 updated: 2003/06/06 00:48:41 -+dnl --------------- -+dnl Check if we use the messages included with this program -+dnl -+dnl $1 specifies either Makefile or makefile, defaulting to the former. -+dnl -+dnl Sets variables which can be used to substitute in makefiles: -+dnl MSG_DIR_MAKE - to make ./po directory -+dnl SUB_MAKEFILE - makefile in ./po directory (see CF_BUNDLED_INTL) -+dnl -+AC_DEFUN([CF_OUR_MESSAGES], -+[ -+cf_makefile=ifelse($1,,Makefile,$1) -+ -+use_our_messages=no -+if test "$USE_NLS" = yes ; then -+if test -d $srcdir/po ; then -+AC_MSG_CHECKING(if we should use included message-library) -+ AC_ARG_ENABLE(included-msgs, -+ [ --enable-included-msgs use included messages, for i18n support], -+ [use_our_messages=$enableval], -+ [use_our_messages=yes]) -+fi -+AC_MSG_RESULT($use_our_messages) -+fi -+ -+MSG_DIR_MAKE="#" -+if test "$use_our_messages" = yes -+then -+ SUB_MAKEFILE="$SUB_MAKEFILE po/$cf_makefile.in:po/$cf_makefile.inn" -+ MSG_DIR_MAKE= -+fi -+ -+AC_SUBST(MSG_DIR_MAKE) -+AC_SUBST(SUB_MAKEFILE) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_PATHSEP version: 3 updated: 2001/01/12 01:23:53 -+dnl ---------- -+dnl Provide a value for the $PATH and similar separator -+AC_DEFUN([CF_PATHSEP], -+[ -+ case $cf_cv_system_name in -+ os2*) PATHSEP=';' ;; -+ *) PATHSEP=':' ;; -+ esac -+ifelse($1,,,[$1=$PATHSEP]) -+ AC_SUBST(PATHSEP) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_PATH_EDITOR version: 5 updated: 2000/07/20 00:41:18 -+dnl -------------- -+dnl Look for the default editor (vi) -+AC_DEFUN([CF_PATH_EDITOR], -+[ -+AC_MSG_CHECKING(for default editor) -+CF_ARG_WITH(editor, -+ [ --with-editor=PROG specify editor], -+ [DEFAULT_EDITOR],,vi) -+if test -z "$DEFAULT_EDITOR" ; then -+ if test -n "$EDITOR" ; then -+ DEFAULT_EDITOR="$EDITOR" -+ elif test -n "$VISUAL" ; then -+ DEFAULT_EDITOR="$VISUAL" -+ else -+ AC_PATH_PROG(DEFAULT_EDITOR,vi,vi,$PATH:/usr/bin:/usr/ucb) -+ fi -+fi -+AC_MSG_RESULT($DEFAULT_EDITOR) -+AC_DEFINE_UNQUOTED(DEFAULT_EDITOR,"$DEFAULT_EDITOR") -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_PATH_MAILBOX version: 4 updated: 1998/04/01 11:39:13 -+dnl --------------- -+dnl Look for the directory that contains incoming mail. I would check for an -+dnl actual mail-file, to verify this, but that is not always easy to arrange. -+AC_DEFUN([CF_PATH_MAILBOX], -+[ -+AC_MSG_CHECKING(for incoming-mail directory) -+CF_ARG_WITH(mailbox, -+ [ --with-mailbox=DIR directory for incoming mailboxes], -+ [DEFAULT_MAILBOX]) -+if test -z "$DEFAULT_MAILBOX" ; then -+for cf_dir in \ -+ /var/spool/mail \ -+ /usr/spool/mail \ -+ /var/mail \ -+ /usr/mail \ -+ /mail -+ do -+ if test -d $cf_dir ; then -+ DEFAULT_MAILBOX=$cf_dir -+ break -+ fi -+ done -+fi -+if test -n "$DEFAULT_MAILBOX" ; then -+ AC_DEFINE_UNQUOTED(DEFAULT_MAILBOX,"$DEFAULT_MAILBOX") -+else -+ DEFAULT_MAILBOX=none -+fi -+AC_MSG_RESULT($DEFAULT_MAILBOX) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_PATH_MAILER version: 6 updated: 2001/05/27 21:36:02 -+dnl -------------- -+dnl Look for the program that sends outgoing mail. -+AC_DEFUN([CF_PATH_MAILER], -+[ -+AC_PATH_PROG(DEFAULT_MAILER,sendmail,,$PATH:/usr/sbin:/usr/lib) -+CF_ARG_WITH(mailer, -+ [ --with-mailer=PROG specify default mailer-program], -+ [DEFAULT_MAILER],,mailx) -+if test -z "$DEFAULT_MAILER" ; then -+AC_PATH_PROG(DEFAULT_MAILER,mailx,,$PATH:/usr/bin) -+fi -+if test -z "$DEFAULT_MAILER" ; then -+AC_PATH_PROG(DEFAULT_MAILER,mail,,$PATH:/usr/bin) -+fi -+AC_MSG_CHECKING(for default mailer) -+if test -n "$DEFAULT_MAILER" ; then -+ CF_FIX_SLASHES(ac_cv_path_DEFAULT_MAILER) -+ CF_FIX_SLASHES(DEFAULT_MAILER) -+ AC_DEFINE_UNQUOTED(DEFAULT_MAILER,"$DEFAULT_MAILER") -+else -+ DEFAULT_MAILER=none -+fi -+AC_MSG_RESULT($DEFAULT_MAILER) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_PATH_SYNTAX version: 9 updated: 2002/09/17 23:03:38 -+dnl -------------- -+dnl Check the argument to see that it looks like a pathname. Rewrite it if it -+dnl begins with one of the prefix/exec_prefix variables, and then again if the -+dnl result begins with 'NONE'. This is necessary to work around autoconf's -+dnl delayed evaluation of those symbols. -+AC_DEFUN([CF_PATH_SYNTAX],[ -+case ".[$]$1" in #(vi -+.\[$]\(*\)*|.\'*\'*) #(vi -+ ;; -+..|./*|.\\*) #(vi -+ ;; -+.[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX -+ ;; -+.\[$]{*prefix}*) #(vi -+ eval $1="[$]$1" -+ case ".[$]$1" in #(vi -+ .NONE/*) -+ $1=`echo [$]$1 | sed -e s%NONE%$ac_default_prefix%` -+ ;; -+ esac -+ ;; #(vi -+.NONE/*) -+ $1=`echo [$]$1 | sed -e s%NONE%$ac_default_prefix%` -+ ;; -+*) -+ ifelse($2,,[AC_ERROR([expected a pathname, not \"[$]$1\"])],$2) -+ ;; -+esac -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_PDCURSES_X11 version: 6 updated: 2002/10/27 18:21:42 -+dnl --------------- -+dnl Configure for PDCurses' X11 library -+AC_DEFUN([CF_PDCURSES_X11],[ -+AC_REQUIRE([CF_X_ATHENA]) -+LDFLAGS="$LDFLAGS $X_LIBS" -+CF_CHECK_CFLAGS($X_CFLAGS) -+AC_CHECK_LIB(X11,XOpenDisplay, -+ [LIBS="-lX11 $LIBS"],, -+ [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS]) -+AC_CACHE_CHECK(for XCurses library,cf_cv_lib_XCurses,[ -+LIBS="-lXCurses $LIBS" -+AC_TRY_LINK([ -+#include -+char *XCursesProgramName = "test"; -+],[XCursesExit();], -+[cf_cv_lib_XCurses=yes], -+[cf_cv_lib_XCurses=no]) -+]) -+if test $cf_cv_lib_XCurses = yes ; then -+ AC_DEFINE(UNIX) -+ AC_DEFINE(XCURSES) -+ AC_DEFINE(HAVE_XCURSES) -+else -+ AC_ERROR(Cannot link with XCurses) -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_POSIX_JC version: 3 updated: 2001/05/27 21:36:02 -+dnl ----------- -+dnl Check if we have POSIX-style job control (i.e., sigaction), or if we must -+dnl use the signal functions. Use AC_CHECK_FUNCS(sigaction) first. -+AC_DEFUN([CF_POSIX_JC],[ -+ -+AC_REQUIRE([AC_TYPE_SIGNAL]) -+AC_REQUIRE([CF_SIG_ARGS]) -+ -+if test "$ac_cv_func_sigaction" = yes; then -+ -+AC_CACHE_CHECK(whether sigaction needs _POSIX_SOURCE,cf_cv_sigact_bad,[ -+AC_TRY_COMPILE([ -+#include -+#include ],[struct sigaction act], -+ [cf_cv_sigact_bad=no],[cf_cv_sigact_bad=yes]) -+]) -+ -+test "$cf_cv_sigact_bad" = yes && AC_DEFINE(SVR4_ACTION) -+ -+AC_CACHE_CHECK(if we have sigaction/related functions,cf_cv_sigaction_funcs,[ -+AC_TRY_LINK([ -+#ifdef SVR4_ACTION -+#define _POSIX_SOURCE -+#endif -+#include -+#include ],[ -+ RETSIGTYPE (*func)(SIG_ARGS) = SIG_IGN; -+ struct sigaction sa, osa; -+ sa.sa_handler = func; -+ sa.sa_flags = 0; -+ sigemptyset (&sa.sa_mask); -+ sigaction (SIGBUS,&sa,&osa);], -+ [cf_cv_sigaction_funcs=yes], -+ [cf_cv_sigaction_funcs=no])]) -+ -+test "$cf_cv_sigaction_funcs" = yes && AC_DEFINE(HAVE_POSIX_JC) -+ -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_PROG_EXT version: 8 updated: 2002/12/21 19:25:52 -+dnl ----------- -+dnl Compute $PROG_EXT, used for non-Unix ports, such as OS/2 EMX. -+AC_DEFUN([CF_PROG_EXT], -+[ -+AC_REQUIRE([CF_CHECK_CACHE]) -+PROG_EXT= -+case $cf_cv_system_name in -+os2*) -+ # We make sure -Zexe is not used -- it would interfere with @PROG_EXT@ -+ CFLAGS="$CFLAGS -Zmt" -+ CPPFLAGS="$CPPFLAGS -D__ST_MT_ERRNO__" -+ CXXFLAGS="$CXXFLAGS -Zmt" -+ LDFLAGS=`echo "$LDFLAGS -Zmt -Zcrtdll" | sed -e "s%-Zexe%%g"` -+ PROG_EXT=".exe" -+ ;; -+cygwin*) -+ PROG_EXT=".exe" -+ ;; -+esac -+AC_SUBST(PROG_EXT) -+test -n "$PROG_EXT" && AC_DEFINE_UNQUOTED(PROG_EXT,"$PROG_EXT") -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_PROG_SUM_R version: 2 updated: 1997/08/28 23:57:55 -+dnl ------------- -+dnl See if sum can take -r -+AC_DEFUN([CF_PROG_SUM_R], -+[ -+if test $ac_cv_path_PATH_SUM -+then -+AC_MSG_CHECKING([if $ac_cv_path_PATH_SUM takes -r]) -+AC_CACHE_VAL(ac_cv_prog_sum_r,[ -+if AC_TRY_COMMAND($ac_cv_path_PATH_SUM -r config.log 1>&AC_FD_CC) -+then -+ ac_cv_prog_sum_r=yes -+else -+ ac_cv_prog_sum_r=no -+fi -+]) -+if test $ac_cv_prog_sum_r = yes; then -+ AC_DEFINE(SUM_TAKES_DASH_R) -+ AC_DEFINE_UNQUOTED(PATH_SUM_R, "$ac_cv_path_PATH_SUM -r") -+else -+ AC_DEFINE_UNQUOTED(PATH_SUM_R, "$ac_cv_path_PATH_SUM") -+fi -+AC_MSG_RESULT($ac_cv_prog_sum_r) -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_PROG_YACC version: 2 updated: 1997/12/16 11:20:41 -+dnl ------------ -+dnl A better version of AC_PROC_YACC, verifies that we'll only choose bison if -+dnl we'll be able to compile with it. Bison uses alloca, which isn't all that -+dnl portable. -+AC_DEFUN([CF_PROG_YACC], -+[ -+AC_REQUIRE([AC_PROG_CC]) -+AC_CACHE_VAL(cf_cv_prog_YACC,[ -+if test -n "$YACC" ; then -+ cf_cv_prog_YACC="$YACC" # Let the user override the test. -+else -+cat >conftest.y < -+],[ -+ struct passwd foo; -+ char bar = foo.pw_gecos], -+ [cf_cv_pw_gecos=yes], -+ [cf_cv_pw_gecos=no])]) -+test $cf_cv_pw_gecos = no && AC_DEFINE(DONT_HAVE_PW_GECOS) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_RECHECK_FUNC version: 3 updated: 2000/10/18 19:29:13 -+dnl --------------- -+dnl Re-check on a function to see if we can pick it up by adding a library. -+dnl $1 = function to check -+dnl $2 = library to check in -+dnl $3 = environment to update (e.g., $LIBS) -+dnl $4 = what to do if this fails -+dnl -+dnl This uses 'unset' if the shell happens to support it, but leaves the -+dnl configuration variable set to 'unknown' if not. This is a little better -+dnl than the normal autoconf test, which gives misleading results if a test -+dnl for the function is made (e.g., with AC_CHECK_FUNC) after this macro is -+dnl used (autoconf does not distinguish between a null token and one that is -+dnl set to 'no'). -+AC_DEFUN([CF_RECHECK_FUNC],[ -+AC_CHECK_LIB($2,$1,[ -+ CF_UPPER(cf_tr_func,$1) -+ AC_DEFINE_UNQUOTED(HAVE_$cf_tr_func) -+ ac_cv_func_$1=yes -+ if test "$cf_used_lib_$2" != yes ; then cf_used_lib_$2=yes; $3="-l$2 [$]$3"; fi],[ -+ ac_cv_func_$1=unknown -+ unset ac_cv_func_$1 2>/dev/null -+ $4], -+ [[$]$3]) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_SET_GID_UID version: 2 updated: 1997/08/28 23:57:55 -+dnl -------------- -+dnl Check for the functions that set effective/real uid/gid. This has to -+dnl follow the AC_CHECK_FUNCS call. -+AC_DEFUN([CF_SET_GID_UID], -+[ -+AC_MSG_CHECKING([for setuid-like functions]) -+AC_CACHE_VAL(cf_cv_setuid_funcs,[ -+if test -n "${ac_cv_func_setuid}${ac_cv_func_seteuid}${ac_cv_func_setreuid}"; then -+ cf_cv_setuid_funcs=yes -+else -+ cf_cv_setuid_funcs=no -+fi -+]) -+AC_MSG_RESULT($cf_cv_setuid_funcs) -+test $cf_cv_setuid_funcs = yes && AC_DEFINE(HAVE_SET_GID_UID) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_SIG_ARGS version: 2 updated: 1997/08/28 23:57:55 -+dnl ----------- -+dnl Check for systems that have signal-handlers prototyped with one argument -+dnl versus those with more than one argument, define the symbol SIG_ARGS to -+dnl match. (If it's empty, that's ok too). -+AC_DEFUN([CF_SIG_ARGS], -+[ -+AC_MSG_CHECKING([declaration of signal arguments]) -+AC_CACHE_VAL(cf_cv_sig_args,[ -+cf_cv_sig_args= -+for cf_test in "int sig" "int sig, ..." -+do -+ AC_TRY_COMPILE([ -+#include ], -+ [extern RETSIGTYPE catch($cf_test); signal(SIGINT, catch)], -+ [cf_cv_sig_args="$cf_test";break]) -+done -+]) -+AC_MSG_RESULT($cf_cv_sig_args) -+AC_DEFINE_UNQUOTED(SIG_ARGS,$cf_cv_sig_args) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_SIG_CONST version: 2 updated: 1997/08/28 23:57:55 -+dnl ------------ -+dnl Check for systems where the special signal constants aren't prototyped -+dnl (there's a lot of them, and the compiler can generate a lot of warning -+dnl messages that make it hard to pick out genuine errors). -+AC_DEFUN([CF_SIG_CONST], -+[ -+AC_REQUIRE([CF_SIG_ARGS]) -+AC_MSG_CHECKING([for redefinable signal constants]) -+AC_CACHE_VAL(cf_cv_sig_const,[ -+cf_cv_sig_const=no -+if test -n "$cf_cv_sig_args"; then -+ cf_test=`echo $cf_cv_sig_args|sed -e s/sig//` -+ AC_TRY_RUN([ -+#define NEW_DFL ((RETSIGTYPE (*)($cf_test))0) -+#define NEW_IGN ((RETSIGTYPE (*)($cf_test))1) -+#define NEW_ERR ((RETSIGTYPE (*)($cf_test))-1) -+ -+#include -+ -+int main() -+{ -+ if (NEW_DFL != SIG_DFL -+ || NEW_IGN != SIG_IGN -+ || NEW_ERR != SIG_ERR -+ /* at least one system won't let me redefine these! */ -+#undef SIG_DFL -+#undef SIG_IGN -+#undef SIG_ERR -+#define SIG_DFL NEW_DFL -+#define SIG_IGN NEW_IGN -+#define SIG_ERR NEW_ERR -+ || NEW_DFL != SIG_DFL) -+ exit(1); -+ signal(SIGINT, SIG_DFL); -+ exit(0); -+}], -+ [cf_cv_sig_const=yes], -+ [cf_cv_sig_const=no], -+ [cf_cv_sig_const=unknown]) -+fi -+]) -+AC_MSG_RESULT($cf_cv_sig_const) -+test "$cf_cv_sig_const" = yes && AC_DEFINE(DECL_SIG_CONST) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_SIZECHANGE version: 8 updated: 2000/11/04 12:22:16 -+dnl ------------- -+dnl Check for definitions & structures needed for window size-changing -+dnl FIXME: check that this works with "snake" (HP-UX 10.x) -+AC_DEFUN([CF_SIZECHANGE], -+[ -+AC_REQUIRE([CF_STRUCT_TERMIOS]) -+AC_CACHE_CHECK(declaration of size-change, cf_cv_sizechange,[ -+ cf_cv_sizechange=unknown -+ cf_save_CPPFLAGS="$CPPFLAGS" -+ -+for cf_opts in "" "NEED_PTEM_H" -+do -+ -+ CPPFLAGS="$cf_save_CPPFLAGS" -+ test -n "$cf_opts" && CPPFLAGS="$CPPFLAGS -D$cf_opts" -+ AC_TRY_COMPILE([#include -+#ifdef HAVE_TERMIOS_H -+#include -+#else -+#ifdef HAVE_TERMIO_H -+#include -+#endif -+#endif -+#ifdef NEED_PTEM_H -+/* This is a workaround for SCO: they neglected to define struct winsize in -+ * termios.h -- it's only in termio.h and ptem.h -+ */ -+#include -+#include -+#endif -+#if !defined(sun) || !defined(HAVE_TERMIOS_H) -+#include -+#endif -+],[ -+#ifdef TIOCGSIZE -+ struct ttysize win; /* FIXME: what system is this? */ -+ int y = win.ts_lines; -+ int x = win.ts_cols; -+#else -+#ifdef TIOCGWINSZ -+ struct winsize win; -+ int y = win.ws_row; -+ int x = win.ws_col; -+#else -+ no TIOCGSIZE or TIOCGWINSZ -+#endif /* TIOCGWINSZ */ -+#endif /* TIOCGSIZE */ -+ ], -+ [cf_cv_sizechange=yes], -+ [cf_cv_sizechange=no]) -+ -+ CPPFLAGS="$cf_save_CPPFLAGS" -+ if test "$cf_cv_sizechange" = yes ; then -+ echo "size-change succeeded ($cf_opts)" >&AC_FD_CC -+ test -n "$cf_opts" && cf_cv_sizechange="$cf_opts" -+ break -+ fi -+done -+]) -+if test "$cf_cv_sizechange" != no ; then -+ AC_DEFINE(HAVE_SIZECHANGE) -+ case $cf_cv_sizechange in #(vi -+ NEED*) -+ AC_DEFINE_UNQUOTED($cf_cv_sizechange ) -+ ;; -+ esac -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_SOCKS version: 3 updated: 2001/01/01 09:54:40 -+dnl -------- -+dnl Check for socks library -+dnl $1 = the [optional] directory in which the library may be found -+AC_DEFUN([CF_SOCKS],[ -+case "$1" in #(vi -+no|yes) #(vi -+ ;; -+*) -+ if test -d $1 ; then -+ if test -d $1/include ; then -+ CPPFLAGS="$CPPFLAGS -I$1/include" -+ LIBS="$LIBS -L$1/lib" -+ else -+ LIBS="$LIBS -L$1" -+ test -d $1/../include && CPPFLAGS="$CPPFLAGS -I$1/../include" -+ fi -+ else -+ AC_MSG_WARN(expected a directory: $1) -+ fi -+ ;; -+esac -+LIBS="$LIBS -lsocks" -+AC_DEFINE(SOCKS) -+AC_DEFINE(accept,Raccept) -+AC_DEFINE(bind,Rbind) -+AC_DEFINE(connect,Rconnect) -+AC_DEFINE(getpeername,Rgetpeername) -+AC_DEFINE(getsockname,Rgetsockname) -+AC_DEFINE(listen,Rlisten) -+AC_DEFINE(recvfrom,Rrecvfrom) -+AC_DEFINE(select,Rselect) -+AC_TRY_LINK([ -+#include ],[ -+ accept((char *)0)],, -+ [AC_ERROR(Cannot link with socks library)]) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_SOCKS5 version: 7 updated: 2001/01/01 09:54:40 -+dnl --------- -+dnl Check for socks5 configuration -+dnl $1 = the [optional] directory in which the library may be found -+AC_DEFUN([CF_SOCKS5],[ -+case "$1" in #(vi -+no|yes) #(vi -+ ;; -+*) -+ if test -d $1 ; then -+ if test -d $1/include ; then -+ CPPFLAGS="$CPPFLAGS -I$1/include" -+ LIBS="$LIBS -L$1/lib" -+ else -+ LIBS="$LIBS -L$1" -+ test -d $1/../include && CPPFLAGS="$CPPFLAGS -I$1/../include" -+ fi -+ else -+ AC_MSG_WARN(expected a directory: $1) -+ fi -+ ;; -+esac -+LIBS="$LIBS -lsocks5" -+AC_DEFINE(USE_SOCKS5) -+AC_DEFINE(SOCKS) -+AC_MSG_CHECKING(if the socks library uses socks4 prefix) -+cf_use_socks4=error -+AC_TRY_LINK([ -+#include ],[ -+ Rinit((char *)0)], -+ [AC_DEFINE(USE_SOCKS4_PREFIX) -+ cf_use_socks4=yes], -+ [AC_TRY_LINK([#include ], -+ [SOCKSinit((char *)0)], -+ [cf_use_socks4=no], -+ [AC_ERROR(Cannot link with socks5 library)])]) -+AC_MSG_RESULT($cf_use_socks4) -+if test "$cf_use_socks4" = "yes" ; then -+ AC_DEFINE(accept,Raccept) -+ AC_DEFINE(bind,Rbind) -+ AC_DEFINE(connect,Rconnect) -+ AC_DEFINE(getpeername,Rgetpeername) -+ AC_DEFINE(getsockname,Rgetsockname) -+ AC_DEFINE(listen,Rlisten) -+ AC_DEFINE(recvfrom,Rrecvfrom) -+ AC_DEFINE(select,Rselect) -+else -+ AC_DEFINE(accept,SOCKSaccept) -+ AC_DEFINE(getpeername,SOCKSgetpeername) -+ AC_DEFINE(getsockname,SOCKSgetsockname) -+ AC_DEFINE(recvfrom,SOCKSrecvfrom) -+fi -+AC_MSG_CHECKING(if socks5p.h is available) -+AC_TRY_COMPILE([ -+#define INCLUDE_PROTOTYPES -+#include ],[ -+ init((char *)0)], -+ [cf_use_socks5p_h=yes], -+ [cf_use_socks5p_h=no]) -+AC_MSG_RESULT($cf_use_socks5p_h) -+test "$cf_use_socks5p_h" = yes && AC_DEFINE(INCLUDE_PROTOTYPES) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_STRERROR version: 2 updated: 2001/07/11 09:34:49 -+dnl ----------- -+dnl Check for strerror(), or it is not found, for the related data. POSIX -+dnl requires strerror(), so only old systems such as SunOS lack it. -+AC_DEFUN([CF_STRERROR],[ -+AC_CHECK_FUNCS(strerror, AC_DEFINE(HAVE_STRERROR),[CF_SYS_ERRLIST]) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_STRUCT_TERMIOS version: 5 updated: 2000/11/04 12:22:46 -+dnl ----------------- -+dnl Some machines require _POSIX_SOURCE to completely define struct termios. -+dnl If so, define SVR4_TERMIO -+AC_DEFUN([CF_STRUCT_TERMIOS],[ -+AC_CHECK_HEADERS( \ -+termio.h \ -+termios.h \ -+unistd.h \ -+) -+if test "$ISC" = yes ; then -+ AC_CHECK_HEADERS( sys/termio.h ) -+fi -+if test "$ac_cv_header_termios_h" = yes ; then -+ case "$CFLAGS $CPPFLAGS" in -+ *-D_POSIX_SOURCE*) -+ termios_bad=dunno ;; -+ *) termios_bad=maybe ;; -+ esac -+ if test "$termios_bad" = maybe ; then -+ AC_MSG_CHECKING(whether termios.h needs _POSIX_SOURCE) -+ AC_TRY_COMPILE([#include ], -+ [struct termios foo; int x = foo.c_iflag], -+ termios_bad=no, [ -+ AC_TRY_COMPILE([ -+#define _POSIX_SOURCE -+#include ], -+ [struct termios foo; int x = foo.c_iflag], -+ termios_bad=unknown, -+ termios_bad=yes AC_DEFINE(SVR4_TERMIO)) -+ ]) -+ AC_MSG_RESULT($termios_bad) -+ fi -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_SUBDIR_PATH version: 3 updated: 2002/12/29 18:30:46 -+dnl -------------- -+dnl Construct a search-list for a nonstandard header/lib-file -+dnl $1 = the variable to return as result -+dnl $2 = the package name -+dnl $3 = the subdirectory, e.g., bin, include or lib -+AC_DEFUN([CF_SUBDIR_PATH], -+[$1="" -+ -+test -d [$]HOME && { -+ test -n "$verbose" && echo " ... testing $3-directories under [$]HOME" -+ test -d [$]HOME/$3 && $1="[$]$1 [$]HOME/$3" -+ test -d [$]HOME/$3/$2 && $1="[$]$1 [$]HOME/$3/$2" -+ test -d [$]HOME/$3/$2/$3 && $1="[$]$1 [$]HOME/$3/$2/$3" -+} -+ -+# For other stuff under the home directory, it should be sufficient to put -+# a symbolic link for $HOME/$2 to the actual package location: -+test -d [$]HOME/$2 && { -+ test -n "$verbose" && echo " ... testing $3-directories under [$]HOME/$2" -+ test -d [$]HOME/$2/$3 && $1="[$]$1 [$]HOME/$2/$3" -+ test -d [$]HOME/$2/$3/$2 && $1="[$]$1 [$]HOME/$2/$3/$2" -+} -+ -+test "$prefix" != /usr/local && \ -+test -d /usr/local && { -+ test -n "$verbose" && echo " ... testing $3-directories under /usr/local" -+ test -d /usr/local/$3 && $1="[$]$1 /usr/local/$3" -+ test -d /usr/local/$3/$2 && $1="[$]$1 /usr/local/$3/$2" -+ test -d /usr/local/$3/$2/$3 && $1="[$]$1 /usr/local/$3/$2/$3" -+ test -d /usr/local/$2/$3 && $1="[$]$1 /usr/local/$2/$3" -+ test -d /usr/local/$2/$3/$2 && $1="[$]$1 /usr/local/$2/$3/$2" -+} -+ -+test "$prefix" != NONE && \ -+test -d $prefix && { -+ test -n "$verbose" && echo " ... testing $3-directories under $prefix" -+ test -d $prefix/$3 && $1="[$]$1 $prefix/$3" -+ test -d $prefix/$3/$2 && $1="[$]$1 $prefix/$3/$2" -+ test -d $prefix/$3/$2/$3 && $1="[$]$1 $prefix/$3/$2/$3" -+ test -d $prefix/$2/$3 && $1="[$]$1 $prefix/$2/$3" -+ test -d $prefix/$2/$3/$2 && $1="[$]$1 $prefix/$2/$3/$2" -+} -+ -+test "$prefix" != /opt && \ -+test -d /opt && { -+ test -n "$verbose" && echo " ... testing $3-directories under /opt" -+ test -d /opt/$3 && $1="[$]$1 /opt/$3" -+ test -d /opt/$3/$2 && $1="[$]$1 /opt/$3/$2" -+ test -d /opt/$3/$2/$3 && $1="[$]$1 /opt/$3/$2/$3" -+ test -d /opt/$2/$3 && $1="[$]$1 /opt/$2/$3" -+ test -d /opt/$2/$3/$2 && $1="[$]$1 /opt/$2/$3/$2" -+} -+ -+test "$prefix" != /usr && \ -+test -d /usr && { -+ test -n "$verbose" && echo " ... testing $3-directories under /usr" -+ test -d /usr/$3 && $1="[$]$1 /usr/$3" -+ test -d /usr/$3/$2 && $1="[$]$1 /usr/$3/$2" -+ test -d /usr/$3/$2/$3 && $1="[$]$1 /usr/$3/$2/$3" -+ test -d /usr/$2/$3 && $1="[$]$1 /usr/$2/$3" -+} -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_SYS_ERRLIST version: 6 updated: 2001/12/30 13:03:23 -+dnl -------------- -+dnl Check for declaration of sys_nerr and sys_errlist in one of stdio.h and -+dnl errno.h. Declaration of sys_errlist on BSD4.4 interferes with our -+dnl declaration. Reported by Keith Bostic. -+AC_DEFUN([CF_SYS_ERRLIST], -+[ -+ CF_CHECK_ERRNO(sys_nerr) -+ CF_CHECK_ERRNO(sys_errlist) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_SYS_SELECT_TIMEVAL version: 4 updated: 1997/12/16 11:22:31 -+dnl --------------------- -+dnl Check if there is a conflict between and . -+dnl This is known to be a problem with SCO. -+AC_DEFUN([CF_SYS_SELECT_TIMEVAL], -+[ -+AC_MSG_CHECKING(if sys/time.h conflicts with sys/select.h) -+AC_CACHE_VAL(cf_cv_sys_select_timeval,[ -+for cf_opts in no yes -+do -+AC_TRY_COMPILE([ -+#define yes 1 -+#define no 0 -+#if $cf_opts -+#define timeval fake_timeval -+#endif -+#include -+#ifdef TIME_WITH_SYS_TIME -+# include -+# include -+#else -+# ifdef HAVE_SYS_TIME_H -+# include -+# else -+# include -+# endif -+#endif -+#undef timeval -+#ifdef HAVE_SYS_SELECT_H -+# include -+#endif -+],[struct timeval foo], -+ [cf_cv_sys_select_timeval=$cf_opts -+ break], -+ [cf_cv_sys_select_timeval=no]) -+done -+]) -+AC_MSG_RESULT($cf_cv_sys_select_timeval) -+test $cf_cv_sys_select_timeval = yes && AC_DEFINE(NEED_TIMEVAL_FIX) -+]) -+dnl --------------------------------------------------------------------------- -+dnl CF_TERMCAP_LIBS version: 10 updated: 2001/10/18 20:42:39 -+dnl --------------- -+dnl Look for termcap libraries, or the equivalent in terminfo. -+AC_DEFUN([CF_TERMCAP_LIBS], -+[ -+AC_CACHE_VAL(cf_cv_termlib,[ -+cf_cv_termlib=none -+AC_TRY_LINK([],[char *x=(char*)tgoto("",0,0)], -+[AC_TRY_LINK([],[int x=tigetstr("")], -+ [cf_cv_termlib=terminfo], -+ [cf_cv_termlib=termcap]) -+ CF_VERBOSE(using functions in predefined $cf_cv_termlib LIBS) -+],[ -+ifelse([$1],,,[ -+case "$1" in # (vi -+ncurses*) -+ CF_NCURSES_CPPFLAGS($1) -+ CF_NCURSES_LIBS($1) -+ cf_cv_termlib=terminfo -+ ;; -+esac -+]) -+if test "$cf_cv_termlib" = none; then -+ # FreeBSD's linker gives bogus results for AC_CHECK_LIB, saying that -+ # tgetstr lives in -lcurses when it is only an unsatisfied extern. -+ cf_save_LIBS="$LIBS" -+ for cf_lib in curses ncurses termlib termcap -+ do -+ LIBS="-l$cf_lib $cf_save_LIBS" -+ for cf_func in tigetstr tgetstr -+ do -+ AC_MSG_CHECKING(for $cf_func in -l$cf_lib) -+ AC_TRY_LINK([],[int x=$cf_func("")],[cf_result=yes],[cf_result=no]) -+ AC_MSG_RESULT($cf_result) -+ if test "$cf_result" = yes ; then -+ if test "$cf_func" = tigetstr ; then -+ cf_cv_termlib=terminfo -+ else -+ cf_cv_termlib=termcap -+ fi -+ break -+ fi -+ done -+ test "$cf_result" = yes && break -+ done -+ test "$cf_result" = no && LIBS="$cf_save_LIBS" -+fi -+if test "$cf_cv_termlib" = none; then -+ # allow curses library for broken AIX system. -+ AC_CHECK_LIB(curses, initscr, [LIBS="$LIBS -lcurses" cf_cv_termlib=termcap]) -+ AC_CHECK_LIB(termcap, tgoto, [LIBS="$LIBS -ltermcap" cf_cv_termlib=termcap]) -+fi -+]) -+if test "$cf_cv_termlib" = none; then -+ AC_MSG_WARN([Cannot find -ltermlib, -lcurses, or -ltermcap]) -+fi -+])])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_TERMIOS version: 2 updated: 1997/08/28 23:57:55 -+dnl ---------- -+dnl See if we can link with the termios functions tcsetattr/tcgetattr -+AC_DEFUN([CF_TERMIOS], -+[ -+AC_MSG_CHECKING([for nonconflicting termios.h]) -+AC_CACHE_VAL(cf_cv_use_termios_h,[ -+ AC_TRY_LINK([ -+#ifdef HAVE_IOCTL_H -+# include -+#else -+# ifdef HAVE_SYS_IOCTL_H -+# include -+# endif -+#endif -+ -+#if !defined(sun) || !defined(NL0) -+#include -+#endif -+],[ -+ struct termios save_tty; -+ (void) tcsetattr (0, TCSANOW, &save_tty); -+ (void) tcgetattr (0, &save_tty)], -+ [cf_cv_use_termios_h=yes], -+ [cf_cv_use_termios_h=no]) -+]) -+AC_MSG_RESULT($cf_cv_use_termios_h) -+if test $cf_cv_use_termios_h = yes; then -+ AC_DEFINE(HAVE_TERMIOS_H) -+ AC_DEFINE(HAVE_TCGETATTR) -+ AC_DEFINE(HAVE_TCSETATTR) -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_TIOCGWINSZ version: 3 updated: 1997/11/29 01:04:53 -+dnl ------------- -+dnl On some systems ioctl(fd, TIOCGWINSZ, &size) will always return {0,0} until -+dnl ioctl(fd, TIOCSWINSZ, &size) is called to explicitly set the size of the -+dnl screen. -+dnl -+dnl Attempt to determine if we're on such a system by running a test-program. -+dnl This won't work, of course, if the configure script is run in batch mode, -+dnl since we've got to have access to the terminal. -+dnl -+dnl CHECK_DECL_FLAG and CHECK_DECL_HDRS must be set in configure.in -+AC_DEFUN([CF_TIOCGWINSZ], -+[ -+AC_MSG_CHECKING([for working TIOCGWINSZ]) -+AC_CACHE_VAL(cf_cv_use_tiocgwinsz,[ -+ cf_save_CFLAGS="$CFLAGS" -+ CFLAGS="$CFLAGS -D__CPROTO__ $CHECK_DECL_FLAG" -+ AC_TRY_RUN([ -+$CHECK_DECL_HDRS -+int main() -+{ -+ int fd; -+ for (fd = 0; fd <= 2; fd++) { /* try in/out/err in case redirected */ -+#ifdef TIOCGSIZE -+ struct ttysize size; -+ if (ioctl (0, TIOCGSIZE, &size) == 0 -+ && size.ts_lines > 0 -+ && size.ts_cols > 0) -+ exit(0); -+#else -+ struct winsize size; -+ if (ioctl(0, TIOCGWINSZ, &size) == 0 -+ && size.ws_row > 0 -+ && size.ws_col > 0) -+ exit(0); -+#endif -+ } -+ exit(0); /* we cannot guarantee this is run interactively */ -+}], -+ [cf_cv_use_tiocgwinsz=yes], -+ [cf_cv_use_tiocgwinsz=no], -+ [cf_cv_use_tiocgwinsz=unknown]) -+ rm -f autoconf.h -+ CFLAGS="$cf_save_CFLAGS"]) -+AC_MSG_RESULT($cf_cv_use_tiocgwinsz) -+test $cf_cv_use_tiocgwinsz != yes && AC_DEFINE(DONT_HAVE_SIGWINCH) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_TM_GMTOFF version: 2 updated: 1997/08/28 23:57:55 -+dnl ------------ -+dnl Check if the tm-struct defines the '.tm_gmtoff' member (useful in decoding -+dnl dates). -+AC_DEFUN([CF_TM_GMTOFF], -+[ -+AC_MSG_CHECKING([for tm.tm_gmtoff]) -+AC_CACHE_VAL(cf_cv_tm_gmtoff,[ -+ AC_TRY_COMPILE([ -+#ifdef TIME_WITH_SYS_TIME -+# include -+# include -+#else -+# ifdef HAVE_SYS_TIME_H -+# include -+# else -+# include -+# endif -+#endif -+],[ -+ struct tm foo; -+ long bar = foo.tm_gmtoff], -+ [cf_cv_tm_gmtoff=yes], -+ [cf_cv_tm_gmtoff=no])]) -+AC_MSG_RESULT($cf_cv_tm_gmtoff) -+test $cf_cv_tm_gmtoff = no && AC_DEFINE(DONT_HAVE_TM_GMTOFF) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_TYPE_OUTCHAR version: 13 updated: 2002/10/09 20:00:37 -+dnl --------------- -+dnl Check for return and param type of 3rd -- OutChar() -- param of tputs(). -+dnl -+dnl For this check, and for CF_CURSES_TERMCAP, the $CHECK_DECL_HDRS variable -+dnl must point to a header file containing this (or equivalent): -+dnl -+dnl #ifdef NEED_CURSES_H -+dnl # ifdef HAVE_NCURSES_NCURSES_H -+dnl # include -+dnl # else -+dnl # ifdef HAVE_NCURSES_H -+dnl # include -+dnl # else -+dnl # include -+dnl # endif -+dnl # endif -+dnl #endif -+dnl -+dnl #ifdef HAVE_NCURSES_TERM_H -+dnl # include -+dnl #else -+dnl # ifdef HAVE_TERM_H -+dnl # include -+dnl # endif -+dnl #endif -+dnl -+dnl #if NEED_TERMCAP_H -+dnl # include -+dnl #endif -+dnl -+AC_DEFUN([CF_TYPE_OUTCHAR], -+[ -+AC_REQUIRE([CF_CURSES_TERMCAP]) -+ -+AC_CACHE_CHECK(declaration of tputs 3rd param, cf_cv_type_outchar,[ -+ -+cf_cv_type_outchar="int OutChar(int)" -+cf_cv_found=no -+cf_save_CPPFLAGS="$CPPFLAGS" -+CPPFLAGS="$CPPFLAGS $CHECK_DECL_FLAG" -+ -+for P in int void; do -+for Q in int void; do -+for R in int char; do -+for S in "" const; do -+ CF_MSG_LOG(loop variables [P:[$]P, Q:[$]Q, R:[$]R, S:[$]S]) -+ AC_TRY_COMPILE([$CHECK_DECL_HDRS], -+ [extern $Q OutChar($R); -+ extern $P tputs ($S char *string, int nlines, $Q (*_f)($R)); -+ tputs("", 1, OutChar)], -+ [cf_cv_type_outchar="$Q OutChar($R)" -+ cf_cv_found=yes -+ break]) -+done -+ test $cf_cv_found = yes && break -+done -+ test $cf_cv_found = yes && break -+done -+ test $cf_cv_found = yes && break -+done -+]) -+ -+case $cf_cv_type_outchar in -+int*) -+ AC_DEFINE(OUTC_RETURN) -+ ;; -+esac -+case $cf_cv_type_outchar in -+*char*) -+ AC_DEFINE(OUTC_ARGS,char c) -+ ;; -+esac -+ -+CPPFLAGS="$cf_save_CPPFLAGS" -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_TYPE_SIGACTION version: 3 updated: 2000/08/12 23:18:52 -+dnl ----------------- -+dnl -+AC_DEFUN([CF_TYPE_SIGACTION], -+[ -+AC_MSG_CHECKING([for type sigaction_t]) -+AC_CACHE_VAL(cf_cv_type_sigaction,[ -+ AC_TRY_COMPILE([ -+#include ], -+ [sigaction_t x], -+ [cf_cv_type_sigaction=yes], -+ [cf_cv_type_sigaction=no])]) -+AC_MSG_RESULT($cf_cv_type_sigaction) -+test "$cf_cv_type_sigaction" = yes && AC_DEFINE(HAVE_TYPE_SIGACTION) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_UNION_WAIT version: 5 updated: 1997/11/23 14:49:44 -+dnl ------------- -+dnl Check to see if the BSD-style union wait is declared. Some platforms may -+dnl use this, though it is deprecated in favor of the 'int' type in Posix. -+dnl Some vendors provide a bogus implementation that declares union wait, but -+dnl uses the 'int' type instead; we try to spot these by checking for the -+dnl associated macros. -+dnl -+dnl Ahem. Some implementers cast the status value to an int*, as an attempt to -+dnl use the macros for either union wait or int. So we do a check compile to -+dnl see if the macros are defined and apply to an int. -+dnl -+dnl Sets: $cf_cv_type_unionwait -+dnl Defines: HAVE_TYPE_UNIONWAIT -+AC_DEFUN([CF_UNION_WAIT], -+[ -+AC_REQUIRE([CF_WAIT_HEADERS]) -+AC_MSG_CHECKING([for union wait]) -+AC_CACHE_VAL(cf_cv_type_unionwait,[ -+ AC_TRY_LINK($cf_wait_headers, -+ [int x; -+ int y = WEXITSTATUS(x); -+ int z = WTERMSIG(x); -+ wait(&x); -+ ], -+ [cf_cv_type_unionwait=no -+ echo compiles ok w/o union wait 1>&AC_FD_CC -+ ],[ -+ AC_TRY_LINK($cf_wait_headers, -+ [union wait x; -+#ifdef WEXITSTATUS -+ int y = WEXITSTATUS(x); -+#endif -+#ifdef WTERMSIG -+ int z = WTERMSIG(x); -+#endif -+ wait(&x); -+ ], -+ [cf_cv_type_unionwait=yes -+ echo compiles ok with union wait and possibly macros too 1>&AC_FD_CC -+ ], -+ [cf_cv_type_unionwait=no])])]) -+AC_MSG_RESULT($cf_cv_type_unionwait) -+test $cf_cv_type_unionwait = yes && AC_DEFINE(HAVE_TYPE_UNIONWAIT) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59 -+dnl -------- -+dnl Make an uppercase version of a variable -+dnl $1=uppercase($2) -+AC_DEFUN([CF_UPPER], -+[ -+$1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_VERBOSE version: 2 updated: 1997/09/05 10:45:14 -+dnl ---------- -+dnl Use AC_VERBOSE w/o the warnings -+AC_DEFUN([CF_VERBOSE], -+[test -n "$verbose" && echo " $1" 1>&AC_FD_MSG -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_WAIT_HEADERS version: 2 updated: 1997/10/21 19:45:33 -+dnl --------------- -+dnl Build up an expression $cf_wait_headers with the header files needed to -+dnl compile against the prototypes for 'wait()', 'waitpid()', etc. Assume it's -+dnl Posix, which uses and , but allow SVr4 variation -+dnl with . -+AC_DEFUN([CF_WAIT_HEADERS], -+[ -+AC_HAVE_HEADERS(sys/wait.h) -+cf_wait_headers="#include -+" -+if test $ac_cv_header_sys_wait_h = yes; then -+cf_wait_headers="$cf_wait_headers -+#include -+" -+else -+AC_HAVE_HEADERS(wait.h) -+AC_HAVE_HEADERS(waitstatus.h) -+if test $ac_cv_header_wait_h = yes; then -+cf_wait_headers="$cf_wait_headers -+#include -+" -+fi -+if test $ac_cv_header_waitstatus_h = yes; then -+cf_wait_headers="$cf_wait_headers -+#include -+" -+fi -+fi -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_WITH_CURSES_DIR version: 2 updated: 2002/11/10 14:46:59 -+dnl ------------------ -+dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses -+dnl libraries. -+AC_DEFUN([CF_WITH_CURSES_DIR],[ -+AC_ARG_WITH(curses-dir, -+ [ --with-curses-dir=DIR directory in which (n)curses is installed], -+ [CF_PATH_SYNTAX(withval) -+ cf_cv_curses_dir=$withval], -+ [cf_cv_curses_dir=no]) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_WITH_DFTENV version: 3 updated: 1998/04/01 11:39:13 -+dnl -------------- -+dnl Wrapper for AC_ARG_WITH to inherit/override an environment variable's -+dnl "#define" in the compile. -+dnl $1 = option name -+dnl $2 = help-message -+dnl $3 = name of variable to inherit/override -+dnl $4 = default value of variable, if any -+AC_DEFUN([CF_WITH_DFTENV], -+[AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),, -+ifelse($4,,[withval="${$3}"],[withval="${$3-$4}"]))dnl -+case "$withval" in #(vi -+yes|no) -+ AC_ERROR(expected a value for --with-$1) -+ ;; -+esac -+$3="$withval" -+AC_DEFINE_UNQUOTED($3,"[$]$3")dnl -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_WITH_PATH version: 6 updated: 1998/10/11 00:40:17 -+dnl ------------ -+dnl Wrapper for AC_ARG_WITH to ensure that user supplies a pathname, not just -+dnl defaulting to yes/no. -+dnl -+dnl $1 = option name -+dnl $2 = help-text -+dnl $3 = environment variable to set -+dnl $4 = default value, shown in the help-message, must be a constant -+dnl $5 = default value, if it's an expression & cannot be in the help-message -+dnl -+AC_DEFUN([CF_WITH_PATH], -+[AC_ARG_WITH($1,[$2 ](default: ifelse($4,,empty,$4)),, -+ifelse($4,,[withval="${$3}"],[withval="${$3-ifelse($5,,$4,$5)}"]))dnl -+CF_PATH_SYNTAX(withval) -+eval $3="$withval" -+AC_SUBST($3)dnl -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_WITH_PROGRAM version: 5 updated: 2001/07/22 23:07:22 -+dnl --------------- -+dnl Wrapper for AC_PATH_PROG, with command-line option. -+dnl Params: -+dnl $1 = program name -+dnl $2 = help-string (I'd use format, but someone's disable it in autoconf) -+dnl $3 = caller-supplied default if no --with option is given. If this is -+dnl blank, the macro uses AC_PATH_PROG. -+AC_DEFUN([CF_WITH_PROGRAM], -+[dnl -+define([cf_path_name], PATH_[]translit($1, [a-z], [A-Z]))dnl -+define([cf_have_name], HAVE_[]translit($1, [a-z], [A-Z]))dnl -+AC_ARG_WITH($1,[$2],ifelse($3,, -+[case "$withval" in #(vi -+ yes[)] -+ AC_ERROR(expected a value for --with-$1) -+ ;; #(vi -+ no[)] -+ ;; #(vi -+ *[)] -+ # user supplied option-value for "--with-$1=path" -+ AC_MSG_CHECKING(for $1) -+ ac_cv_path_]cf_path_name[="$withval" -+ AC_DEFINE_UNQUOTED(cf_path_name,"$withval")dnl -+ AC_DEFINE(cf_have_name)dnl -+ AC_MSG_RESULT($withval) -+ ;; -+ esac],[$3]),[ -+ # user did not specify "--with-$1"; do automatic check -+ AC_PATH_PROG(cf_path_name,$1) -+ if test -n "$cf_path_name"; then -+ AC_DEFINE_UNQUOTED(cf_path_name,"$cf_path_name")dnl -+ AC_DEFINE(cf_have_name)dnl -+ fi -+])dnl -+undefine([cf_path_name])undefine([cf_have_name])])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_WITH_VALUE version: 3 updated: 1998/04/01 11:39:13 -+dnl ------------- -+dnl Wrapper for AC_ARG_WITH to ensure that if the user supplies a value, it is -+dnl not simply defaulting to yes/no. Empty strings are ok if the macro is -+dnl invoked without a default value -+dnl $1 = option name -+dnl $2 = help-message -+dnl $3 = variable to inherit/override -+dnl $4 = default value, if any. -+AC_DEFUN([CF_WITH_VALUE], -+[CF_ARG_WITH($1,[$2],[$3],[$4]) -+ AC_DEFINE_UNQUOTED($3,"$withval")dnl -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_XOPEN_CURSES version: 6 updated: 2002/11/12 06:55:30 -+dnl --------------- -+dnl Test if we should define X/Open source for curses, needed on Digital Unix -+dnl 4.x, to see the extended functions, but breaks on IRIX 6.x. -+AC_DEFUN([CF_XOPEN_CURSES], -+[ -+AC_CACHE_CHECK(if we must define _XOPEN_SOURCE_EXTENDED,cf_cv_need_xopen_extension,[ -+AC_TRY_LINK([ -+#include -+#include <${cf_cv_ncurses_header-curses.h}>],[ -+ long x = winnstr(stdscr, "", 0)], -+ [cf_cv_need_xopen_extension=no], -+ [AC_TRY_LINK([ -+#define _XOPEN_SOURCE_EXTENDED -+#include -+#include <${cf_cv_ncurses_header-curses.h}>],[ -+ long x = winnstr(stdscr, "", 0)], -+ [cf_cv_need_xopen_extension=yes], -+ [cf_cv_need_xopen_extension=unknown])])]) -+test $cf_cv_need_xopen_extension = yes && CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE_EXTENDED" -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_X_ATHENA version: 11 updated: 2002/12/26 20:56:10 -+dnl ----------- -+dnl Check for Xaw (Athena) libraries -+dnl -+AC_DEFUN([CF_X_ATHENA], -+[AC_REQUIRE([CF_X_TOOLKIT]) -+cf_x_athena=${cf_x_athena-Xaw} -+ -+AC_ARG_WITH(Xaw3d, -+ [ --with-Xaw3d link with Xaw 3d library], -+ [cf_x_athena=Xaw3d]) -+ -+AC_ARG_WITH(neXtaw, -+ [ --with-neXtaw link with neXT Athena library], -+ [cf_x_athena=neXtaw]) -+ -+AC_ARG_WITH(XawPlus, -+ [ --with-XawPlus link with Athena-Plus library], -+ [cf_x_athena=XawPlus]) -+ -+AC_CHECK_LIB(Xext,XextCreateExtension, -+ [LIBS="-lXext $LIBS"]) -+ -+cf_x_athena_lib="" -+ -+CF_X_ATHENA_CPPFLAGS($cf_x_athena) -+CF_X_ATHENA_LIBS($cf_x_athena) -+])dnl -+dnl --------------------------------------------------------------------------- -+dnl CF_X_ATHENA_CPPFLAGS version: 2 updated: 2002/10/09 20:00:37 -+dnl -------------------- -+dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of -+dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw. -+AC_DEFUN([CF_X_ATHENA_CPPFLAGS], -+[ -+cf_x_athena_root=ifelse($1,,Xaw,$1) -+cf_x_athena_include="" -+ -+for cf_path in default \ -+ /usr/contrib/X11R6 \ -+ /usr/contrib/X11R5 \ -+ /usr/lib/X11R5 \ -+ /usr/local -+do -+ if test -z "$cf_x_athena_include" ; then -+ cf_save="$CPPFLAGS" -+ cf_test=X11/$cf_x_athena_root/SimpleMenu.h -+ if test $cf_path != default ; then -+ CPPFLAGS="-I$cf_path/include $cf_save" -+ AC_MSG_CHECKING(for $cf_test in $cf_path) -+ else -+ AC_MSG_CHECKING(for $cf_test) -+ fi -+ AC_TRY_COMPILE([ -+#include -+#include <$cf_test>],[], -+ [cf_result=yes], -+ [cf_result=no]) -+ AC_MSG_RESULT($cf_result) -+ if test "$cf_result" = yes ; then -+ cf_x_athena_include=$cf_path -+ break -+ else -+ CPPFLAGS="$cf_save" -+ fi -+ fi -+done -+ -+if test -z "$cf_x_athena_include" ; then -+ AC_MSG_WARN( -+[Unable to successfully find Athena header files with test program]) -+elif test "$cf_x_athena_include" != default ; then -+ CPPFLAGS="$CPPFLAGS -I$cf_x_athena_include" -+fi -+]) -+dnl --------------------------------------------------------------------------- -+dnl CF_X_ATHENA_LIBS version: 3 updated: 2003/02/16 15:24:54 -+dnl ---------------- -+dnl Normally invoked by CF_X_ATHENA, with $1 set to the appropriate flavor of -+dnl the Athena widgets, e.g., Xaw, Xaw3d, neXtaw. -+AC_DEFUN([CF_X_ATHENA_LIBS], -+[AC_REQUIRE([CF_X_TOOLKIT]) -+cf_x_athena_root=ifelse($1,,Xaw,$1) -+cf_x_athena_lib="" -+ -+for cf_path in default \ -+ /usr/contrib/X11R6 \ -+ /usr/contrib/X11R5 \ -+ /usr/lib/X11R5 \ -+ /usr/local -+do -+ for cf_lib in \ -+ "-l$cf_x_athena_root -lXmu" \ -+ "-l$cf_x_athena_root -lXpm -lXmu" \ -+ "-l${cf_x_athena_root}_s -lXmu_s" -+ do -+ if test -z "$cf_x_athena_lib" ; then -+ cf_save="$LIBS" -+ cf_test=XawSimpleMenuAddGlobalActions -+ if test $cf_path != default ; then -+ LIBS="-L$cf_path/lib $cf_lib $LIBS" -+ AC_MSG_CHECKING(for $cf_lib in $cf_path) -+ else -+ LIBS="$cf_lib $LIBS" -+ AC_MSG_CHECKING(for $cf_test in $cf_lib) -+ fi -+ cf_SAVE="$LIBS" -+ LIBS="$X_PRE_LIBS $LIBS $X_EXTRA_LIBS" -+ AC_TRY_LINK([],[$cf_test()], -+ [cf_result=yes], -+ [cf_result=no]) -+ AC_MSG_RESULT($cf_result) -+ if test "$cf_result" = yes ; then -+ cf_x_athena_lib="$cf_lib" -+ LIBS="$cf_SAVE" -+ break -+ else -+ LIBS="$cf_save" -+ fi -+ fi -+ done -+done -+ -+if test -z "$cf_x_athena_lib" ; then -+ AC_ERROR( -+[Unable to successfully link Athena library (-l$cf_x_athena_root) with test program]) -+fi -+ -+CF_UPPER(cf_x_athena_LIBS,HAVE_LIB_$cf_x_athena) -+AC_DEFINE_UNQUOTED($cf_x_athena_LIBS) -+]) -+dnl --------------------------------------------------------------------------- -+dnl CF_X_TOOLKIT version: 9 updated: 2001/12/30 19:09:58 -+dnl ------------ -+dnl Check for X Toolkit libraries -+dnl -+AC_DEFUN([CF_X_TOOLKIT], -+[ -+AC_REQUIRE([CF_CHECK_CACHE]) -+# We need to check for -lsocket and -lnsl here in order to work around an -+# autoconf bug. autoconf-2.12 is not checking for these prior to checking for -+# the X11R6 -lSM and -lICE libraries. The resultant failures cascade... -+# (tested on Solaris 2.5 w/ X11R6) -+SYSTEM_NAME=`echo "$cf_cv_system_name"|tr ' ' -` -+cf_have_X_LIBS=no -+case $SYSTEM_NAME in -+irix[[56]]*) ;; -+clix*) -+ # FIXME: modify the library lookup in autoconf to -+ # allow _s.a suffix ahead of .a -+ AC_CHECK_LIB(c_s,open, -+ [LIBS="-lc_s $LIBS" -+ AC_CHECK_LIB(bsd,gethostname, -+ [LIBS="-lbsd $LIBS" -+ AC_CHECK_LIB(nsl_s,gethostname, -+ [LIBS="-lnsl_s $LIBS" -+ AC_CHECK_LIB(X11_s,XOpenDisplay, -+ [LIBS="-lX11_s $LIBS" -+ AC_CHECK_LIB(Xt_s,XtAppInitialize, -+ [LIBS="-lXt_s $LIBS" -+ cf_have_X_LIBS=Xt -+ ]) ]) ]) ]) ]) -+ ;; -+*) -+ AC_CHECK_LIB(socket,socket) -+ AC_CHECK_LIB(nsl,gethostname) -+ ;; -+esac -+ -+if test $cf_have_X_LIBS = no ; then -+ AC_PATH_XTRA -+ LDFLAGS="$LDFLAGS $X_LIBS" -+ CF_CHECK_CFLAGS($X_CFLAGS) -+ AC_CHECK_LIB(X11,XOpenDisplay, -+ [LIBS="-lX11 $LIBS"],, -+ [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS]) -+ AC_CHECK_LIB(Xt, XtAppInitialize, -+ [AC_DEFINE(HAVE_LIBXT) -+ cf_have_X_LIBS=Xt -+ LIBS="-lXt $X_PRE_LIBS $LIBS"],, -+ [$X_PRE_LIBS $LIBS $X_EXTRA_LIBS]) -+else -+ LDFLAGS="$LDFLAGS $X_LIBS" -+ CF_CHECK_CFLAGS($X_CFLAGS) -+fi -+ -+if test $cf_have_X_LIBS = no ; then -+ AC_WARN( -+[Unable to successfully link X Toolkit library (-lXt) with -+test program. You will have to check and add the proper libraries by hand -+to makefile.]) -+fi -+])dnl diff --git a/packages/tin/tin-1.7.3/makecfg-buildcc.patch b/packages/tin/tin-1.7.3/makecfg-buildcc.patch deleted file mode 100644 index 2b3dba44f9..0000000000 --- a/packages/tin/tin-1.7.3/makecfg-buildcc.patch +++ /dev/null @@ -1,24 +0,0 @@ - -# -# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher -# - ---- tin-1.7.3/src/Makefile.in~makecfg-buildcc -+++ tin-1.7.3/src/Makefile.in -@@ -462,7 +462,7 @@ - ./makecfg $(SRCDIR)/tincfg.tbl tincfg.h - - makecfg$(EXEEXT): $(OBJDIR)/makecfg.o -- $(LD) $(LDFLAGS) -o $@ $(OBJDIR)/makecfg.o @LIBS@ -+ $(BUILD_CC) $(BUILD_LDFLAGS) -o $@ $(OBJDIR)/makecfg.o - - $(OBJDIR)/active.o: $(SRCDIR)/active.c $(TIN_DEP) - $(OBJDIR)/art.o: $(SRCDIR)/art.c $(TIN_DEP) \ -@@ -519,6 +519,7 @@ - $(OBJDIR)/main.o: $(SRCDIR)/main.c $(TIN_DEP) \ - $(INCDIR)/version.h - $(OBJDIR)/makecfg.o: $(SRCDIR)/makecfg.c $(TIN_DEP) -+ $(BUILD_CC) $(BUILD_CFLAGS) -c -I../include -I../pcre -o $@ $(SRCDIR)/makecfg.c - $(OBJDIR)/memory.o: $(SRCDIR)/memory.c $(TIN_DEP) \ - $(INCDIR)/rfc2046.h - $(OBJDIR)/mimetypes.o: $(SRCDIR)/mimetypes.c $(TIN_DEP) diff --git a/packages/tin/tin_1.7.3.bb b/packages/tin/tin_1.7.3.bb index aff987a555..3383f74757 100644 --- a/packages/tin/tin_1.7.3.bb +++ b/packages/tin/tin_1.7.3.bb @@ -1,8 +1,9 @@ DESCRIPTION = "Tin is a powerful text mode news reader." SECTION = "console/network" DEPENDS = "ncurses" -PR = "r1" LICENSE = "GPL" +PR = "r3" + SRC_URI = "ftp://ftp.tin.org/pub/news/clients/tin/unstable/tin-${PV}.tar.gz \ file://makecfg-buildcc.patch;patch=1 \ file://m4.patch;patch=1 \ @@ -11,8 +12,9 @@ SRC_URI = "ftp://ftp.tin.org/pub/news/clients/tin/unstable/tin-${PV}.tar.gz \ inherit autotools EXTRA_OECONF = "--with-screen=ncurses" +CFLAGS += "-DM_UNIX" -do_compile () { +do_compile() { ${BUILD_CC} -DLINK_SIZE=2 -I${S}/include -c pcre/dftables.c ${BUILD_CC} dftables.o -o pcre/dftables oe_runmake build diff --git a/packages/tin/tin_1.9.1.bb b/packages/tin/tin_1.9.1.bb new file mode 100644 index 0000000000..560184f413 --- /dev/null +++ b/packages/tin/tin_1.9.1.bb @@ -0,0 +1,23 @@ +DESCRIPTION = "Tin is a powerful text mode news reader." +SECTION = "console/network" +DEPENDS = "ncurses pcre" +LICENSE = "GPL" +PR = "r0" + +SRC_URI = "ftp://ftp.tin.org/pub/news/clients/tin/unstable/tin-${PV}.tar.gz \ + file://m4.patch;patch=1" + +inherit autotools + +PARALLEL_MAKE = "" +EXTRA_OECONF = "--with-screen=ncurses --with-pcre=${STAGING_LIBDIR}/.." + +export BUILD_CFLAGS += "-I${S}/include -DHAVE_CONFIG_H" + +do_configure() { + oe_runconf +} + +do_compile() { + cd src && oe_runmake +} -- cgit v1.2.3