dnl dnl Bash specific tests dnl dnl Some derived from PDKSH 5.1.3 autoconf tests dnl dnl dnl Check if dup2() does not clear the close on exec flag dnl AC_DEFUN(BASH_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 #include 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 ]) dnl Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7) AC_DEFUN(BASH_SIGNAL_CHECK, [AC_REQUIRE([AC_TYPE_SIGNAL]) AC_MSG_CHECKING(for type of signal functions) AC_CACHE_VAL(bash_cv_signal_vintage, [ AC_TRY_LINK([#include ],[ 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_TRY_LINK([#include ], [ int mask = sigmask(SIGINT); sigsetmask(mask); sigblock(mask); sigpause(mask); ], bash_cv_signal_vintage=4.2bsd, [ AC_TRY_LINK([ #include 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_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 #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 ]) 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_MSG_CHECKING(for $1) AC_CACHE_VAL(bash_cv_type_$1, [AC_EGREP_CPP($1, [#include #if STDC_HEADERS #include #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($1, $3) 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_RLIMIT_TYPE, [AC_MSG_CHECKING(for size and type of struct rlimit fields) AC_CACHE_VAL(bash_cv_type_rlimit, [AC_TRY_COMPILE([#include #include ], [rlim_t xxx;], bash_cv_type_rlimit=rlim_t,[ AC_TRY_RUN([ #include #include #include 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 ]) 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 #include #ifdef HAVE_UNISTD_H #include #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 #include #ifdef HAVE_UNISTD_H #include #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_REQUIRE([AC_DECL_SYS_SIGLIST]) AC_MSG_CHECKING([for sys_siglist in system C library]) AC_CACHE_VAL(bash_cv_sys_siglist, [AC_TRY_RUN([ #include #include #ifdef HAVE_UNISTD_H #include #endif #ifndef SYS_SIGLIST_DECLARED 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 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 ], [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 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 #include #include #ifdef HAVE_UNISTD_H # include #endif /* HAVE_UNISTD_H */ #if defined(HAVE_DIRENT_H) # include #else # define dirent direct # ifdef HAVE_SYS_NDIR_H # include # endif /* SYSNDIR */ # ifdef HAVE_SYS_DIR_H # include # endif /* SYSDIR */ # ifdef HAVE_NDIR_H # include # 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 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 #include #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) 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_sv_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 "$ac_cv_sizeof_long" = 8; then AC_CHECK_TYPE(bits64_t, long) else AC_CHECK_TYPE(bits64_t, double) 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 #include ], [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 ]) AC_DEFUN(BASH_FUNC_LSTAT, [dnl Cannot use AC_CHECK_FUNCS(lstat) because Linux defines lstat() as an dnl inline function in . AC_CACHE_CHECK([for lstat], bash_cv_func_lstat, [AC_TRY_LINK([ #include #include ],[ 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 #include #include 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) fi ]) AC_DEFUN(BASH_STRUCT_TERMIOS_LDISC, [AC_MSG_CHECKING([for a c_line member of struct termios]) AC_CACHE_VAL(bash_cv_termios_ldisc, [AC_TRY_COMPILE([#include #include ],[struct termios t; int i; i = t.c_line;], bash_cv_termios_ldisc=yes, bash_cv_termios_ldisc=no)])dnl AC_MSG_RESULT($bash_cv_termios_ldisc) if test $bash_cv_termios_ldisc = yes; then AC_DEFINE(TERMIOS_LDISC) fi ]) AC_DEFUN(BASH_STRUCT_TERMIO_LDISC, [AC_MSG_CHECKING([for a c_line member of struct termio]) AC_CACHE_VAL(bash_cv_termio_ldisc, [AC_TRY_COMPILE([#include #include ],[struct termio t; int i; i = t.c_line;], bash_cv_termio_ldisc=yes, bash_cv_termio_ldisc=no)])dnl AC_MSG_RESULT($bash_cv_termio_ldisc) if test $bash_cv_termio_ldisc = yes; then AC_DEFINE(TERMIO_LDISC) 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 #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 ]) AC_DEFUN(BASH_FUNC_PRINTF, [AC_MSG_CHECKING(for declaration of printf in ) AC_CACHE_VAL(bash_cv_printf_declared, [AC_TRY_RUN([ #include #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_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_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(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 = libncurses; then TERMCAP_LIB=-lncurses TERMCAP_DEP= else TERMCAP_LIB=-lcurses TERMCAP_DEP= 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 #ifdef HAVE_UNISTD_H #include #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) fi ]) 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 #include #ifdef HAVE_UNISTD_H # include #endif /* HAVE_UNISTD_H */ #if defined(HAVE_DIRENT_H) # include #else # define dirent direct # ifdef HAVE_SYS_NDIR_H # include # endif /* SYSNDIR */ # ifdef HAVE_SYS_DIR_H # include # endif /* SYSDIR */ # ifdef HAVE_NDIR_H # include # 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 ]) 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 #include #ifdef HAVE_UNISTD_H # include #endif /* HAVE_UNISTD_H */ #if defined(HAVE_DIRENT_H) # include #else # define dirent direct # ifdef HAVE_SYS_NDIR_H # include # endif /* SYSNDIR */ # ifdef HAVE_SYS_DIR_H # include # endif /* SYSDIR */ # ifdef HAVE_NDIR_H # include # 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_REINSTALL_SIGHANDLERS, [AC_REQUIRE([AC_TYPE_SIGNAL]) AC_REQUIRE([BASH_SIGNAL_CHECK]) AC_MSG_CHECKING([if signal handlers must be reinstalled when invoked]) AC_CACHE_VAL(bash_cv_must_reinstall_sighandlers, [AC_TRY_RUN([ #include #ifdef HAVE_UNISTD_H #include #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 ]) AC_DEFUN(BASH_FUNC_SBRK_DECLARED, [AC_MSG_CHECKING(for declaration of sbrk in ) 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 check that some necessary job control definitions are present AC_DEFUN(BASH_JOB_CONTROL_MISSING, [AC_REQUIRE([BASH_SIGNAL_CHECK]) AC_MSG_CHECKING(for presence of necessary job control definitions) AC_CACHE_VAL(bash_cv_job_control_missing, [AC_TRY_RUN([ #include #ifdef HAVE_SYS_WAIT_H #include #endif #ifdef HAVE_UNISTD_H #include #endif #include /* 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 #include #ifdef HAVE_UNISTD_H #include #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_FUNC_POSIX_SETJMP, [AC_REQUIRE([BASH_SIGNAL_CHECK]) 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 #endif #include #include #include 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 ]) 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 #include ], [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 ]) 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 #include ], [struct winsize x;], bash_cv_struct_winsize_header=ioctl_h, [AC_TRY_COMPILE([#include #include ], [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 ]) 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 #include ], [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 ]) 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 #include ], [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 . Some versions of linux dnl require a definition of speed_t each time is included, dnl but you can only get speed_t if you include (on some dnl versions) or (on others). dnl AC_DEFUN(BASH_MISC_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 ], [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 ]) 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 #ifdef HAVE_UNISTD_H # include #endif #include ], 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 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_SOCKLIB, [ 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 ]) 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 ], [ 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_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 /usr/mail; then bash_cv_mail_dir=/usr/mail elif test -d /var/spool/mail; then bash_cv_mail_dir=/var/spool/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) if test $bash_cv_mail_dir = "/var/mail"; then AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/mail") elif test $bash_cv_mail_dir = "/usr/mail"; then AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/mail") elif test $bash_cv_mail_dir = "/var/spool/mail"; then AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/spool/mail") elif test $bash_cv_mail_dir = "/usr/spool/mail"; then AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/spool/mail") else AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "unknown") fi ]) dnl dnl Check if HPUX needs _KERNEL defined for RLIMIT_* definitions dnl AC_DEFUN(BASH_KERNEL_RLIMIT_CHECK, [AC_MSG_CHECKING([whether $host_os needs _KERNEL for RLIMIT defines]) AC_CACHE_VAL(bash_cv_kernel_rlimit, [AC_TRY_COMPILE([ #include #include ], [ int f; f = RLIMIT_DATA; ], bash_cv_kernel_rlimit=no, [AC_TRY_COMPILE([ #include #define _KERNEL #include #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 ]) 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 #if defined (HAVE_LOCALE_H) #include #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 ]) dnl dnl If available, use support for large files unless the user specified dnl one of the CPPFLAGS, LDFLAGS, or LIBS variables ( dnl via GNU patch 2.5) dnl AC_DEFUN(BASH_LARGE_FILE_SUPPORT, [AC_MSG_CHECKING(whether large file support needs explicit enabling) ac_getconfs='' ac_result=yes ac_set='' ac_shellvars='CPPFLAGS LDFLAGS LIBS' for ac_shellvar in $ac_shellvars; do case $ac_shellvar in CPPFLAGS) ac_lfsvar=LFS_CFLAGS ac_lfs64var=LFS64_CFLAGS ;; *) ac_lfsvar=LFS_$ac_shellvar ac_lfs64var=LFS64_$ac_shellvar ;; esac eval test '"${'$ac_shellvar'+set}"' = set && ac_set=$ac_shellvar (getconf $ac_lfsvar) >/dev/null 2>&1 || { ac_result=no; break; } ac_getconf=`getconf $ac_lfsvar` ac_getconf64=`getconf $ac_lfs64var` ac_getconfs=$ac_getconfs$ac_getconf\ $ac_getconf64 eval ac_test_$ac_shellvar="\$ac_getconf\ \$ac_getconf64" done case "$ac_result$ac_getconfs" in yes) ac_result=no ;; esac case "$ac_result$ac_set" in yes?*) ac_result="yes, but $ac_set is already set, so use its settings" esac AC_MSG_RESULT($ac_result) case $ac_result in yes) for ac_shellvar in $ac_shellvars; do eval $ac_shellvar=\$ac_test_$ac_shellvar done ;; esac ]) dnl dnl AC_SYS_RESTARTABLE_SYSCALLS tests only for restarted system calls dnl after a signal handler has been installed with signal(). Since dnl Bash uses sigaction() if it is available, we need to check whether dnl or not a signal handler installed with sigaction and SA_RESTART dnl causes system calls to be restarted after the signal is caught dnl AC_DEFUN(BASH_SYS_RESTARTABLE_SYSCALLS, [AC_REQUIRE([BASH_SIGNAL_CHECK]) AC_CACHE_CHECK(whether posix sigaction restarts system calls by default, bash_cv_sys_restartable_syscalls, [AC_TRY_RUN( [/* Exit 0 (true) if wait returns something other than -1, i.e. the pid of the child, which means that wait was restarted after getting the signal. */ #ifdef HAVE_UNISTD_H # include #endif #include #include static int caught = 0; void ucatch (isig) int isig; { caught = 1; } main () { #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS) exit (1); #else struct sigaction act, oact; int i, status; act.sa_handler = ucatch; /* Might want to add SA_RESTART here, but bash's set_signal_handler does not. */ act.sa_flags = 0; sigemptyset(&act.sa_mask); sigemptyset(&oact.sa_mask); i = fork (); /* A possible race condition here, but in practice it never happens. */ if (i == 0) { sleep (3); kill (getppid (), SIGINT); sleep (3); exit (0); } sigaction(SIGINT, &act, &oact); status = wait(&i); if (status == -1) wait(&i); exit (status == -1); #endif } ], bash_cv_sys_restartable_syscalls=yes, bash_cv_sys_restartable_syscalls=no, AC_MSG_WARN(cannot check restartable syscalls if cross compiling)) ]) if test $bash_cv_sys_restartable_syscalls = yes; then AC_DEFINE(HAVE_RESTARTABLE_SYSCALLS) 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 #endif #include ],[ 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_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 ]) 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 #include #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 ])