diff options
Diffstat (limited to 'bash')
| -rw-r--r-- | bash/bash-2.05b/autofoo.patch | 1994 |
1 files changed, 1994 insertions, 0 deletions
diff --git a/bash/bash-2.05b/autofoo.patch b/bash/bash-2.05b/autofoo.patch index e69de29bb2..a3b9a8b3a2 100644 --- a/bash/bash-2.05b/autofoo.patch +++ b/bash/bash-2.05b/autofoo.patch @@ -0,0 +1,1994 @@ + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- /dev/null ++++ bash-2.05b/acinclude.m4 +@@ -0,0 +1,1815 @@ ++dnl ++dnl Bash specific tests ++dnl ++dnl Some derived from PDKSH 5.1.3 autoconf tests ++dnl ++ ++AC_DEFUN([BASH_C_LONG_LONG], ++[AC_CACHE_CHECK(for long long, ac_cv_c_long_long, ++[if test "$GCC" = yes; then ++ ac_cv_c_long_long=yes ++else ++AC_TRY_RUN([ ++int ++main() ++{ ++long long foo = 0; ++exit(sizeof(long long) < sizeof(long)); ++} ++], ac_cv_c_long_long=yes, ac_cv_c_long_long=no) ++fi]) ++if test $ac_cv_c_long_long = yes; then ++ AC_DEFINE(HAVE_LONG_LONG, 1, [Define if the `long long' type works.]) ++fi ++]) ++ ++dnl ++dnl This is very similar to AC_C_LONG_DOUBLE, with the fix for IRIX ++dnl (< changed to <=) added. ++dnl ++AC_DEFUN([BASH_C_LONG_DOUBLE], ++[AC_CACHE_CHECK(for long double, ac_cv_c_long_double, ++[if test "$GCC" = yes; then ++ ac_cv_c_long_double=yes ++else ++AC_TRY_RUN([ ++int ++main() ++{ ++ /* The Stardent Vistra knows sizeof(long double), but does not ++ support it. */ ++ long double foo = 0.0; ++ /* On Ultrix 4.3 cc, long double is 4 and double is 8. */ ++ /* On IRIX 5.3, the compiler converts long double to double with a warning, ++ but compiles this successfully. */ ++ exit(sizeof(long double) <= sizeof(double)); ++} ++], ac_cv_c_long_double=yes, ac_cv_c_long_double=no) ++fi]) ++if test $ac_cv_c_long_double = yes; then ++ AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define if the `long double' type works.]) ++fi ++]) ++ ++dnl ++dnl Check for <inttypes.h>. This is separated out so that it can be ++dnl AC_REQUIREd. ++dnl ++dnl BASH_HEADER_INTTYPES ++AC_DEFUN([BASH_HEADER_INTTYPES], ++[ ++ AC_CHECK_HEADERS(inttypes.h) ++]) ++ ++dnl ++dnl check for typedef'd symbols in header files, but allow the caller to ++dnl specify the include files to be checked in addition to the default ++dnl ++dnl BASH_CHECK_TYPE(TYPE, HEADERS, DEFAULT[, VALUE-IF-FOUND]) ++AC_DEFUN([BASH_CHECK_TYPE], ++[ ++AC_REQUIRE([AC_HEADER_STDC])dnl ++AC_REQUIRE([BASH_HEADER_INTTYPES]) ++AC_MSG_CHECKING(for $1) ++AC_CACHE_VAL(bash_cv_type_$1, ++[AC_EGREP_CPP($1, [#include <sys/types.h> ++#if STDC_HEADERS ++#include <stdlib.h> ++#include <stddef.h> ++#endif ++#if HAVE_INTTYPES_H ++#include <inttypes.h> ++#endif ++$2 ++], bash_cv_type_$1=yes, bash_cv_type_$1=no)]) ++AC_MSG_RESULT($bash_cv_type_$1) ++ifelse($#, 4, [if test $bash_cv_type_$1 = yes; then ++ AC_DEFINE($4) ++ fi]) ++if test $bash_cv_type_$1 = no; then ++ AC_DEFINE_UNQUOTED($1, $3) ++fi ++]) ++ ++dnl ++dnl BASH_CHECK_DECL(FUNC) ++dnl ++dnl Check for a declaration of FUNC in stdlib.h and inttypes.h like ++dnl AC_CHECK_DECL ++dnl ++AC_DEFUN([BASH_CHECK_DECL], ++[ ++AC_REQUIRE([AC_HEADER_STDC]) ++AC_REQUIRE([BASH_HEADER_INTTYPES]) ++AC_CACHE_CHECK([for declaration of $1], bash_cv_decl_$1, ++[AC_TRY_LINK( ++[ ++#if STDC_HEADERS ++# include <stdlib.h> ++#endif ++#if HAVE_INTTYPES_H ++# include <inttypes.h> ++#endif ++], ++[return !$1;], ++bash_cv_decl_$1=yes, bash_cv_decl_$1=no)]) ++bash_tr_func=HAVE_DECL_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` ++if test $bash_cv_decl_$1 = yes; then ++ AC_DEFINE_UNQUOTED($bash_tr_func, 1) ++else ++ AC_DEFINE_UNQUOTED($bash_tr_func, 0) ++fi ++]) ++ ++AC_DEFUN([BASH_DECL_PRINTF], ++[AC_MSG_CHECKING(for declaration of printf in <stdio.h>) ++AC_CACHE_VAL(bash_cv_printf_declared, ++[AC_TRY_RUN([ ++#include <stdio.h> ++#ifdef __STDC__ ++typedef int (*_bashfunc)(const char *, ...); ++#else ++typedef int (*_bashfunc)(); ++#endif ++main() ++{ ++_bashfunc pf; ++pf = (_bashfunc) printf; ++exit(pf == 0); ++} ++], bash_cv_printf_declared=yes, bash_cv_printf_declared=no, ++ [AC_MSG_WARN(cannot check printf declaration if cross compiling -- defaulting to yes) ++ bash_cv_printf_declared=yes] ++)]) ++AC_MSG_RESULT($bash_cv_printf_declared) ++if test $bash_cv_printf_declared = yes; then ++AC_DEFINE(PRINTF_DECLARED) ++fi ++]) ++ ++AC_DEFUN([BASH_DECL_SBRK], ++[AC_MSG_CHECKING(for declaration of sbrk in <unistd.h>) ++AC_CACHE_VAL(bash_cv_sbrk_declared, ++[AC_EGREP_HEADER(sbrk, unistd.h, ++ bash_cv_sbrk_declared=yes, bash_cv_sbrk_declared=no)]) ++AC_MSG_RESULT($bash_cv_sbrk_declared) ++if test $bash_cv_sbrk_declared = yes; then ++AC_DEFINE(SBRK_DECLARED) ++fi ++]) ++ ++dnl ++dnl Check for sys_siglist[] or _sys_siglist[] ++dnl ++AC_DEFUN([BASH_DECL_UNDER_SYS_SIGLIST], ++[AC_MSG_CHECKING([for _sys_siglist in signal.h or unistd.h]) ++AC_CACHE_VAL(bash_cv_decl_under_sys_siglist, ++[AC_TRY_COMPILE([ ++#include <sys/types.h> ++#include <signal.h> ++#ifdef HAVE_UNISTD_H ++#include <unistd.h> ++#endif], [ char *msg = _sys_siglist[2]; ], ++ bash_cv_decl_under_sys_siglist=yes, bash_cv_decl_under_sys_siglist=no, ++ [AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)])])dnl ++AC_MSG_RESULT($bash_cv_decl_under_sys_siglist) ++if test $bash_cv_decl_under_sys_siglist = yes; then ++AC_DEFINE(UNDER_SYS_SIGLIST_DECLARED) ++fi ++]) ++ ++AC_DEFUN([BASH_UNDER_SYS_SIGLIST], ++[AC_REQUIRE([BASH_DECL_UNDER_SYS_SIGLIST]) ++AC_MSG_CHECKING([for _sys_siglist in system C library]) ++AC_CACHE_VAL(bash_cv_under_sys_siglist, ++[AC_TRY_RUN([ ++#include <sys/types.h> ++#include <signal.h> ++#ifdef HAVE_UNISTD_H ++#include <unistd.h> ++#endif ++#ifndef UNDER_SYS_SIGLIST_DECLARED ++extern char *_sys_siglist[]; ++#endif ++main() ++{ ++char *msg = (char *)_sys_siglist[2]; ++exit(msg == 0); ++}], ++ bash_cv_under_sys_siglist=yes, bash_cv_under_sys_siglist=no, ++ [AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no) ++ bash_cv_under_sys_siglist=no])]) ++AC_MSG_RESULT($bash_cv_under_sys_siglist) ++if test $bash_cv_under_sys_siglist = yes; then ++AC_DEFINE(HAVE_UNDER_SYS_SIGLIST) ++fi ++]) ++ ++AC_DEFUN([BASH_SYS_SIGLIST], ++[ ++AC_CHECK_DECLS([sys_siglist]) ++AC_MSG_CHECKING([for sys_siglist in system C library]) ++AC_CACHE_VAL(bash_cv_sys_siglist, ++[AC_TRY_RUN([ ++#include <sys/types.h> ++#include <signal.h> ++#ifdef HAVE_UNISTD_H ++#include <unistd.h> ++#endif ++#ifndef HAVE_DECL_SYS_SIGLIST ++extern char *sys_siglist[]; ++#endif ++main() ++{ ++char *msg = sys_siglist[2]; ++exit(msg == 0); ++}], ++ bash_cv_sys_siglist=yes, bash_cv_sys_siglist=no, ++ [AC_MSG_WARN(cannot check for sys_siglist if cross compiling -- defaulting to no) ++ bash_cv_sys_siglist=no])]) ++AC_MSG_RESULT($bash_cv_sys_siglist) ++if test $bash_cv_sys_siglist = yes; then ++AC_DEFINE(HAVE_SYS_SIGLIST) ++fi ++]) ++ ++dnl Check for the various permutations of sys_siglist and make sure we ++dnl compile in siglist.o if they're not defined ++AC_DEFUN([BASH_CHECK_SYS_SIGLIST], [ ++AC_REQUIRE([BASH_SYS_SIGLIST]) ++AC_REQUIRE([BASH_DECL_UNDER_SYS_SIGLIST]) ++AC_REQUIRE([BASH_FUNC_STRSIGNAL]) ++if test "$bash_cv_sys_siglist" = no && test "$bash_cv_under_sys_siglist" = no && test "$bash_cv_have_strsignal" = no; then ++ SIGLIST_O=siglist.o ++else ++ SIGLIST_O= ++fi ++AC_SUBST([SIGLIST_O]) ++]) ++ ++dnl Check for sys_errlist[] and sys_nerr, check for declaration ++AC_DEFUN([BASH_SYS_ERRLIST], ++[AC_MSG_CHECKING([for sys_errlist and sys_nerr]) ++AC_CACHE_VAL(bash_cv_sys_errlist, ++[AC_TRY_LINK([#include <errno.h>], ++[extern char *sys_errlist[]; ++ extern int sys_nerr; ++ char *msg = sys_errlist[sys_nerr - 1];], ++ bash_cv_sys_errlist=yes, bash_cv_sys_errlist=no)])dnl ++AC_MSG_RESULT($bash_cv_sys_errlist) ++if test $bash_cv_sys_errlist = yes; then ++AC_DEFINE(HAVE_SYS_ERRLIST) ++fi ++]) ++ ++dnl ++dnl Check if dup2() does not clear the close on exec flag ++dnl ++AC_DEFUN([BASH_FUNC_DUP2_CLOEXEC_CHECK], ++[AC_MSG_CHECKING(if dup2 fails to clear the close-on-exec flag) ++AC_CACHE_VAL(bash_cv_dup2_broken, ++[AC_TRY_RUN([ ++#include <sys/types.h> ++#include <fcntl.h> ++main() ++{ ++ int fd1, fd2, fl; ++ fd1 = open("/dev/null", 2); ++ if (fcntl(fd1, 2, 1) < 0) ++ exit(1); ++ fd2 = dup2(fd1, 1); ++ if (fd2 < 0) ++ exit(2); ++ fl = fcntl(fd2, 1, 0); ++ /* fl will be 1 if dup2 did not reset the close-on-exec flag. */ ++ exit(fl != 1); ++} ++], bash_cv_dup2_broken=yes, bash_cv_dup2_broken=no, ++ [AC_MSG_WARN(cannot check dup2 if cross compiling -- defaulting to no) ++ bash_cv_dup2_broken=no]) ++]) ++AC_MSG_RESULT($bash_cv_dup2_broken) ++if test $bash_cv_dup2_broken = yes; then ++AC_DEFINE(DUP2_BROKEN) ++fi ++]) ++ ++AC_DEFUN([BASH_FUNC_STRSIGNAL], ++[AC_MSG_CHECKING([for the existence of strsignal]) ++AC_CACHE_VAL(bash_cv_have_strsignal, ++[AC_TRY_LINK([#include <sys/types.h> ++#include <signal.h>], ++[char *s = (char *)strsignal(2);], ++ bash_cv_have_strsignal=yes, bash_cv_have_strsignal=no)]) ++AC_MSG_RESULT($bash_cv_have_strsignal) ++if test $bash_cv_have_strsignal = yes; then ++AC_DEFINE(HAVE_STRSIGNAL) ++fi ++]) ++ ++dnl Check to see if opendir will open non-directories (not a nice thing) ++AC_DEFUN([BASH_FUNC_OPENDIR_CHECK], ++[AC_REQUIRE([AC_HEADER_DIRENT])dnl ++AC_MSG_CHECKING(if opendir() opens non-directories) ++AC_CACHE_VAL(bash_cv_opendir_not_robust, ++[AC_TRY_RUN([ ++#include <stdio.h> ++#include <sys/types.h> ++#include <fcntl.h> ++#ifdef HAVE_UNISTD_H ++# include <unistd.h> ++#endif /* HAVE_UNISTD_H */ ++#if defined(HAVE_DIRENT_H) ++# include <dirent.h> ++#else ++# define dirent direct ++# ifdef HAVE_SYS_NDIR_H ++# include <sys/ndir.h> ++# endif /* SYSNDIR */ ++# ifdef HAVE_SYS_DIR_H ++# include <sys/dir.h> ++# endif /* SYSDIR */ ++# ifdef HAVE_NDIR_H ++# include <ndir.h> ++# endif ++#endif /* HAVE_DIRENT_H */ ++main() ++{ ++DIR *dir; ++int fd, err; ++err = mkdir("/tmp/bash-aclocal", 0700); ++if (err < 0) { ++ perror("mkdir"); ++ exit(1); ++} ++unlink("/tmp/bash-aclocal/not_a_directory"); ++fd = open("/tmp/bash-aclocal/not_a_directory", O_WRONLY|O_CREAT|O_EXCL, 0666); ++write(fd, "\n", 1); ++close(fd); ++dir = opendir("/tmp/bash-aclocal/not_a_directory"); ++unlink("/tmp/bash-aclocal/not_a_directory"); ++rmdir("/tmp/bash-aclocal"); ++exit (dir == 0); ++}], bash_cv_opendir_not_robust=yes,bash_cv_opendir_not_robust=no, ++ [AC_MSG_WARN(cannot check opendir if cross compiling -- defaulting to no) ++ bash_cv_opendir_not_robust=no] ++)]) ++AC_MSG_RESULT($bash_cv_opendir_not_robust) ++if test $bash_cv_opendir_not_robust = yes; then ++AC_DEFINE(OPENDIR_NOT_ROBUST) ++fi ++]) ++ ++dnl ++AH_TEMPLATE([VOID_SIGHANDLER], [Define if signal handlers return type void]) ++AC_DEFUN([BASH_TYPE_SIGHANDLER], ++[AC_MSG_CHECKING([whether signal handlers are of type void]) ++AC_CACHE_VAL(bash_cv_void_sighandler, ++[AC_TRY_COMPILE([#include <sys/types.h> ++#include <signal.h> ++#ifdef signal ++#undef signal ++#endif ++#ifdef __cplusplus ++extern "C" ++#endif ++void (*signal ()) ();], ++[int i;], bash_cv_void_sighandler=yes, bash_cv_void_sighandler=no)])dnl ++AC_MSG_RESULT($bash_cv_void_sighandler) ++if test $bash_cv_void_sighandler = yes; then ++AC_DEFINE(VOID_SIGHANDLER) ++fi ++]) ++ ++dnl ++dnl A signed 16-bit integer quantity ++dnl ++AC_DEFUN([BASH_TYPE_BITS16_T], ++[ ++if test "$ac_cv_sizeof_short" = 2; then ++ AC_CHECK_TYPE(bits16_t, short) ++elif test "$ac_cv_sizeof_char" = 2; then ++ AC_CHECK_TYPE(bits16_t, char) ++else ++ AC_CHECK_TYPE(bits16_t, short) ++fi ++]) ++ ++dnl ++dnl An unsigned 16-bit integer quantity ++dnl ++AC_DEFUN([BASH_TYPE_U_BITS16_T], ++[ ++if test "$ac_cv_sizeof_short" = 2; then ++ AC_CHECK_TYPE(u_bits16_t, unsigned short) ++elif test "$ac_cv_sizeof_char" = 2; then ++ AC_CHECK_TYPE(u_bits16_t, unsigned char) ++else ++ AC_CHECK_TYPE(u_bits16_t, unsigned short) ++fi ++]) ++ ++dnl ++dnl A signed 32-bit integer quantity ++dnl ++AC_DEFUN([BASH_TYPE_BITS32_T], ++[ ++if test "$ac_cv_sizeof_int" = 4; then ++ AC_CHECK_TYPE(bits32_t, int) ++elif test "$ac_cv_sizeof_long" = 4; then ++ AC_CHECK_TYPE(bits32_t, long) ++else ++ AC_CHECK_TYPE(bits32_t, int) ++fi ++]) ++ ++dnl ++dnl An unsigned 32-bit integer quantity ++dnl ++AC_DEFUN([BASH_TYPE_U_BITS32_T], ++[ ++if test "$ac_cv_sizeof_int" = 4; then ++ AC_CHECK_TYPE(u_bits32_t, unsigned int) ++elif test "$ac_cv_sizeof_long" = 4; then ++ AC_CHECK_TYPE(u_bits32_t, unsigned long) ++else ++ AC_CHECK_TYPE(u_bits32_t, unsigned int) ++fi ++]) ++ ++AC_DEFUN([BASH_TYPE_PTRDIFF_T], ++[ ++if test "$ac_cv_sizeof_int" = "$ac_cv_sizeof_char_p"; then ++ AC_CHECK_TYPE(ptrdiff_t, int) ++elif test "$ac_cv_sizeof_long" = "$ac_cv_sizeof_char_p"; then ++ AC_CHECK_TYPE(ptrdiff_t, long) ++elif test "$ac_cv_type_long_long" = yes && test "$ac_cv_sizeof_long_long" = "$ac_cv_sizeof_char_p"; then ++ AC_CHECK_TYPE(ptrdiff_t, [long long]) ++else ++ AC_CHECK_TYPE(ptrdiff_t, int) ++fi ++]) ++ ++dnl ++dnl A signed 64-bit quantity ++dnl ++AC_DEFUN([BASH_TYPE_BITS64_T], ++[ ++if test "$ac_cv_sizeof_char_p" = 8; then ++ AC_CHECK_TYPE(bits64_t, char *) ++elif test "$ac_cv_sizeof_double" = 8; then ++ AC_CHECK_TYPE(bits64_t, double) ++elif test -n "$ac_cv_type_long_long" && test "$ac_cv_sizeof_long_long" = 8; then ++ AC_CHECK_TYPE(bits64_t, [long long]) ++elif test "$ac_cv_sizeof_long" = 8; then ++ AC_CHECK_TYPE(bits64_t, long) ++else ++ AC_CHECK_TYPE(bits64_t, double) ++fi ++]) ++ ++AC_DEFUN([BASH_TYPE_LONG_LONG], ++[ ++AC_CACHE_CHECK([for long long], bash_cv_type_long_long, ++[AC_TRY_LINK([ ++long long ll = 1; int i = 63;], ++[ ++long long llm = (long long) -1; ++return ll << i | ll >> i | llm / ll | llm % ll; ++], bash_cv_type_long_long='long long', bash_cv_type_long_long='long')]) ++if test "$bash_cv_type_long_long" = 'long long'; then ++ AC_DEFINE(HAVE_LONG_LONG, 1) ++fi ++]) ++ ++AC_DEFUN([BASH_TYPE_UNSIGNED_LONG_LONG], ++[ ++AC_CACHE_CHECK([for unsigned long long], bash_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; ++], bash_cv_type_unsigned_long_long='unsigned long long', ++ bash_cv_type_unsigned_long_long='unsigned long')]) ++if test "$bash_cv_type_unsigned_long_long" = 'unsigned long long'; then ++ AC_DEFINE(HAVE_UNSIGNED_LONG_LONG, 1) ++fi ++]) ++ ++dnl ++dnl Type of struct rlimit fields: some systems (OSF/1, NetBSD, RISC/os 5.0) ++dnl have a rlim_t, others (4.4BSD based systems) use quad_t, others use ++dnl long and still others use int (HP-UX 9.01, SunOS 4.1.3). To simplify ++dnl matters, this just checks for rlim_t, quad_t, or long. ++dnl ++AC_DEFUN([BASH_TYPE_RLIMIT], ++[AC_MSG_CHECKING(for size and type of struct rlimit fields) ++AC_CACHE_VAL(bash_cv_type_rlimit, ++[AC_TRY_COMPILE([#include <sys/types.h> ++#include <sys/resource.h>], ++[rlim_t xxx;], bash_cv_type_rlimit=rlim_t,[ ++AC_TRY_RUN([ ++#include <sys/types.h> ++#include <sys/time.h> ++#include <sys/resource.h> ++main() ++{ ++#ifdef HAVE_QUAD_T ++ struct rlimit rl; ++ if (sizeof(rl.rlim_cur) == sizeof(quad_t)) ++ exit(0); ++#endif ++ exit(1); ++}], bash_cv_type_rlimit=quad_t, bash_cv_type_rlimit=long, ++ [AC_MSG_WARN(cannot check quad_t if cross compiling -- defaulting to long) ++ bash_cv_type_rlimit=long])]) ++]) ++AC_MSG_RESULT($bash_cv_type_rlimit) ++if test $bash_cv_type_rlimit = quad_t; then ++AC_DEFINE(RLIMTYPE, quad_t) ++elif test $bash_cv_type_rlimit = rlim_t; then ++AC_DEFINE(RLIMTYPE, rlim_t) ++fi ++]) ++ ++AC_DEFUN([BASH_FUNC_LSTAT], ++[dnl Cannot use AC_CHECK_FUNCS(lstat) because Linux defines lstat() as an ++dnl inline function in <sys/stat.h>. ++AC_CACHE_CHECK([for lstat], bash_cv_func_lstat, ++[AC_TRY_LINK([ ++#include <sys/types.h> ++#include <sys/stat.h> ++],[ lstat(".",(struct stat *)0); ], ++bash_cv_func_lstat=yes, bash_cv_func_lstat=no)]) ++if test $bash_cv_func_lstat = yes; then ++ AC_DEFINE(HAVE_LSTAT) ++fi ++]) ++ ++AC_DEFUN([BASH_FUNC_INET_ATON], ++[ ++AC_CACHE_CHECK([for inet_aton], bash_cv_func_inet_aton, ++[AC_TRY_LINK([ ++#include <sys/types.h> ++#include <netinet/in.h> ++#include <arpa/inet.h> ++struct in_addr ap;], [ inet_aton("127.0.0.1", &ap); ], ++bash_cv_func_inet_aton=yes, bash_cv_func_inet_aton=no)]) ++if test $bash_cv_func_inet_aton = yes; then ++ AC_DEFINE(HAVE_INET_ATON) ++else ++ AC_LIBOBJ(inet_aton) ++fi ++]) ++ ++AC_DEFUN([BASH_FUNC_GETENV], ++[AC_MSG_CHECKING(to see if getenv can be redefined) ++AC_CACHE_VAL(bash_cv_getenv_redef, ++[AC_TRY_RUN([ ++#ifdef HAVE_UNISTD_H ++# include <unistd.h> ++#endif ++#ifndef __STDC__ ++# ifndef const ++# define const ++# endif ++#endif ++char * ++getenv (name) ++#if defined (__linux__) || defined (__bsdi__) || defined (convex) ++ const char *name; ++#else ++ char const *name; ++#endif /* !__linux__ && !__bsdi__ && !convex */ ++{ ++return "42"; ++} ++main() ++{ ++char *s; ++/* The next allows this program to run, but does not allow bash to link ++ when it redefines getenv. I'm not really interested in figuring out ++ why not. */ ++#if defined (NeXT) ++exit(1); ++#endif ++s = getenv("ABCDE"); ++exit(s == 0); /* force optimizer to leave getenv in */ ++} ++], bash_cv_getenv_redef=yes, bash_cv_getenv_redef=no, ++ [AC_MSG_WARN(cannot check getenv redefinition if cross compiling -- defaulting to yes) ++ bash_cv_getenv_redef=yes] ++)]) ++AC_MSG_RESULT($bash_cv_getenv_redef) ++if test $bash_cv_getenv_redef = yes; then ++AC_DEFINE(CAN_REDEFINE_GETENV) ++fi ++]) ++ ++# We should check for putenv before calling this ++AC_DEFUN([BASH_FUNC_STD_PUTENV], ++[ ++AC_REQUIRE([AC_HEADER_STDC]) ++AC_REQUIRE([AC_C_PROTOTYPES]) ++AC_CACHE_CHECK([for standard-conformant putenv declaration], bash_cv_std_putenv, ++[AC_TRY_LINK([ ++#if STDC_HEADERS ++#include <stdlib.h> ++#include <stddef.h> ++#endif ++#ifndef __STDC__ ++# ifndef const ++# define const ++# endif ++#endif ++#ifdef PROTOTYPES ++extern int putenv (char *); ++#else ++extern int putenv (); ++#endif ++], ++[return (putenv == 0);], ++bash_cv_std_putenv=yes, bash_cv_std_putenv=no ++)]) ++if test $bash_cv_std_putenv = yes; then ++AC_DEFINE(HAVE_STD_PUTENV) ++fi ++]) ++ ++# We should check for unsetenv before calling this ++AC_DEFUN([BASH_FUNC_STD_UNSETENV], ++[ ++AC_REQUIRE([AC_HEADER_STDC]) ++AC_REQUIRE([AC_C_PROTOTYPES]) ++AC_CACHE_CHECK([for standard-conformant unsetenv declaration], bash_cv_std_unsetenv, ++[AC_TRY_LINK([ ++#if STDC_HEADERS ++#include <stdlib.h> ++#include <stddef.h> ++#endif ++#ifndef __STDC__ ++# ifndef const ++# define const ++# endif ++#endif ++#ifdef PROTOTYPES ++extern int unsetenv (const char *); ++#else ++extern int unsetenv (); ++#endif ++], ++[return (unsetenv == 0);], ++bash_cv_std_unsetenv=yes, bash_cv_std_unsetenv=no ++)]) ++if test $bash_cv_std_unsetenv = yes; then ++AC_DEFINE(HAVE_STD_UNSETENV) ++fi ++]) ++ ++AC_DEFUN([BASH_FUNC_ULIMIT_MAXFDS], ++[AC_MSG_CHECKING(whether ulimit can substitute for getdtablesize) ++AC_CACHE_VAL(bash_cv_ulimit_maxfds, ++[AC_TRY_RUN([ ++main() ++{ ++long maxfds = ulimit(4, 0L); ++exit (maxfds == -1L); ++} ++], bash_cv_ulimit_maxfds=yes, bash_cv_ulimit_maxfds=no, ++ [AC_MSG_WARN(cannot check ulimit if cross compiling -- defaulting to no) ++ bash_cv_ulimit_maxfds=no] ++)]) ++AC_MSG_RESULT($bash_cv_ulimit_maxfds) ++if test $bash_cv_ulimit_maxfds = yes; then ++AC_DEFINE(ULIMIT_MAXFDS) ++fi ++]) ++ ++AC_DEFUN([BASH_FUNC_GETCWD], ++[AC_MSG_CHECKING([if getcwd() calls popen()]) ++AC_CACHE_VAL(bash_cv_getcwd_calls_popen, ++[AC_TRY_RUN([ ++#include <stdio.h> ++#ifdef HAVE_UNISTD_H ++#include <unistd.h> ++#endif ++ ++#ifndef __STDC__ ++#ifndef const ++#define const ++#endif ++#endif ++ ++int popen_called; ++ ++FILE * ++popen(command, type) ++ const char *command; ++ const char *type; ++{ ++ popen_called = 1; ++ return (FILE *)NULL; ++} ++ ++FILE *_popen(command, type) ++ const char *command; ++ const char *type; ++{ ++ return (popen (command, type)); ++} ++ ++int ++pclose(stream) ++FILE *stream; ++{ ++ return 0; ++} ++ ++int ++_pclose(stream) ++FILE *stream; ++{ ++ return 0; ++} ++ ++main() ++{ ++ char lbuf[32]; ++ popen_called = 0; ++ getcwd(lbuf, 32); ++ exit (popen_called); ++} ++], bash_cv_getcwd_calls_popen=no, bash_cv_getcwd_calls_popen=yes, ++ [AC_MSG_WARN(cannot check whether getcwd calls popen if cross compiling -- defaulting to no) ++ bash_cv_getcwd_calls_popen=no] ++)]) ++AC_MSG_RESULT($bash_cv_getcwd_calls_popen) ++if test $bash_cv_getcwd_calls_popen = yes; then ++AC_DEFINE(GETCWD_BROKEN) ++AC_LIBOBJ(getcwd) ++fi ++]) ++ ++dnl ++dnl This needs BASH_CHECK_SOCKLIB, but since that's not called on every ++dnl system, we can't use AC_PREREQ ++dnl ++AC_DEFUN([BASH_FUNC_GETHOSTBYNAME], ++[if test "X$bash_cv_have_gethostbyname" = "X"; then ++_bash_needmsg=yes ++else ++AC_MSG_CHECKING(for gethostbyname in socket library) ++_bash_needmsg= ++fi ++AC_CACHE_VAL(bash_cv_have_gethostbyname, ++[AC_TRY_LINK([#include <netdb.h>], ++[ struct hostent *hp; ++ hp = gethostbyname("localhost"); ++], bash_cv_have_gethostbyname=yes, bash_cv_have_gethostbyname=no)] ++) ++if test "X$_bash_needmsg" = Xyes; then ++ AC_MSG_CHECKING(for gethostbyname in socket library) ++fi ++AC_MSG_RESULT($bash_cv_have_gethostbyname) ++if test "$bash_cv_have_gethostbyname" = yes; then ++AC_DEFINE(HAVE_GETHOSTBYNAME) ++fi ++]) ++ ++AC_DEFUN([BASH_FUNC_FNMATCH_EXTMATCH], ++[AC_MSG_CHECKING(if fnmatch does extended pattern matching with FNM_EXTMATCH) ++AC_CACHE_VAL(bash_cv_fnm_extmatch, ++[AC_TRY_RUN([ ++#include <fnmatch.h> ++ ++main() ++{ ++#ifdef FNM_EXTMATCH ++ exit (0); ++#else ++ exit (1); ++#endif ++} ++], bash_cv_fnm_extmatch=yes, bash_cv_fnm_extmatch=no, ++ [AC_MSG_WARN(cannot check FNM_EXTMATCH if cross compiling -- defaulting to no) ++ bash_cv_fnm_extmatch=no]) ++]) ++AC_MSG_RESULT($bash_cv_fnm_extmatch) ++if test $bash_cv_fnm_extmatch = yes; then ++AC_DEFINE(HAVE_LIBC_FNM_EXTMATCH) ++fi ++]) ++ ++AH_TEMPLATE([HAVE_POSIX_SIGSETJMP], [Define if we POSIX-style sigsetjmp/siglongjmp are available]) ++AC_DEFUN([BASH_FUNC_POSIX_SETJMP], ++[AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE]) ++AC_MSG_CHECKING(for presence of POSIX-style sigsetjmp/siglongjmp) ++AC_CACHE_VAL(bash_cv_func_sigsetjmp, ++[AC_TRY_RUN([ ++#ifdef HAVE_UNISTD_H ++#include <unistd.h> ++#endif ++#include <sys/types.h> ++#include <signal.h> ++#include <setjmp.h> ++ ++main() ++{ ++#if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS) ++exit (1); ++#else ++ ++int code; ++sigset_t set, oset; ++sigjmp_buf xx; ++ ++/* get the mask */ ++sigemptyset(&set); ++sigemptyset(&oset); ++sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &set); ++sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset); ++ ++/* save it */ ++code = sigsetjmp(xx, 1); ++if (code) ++ exit(0); /* could get sigmask and compare to oset here. */ ++ ++/* change it */ ++sigaddset(&set, SIGINT); ++sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL); ++ ++/* and siglongjmp */ ++siglongjmp(xx, 10); ++exit(1); ++#endif ++}], bash_cv_func_sigsetjmp=present, bash_cv_func_sigsetjmp=missing, ++ [AC_MSG_WARN(cannot check for sigsetjmp/siglongjmp if cross-compiling -- defaulting to missing) ++ bash_cv_func_sigsetjmp=missing] ++)]) ++AC_MSG_RESULT($bash_cv_func_sigsetjmp) ++if test $bash_cv_func_sigsetjmp = present; then ++AC_DEFINE(HAVE_POSIX_SIGSETJMP) ++fi ++]) ++ ++AH_TEMPLATE([STRCOLL_BROKEN], [Define if strcoll is broken with respect to strcmp in the default locale.]) ++AC_DEFUN([BASH_FUNC_STRCOLL], ++[ ++AC_MSG_CHECKING(whether or not strcoll and strcmp differ) ++AC_CACHE_VAL(bash_cv_func_strcoll_broken, ++[AC_TRY_RUN([ ++#include <stdio.h> ++#if defined (HAVE_LOCALE_H) ++#include <locale.h> ++#endif ++ ++main(c, v) ++int c; ++char *v[]; ++{ ++ int r1, r2; ++ char *deflocale, *defcoll; ++ ++#ifdef HAVE_SETLOCALE ++ deflocale = setlocale(LC_ALL, ""); ++ defcoll = setlocale(LC_COLLATE, ""); ++#endif ++ ++#ifdef HAVE_STRCOLL ++ /* These two values are taken from tests/glob-test. */ ++ r1 = strcoll("abd", "aXd"); ++#else ++ r1 = 0; ++#endif ++ r2 = strcmp("abd", "aXd"); ++ ++ /* These two should both be greater than 0. It is permissible for ++ a system to return different values, as long as the sign is the ++ same. */ ++ ++ /* Exit with 1 (failure) if these two values are both > 0, since ++ this tests whether strcoll(3) is broken with respect to strcmp(3) ++ in the default locale. */ ++ exit (r1 > 0 && r2 > 0); ++} ++], bash_cv_func_strcoll_broken=yes, bash_cv_func_strcoll_broken=no, ++ [AC_MSG_WARN(cannot check strcoll if cross compiling -- defaulting to no) ++ bash_cv_func_strcoll_broken=no] ++)]) ++AC_MSG_RESULT($bash_cv_func_strcoll_broken) ++if test $bash_cv_func_strcoll_broken = yes; then ++AC_DEFINE(STRCOLL_BROKEN) ++fi ++]) ++ ++AC_DEFUN([BASH_FUNC_PRINTF_A_FORMAT], ++[AC_MSG_CHECKING([for printf floating point output in hex notation]) ++AC_CACHE_VAL(bash_cv_printf_a_format, ++[AC_TRY_RUN([ ++#include <stdio.h> ++#include <string.h> ++ ++int ++main() ++{ ++ double y = 0.0; ++ char abuf[1024]; ++ ++ sprintf(abuf, "%A", y); ++ exit(strchr(abuf, 'P') == (char *)0); ++} ++], bash_cv_printf_a_format=yes, bash_cv_printf_a_format=no, ++ [AC_MSG_WARN(cannot check printf if cross compiling -- defaulting to no) ++ bash_cv_printf_a_format=no] ++)]) ++AC_MSG_RESULT($bash_cv_printf_a_format) ++if test $bash_cv_printf_a_format = yes; then ++AC_DEFINE(HAVE_PRINTF_A_FORMAT) ++fi ++]) ++ ++AC_DEFUN([BASH_STRUCT_TERMIOS_LDISC], ++[ ++AC_CHECK_MEMBER(struct termios.c_line, AC_DEFINE(TERMIOS_LDISC), ,[ ++#include <sys/types.h> ++#include <termios.h> ++]) ++]) ++ ++AC_DEFUN([BASH_STRUCT_TERMIO_LDISC], ++[ ++AC_CHECK_MEMBER(struct termio.c_line, AC_DEFINE(TERMIO_LDISC), ,[ ++#include <sys/types.h> ++#include <termio.h> ++]) ++]) ++ ++dnl ++dnl Like AC_STRUCT_ST_BLOCKS, but doesn't muck with LIBOBJS ++dnl ++dnl sets bash_cv_struct_stat_st_blocks ++dnl ++dnl unused for now; we'll see how AC_CHECK_MEMBERS works ++dnl ++AC_DEFUN([BASH_STRUCT_ST_BLOCKS], ++[ ++AC_MSG_CHECKING([for struct stat.st_blocks]) ++AC_CACHE_VAL(bash_cv_struct_stat_st_blocks, ++[AC_TRY_COMPILE( ++[ ++#include <sys/types.h> ++#include <sys/stat.h> ++], ++[ ++main() ++{ ++static struct stat a; ++if (a.st_blocks) return 0; ++return 0; ++} ++], bash_cv_struct_stat_st_blocks=yes, bash_cv_struct_stat_st_blocks=no) ++]) ++AC_MSG_RESULT($bash_cv_struct_stat_st_blocks) ++if test "$bash_cv_struct_stat_st_blocks" = "yes"; then ++AC_DEFINE(HAVE_STRUCT_STAT_ST_BLOCKS) ++fi ++]) ++ ++AC_DEFUN([BASH_CHECK_LIB_TERMCAP], ++[ ++if test "X$bash_cv_termcap_lib" = "X"; then ++_bash_needmsg=yes ++else ++AC_MSG_CHECKING(which library has the termcap functions) ++_bash_needmsg= ++fi ++AC_CACHE_VAL(bash_cv_termcap_lib, ++[AC_CHECK_LIB(termcap, tgetent, bash_cv_termcap_lib=libtermcap, ++ [AC_CHECK_LIB(tinfo, tgetent, bash_cv_termcap_lib=libtinfo, ++ [AC_CHECK_LIB(curses, tgetent, bash_cv_termcap_lib=libcurses, ++ [AC_CHECK_LIB(ncurses, tgetent, bash_cv_termcap_lib=libncurses, ++ bash_cv_termcap_lib=gnutermcap)])])])]) ++if test "X$_bash_needmsg" = "Xyes"; then ++AC_MSG_CHECKING(which library has the termcap functions) ++fi ++AC_MSG_RESULT(using $bash_cv_termcap_lib) ++if test $bash_cv_termcap_lib = gnutermcap && test -z "$prefer_curses"; then ++LDFLAGS="$LDFLAGS -L./lib/termcap" ++TERMCAP_LIB="./lib/termcap/libtermcap.a" ++TERMCAP_DEP="./lib/termcap/libtermcap.a" ++elif test $bash_cv_termcap_lib = libtermcap && test -z "$prefer_curses"; then ++TERMCAP_LIB=-ltermcap ++TERMCAP_DEP= ++elif test $bash_cv_termcap_lib = libtinfo; then ++TERMCAP_LIB=-ltinfo ++TERMCAP_DEP= ++elif test $bash_cv_termcap_lib = libncurses; then ++TERMCAP_LIB=-lncurses ++TERMCAP_DEP= ++else ++TERMCAP_LIB=-lcurses ++TERMCAP_DEP= ++fi ++]) ++ ++dnl ++dnl Check for the presence of getpeername in libsocket. ++dnl If libsocket is present, check for libnsl and add it to LIBS if ++dnl it's there, since most systems with libsocket require linking ++dnl with libnsl as well. This should only be called if getpeername ++dnl was not found in libc. ++dnl ++dnl NOTE: IF WE FIND GETPEERNAME, WE ASSUME THAT WE HAVE BIND/CONNECT ++dnl AS WELL ++dnl ++AC_DEFUN([BASH_CHECK_LIB_SOCKET], ++[ ++if test "X$bash_cv_have_socklib" = "X"; then ++_bash_needmsg= ++else ++AC_MSG_CHECKING(for socket library) ++_bash_needmsg=yes ++fi ++AC_CACHE_VAL(bash_cv_have_socklib, ++[AC_CHECK_LIB(socket, getpeername, ++ bash_cv_have_socklib=yes, bash_cv_have_socklib=no, -lnsl)]) ++if test "X$_bash_needmsg" = Xyes; then ++ AC_MSG_RESULT($bash_cv_have_socklib) ++ _bash_needmsg= ++fi ++if test $bash_cv_have_socklib = yes; then ++ # check for libnsl, add it to LIBS if present ++ if test "X$bash_cv_have_libnsl" = "X"; then ++ _bash_needmsg= ++ else ++ AC_MSG_CHECKING(for libnsl) ++ _bash_needmsg=yes ++ fi ++ AC_CACHE_VAL(bash_cv_have_libnsl, ++ [AC_CHECK_LIB(nsl, t_open, ++ bash_cv_have_libnsl=yes, bash_cv_have_libnsl=no)]) ++ if test "X$_bash_needmsg" = Xyes; then ++ AC_MSG_RESULT($bash_cv_have_libnsl) ++ _bash_needmsg= ++ fi ++ if test $bash_cv_have_libnsl = yes; then ++ LIBS="-lsocket -lnsl $LIBS" ++ else ++ LIBS="-lsocket $LIBS" ++ fi ++ AC_DEFINE(HAVE_LIBSOCKET) ++ AC_DEFINE(HAVE_GETPEERNAME) ++fi ++]) ++ ++AH_TEMPLATE([STRUCT_DIRENT_HAS_D_INO], [Define if struct dirent has a d_ino member]) ++AC_DEFUN([BASH_STRUCT_DIRENT_D_INO], ++[AC_REQUIRE([AC_HEADER_DIRENT]) ++AC_MSG_CHECKING(if struct dirent has a d_ino member) ++AC_CACHE_VAL(bash_cv_dirent_has_dino, ++[AC_TRY_COMPILE([ ++#include <stdio.h> ++#include <sys/types.h> ++#ifdef HAVE_UNISTD_H ++# include <unistd.h> ++#endif /* HAVE_UNISTD_H */ ++#if defined(HAVE_DIRENT_H) ++# include <dirent.h> ++#else ++# define dirent direct ++# ifdef HAVE_SYS_NDIR_H ++# include <sys/ndir.h> ++# endif /* SYSNDIR */ ++# ifdef HAVE_SYS_DIR_H ++# include <sys/dir.h> ++# endif /* SYSDIR */ ++# ifdef HAVE_NDIR_H ++# include <ndir.h> ++# endif ++#endif /* HAVE_DIRENT_H */ ++],[ ++struct dirent d; int z; z = d.d_ino; ++], bash_cv_dirent_has_dino=yes, bash_cv_dirent_has_dino=no)]) ++AC_MSG_RESULT($bash_cv_dirent_has_dino) ++if test $bash_cv_dirent_has_dino = yes; then ++AC_DEFINE(STRUCT_DIRENT_HAS_D_INO) ++fi ++]) ++ ++AH_TEMPLATE([STRUCT_DIRENT_HAS_D_FILENO], [Define if struct dirent has a d_fileno member]) ++AC_DEFUN([BASH_STRUCT_DIRENT_D_FILENO], ++[AC_REQUIRE([AC_HEADER_DIRENT]) ++AC_MSG_CHECKING(if struct dirent has a d_fileno member) ++AC_CACHE_VAL(bash_cv_dirent_has_d_fileno, ++[AC_TRY_COMPILE([ ++#include <stdio.h> ++#include <sys/types.h> ++#ifdef HAVE_UNISTD_H ++# include <unistd.h> ++#endif /* HAVE_UNISTD_H */ ++#if defined(HAVE_DIRENT_H) ++# include <dirent.h> ++#else ++# define dirent direct ++# ifdef HAVE_SYS_NDIR_H ++# include <sys/ndir.h> ++# endif /* SYSNDIR */ ++# ifdef HAVE_SYS_DIR_H ++# include <sys/dir.h> ++# endif /* SYSDIR */ ++# ifdef HAVE_NDIR_H ++# include <ndir.h> ++# endif ++#endif /* HAVE_DIRENT_H */ ++],[ ++struct dirent d; int z; z = d.d_fileno; ++], bash_cv_dirent_has_d_fileno=yes, bash_cv_dirent_has_d_fileno=no)]) ++AC_MSG_RESULT($bash_cv_dirent_has_d_fileno) ++if test $bash_cv_dirent_has_d_fileno = yes; then ++AC_DEFINE(STRUCT_DIRENT_HAS_D_FILENO) ++fi ++]) ++ ++AC_DEFUN([BASH_STRUCT_TIMEVAL], ++[AC_MSG_CHECKING(for struct timeval in sys/time.h and time.h) ++AC_CACHE_VAL(bash_cv_struct_timeval, ++[ ++AC_EGREP_HEADER(struct timeval, sys/time.h, ++ bash_cv_struct_timeval=yes, ++ AC_EGREP_HEADER(struct timeval, time.h, ++ bash_cv_struct_timeval=yes, ++ bash_cv_struct_timeval=no)) ++]) ++AC_MSG_RESULT($bash_cv_struct_timeval) ++if test $bash_cv_struct_timeval = yes; then ++ AC_DEFINE(HAVE_TIMEVAL) ++fi ++]) ++ ++AH_TEMPLATE([STRUCT_WINSIZE_IN_SYS_IOCTL], [Define if struct winsize is in sys/ioctl.h]) ++AH_TEMPLATE([STRUCT_WINSIZE_IN_TERMIOS], [Define if struct winsize is in termios.h]) ++AC_DEFUN([BASH_STRUCT_WINSIZE], ++[AC_MSG_CHECKING(for struct winsize in sys/ioctl.h and termios.h) ++AC_CACHE_VAL(bash_cv_struct_winsize_header, ++[AC_TRY_COMPILE([#include <sys/types.h> ++#include <sys/ioctl.h>], [struct winsize x;], ++ bash_cv_struct_winsize_header=ioctl_h, ++ [AC_TRY_COMPILE([#include <sys/types.h> ++#include <termios.h>], [struct winsize x;], ++ bash_cv_struct_winsize_header=termios_h, bash_cv_struct_winsize_header=other) ++])]) ++if test $bash_cv_struct_winsize_header = ioctl_h; then ++ AC_MSG_RESULT(sys/ioctl.h) ++ AC_DEFINE(STRUCT_WINSIZE_IN_SYS_IOCTL) ++elif test $bash_cv_struct_winsize_header = termios_h; then ++ AC_MSG_RESULT(termios.h) ++ AC_DEFINE(STRUCT_WINSIZE_IN_TERMIOS) ++else ++ AC_MSG_RESULT(not found) ++fi ++]) ++ ++dnl Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7) ++AH_TEMPLATE([HAVE_POSIX_SIGNALS], [Define if we have the POSIX signal routines]) ++AH_TEMPLATE([HAVE_BSD_SIGNALS], [Define if we have the BSD signal routines]) ++AH_TEMPLATE([HAVE_USG_SIGHOLD], [Define if we have the USG signal routines]) ++AC_DEFUN([BASH_SYS_SIGNAL_VINTAGE], ++[AC_REQUIRE([AC_TYPE_SIGNAL]) ++AC_MSG_CHECKING(for type of signal functions) ++AC_CACHE_VAL(bash_cv_signal_vintage, ++[ ++ AC_MSG_WARN([checking for posix...]) ++ AC_TRY_LINK([#include <signal.h>],[ ++ sigset_t ss; ++ struct sigaction sa; ++ sigemptyset(&ss); sigsuspend(&ss); ++ sigaction(SIGINT, &sa, (struct sigaction *) 0); ++ sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0); ++ ], bash_cv_signal_vintage="posix", ++ [ ++ AC_MSG_WARN([checking for 4.2bsd...]) ++ AC_TRY_LINK([#include <signal.h>], [ ++ int mask = sigmask(SIGINT); ++ sigsetmask(mask); sigblock(mask); sigpause(mask); ++ ], bash_cv_signal_vintage="4.2bsd", ++ [ ++ AC_MSG_WARN([checking for svr3...]) ++ AC_TRY_LINK([ ++ #include <signal.h> ++ RETSIGTYPE foo() { }], [ ++ int mask = sigmask(SIGINT); ++ sigset(SIGINT, foo); sigrelse(SIGINT); ++ sighold(SIGINT); sigpause(SIGINT); ++ ], bash_cv_signal_vintage="svr3", bash_cv_signal_vintage="v7" ++ )] ++ )] ++) ++]) ++AC_MSG_RESULT($bash_cv_signal_vintage) ++if test "$bash_cv_signal_vintage" = "posix"; then ++AC_DEFINE(HAVE_POSIX_SIGNALS) ++elif test "$bash_cv_signal_vintage" = "4.2bsd"; then ++AC_DEFINE(HAVE_BSD_SIGNALS) ++elif test "$bash_cv_signal_vintage" = "svr3"; then ++AC_DEFINE(HAVE_USG_SIGHOLD) ++fi ++]) ++ ++dnl Check if the pgrp of setpgrp() can't be the pid of a zombie process. ++AC_DEFUN([BASH_SYS_PGRP_SYNC], ++[AC_REQUIRE([AC_FUNC_GETPGRP]) ++AC_MSG_CHECKING(whether pgrps need synchronization) ++AC_CACHE_VAL(bash_cv_pgrp_pipe, ++[AC_TRY_RUN([ ++#ifdef HAVE_UNISTD_H ++# include <unistd.h> ++#endif ++main() ++{ ++# ifdef GETPGRP_VOID ++# define getpgID() getpgrp() ++# else ++# define getpgID() getpgrp(0) ++# define setpgid(x,y) setpgrp(x,y) ++# endif ++ int pid1, pid2, fds[2]; ++ int status; ++ char ok; ++ ++ switch (pid1 = fork()) { ++ case -1: ++ exit(1); ++ case 0: ++ setpgid(0, getpid()); ++ exit(0); ++ } ++ setpgid(pid1, pid1); ++ ++ sleep(2); /* let first child die */ ++ ++ if (pipe(fds) < 0) ++ exit(2); ++ ++ switch (pid2 = fork()) { ++ case -1: ++ exit(3); ++ case 0: ++ setpgid(0, pid1); ++ ok = getpgID() == pid1; ++ write(fds[1], &ok, 1); ++ exit(0); ++ } ++ setpgid(pid2, pid1); ++ ++ close(fds[1]); ++ if (read(fds[0], &ok, 1) != 1) ++ exit(4); ++ wait(&status); ++ wait(&status); ++ exit(ok ? 0 : 5); ++} ++], bash_cv_pgrp_pipe=no,bash_cv_pgrp_pipe=yes, ++ [AC_MSG_WARN(cannot check pgrp synchronization if cross compiling -- defaulting to no) ++ bash_cv_pgrp_pipe=no]) ++]) ++AC_MSG_RESULT($bash_cv_pgrp_pipe) ++if test $bash_cv_pgrp_pipe = yes; then ++AC_DEFINE(PGRP_PIPE) ++fi ++]) ++ ++AH_TEMPLATE([MUST_REINSTALL_SIGHANDLERS], [Define if signal handlers must be reinstalled when invoked.]) ++AC_DEFUN([BASH_SYS_REINSTALL_SIGHANDLERS], ++[AC_REQUIRE([AC_TYPE_SIGNAL]) ++AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE]) ++AC_MSG_CHECKING([if signal handlers must be reinstalled when invoked]) ++AC_CACHE_VAL(bash_cv_must_reinstall_sighandlers, ++[AC_TRY_RUN([ ++#include <signal.h> ++#ifdef HAVE_UNISTD_H ++#include <unistd.h> ++#endif ++ ++typedef RETSIGTYPE sigfunc(); ++ ++int nsigint; ++ ++#ifdef HAVE_POSIX_SIGNALS ++sigfunc * ++set_signal_handler(sig, handler) ++ int sig; ++ sigfunc *handler; ++{ ++ struct sigaction act, oact; ++ act.sa_handler = handler; ++ act.sa_flags = 0; ++ sigemptyset (&act.sa_mask); ++ sigemptyset (&oact.sa_mask); ++ sigaction (sig, &act, &oact); ++ return (oact.sa_handler); ++} ++#else ++#define set_signal_handler(s, h) signal(s, h) ++#endif ++ ++RETSIGTYPE ++sigint(s) ++int s; ++{ ++ nsigint++; ++} ++ ++main() ++{ ++ nsigint = 0; ++ set_signal_handler(SIGINT, sigint); ++ kill((int)getpid(), SIGINT); ++ kill((int)getpid(), SIGINT); ++ exit(nsigint != 2); ++} ++], bash_cv_must_reinstall_sighandlers=no, bash_cv_must_reinstall_sighandlers=yes, ++ [AC_MSG_WARN(cannot check signal handling if cross compiling -- defaulting to no) ++ bash_cv_must_reinstall_sighandlers=no] ++)]) ++AC_MSG_RESULT($bash_cv_must_reinstall_sighandlers) ++if test $bash_cv_must_reinstall_sighandlers = yes; then ++AC_DEFINE(MUST_REINSTALL_SIGHANDLERS) ++fi ++]) ++ ++dnl check that some necessary job control definitions are present ++AC_DEFUN([BASH_SYS_JOB_CONTROL_MISSING], ++[AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE]) ++AC_MSG_CHECKING(for presence of necessary job control definitions) ++AC_CACHE_VAL(bash_cv_job_control_missing, ++[AC_TRY_RUN([ ++#include <sys/types.h> ++#ifdef HAVE_SYS_WAIT_H ++#include <sys/wait.h> ++#endif ++#ifdef HAVE_UNISTD_H ++#include <unistd.h> ++#endif ++#include <signal.h> ++ ++/* Add more tests in here as appropriate. */ ++main() ++{ ++/* signal type */ ++#if !defined (HAVE_POSIX_SIGNALS) && !defined (HAVE_BSD_SIGNALS) ++exit(1); ++#endif ++ ++/* signals and tty control. */ ++#if !defined (SIGTSTP) || !defined (SIGSTOP) || !defined (SIGCONT) ++exit (1); ++#endif ++ ++/* process control */ ++#if !defined (WNOHANG) || !defined (WUNTRACED) ++exit(1); ++#endif ++ ++/* Posix systems have tcgetpgrp and waitpid. */ ++#if defined (_POSIX_VERSION) && !defined (HAVE_TCGETPGRP) ++exit(1); ++#endif ++ ++#if defined (_POSIX_VERSION) && !defined (HAVE_WAITPID) ++exit(1); ++#endif ++ ++/* Other systems have TIOCSPGRP/TIOCGPRGP and wait3. */ ++#if !defined (_POSIX_VERSION) && !defined (HAVE_WAIT3) ++exit(1); ++#endif ++ ++exit(0); ++}], bash_cv_job_control_missing=present, bash_cv_job_control_missing=missing, ++ [AC_MSG_WARN(cannot check job control if cross-compiling -- defaulting to missing) ++ bash_cv_job_control_missing=missing] ++)]) ++AC_MSG_RESULT($bash_cv_job_control_missing) ++if test $bash_cv_job_control_missing = missing; then ++AC_DEFINE(JOB_CONTROL_MISSING) ++fi ++]) ++ ++dnl check whether named pipes are present ++dnl this requires a previous check for mkfifo, but that is awkward to specify ++AC_DEFUN([BASH_SYS_NAMED_PIPES], ++[AC_MSG_CHECKING(for presence of named pipes) ++AC_CACHE_VAL(bash_cv_sys_named_pipes, ++[AC_TRY_RUN([ ++#include <sys/types.h> ++#include <sys/stat.h> ++#ifdef HAVE_UNISTD_H ++#include <unistd.h> ++#endif ++ ++/* Add more tests in here as appropriate. */ ++main() ++{ ++int fd, err; ++ ++#if defined (HAVE_MKFIFO) ++exit (0); ++#endif ++ ++#if !defined (S_IFIFO) && (defined (_POSIX_VERSION) && !defined (S_ISFIFO)) ++exit (1); ++#endif ++ ++#if defined (NeXT) ++exit (1); ++#endif ++err = mkdir("/tmp/bash-aclocal", 0700); ++if (err < 0) { ++ perror ("mkdir"); ++ exit(1); ++} ++fd = mknod ("/tmp/bash-aclocal/sh-np-autoconf", 0666 | S_IFIFO, 0); ++if (fd == -1) { ++ rmdir ("/tmp/bash-aclocal"); ++ exit (1); ++} ++close(fd); ++unlink ("/tmp/bash-aclocal/sh-np-autoconf"); ++rmdir ("/tmp/bash-aclocal"); ++exit(0); ++}], bash_cv_sys_named_pipes=present, bash_cv_sys_named_pipes=missing, ++ [AC_MSG_WARN(cannot check for named pipes if cross-compiling -- defaulting to missing) ++ bash_cv_sys_named_pipes=missing] ++)]) ++AC_MSG_RESULT($bash_cv_sys_named_pipes) ++if test $bash_cv_sys_named_pipes = missing; then ++AC_DEFINE(NAMED_PIPES_MISSING) ++fi ++]) ++ ++AC_DEFUN([BASH_SYS_DEFAULT_MAIL_DIR], ++[AC_MSG_CHECKING(for default mail directory) ++AC_CACHE_VAL(bash_cv_mail_dir, ++[if test -d /var/mail; then ++ bash_cv_mail_dir=/var/mail ++ elif test -d /var/spool/mail; then ++ bash_cv_mail_dir=/var/spool/mail ++ elif test -d /usr/mail; then ++ bash_cv_mail_dir=/usr/mail ++ elif test -d /usr/spool/mail; then ++ bash_cv_mail_dir=/usr/spool/mail ++ else ++ bash_cv_mail_dir=unknown ++ fi ++]) ++AC_MSG_RESULT($bash_cv_mail_dir) ++AC_DEFINE_UNQUOTED(DEFAULT_MAIL_DIRECTORY, "$bash_cv_mail_dir") ++]) ++ ++AC_DEFUN([BASH_HAVE_TIOCGWINSZ], ++[AC_MSG_CHECKING(for TIOCGWINSZ in sys/ioctl.h) ++AC_CACHE_VAL(bash_cv_tiocgwinsz_in_ioctl, ++[AC_TRY_COMPILE([#include <sys/types.h> ++#include <sys/ioctl.h>], [int x = TIOCGWINSZ;], ++ bash_cv_tiocgwinsz_in_ioctl=yes,bash_cv_tiocgwinsz_in_ioctl=no)]) ++AC_MSG_RESULT($bash_cv_tiocgwinsz_in_ioctl) ++if test $bash_cv_tiocgwinsz_in_ioctl = yes; then ++AC_DEFINE(GWINSZ_IN_SYS_IOCTL) ++fi ++]) ++ ++AH_TEMPLATE([TIOCSTAT_IN_SYS_IOCTL], [Define if TIOCSTAT is in sys/ioctl.h]) ++AC_DEFUN([BASH_HAVE_TIOCSTAT], ++[AC_MSG_CHECKING(for TIOCSTAT in sys/ioctl.h) ++AC_CACHE_VAL(bash_cv_tiocstat_in_ioctl, ++[AC_TRY_COMPILE([#include <sys/types.h> ++#include <sys/ioctl.h>], [int x = TIOCSTAT;], ++ bash_cv_tiocstat_in_ioctl=yes,bash_cv_tiocstat_in_ioctl=no)]) ++AC_MSG_RESULT($bash_cv_tiocstat_in_ioctl) ++if test $bash_cv_tiocstat_in_ioctl = yes; then ++AC_DEFINE(TIOCSTAT_IN_SYS_IOCTL) ++fi ++]) ++ ++AH_TEMPLATE([FIONREAD_IN_SYS_IOCTL], [Define if FIONREAD is in sys/ioctl.h]) ++AC_DEFUN([BASH_HAVE_FIONREAD], ++[AC_MSG_CHECKING(for FIONREAD in sys/ioctl.h) ++AC_CACHE_VAL(bash_cv_fionread_in_ioctl, ++[AC_TRY_COMPILE([#include <sys/types.h> ++#include <sys/ioctl.h>], [int x = FIONREAD;], ++ bash_cv_fionread_in_ioctl=yes,bash_cv_fionread_in_ioctl=no)]) ++AC_MSG_RESULT($bash_cv_fionread_in_ioctl) ++if test $bash_cv_fionread_in_ioctl = yes; then ++AC_DEFINE(FIONREAD_IN_SYS_IOCTL) ++fi ++]) ++ ++dnl ++dnl See if speed_t is declared in <sys/types.h>. Some versions of linux ++dnl require a definition of speed_t each time <termcap.h> is included, ++dnl but you can only get speed_t if you include <termios.h> (on some ++dnl versions) or <sys/types.h> (on others). ++dnl ++AH_TEMPLATE([SPEED_T_IN_SYS_TYPES], [Define if speed_t is in sys/types.h]) ++AC_DEFUN([BASH_CHECK_SPEED_T], ++[AC_MSG_CHECKING(for speed_t in sys/types.h) ++AC_CACHE_VAL(bash_cv_speed_t_in_sys_types, ++[AC_TRY_COMPILE([#include <sys/types.h>], [speed_t x;], ++ bash_cv_speed_t_in_sys_types=yes,bash_cv_speed_t_in_sys_types=no)]) ++AC_MSG_RESULT($bash_cv_speed_t_in_sys_types) ++if test $bash_cv_speed_t_in_sys_types = yes; then ++AC_DEFINE(SPEED_T_IN_SYS_TYPES) ++fi ++]) ++ ++AH_TEMPLATE([HAVE_GETPW_DECLS], [Define if getpw functions are declared in pwd.h]) ++AC_DEFUN([BASH_CHECK_GETPW_FUNCS], ++[AC_MSG_CHECKING(whether getpw functions are declared in pwd.h) ++AC_CACHE_VAL(bash_cv_getpw_declared, ++[AC_EGREP_CPP(getpwuid, ++[ ++#include <sys/types.h> ++#ifdef HAVE_UNISTD_H ++# include <unistd.h> ++#endif ++#include <pwd.h> ++], ++bash_cv_getpw_declared=yes,bash_cv_getpw_declared=no)]) ++AC_MSG_RESULT($bash_cv_getpw_declared) ++if test $bash_cv_getpw_declared = yes; then ++AC_DEFINE(HAVE_GETPW_DECLS) ++fi ++]) ++ ++AC_DEFUN([BASH_CHECK_DEV_FD], ++[AC_MSG_CHECKING(whether /dev/fd is available) ++AC_CACHE_VAL(bash_cv_dev_fd, ++[if test -d /dev/fd && test -r /dev/fd/0; then ++ bash_cv_dev_fd=standard ++ elif test -d /proc/self/fd && test -r /proc/self/fd/0; then ++ bash_cv_dev_fd=whacky ++ else ++ bash_cv_dev_fd=absent ++ fi ++]) ++AC_MSG_RESULT($bash_cv_dev_fd) ++if test $bash_cv_dev_fd = "standard"; then ++ AC_DEFINE(HAVE_DEV_FD) ++ AC_DEFINE(DEV_FD_PREFIX, "/dev/fd/") ++elif test $bash_cv_dev_fd = "whacky"; then ++ AC_DEFINE(HAVE_DEV_FD) ++ AC_DEFINE(DEV_FD_PREFIX, "/proc/self/fd/") ++fi ++]) ++ ++AC_DEFUN([BASH_CHECK_DEV_STDIN], ++[AC_MSG_CHECKING(whether /dev/stdin stdout stderr are available) ++AC_CACHE_VAL(bash_cv_dev_stdin, ++[if test -d /dev/fd && test -r /dev/stdin; then ++ bash_cv_dev_stdin=present ++ elif test -d /proc/self/fd && test -r /dev/stdin; then ++ bash_cv_dev_stdin=present ++ else ++ bash_cv_dev_stdin=absent ++ fi ++]) ++AC_MSG_RESULT($bash_cv_dev_stdin) ++if test $bash_cv_dev_stdin = "present"; then ++ AC_DEFINE(HAVE_DEV_STDIN) ++fi ++]) ++ ++dnl ++dnl Check if HPUX needs _KERNEL defined for RLIMIT_* definitions ++dnl ++AC_DEFUN([BASH_CHECK_KERNEL_RLIMIT], ++[AC_MSG_CHECKING([whether $host_os needs _KERNEL for RLIMIT defines]) ++AC_CACHE_VAL(bash_cv_kernel_rlimit, ++[AC_TRY_COMPILE([ ++#include <sys/types.h> ++#include <sys/resource.h> ++], ++[ ++ int f; ++ f = RLIMIT_DATA; ++], bash_cv_kernel_rlimit=no, ++[AC_TRY_COMPILE([ ++#include <sys/types.h> ++#define _KERNEL ++#include <sys/resource.h> ++#undef _KERNEL ++], ++[ ++ int f; ++ f = RLIMIT_DATA; ++], bash_cv_kernel_rlimit=yes, bash_cv_kernel_rlimit=no)] ++)]) ++AC_MSG_RESULT($bash_cv_kernel_rlimit) ++if test $bash_cv_kernel_rlimit = yes; then ++AC_DEFINE(RLIMIT_NEEDS_KERNEL) ++fi ++]) ++ ++dnl ++dnl Check for 64-bit off_t -- used for malloc alignment ++dnl ++dnl C does not allow duplicate case labels, so the compile will fail if ++dnl sizeof(off_t) is > 4. ++dnl ++AC_DEFUN([BASH_CHECK_OFF_T_64], ++[AC_CACHE_CHECK(for 64-bit off_t, bash_cv_off_t_64, ++AC_TRY_COMPILE([ ++#ifdef HAVE_UNISTD_H ++#include <unistd.h> ++#endif ++#include <sys/types.h> ++],[ ++switch (0) case 0: case (sizeof (off_t) <= 4):; ++], bash_cv_off_t_64=no, bash_cv_off_t_64=yes)) ++if test $bash_cv_off_t_64 = yes; then ++ AC_DEFINE(HAVE_OFF_T_64) ++fi]) ++ ++AC_DEFUN([BASH_CHECK_RTSIGS], ++[AC_MSG_CHECKING(for unusable real-time signals due to large values) ++AC_CACHE_VAL(bash_cv_unusable_rtsigs, ++[AC_TRY_RUN([ ++#include <sys/types.h> ++#include <signal.h> ++ ++#ifndef NSIG ++# define NSIG 64 ++#endif ++ ++main () ++{ ++ int n_sigs = 2 * NSIG; ++#ifdef SIGRTMIN ++ int rtmin = SIGRTMIN; ++#else ++ int rtmin = 0; ++#endif ++ ++ exit(rtmin < n_sigs); ++}], bash_cv_unusable_rtsigs=yes, bash_cv_unusable_rtsigs=no, ++ [AC_MSG_WARN(cannot check real-time signals if cross compiling -- defaulting to yes) ++ bash_cv_unusable_rtsigs=yes] ++)]) ++AC_MSG_RESULT($bash_cv_unusable_rtsigs) ++if test $bash_cv_unusable_rtsigs = yes; then ++AC_DEFINE(UNUSABLE_RT_SIGNALS) ++fi ++]) ++ ++dnl ++dnl check for availability of multibyte characters and functions ++dnl ++AH_TEMPLATE([HAVE_MBSRTOWCS], [Define if we have the mbsrtowcs function]) ++AH_TEMPLATE([HAVE_WCWIDTH], [Define if we have the wcwidth function]) ++AH_TEMPLATE([HAVE_MBSTATE_T], [Define if we have mbstate_t]) ++AH_TEMPLATE([HAVE_LANGINFO_CODESET], [Define if we have nl_langinfo and CODESET]) ++AC_DEFUN([BASH_CHECK_MULTIBYTE], ++[ ++AC_CHECK_HEADERS(wctype.h) ++AC_CHECK_HEADERS(wchar.h) ++AC_CHECK_HEADERS(langinfo.h) ++ ++AC_CHECK_FUNC(mbsrtowcs, AC_DEFINE(HAVE_MBSRTOWCS)) ++AC_CHECK_FUNC(wcwidth, AC_DEFINE(HAVE_WCWIDTH)) ++ ++AC_CACHE_CHECK([for mbstate_t], bash_cv_have_mbstate_t, ++[AC_TRY_RUN([ ++#include <wchar.h> ++int ++main () ++{ ++ mbstate_t ps; ++ return 0; ++}], bash_cv_have_mbstate_t=yes, bash_cv_have_mbstate_t=no)]) ++if test $bash_cv_have_mbstate_t = yes; then ++ AC_DEFINE(HAVE_MBSTATE_T) ++fi ++ ++AC_CACHE_CHECK([for nl_langinfo and CODESET], bash_cv_langinfo_codeset, ++[AC_TRY_LINK( ++[#include <langinfo.h>], ++[char* cs = nl_langinfo(CODESET);], ++bash_cv_langinfo_codeset=yes, bash_cv_langinfo_codeset=no)]) ++if test $bash_cv_langinfo_codeset = yes; then ++ AC_DEFINE(HAVE_LANGINFO_CODESET) ++fi ++ ++]) ++ ++dnl need: prefix exec_prefix libdir includedir CC TERMCAP_LIB ++dnl require: ++dnl AC_PROG_CC ++dnl BASH_CHECK_LIB_TERMCAP ++ ++AC_DEFUN([RL_LIB_READLINE_VERSION], ++[ ++AC_REQUIRE([BASH_CHECK_LIB_TERMCAP]) ++ ++AC_MSG_CHECKING([version of installed readline library]) ++ ++# What a pain in the ass this is. ++ ++# save cpp and ld options ++_save_CFLAGS="$CFLAGS" ++_save_LDFLAGS="$LDFLAGS" ++_save_LIBS="$LIBS" ++ ++# Don't set ac_cv_rl_prefix if the caller has already assigned a value. This ++# allows the caller to do something like $_rl_prefix=$withval if the user ++# specifies --with-installed-readline=PREFIX as an argument to configure ++ ++if test -z "$ac_cv_rl_prefix"; then ++test "x$prefix" = xNONE && ac_cv_rl_prefix=$ac_default_prefix || ac_cv_rl_prefix=${prefix} ++fi ++ ++eval ac_cv_rl_includedir=${ac_cv_rl_prefix}/include ++eval ac_cv_rl_libdir=${ac_cv_rl_prefix}/lib ++ ++LIBS="$LIBS -lreadline ${TERMCAP_LIB}" ++CFLAGS="$CFLAGS -I${ac_cv_rl_includedir}" ++LDFLAGS="$LDFLAGS -L${ac_cv_rl_libdir}" ++ ++AC_TRY_RUN([ ++#include <stdio.h> ++#include <readline/readline.h> ++ ++main() ++{ ++ FILE *fp; ++ fp = fopen("conftest.rlv", "w"); ++ if (fp == 0) exit(1); ++ fprintf(fp, "%s\n", rl_library_version ? rl_library_version : "0.0"); ++ fclose(fp); ++ exit(0); ++} ++], ++ac_cv_rl_version=`cat conftest.rlv`, ++ac_cv_rl_version='0.0', ++ac_cv_rl_version='4.2') ++ ++CFLAGS="$_save_CFLAGS" ++LDFLAGS="$_save_LDFLAGS" ++LIBS="$_save_LIBS" ++ ++RL_MAJOR=0 ++RL_MINOR=0 ++ ++# ( ++case "$ac_cv_rl_version" in ++2*|3*|4*|5*|6*|7*|8*|9*) ++ RL_MAJOR=`echo $ac_cv_rl_version | sed 's:\..*$::'` ++ RL_MINOR=`echo $ac_cv_rl_version | sed -e 's:^.*\.::' -e 's:[[a-zA-Z]]*$::'` ++ ;; ++esac ++ ++# ((( ++case $RL_MAJOR in ++[[0-9][0-9]]) _RL_MAJOR=$RL_MAJOR ;; ++[[0-9]]) _RL_MAJOR=0$RL_MAJOR ;; ++*) _RL_MAJOR=00 ;; ++esac ++ ++# ((( ++case $RL_MINOR in ++[[0-9][0-9]]) _RL_MINOR=$RL_MINOR ;; ++[[0-9]]) _RL_MINOR=0$RL_MINOR ;; ++*) _RL_MINOR=00 ;; ++esac ++ ++RL_VERSION="0x${_RL_MAJOR}${_RL_MINOR}" ++ ++# Readline versions greater than 4.2 have these defines in readline.h ++ ++if test $ac_cv_rl_version = '0.0' ; then ++ AC_MSG_WARN([Could not test version of installed readline library.]) ++elif test $RL_MAJOR -gt 4 || { test $RL_MAJOR = 4 && test $RL_MINOR -gt 2 ; } ; then ++ # set these for use by the caller ++ RL_PREFIX=$ac_cv_rl_prefix ++ RL_LIBDIR=$ac_cv_rl_libdir ++ RL_INCLUDEDIR=$ac_cv_rl_includedir ++ AC_MSG_RESULT($ac_cv_rl_version) ++else ++ ++AC_DEFINE_UNQUOTED(RL_READLINE_VERSION, $RL_VERSION, [encoded version of the installed readline library]) ++AC_DEFINE_UNQUOTED(RL_VERSION_MAJOR, $RL_MAJOR, [major version of installed readline library]) ++AC_DEFINE_UNQUOTED(RL_VERSION_MINOR, $RL_MINOR, [minor version of installed readline library]) ++ ++AC_SUBST(RL_VERSION) ++AC_SUBST(RL_MAJOR) ++AC_SUBST(RL_MINOR) ++ ++# set these for use by the caller ++RL_PREFIX=$ac_cv_rl_prefix ++RL_LIBDIR=$ac_cv_rl_libdir ++RL_INCLUDEDIR=$ac_cv_rl_includedir ++ ++AC_MSG_RESULT($ac_cv_rl_version) ++ ++fi ++]) +--- bash-2.05b/configure.in~autofoo.patch ++++ bash-2.05b/configure.in +@@ -34,6 +34,102 @@ + AC_CONFIG_AUX_DIR(./support) + AC_CONFIG_HEADERS(config.h) + ++AH_TOP([#include "config-top.h"]) ++AH_BOTTOM([#include "config-bot.h"]) ++ ++AH_TEMPLATE([AFS]) ++AH_TEMPLATE([ALIAS]) ++AH_TEMPLATE([ARITH_FOR_COMMAND]) ++AH_TEMPLATE([ARRAY_VARS]) ++AH_TEMPLATE([BANG_HISTORY]) ++AH_TEMPLATE([BRACE_EXPANSION]) ++AH_TEMPLATE([CAN_REDEFINE_GETENV]) ++AH_TEMPLATE([COMMAND_TIMING]) ++AH_TEMPLATE([COND_COMMAND]) ++AH_TEMPLATE([DEFAULT_ECHO_TO_XPG]) ++AH_TEMPLATE([DEFAULT_MAIL_DIRECTORY]) ++AH_TEMPLATE([DEV_FD_PREFIX]) ++AH_TEMPLATE([DISABLED_BUILTINS]) ++AH_TEMPLATE([DISABLE_MALLOC_WRAPPERS]) ++AH_TEMPLATE([DPAREN_ARITHMETIC]) ++AH_TEMPLATE([DUP2_BROKEN]) ++AH_TEMPLATE([EXTENDED_GLOB]) ++AH_TEMPLATE([FIONREAD_IN_SYS_IOCTL]) ++AH_TEMPLATE([GETCWD_BROKEN]) ++AH_TEMPLATE([HAVE_BSD_SIGNALS]) ++AH_TEMPLATE([HAVE_DEV_FD]) ++AH_TEMPLATE([HAVE_DEV_STDIN]) ++AH_TEMPLATE([HAVE_GETPW_DECLS]) ++AH_TEMPLATE([HAVE_HASH_BANG_EXEC]) ++AH_TEMPLATE([HAVE_ISINF_IN_LIBC]) ++AH_TEMPLATE([HAVE_LANGINFO_CODESET]) ++AH_TEMPLATE([HAVE_LIBSOCKET]) ++AH_TEMPLATE([HAVE_LONG_LONG]) ++AH_TEMPLATE([HAVE_MBSRTOWCS]) ++AH_TEMPLATE([HAVE_MBSTATE_T]) ++AH_TEMPLATE([HAVE_MKFIFO]) ++AH_TEMPLATE([HAVE_POSIX_SIGNALS]) ++AH_TEMPLATE([HAVE_POSIX_SIGSETJMP]) ++AH_TEMPLATE([HAVE_PRINTF_A_FORMAT]) ++AH_TEMPLATE([HAVE_QUAD_T]) ++AH_TEMPLATE([HAVE_SETOSTYPE]) ++AH_TEMPLATE([HAVE_SOCKLEN_T]) ++AH_TEMPLATE([HAVE_STD_PUTENV]) ++AH_TEMPLATE([HAVE_STD_UNSETENV]) ++AH_TEMPLATE([HAVE_STRSIGNAL]) ++AH_TEMPLATE([HAVE_SYS_ERRLIST]) ++AH_TEMPLATE([HAVE_SYS_SIGLIST]) ++AH_TEMPLATE([HAVE_TIMEVAL]) ++AH_TEMPLATE([HAVE_UNDER_SYS_SIGLIST]) ++AH_TEMPLATE([HAVE_UNSIGNED_LONG_LONG]) ++AH_TEMPLATE([HAVE_USG_SIGHOLD]) ++AH_TEMPLATE([HAVE_WAIT3]) ++AH_TEMPLATE([HAVE_WCWIDTH]) ++AH_TEMPLATE([HELP_BUILTIN]) ++AH_TEMPLATE([HISTORY]) ++AH_TEMPLATE([JOB_CONTROL]) ++AH_TEMPLATE([JOB_CONTROL_MISSING]) ++AH_TEMPLATE([MEMSCRAMBLE]) ++AH_TEMPLATE([MKFIFO_MISSING]) ++AH_TEMPLATE([MUST_REINSTALL_SIGHANDLERS]) ++AH_TEMPLATE([NAMED_PIPES_MISSING]) ++AH_TEMPLATE([NETWORK_REDIRECTIONS]) ++AH_TEMPLATE([OPENDIR_NOT_ROBUST]) ++AH_TEMPLATE([PGRP_PIPE]) ++AH_TEMPLATE([PROCESS_SUBSTITUTION]) ++AH_TEMPLATE([PROGRAMMABLE_COMPLETION]) ++AH_TEMPLATE([PROMPT_STRING_DECODE]) ++AH_TEMPLATE([PUSHD_AND_POPD]) ++AH_TEMPLATE([READLINE]) ++AH_TEMPLATE([RESTRICTED_SHELL]) ++AH_TEMPLATE([RLIMIT_NEEDS_KERNEL]) ++AH_TEMPLATE([RLIMTYPE]) ++AH_TEMPLATE([SELECT_COMMAND]) ++AH_TEMPLATE([SPEED_T_IN_SYS_TYPES]) ++AH_TEMPLATE([STRCOLL_BROKEN]) ++AH_TEMPLATE([STRUCT_DIRENT_HAS_D_FILENO]) ++AH_TEMPLATE([STRUCT_DIRENT_HAS_D_INO]) ++AH_TEMPLATE([STRUCT_WINSIZE_IN_SYS_IOCTL]) ++AH_TEMPLATE([STRUCT_WINSIZE_IN_TERMIOS]) ++AH_TEMPLATE([SVR4]) ++AH_TEMPLATE([SVR4_2]) ++AH_TEMPLATE([SVR5]) ++AH_TEMPLATE([TERMIOS_LDISC]) ++AH_TEMPLATE([TERMIO_LDISC]) ++AH_TEMPLATE([TIOCSTAT_IN_SYS_IOCTL]) ++AH_TEMPLATE([ULIMIT_MAXFDS]) ++AH_TEMPLATE([UNDER_SYS_SIGLIST_DECLARED]) ++AH_TEMPLATE([UNUSABLE_RT_SIGNALS]) ++AH_TEMPLATE([USING_BASH_MALLOC]) ++AH_TEMPLATE([VOID_SIGHANDLER]) ++AH_TEMPLATE([_GNU_SOURCE]) ++AH_TEMPLATE([clock_t]) ++AH_TEMPLATE([intmax_t]) ++AH_TEMPLATE([quad_t]) ++AH_TEMPLATE([sigset_t]) ++AH_TEMPLATE([socklen_t]) ++AH_TEMPLATE([uintmax_t]) ++ + dnl checks for version info + BASHVERS=2.05b + RELSTATUS=release +@@ -405,6 +501,7 @@ + + test -z "$CPPFLAGS_FOR_BUILD" && CPPFLAGS_FOR_BUILD="$CPPFLAGS" + test -z "$CFLAGS_FOR_BUILD" && CFLAGS_FOR_BUILD="-g" ++test -z "$LDFLAGS_FOR_BUILD" && LDFLAGS_FOR_BUILD="$LDFLAGS" + + AC_SUBST(CFLAGS) + AC_SUBST(CPPFLAGS) +--- bash-2.05b/sig.h~autofoo.patch ++++ bash-2.05b/sig.h +@@ -23,6 +23,7 @@ + #if !defined (_SIG_H_) + # define _SIG_H_ + ++#include <signal.h> + #include "stdc.h" + + #if !defined (SIGABRT) && defined (SIGIOT) +--- bash-2.05b/siglist.h~autofoo.patch ++++ bash-2.05b/siglist.h +@@ -21,7 +21,7 @@ + #if !defined (_SIGLIST_H_) + #define _SIGLIST_H_ + +-#if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_STRSIGNAL) ++#if !defined (HAVE_DECL_SYS_SIGLIST) && !defined (HAVE_STRSIGNAL) + + #if defined (HAVE_UNDER_SYS_SIGLIST) && !defined (HAVE_SYS_SIGLIST) && !defined (sys_siglist) + # define sys_siglist _sys_siglist +--- bash-2.05b/builtins/Makefile.in~autofoo.patch ++++ bash-2.05b/builtins/Makefile.in +@@ -54,10 +54,10 @@ + + LIBS = @LIBS@ + LDFLAGS = @LDFLAGS@ $(LOCAL_LDFLAGS) $(CFLAGS) +-LDFLAGS_FOR_BUILD = $(LDFLAGS) ++LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@ + LOCAL_LDFLAGS = @LOCAL_LDFLAGS@ + #LIBS_FOR_BUILD = @LIBS_FOR_BUILD@ +-LIBS_FOR_BUILD = $(LIBS) ++LIBS_FOR_BUILD = $(filter-out -lintl,$(LIBS)) # mkbuiltins doesn't need libintl -CL + + BASHINCDIR = ${topdir}/include + +--- bash-2.05b/Makefile.in~autofoo.patch ++++ bash-2.05b/Makefile.in +@@ -128,7 +128,7 @@ + CCFLAGS_FOR_BUILD = $(BASE_CCFLAGS) $(CPPFLAGS_FOR_BUILD) $(CFLAGS_FOR_BUILD) + + LDFLAGS = @LDFLAGS@ $(STATIC_LD) $(LOCAL_LDFLAGS) $(PROFILE_FLAGS) $(CFLAGS) +-LDFLAGS_FOR_BUILD = $(LDFLAGS) ++LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@ + + INCLUDES = -I. @RL_INCLUDE@ -I$(srcdir) -I$(BASHINCDIR) -I$(LIBSRC) + +--- bash-2.05b/support/Makefile.in~autofoo.patch ++++ bash-2.05b/support/Makefile.in +@@ -55,7 +55,7 @@ + LOCAL_LDFLAGS = @LOCAL_LDFLAGS@ + LIBS = @LIBS@ + LDFLAGS = @LDFLAGS@ $(LOCAL_LDFLAGS) $(CFLAGS) +-LDFLAGS_FOR_BUILD = $(LDFLAGS) ++LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@ + + INCLUDES = -I${BUILD_DIR} -I${topdir} + |