readline/aclocal.m4

   1 dnl
   2 dnl Bash specific tests
   3 dnl
   4 dnl Some derived from PDKSH 5.1.3 autoconf tests
   5 dnl
   6 dnl
   7 dnl Check if dup2() does not clear the close on exec flag
   8 dnl
   9 AC_DEFUN(BASH_DUP2_CLOEXEC_CHECK,
  10 [AC_MSG_CHECKING(if dup2 fails to clear the close-on-exec flag)
  11 AC_CACHE_VAL(bash_cv_dup2_broken,
  12 [AC_TRY_RUN([
  13 #include <sys/types.h>
  14 #include <fcntl.h>
  15 main()
  16 {
  17   int fd1, fd2, fl;
  18   fd1 = open("/dev/null", 2);
  19   if (fcntl(fd1, 2, 1) < 0)
  20     exit(1);
  21   fd2 = dup2(fd1, 1);
  22   if (fd2 < 0)
  23     exit(2);
  24   fl = fcntl(fd2, 1, 0);
  25   /* fl will be 1 if dup2 did not reset the close-on-exec flag. */
  26   exit(fl != 1);
  27 }
  28 ], bash_cv_dup2_broken=yes, bash_cv_dup2_broken=no,
  29     [AC_MSG_WARN(cannot check dup2 if cross compiling -- defaulting to no)
  30      bash_cv_dup2_broken=no])
  31 ])
  32 AC_MSG_RESULT($bash_cv_dup2_broken)
  33 if test $bash_cv_dup2_broken = yes; then
  34 AC_DEFINE(DUP2_BROKEN)
  35 fi
  36 ])
  37
  38 dnl Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7)
  39 AC_DEFUN(BASH_SIGNAL_CHECK,
  40 [AC_REQUIRE([AC_TYPE_SIGNAL])
  41 AC_MSG_CHECKING(for type of signal functions)
  42 AC_CACHE_VAL(bash_cv_signal_vintage,
  43 [
  44   AC_TRY_LINK([#include <signal.h>],[
  45     sigset_t ss;
  46     struct sigaction sa;
  47     sigemptyset(&ss); sigsuspend(&ss);
  48     sigaction(SIGINT, &sa, (struct sigaction *) 0);
  49     sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0);
  50   ], bash_cv_signal_vintage=posix,
  51   [
  52     AC_TRY_LINK([#include <signal.h>], [
  53         int mask = sigmask(SIGINT);
  54         sigsetmask(mask); sigblock(mask); sigpause(mask);
  55     ], bash_cv_signal_vintage=4.2bsd,
  56     [
  57       AC_TRY_LINK([
  58         #include <signal.h>
  59         RETSIGTYPE foo() { }], [
  60                 int mask = sigmask(SIGINT);
  61                 sigset(SIGINT, foo); sigrelse(SIGINT);
  62                 sighold(SIGINT); sigpause(SIGINT);
  63         ], bash_cv_signal_vintage=svr3, bash_cv_signal_vintage=v7
  64     )]
  65   )]
  66 )
  67 ])
  68 AC_MSG_RESULT($bash_cv_signal_vintage)
  69 if test "$bash_cv_signal_vintage" = posix; then
  70 AC_DEFINE(HAVE_POSIX_SIGNALS)
  71 elif test "$bash_cv_signal_vintage" = "4.2bsd"; then
  72 AC_DEFINE(HAVE_BSD_SIGNALS)
  73 elif test "$bash_cv_signal_vintage" = svr3; then
  74 AC_DEFINE(HAVE_USG_SIGHOLD)
  75 fi
  76 ])
  77
  78 dnl Check if the pgrp of setpgrp() can't be the pid of a zombie process.
  79 AC_DEFUN(BASH_PGRP_SYNC,
  80 [AC_REQUIRE([AC_FUNC_GETPGRP])
  81 AC_MSG_CHECKING(whether pgrps need synchronization)
  82 AC_CACHE_VAL(bash_cv_pgrp_pipe,
  83 [AC_TRY_RUN([
  84 #ifdef HAVE_UNISTD_H
  85 #  include <unistd.h>
  86 #endif
  87 main()
  88 {
  89 # ifdef GETPGRP_VOID
  90 #  define getpgID()     getpgrp()
  91 # else
  92 #  define getpgID()     getpgrp(0)
  93 #  define setpgid(x,y)  setpgrp(x,y)
  94 # endif
  95         int pid1, pid2, fds[2];
  96         int status;
  97         char ok;
  98
  99         switch (pid1 = fork()) {
 100           case -1:
 101             exit(1);
 102           case 0:
 103             setpgid(0, getpid());
 104             exit(0);
 105         }
 106         setpgid(pid1, pid1);
 107
 108         sleep(2);       /* let first child die */
 109
 110         if (pipe(fds) < 0)
 111           exit(2);
 112
 113         switch (pid2 = fork()) {
 114           case -1:
 115             exit(3);
 116           case 0:
 117             setpgid(0, pid1);
 118             ok = getpgID() == pid1;
 119             write(fds[1], &ok, 1);
 120             exit(0);
 121         }
 122         setpgid(pid2, pid1);
 123
 124         close(fds[1]);
 125         if (read(fds[0], &ok, 1) != 1)
 126           exit(4);
 127         wait(&status);
 128         wait(&status);
 129         exit(ok ? 0 : 5);
 130 }
 131 ], bash_cv_pgrp_pipe=no,bash_cv_pgrp_pipe=yes,
 132    [AC_MSG_WARN(cannot check pgrp synchronization if cross compiling -- defaulting to no)
 133     bash_cv_pgrp_pipe=no])
 134 ])
 135 AC_MSG_RESULT($bash_cv_pgrp_pipe)
 136 if test $bash_cv_pgrp_pipe = yes; then
 137 AC_DEFINE(PGRP_PIPE)
 138 fi
 139 ])
 140
 141 dnl
 142 dnl check for typedef'd symbols in header files, but allow the caller to
 143 dnl specify the include files to be checked in addition to the default
 144 dnl
 145 dnl BASH_CHECK_TYPE(TYPE, HEADERS, DEFAULT[, VALUE-IF-FOUND])
 146 AC_DEFUN(BASH_CHECK_TYPE,
 147 [AC_REQUIRE([AC_HEADER_STDC])dnl
 148 AC_MSG_CHECKING(for $1)
 149 AC_CACHE_VAL(bash_cv_type_$1,
 150 [AC_EGREP_CPP($1, [#include <sys/types.h>
 151 #if STDC_HEADERS
 152 #include <stdlib.h>
 153 #endif
 154 $2
 155 ], bash_cv_type_$1=yes, bash_cv_type_$1=no)])
 156 AC_MSG_RESULT($bash_cv_type_$1)
 157 ifelse($#, 4, [if test $bash_cv_type_$1 = yes; then
 158         AC_DEFINE($4)
 159         fi])
 160 if test $bash_cv_type_$1 = no; then
 161   AC_DEFINE($1, $3)
 162 fi
 163 ])
 164
 165 dnl
 166 dnl Type of struct rlimit fields: some systems (OSF/1, NetBSD, RISC/os 5.0)
 167 dnl have a rlim_t, others (4.4BSD based systems) use quad_t, others use
 168 dnl long and still others use int (HP-UX 9.01, SunOS 4.1.3).  To simplify
 169 dnl matters, this just checks for rlim_t, quad_t, or long.
 170 dnl
 171 AC_DEFUN(BASH_RLIMIT_TYPE,
 172 [AC_MSG_CHECKING(for size and type of struct rlimit fields)
 173 AC_CACHE_VAL(bash_cv_type_rlimit,
 174 [AC_TRY_COMPILE([#include <sys/types.h>
 175 #include <sys/resource.h>],
 176 [rlim_t xxx;], bash_cv_type_rlimit=rlim_t,[
 177 AC_TRY_RUN([
 178 #include <sys/types.h>
 179 #include <sys/time.h>
 180 #include <sys/resource.h>
 181 main()
 182 {
 183 #ifdef HAVE_QUAD_T
 184   struct rlimit rl;
 185   if (sizeof(rl.rlim_cur) == sizeof(quad_t))
 186     exit(0);
 187 #endif
 188   exit(1);
 189 }], bash_cv_type_rlimit=quad_t, bash_cv_type_rlimit=long,
 190         [AC_MSG_WARN(cannot check quad_t if cross compiling -- defaulting to long)
 191          bash_cv_type_rlimit=long])])
 192 ])
 193 AC_MSG_RESULT($bash_cv_type_rlimit)
 194 if test $bash_cv_type_rlimit = quad_t; then
 195 AC_DEFINE(RLIMTYPE, quad_t)
 196 elif test $bash_cv_type_rlimit = rlim_t; then
 197 AC_DEFINE(RLIMTYPE, rlim_t)
 198 fi
 199 ])
 200
 201 dnl
 202 dnl Check for sys_siglist[] or _sys_siglist[]
 203 dnl
 204 AC_DEFUN(BASH_DECL_UNDER_SYS_SIGLIST,
 205 [AC_MSG_CHECKING([for _sys_siglist in signal.h or unistd.h])
 206 AC_CACHE_VAL(bash_cv_decl_under_sys_siglist,
 207 [AC_TRY_COMPILE([
 208 #include <sys/types.h>
 209 #include <signal.h>
 210 #ifdef HAVE_UNISTD_H
 211 #include <unistd.h>
 212 #endif], [ char *msg = _sys_siglist[2]; ],
 213   bash_cv_decl_under_sys_siglist=yes, bash_cv_decl_under_sys_siglist=no,
 214   [AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)])])dnl
 215 AC_MSG_RESULT($bash_cv_decl_under_sys_siglist)
 216 if test $bash_cv_decl_under_sys_siglist = yes; then
 217 AC_DEFINE(UNDER_SYS_SIGLIST_DECLARED)
 218 fi
 219 ])
 220
 221 AC_DEFUN(BASH_UNDER_SYS_SIGLIST,
 222 [AC_REQUIRE([BASH_DECL_UNDER_SYS_SIGLIST])
 223 AC_MSG_CHECKING([for _sys_siglist in system C library])
 224 AC_CACHE_VAL(bash_cv_under_sys_siglist,
 225 [AC_TRY_RUN([
 226 #include <sys/types.h>
 227 #include <signal.h>
 228 #ifdef HAVE_UNISTD_H
 229 #include <unistd.h>
 230 #endif
 231 #ifndef UNDER_SYS_SIGLIST_DECLARED
 232 extern char *_sys_siglist[];
 233 #endif
 234 main()
 235 {
 236 char *msg = (char *)_sys_siglist[2];
 237 exit(msg == 0);
 238 }],
 239         bash_cv_under_sys_siglist=yes, bash_cv_under_sys_siglist=no,
 240         [AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)
 241          bash_cv_under_sys_siglist=no])])
 242 AC_MSG_RESULT($bash_cv_under_sys_siglist)
 243 if test $bash_cv_under_sys_siglist = yes; then
 244 AC_DEFINE(HAVE_UNDER_SYS_SIGLIST)
 245 fi
 246 ])
 247
 248 AC_DEFUN(BASH_SYS_SIGLIST,
 249 [AC_REQUIRE([AC_DECL_SYS_SIGLIST])
 250 AC_MSG_CHECKING([for sys_siglist in system C library])
 251 AC_CACHE_VAL(bash_cv_sys_siglist,
 252 [AC_TRY_RUN([
 253 #include <sys/types.h>
 254 #include <signal.h>
 255 #ifdef HAVE_UNISTD_H
 256 #include <unistd.h>
 257 #endif
 258 #ifndef SYS_SIGLIST_DECLARED
 259 extern char *sys_siglist[];
 260 #endif
 261 main()
 262 {
 263 char *msg = sys_siglist[2];
 264 exit(msg == 0);
 265 }],
 266         bash_cv_sys_siglist=yes, bash_cv_sys_siglist=no,
 267         [AC_MSG_WARN(cannot check for sys_siglist if cross compiling -- defaulting to no)
 268          bash_cv_sys_siglist=no])])
 269 AC_MSG_RESULT($bash_cv_sys_siglist)
 270 if test $bash_cv_sys_siglist = yes; then
 271 AC_DEFINE(HAVE_SYS_SIGLIST)
 272 fi
 273 ])
 274
 275 dnl Check for sys_errlist[] and sys_nerr, check for declaration
 276 AC_DEFUN(BASH_SYS_ERRLIST,
 277 [AC_MSG_CHECKING([for sys_errlist and sys_nerr])
 278 AC_CACHE_VAL(bash_cv_sys_errlist,
 279 [AC_TRY_LINK([#include <errno.h>],
 280 [extern char *sys_errlist[];
 281  extern int sys_nerr;
 282  char *msg = sys_errlist[sys_nerr - 1];],
 283     bash_cv_sys_errlist=yes, bash_cv_sys_errlist=no)])dnl
 284 AC_MSG_RESULT($bash_cv_sys_errlist)
 285 if test $bash_cv_sys_errlist = yes; then
 286 AC_DEFINE(HAVE_SYS_ERRLIST)
 287 fi
 288 ])
 289
 290 dnl Check to see if opendir will open non-directories (not a nice thing)
 291 AC_DEFUN(BASH_FUNC_OPENDIR_CHECK,
 292 [AC_REQUIRE([AC_HEADER_DIRENT])dnl
 293 AC_MSG_CHECKING(if opendir() opens non-directories)
 294 AC_CACHE_VAL(bash_cv_opendir_not_robust,
 295 [AC_TRY_RUN([
 296 #include <stdio.h>
 297 #include <sys/types.h>
 298 #include <fcntl.h>
 299 #ifdef HAVE_UNISTD_H
 300 # include <unistd.h>
 301 #endif /* HAVE_UNISTD_H */
 302 #if defined(HAVE_DIRENT_H)
 303 # include <dirent.h>
 304 #else
 305 # define dirent direct
 306 # ifdef HAVE_SYS_NDIR_H
 307 #  include <sys/ndir.h>
 308 # endif /* SYSNDIR */
 309 # ifdef HAVE_SYS_DIR_H
 310 #  include <sys/dir.h>
 311 # endif /* SYSDIR */
 312 # ifdef HAVE_NDIR_H
 313 #  include <ndir.h>
 314 # endif
 315 #endif /* HAVE_DIRENT_H */
 316 main()
 317 {
 318 DIR *dir;
 319 int fd;
 320 unlink("/tmp/not_a_directory");
 321 fd = open("/tmp/not_a_directory", O_WRONLY|O_CREAT, 0666);
 322 write(fd, "\n", 1);
 323 close(fd);
 324 dir = opendir("/tmp/not_a_directory");
 325 unlink("/tmp/not_a_directory");
 326 exit (dir == 0);
 327 }], bash_cv_opendir_not_robust=yes,bash_cv_opendir_not_robust=no,
 328     [AC_MSG_WARN(cannot check opendir if cross compiling -- defaulting to no)
 329      bash_cv_opendir_not_robust=no]
 330 )])
 331 AC_MSG_RESULT($bash_cv_opendir_not_robust)
 332 if test $bash_cv_opendir_not_robust = yes; then
 333 AC_DEFINE(OPENDIR_NOT_ROBUST)
 334 fi
 335 ])
 336
 337 dnl
 338 AC_DEFUN(BASH_TYPE_SIGHANDLER,
 339 [AC_MSG_CHECKING([whether signal handlers are of type void])
 340 AC_CACHE_VAL(bash_cv_void_sighandler,
 341 [AC_TRY_COMPILE([#include <sys/types.h>
 342 #include <signal.h>
 343 #ifdef signal
 344 #undef signal
 345 #endif
 346 #ifdef __cplusplus
 347 extern "C"
 348 #endif
 349 void (*signal ()) ();],
 350 [int i;], bash_cv_void_sighandler=yes, bash_cv_void_sighandler=no)])dnl
 351 AC_MSG_RESULT($bash_cv_void_sighandler)
 352 if test $bash_cv_void_sighandler = yes; then
 353 AC_DEFINE(VOID_SIGHANDLER)
 354 fi
 355 ])
 356
 357 AC_DEFUN(BASH_TYPE_INT32_T,
 358 [
 359 if test "$ac_cv_sizeof_int" = 4; then
 360   AC_CHECK_TYPE(int32_t, int)
 361 elif test "$ac_cv_sizeof_long" = 4; then
 362   AC_CHECK_TYPE(int32_t, long)
 363 else
 364   AC_CHECK_TYPE(int32_t, int)
 365 fi
 366 ])
 367
 368 AC_DEFUN(BASH_TYPE_U_INT32_T,
 369 [
 370 if test "$ac_cv_sizeof_int" = 4; then
 371   AC_CHECK_TYPE(u_int32_t, unsigned int)
 372 elif test "$ac_cv_sizeof_long" = 4; then
 373   AC_CHECK_TYPE(u_int32_t, unsigned long)
 374 else
 375   AC_CHECK_TYPE(u_int32_t, unsigned int)
 376 fi
 377 ])
 378
 379 AC_DEFUN(BASH_TYPE_PTRDIFF_T,
 380 [
 381 if test "$ac_cv_sizeof_int" = "$ac_cv_sizeof_char_p"; then
 382   AC_CHECK_TYPE(ptrdiff_t, int)
 383 elif test "$ac_cv_sizeof_long" = "$ac_cv_sizeof_char_p"; then
 384   AC_CHECK_TYPE(ptrdiff_t, long)
 385 else
 386   AC_CHECK_TYPE(ptrdiff_t, int)
 387 fi
 388 ])
 389
 390 AC_DEFUN(BASH_TYPE_BITS64_T,
 391 [
 392 if test "$ac_sv_sizeof_char_p" = 8; then
 393   AC_CHECK_TYPE(bits64_t, char *)
 394 elif test "$ac_cv_sizeof_double" = 8; then
 395   AC_CHECK_TYPE(bits64_t, double)
 396 elif test "$ac_cv_sizeof_long" = 8; then
 397   AC_CHECK_TYPE(bits64_t, long)
 398 else
 399   AC_CHECK_TYPE(bits64_t, double)
 400 fi
 401 ])
 402
 403 AC_DEFUN(BASH_FUNC_STRSIGNAL,
 404 [AC_MSG_CHECKING([for the existence of strsignal])
 405 AC_CACHE_VAL(bash_cv_have_strsignal,
 406 [AC_TRY_LINK([#include <sys/types.h>
 407 #include <signal.h>],
 408 [char *s = (char *)strsignal(2);],
 409  bash_cv_have_strsignal=yes, bash_cv_have_strsignal=no)])
 410 AC_MSG_RESULT($bash_cv_have_strsignal)
 411 if test $bash_cv_have_strsignal = yes; then
 412 AC_DEFINE(HAVE_STRSIGNAL)
 413 fi
 414 ])
 415
 416 AC_DEFUN(BASH_FUNC_LSTAT,
 417 [dnl Cannot use AC_CHECK_FUNCS(lstat) because Linux defines lstat() as an
 418 dnl inline function in <sys/stat.h>.
 419 AC_CACHE_CHECK([for lstat], bash_cv_func_lstat,
 420 [AC_TRY_LINK([
 421 #include <sys/types.h>
 422 #include <sys/stat.h>
 423 ],[ lstat(".",(struct stat *)0); ],
 424 bash_cv_func_lstat=yes, bash_cv_func_lstat=no)])
 425 if test $bash_cv_func_lstat = yes; then
 426   AC_DEFINE(HAVE_LSTAT)
 427 fi
 428 ])
 429
 430 AC_DEFUN(BASH_STRUCT_TERMIOS_LDISC,
 431 [AC_MSG_CHECKING([for a c_line member of struct termios])
 432 AC_CACHE_VAL(bash_cv_termios_ldisc,
 433 [AC_TRY_COMPILE([#include <sys/types.h>
 434 #include <termios.h>],[struct termios t; int i; i = t.c_line;],
 435   bash_cv_termios_ldisc=yes, bash_cv_termios_ldisc=no)])dnl
 436 AC_MSG_RESULT($bash_cv_termios_ldisc)
 437 if test $bash_cv_termios_ldisc = yes; then
 438 AC_DEFINE(TERMIOS_LDISC)
 439 fi
 440 ])
 441
 442 AC_DEFUN(BASH_STRUCT_TERMIO_LDISC,
 443 [AC_MSG_CHECKING([for a c_line member of struct termio])
 444 AC_CACHE_VAL(bash_cv_termio_ldisc,
 445 [AC_TRY_COMPILE([#include <sys/types.h>
 446 #include <termio.h>],[struct termio t; int i; i = t.c_line;],
 447   bash_cv_termio_ldisc=yes, bash_cv_termio_ldisc=no)])dnl
 448 AC_MSG_RESULT($bash_cv_termio_ldisc)
 449 if test $bash_cv_termio_ldisc = yes; then
 450 AC_DEFINE(TERMIO_LDISC)
 451 fi
 452 ])
 453
 454 AC_DEFUN(BASH_FUNC_GETENV,
 455 [AC_MSG_CHECKING(to see if getenv can be redefined)
 456 AC_CACHE_VAL(bash_cv_getenv_redef,
 457 [AC_TRY_RUN([
 458 #ifdef HAVE_UNISTD_H
 459 #  include <unistd.h>
 460 #endif
 461 #ifndef __STDC__
 462 #  ifndef const
 463 #    define const
 464 #  endif
 465 #endif
 466 char *
 467 getenv (name)
 468 #if defined (__linux__) || defined (__bsdi__) || defined (convex)
 469      const char *name;
 470 #else
 471      char const *name;
 472 #endif /* !__linux__ && !__bsdi__ && !convex */
 473 {
 474 return "42";
 475 }
 476 main()
 477 {
 478 char *s;
 479 /* The next allows this program to run, but does not allow bash to link
 480    when it redefines getenv.  I'm not really interested in figuring out
 481    why not. */
 482 #if defined (NeXT)
 483 exit(1);
 484 #endif
 485 s = getenv("ABCDE");
 486 exit(s == 0);   /* force optimizer to leave getenv in */
 487 }
 488 ], bash_cv_getenv_redef=yes, bash_cv_getenv_redef=no,
 489    [AC_MSG_WARN(cannot check getenv redefinition if cross compiling -- defaulting to yes)
 490     bash_cv_getenv_redef=yes]
 491 )])
 492 AC_MSG_RESULT($bash_cv_getenv_redef)
 493 if test $bash_cv_getenv_redef = yes; then
 494 AC_DEFINE(CAN_REDEFINE_GETENV)
 495 fi
 496 ])
 497
 498 AC_DEFUN(BASH_FUNC_PRINTF,
 499 [AC_MSG_CHECKING(for declaration of printf in <stdio.h>)
 500 AC_CACHE_VAL(bash_cv_printf_declared,
 501 [AC_TRY_RUN([
 502 #include <stdio.h>
 503 #ifdef __STDC__
 504 typedef int (*_bashfunc)(const char *, ...);
 505 #else
 506 typedef int (*_bashfunc)();
 507 #endif
 508 main()
 509 {
 510 _bashfunc pf;
 511 pf = (_bashfunc) printf;
 512 exit(pf == 0);
 513 }
 514 ], bash_cv_printf_declared=yes, bash_cv_printf_declared=no,
 515    [AC_MSG_WARN(cannot check printf declaration if cross compiling -- defaulting to yes)
 516     bash_cv_printf_declared=yes]
 517 )])
 518 AC_MSG_RESULT($bash_cv_printf_declared)
 519 if test $bash_cv_printf_declared = yes; then
 520 AC_DEFINE(PRINTF_DECLARED)
 521 fi
 522 ])
 523
 524 AC_DEFUN(BASH_FUNC_ULIMIT_MAXFDS,
 525 [AC_MSG_CHECKING(whether ulimit can substitute for getdtablesize)
 526 AC_CACHE_VAL(bash_cv_ulimit_maxfds,
 527 [AC_TRY_RUN([
 528 main()
 529 {
 530 long maxfds = ulimit(4, 0L);
 531 exit (maxfds == -1L);
 532 }
 533 ], bash_cv_ulimit_maxfds=yes, bash_cv_ulimit_maxfds=no,
 534    [AC_MSG_WARN(cannot check ulimit if cross compiling -- defaulting to no)
 535     bash_cv_ulimit_maxfds=no]
 536 )])
 537 AC_MSG_RESULT($bash_cv_ulimit_maxfds)
 538 if test $bash_cv_ulimit_maxfds = yes; then
 539 AC_DEFINE(ULIMIT_MAXFDS)
 540 fi
 541 ])
 542
 543 AC_DEFUN(BASH_CHECK_LIB_TERMCAP,
 544 [
 545 if test "X$bash_cv_termcap_lib" = "X"; then
 546 _bash_needmsg=yes
 547 else
 548 AC_MSG_CHECKING(which library has the termcap functions)
 549 _bash_needmsg=
 550 fi
 551 AC_CACHE_VAL(bash_cv_termcap_lib,
 552 [AC_CHECK_LIB(termcap, tgetent, bash_cv_termcap_lib=libtermcap,
 553     [AC_CHECK_LIB(curses, tgetent, bash_cv_termcap_lib=libcurses,
 554         [AC_CHECK_LIB(ncurses, tgetent, bash_cv_termcap_lib=libncurses,
 555             bash_cv_termcap_lib=gnutermcap)])])])
 556 if test "X$_bash_needmsg" = "Xyes"; then
 557 AC_MSG_CHECKING(which library has the termcap functions)
 558 fi
 559 AC_MSG_RESULT(using $bash_cv_termcap_lib)
 560 if test $bash_cv_termcap_lib = gnutermcap && test -z "$prefer_curses"; then
 561 LDFLAGS="$LDFLAGS -L./lib/termcap"
 562 TERMCAP_LIB="./lib/termcap/libtermcap.a"
 563 TERMCAP_DEP="./lib/termcap/libtermcap.a"
 564 elif test $bash_cv_termcap_lib = libtermcap && test -z "$prefer_curses"; then
 565 TERMCAP_LIB=-ltermcap
 566 TERMCAP_DEP=
 567 elif test $bash_cv_termcap_lib = libncurses; then
 568 TERMCAP_LIB=-lncurses
 569 TERMCAP_DEP=
 570 else
 571 TERMCAP_LIB=-lcurses
 572 TERMCAP_DEP=
 573 fi
 574 ])
 575
 576 AC_DEFUN(BASH_FUNC_GETCWD,
 577 [AC_MSG_CHECKING([if getcwd() calls popen()])
 578 AC_CACHE_VAL(bash_cv_getcwd_calls_popen,
 579 [AC_TRY_RUN([
 580 #include <stdio.h>
 581 #ifdef HAVE_UNISTD_H
 582 #include <unistd.h>
 583 #endif
 584
 585 #ifndef __STDC__
 586 #ifndef const
 587 #define const
 588 #endif
 589 #endif
 590
 591 int popen_called;
 592
 593 FILE *
 594 popen(command, type)
 595      const char *command;
 596      const char *type;
 597 {
 598         popen_called = 1;
 599         return (FILE *)NULL;
 600 }
 601
 602 FILE *_popen(command, type)
 603      const char *command;
 604      const char *type;
 605 {
 606   return (popen (command, type));
 607 }
 608
 609 int
 610 pclose(stream)
 611 FILE *stream;
 612 {
 613         return 0;
 614 }
 615
 616 int
 617 _pclose(stream)
 618 FILE *stream;
 619 {
 620         return 0;
 621 }
 622
 623 main()
 624 {
 625         char    lbuf[32];
 626         popen_called = 0;
 627         getcwd(lbuf, 32);
 628         exit (popen_called);
 629 }
 630 ], bash_cv_getcwd_calls_popen=no, bash_cv_getcwd_calls_popen=yes,
 631    [AC_MSG_WARN(cannot check whether getcwd calls popen if cross compiling -- defaulting to no)
 632     bash_cv_getcwd_calls_popen=no]
 633 )])
 634 AC_MSG_RESULT($bash_cv_getcwd_calls_popen)
 635 if test $bash_cv_getcwd_calls_popen = yes; then
 636 AC_DEFINE(GETCWD_BROKEN)
 637 fi
 638 ])
 639
 640 AC_DEFUN(BASH_STRUCT_DIRENT_D_INO,
 641 [AC_REQUIRE([AC_HEADER_DIRENT])
 642 AC_MSG_CHECKING(if struct dirent has a d_ino member)
 643 AC_CACHE_VAL(bash_cv_dirent_has_dino,
 644 [AC_TRY_COMPILE([
 645 #include <stdio.h>
 646 #include <sys/types.h>
 647 #ifdef HAVE_UNISTD_H
 648 # include <unistd.h>
 649 #endif /* HAVE_UNISTD_H */
 650 #if defined(HAVE_DIRENT_H)
 651 # include <dirent.h>
 652 #else
 653 # define dirent direct
 654 # ifdef HAVE_SYS_NDIR_H
 655 #  include <sys/ndir.h>
 656 # endif /* SYSNDIR */
 657 # ifdef HAVE_SYS_DIR_H
 658 #  include <sys/dir.h>
 659 # endif /* SYSDIR */
 660 # ifdef HAVE_NDIR_H
 661 #  include <ndir.h>
 662 # endif
 663 #endif /* HAVE_DIRENT_H */
 664 ],[
 665 struct dirent d; int z; z = d.d_ino;
 666 ], bash_cv_dirent_has_dino=yes, bash_cv_dirent_has_dino=no)])
 667 AC_MSG_RESULT($bash_cv_dirent_has_dino)
 668 if test $bash_cv_dirent_has_dino = yes; then
 669 AC_DEFINE(STRUCT_DIRENT_HAS_D_INO)
 670 fi
 671 ])
 672
 673 AC_DEFUN(BASH_STRUCT_DIRENT_D_FILENO,
 674 [AC_REQUIRE([AC_HEADER_DIRENT])
 675 AC_MSG_CHECKING(if struct dirent has a d_fileno member)
 676 AC_CACHE_VAL(bash_cv_dirent_has_d_fileno,
 677 [AC_TRY_COMPILE([
 678 #include <stdio.h>
 679 #include <sys/types.h>
 680 #ifdef HAVE_UNISTD_H
 681 # include <unistd.h>
 682 #endif /* HAVE_UNISTD_H */
 683 #if defined(HAVE_DIRENT_H)
 684 # include <dirent.h>
 685 #else
 686 # define dirent direct
 687 # ifdef HAVE_SYS_NDIR_H
 688 #  include <sys/ndir.h>
 689 # endif /* SYSNDIR */
 690 # ifdef HAVE_SYS_DIR_H
 691 #  include <sys/dir.h>
 692 # endif /* SYSDIR */
 693 # ifdef HAVE_NDIR_H
 694 #  include <ndir.h>
 695 # endif
 696 #endif /* HAVE_DIRENT_H */
 697 ],[
 698 struct dirent d; int z; z = d.d_fileno;
 699 ], bash_cv_dirent_has_d_fileno=yes, bash_cv_dirent_has_d_fileno=no)])
 700 AC_MSG_RESULT($bash_cv_dirent_has_d_fileno)
 701 if test $bash_cv_dirent_has_d_fileno = yes; then
 702 AC_DEFINE(STRUCT_DIRENT_HAS_D_FILENO)
 703 fi
 704 ])
 705
 706 AC_DEFUN(BASH_REINSTALL_SIGHANDLERS,
 707 [AC_REQUIRE([AC_TYPE_SIGNAL])
 708 AC_REQUIRE([BASH_SIGNAL_CHECK])
 709 AC_MSG_CHECKING([if signal handlers must be reinstalled when invoked])
 710 AC_CACHE_VAL(bash_cv_must_reinstall_sighandlers,
 711 [AC_TRY_RUN([
 712 #include <signal.h>
 713 #ifdef HAVE_UNISTD_H
 714 #include <unistd.h>
 715 #endif
 716
 717 typedef RETSIGTYPE sigfunc();
 718
 719 int nsigint;
 720
 721 #ifdef HAVE_POSIX_SIGNALS
 722 sigfunc *
 723 set_signal_handler(sig, handler)
 724      int sig;
 725      sigfunc *handler;
 726 {
 727   struct sigaction act, oact;
 728   act.sa_handler = handler;
 729   act.sa_flags = 0;
 730   sigemptyset (&act.sa_mask);
 731   sigemptyset (&oact.sa_mask);
 732   sigaction (sig, &act, &oact);
 733   return (oact.sa_handler);
 734 }
 735 #else
 736 #define set_signal_handler(s, h) signal(s, h)
 737 #endif
 738
 739 RETSIGTYPE
 740 sigint(s)
 741 int s;
 742 {
 743   nsigint++;
 744 }
 745
 746 main()
 747 {
 748         nsigint = 0;
 749         set_signal_handler(SIGINT, sigint);
 750         kill((int)getpid(), SIGINT);
 751         kill((int)getpid(), SIGINT);
 752         exit(nsigint != 2);
 753 }
 754 ], bash_cv_must_reinstall_sighandlers=no, bash_cv_must_reinstall_sighandlers=yes,
 755    [AC_MSG_WARN(cannot check signal handling if cross compiling -- defaulting to no)
 756     bash_cv_must_reinstall_sighandlers=no]
 757 )])
 758 AC_MSG_RESULT($bash_cv_must_reinstall_sighandlers)
 759 if test $bash_cv_must_reinstall_sighandlers = yes; then
 760 AC_DEFINE(MUST_REINSTALL_SIGHANDLERS)
 761 fi
 762 ])
 763
 764 AC_DEFUN(BASH_FUNC_SBRK_DECLARED,
 765 [AC_MSG_CHECKING(for declaration of sbrk in <unistd.h>)
 766 AC_CACHE_VAL(bash_cv_sbrk_declared,
 767 [AC_EGREP_HEADER(sbrk, unistd.h,
 768  bash_cv_sbrk_declared=yes, bash_cv_sbrk_declared=no)])
 769 AC_MSG_RESULT($bash_cv_sbrk_declared)
 770 if test $bash_cv_sbrk_declared = yes; then
 771 AC_DEFINE(SBRK_DECLARED)
 772 fi
 773 ])
 774
 775 dnl check that some necessary job control definitions are present
 776 AC_DEFUN(BASH_JOB_CONTROL_MISSING,
 777 [AC_REQUIRE([BASH_SIGNAL_CHECK])
 778 AC_MSG_CHECKING(for presence of necessary job control definitions)
 779 AC_CACHE_VAL(bash_cv_job_control_missing,
 780 [AC_TRY_RUN([
 781 #include <sys/types.h>
 782 #ifdef HAVE_SYS_WAIT_H
 783 #include <sys/wait.h>
 784 #endif
 785 #ifdef HAVE_UNISTD_H
 786 #include <unistd.h>
 787 #endif
 788 #include <signal.h>
 789
 790 /* Add more tests in here as appropriate. */
 791 main()
 792 {
 793 /* signal type */
 794 #if !defined (HAVE_POSIX_SIGNALS) && !defined (HAVE_BSD_SIGNALS)
 795 exit(1);
 796 #endif
 797
 798 /* signals and tty control. */
 799 #if !defined (SIGTSTP) || !defined (SIGSTOP) || !defined (SIGCONT)
 800 exit (1);
 801 #endif
 802
 803 /* process control */
 804 #if !defined (WNOHANG) || !defined (WUNTRACED)
 805 exit(1);
 806 #endif
 807
 808 /* Posix systems have tcgetpgrp and waitpid. */
 809 #if defined (_POSIX_VERSION) && !defined (HAVE_TCGETPGRP)
 810 exit(1);
 811 #endif
 812
 813 #if defined (_POSIX_VERSION) && !defined (HAVE_WAITPID)
 814 exit(1);
 815 #endif
 816
 817 /* Other systems have TIOCSPGRP/TIOCGPRGP and wait3. */
 818 #if !defined (_POSIX_VERSION) && !defined (HAVE_WAIT3)
 819 exit(1);
 820 #endif
 821
 822 exit(0);
 823 }], bash_cv_job_control_missing=present, bash_cv_job_control_missing=missing,
 824     [AC_MSG_WARN(cannot check job control if cross-compiling -- defaulting to missing)
 825      bash_cv_job_control_missing=missing]
 826 )])
 827 AC_MSG_RESULT($bash_cv_job_control_missing)
 828 if test $bash_cv_job_control_missing = missing; then
 829 AC_DEFINE(JOB_CONTROL_MISSING)
 830 fi
 831 ])
 832
 833 dnl check whether named pipes are present
 834 dnl this requires a previous check for mkfifo, but that is awkward to specify
 835 AC_DEFUN(BASH_SYS_NAMED_PIPES,
 836 [AC_MSG_CHECKING(for presence of named pipes)
 837 AC_CACHE_VAL(bash_cv_sys_named_pipes,
 838 [AC_TRY_RUN([
 839 #include <sys/types.h>
 840 #include <sys/stat.h>
 841 #ifdef HAVE_UNISTD_H
 842 #include <unistd.h>
 843 #endif
 844
 845 /* Add more tests in here as appropriate. */
 846 main()
 847 {
 848 int fd;
 849
 850 #if defined (HAVE_MKFIFO)
 851 exit (0);
 852 #endif
 853
 854 #if !defined (S_IFIFO) && (defined (_POSIX_VERSION) && !defined (S_ISFIFO))
 855 exit (1);
 856 #endif
 857
 858 #if defined (NeXT)
 859 exit (1);
 860 #endif
 861
 862 fd = mknod ("/tmp/sh-np-autoconf", 0666 | S_IFIFO, 0);
 863 if (fd == -1)
 864   exit (1);
 865 close(fd);
 866 unlink ("/tmp/sh-np-autoconf");
 867 exit(0);
 868 }], bash_cv_sys_named_pipes=present, bash_cv_sys_named_pipes=missing,
 869     [AC_MSG_WARN(cannot check for named pipes if cross-compiling -- defaulting to missing)
 870      bash_cv_sys_named_pipes=missing]
 871 )])
 872 AC_MSG_RESULT($bash_cv_sys_named_pipes)
 873 if test $bash_cv_sys_named_pipes = missing; then
 874 AC_DEFINE(NAMED_PIPES_MISSING)
 875 fi
 876 ])
 877
 878 AC_DEFUN(BASH_FUNC_POSIX_SETJMP,
 879 [AC_REQUIRE([BASH_SIGNAL_CHECK])
 880 AC_MSG_CHECKING(for presence of POSIX-style sigsetjmp/siglongjmp)
 881 AC_CACHE_VAL(bash_cv_func_sigsetjmp,
 882 [AC_TRY_RUN([
 883 #ifdef HAVE_UNISTD_H
 884 #include <unistd.h>
 885 #endif
 886 #include <sys/types.h>
 887 #include <signal.h>
 888 #include <setjmp.h>
 889
 890 main()
 891 {
 892 #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
 893 exit (1);
 894 #else
 895
 896 int code;
 897 sigset_t set, oset;
 898 sigjmp_buf xx;
 899
 900 /* get the mask */
 901 sigemptyset(&set);
 902 sigemptyset(&oset);
 903 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &set);
 904 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset);
 905
 906 /* save it */
 907 code = sigsetjmp(xx, 1);
 908 if (code)
 909   exit(0);      /* could get sigmask and compare to oset here. */
 910
 911 /* change it */
 912 sigaddset(&set, SIGINT);
 913 sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL);
 914
 915 /* and siglongjmp */
 916 siglongjmp(xx, 10);
 917 exit(1);
 918 #endif
 919 }], bash_cv_func_sigsetjmp=present, bash_cv_func_sigsetjmp=missing,
 920     [AC_MSG_WARN(cannot check for sigsetjmp/siglongjmp if cross-compiling -- defaulting to missing)
 921      bash_cv_func_sigsetjmp=missing]
 922 )])
 923 AC_MSG_RESULT($bash_cv_func_sigsetjmp)
 924 if test $bash_cv_func_sigsetjmp = present; then
 925 AC_DEFINE(HAVE_POSIX_SIGSETJMP)
 926 fi
 927 ])
 928
 929 AC_DEFUN(BASH_HAVE_TIOCGWINSZ,
 930 [AC_MSG_CHECKING(for TIOCGWINSZ in sys/ioctl.h)
 931 AC_CACHE_VAL(bash_cv_tiocgwinsz_in_ioctl,
 932 [AC_TRY_COMPILE([#include <sys/types.h>
 933 #include <sys/ioctl.h>], [int x = TIOCGWINSZ;],
 934   bash_cv_tiocgwinsz_in_ioctl=yes,bash_cv_tiocgwinsz_in_ioctl=no)])
 935 AC_MSG_RESULT($bash_cv_tiocgwinsz_in_ioctl)
 936 if test $bash_cv_tiocgwinsz_in_ioctl = yes; then
 937 AC_DEFINE(GWINSZ_IN_SYS_IOCTL)
 938 fi
 939 ])
 940
 941 AC_DEFUN(BASH_STRUCT_WINSIZE,
 942 [AC_MSG_CHECKING(for struct winsize in sys/ioctl.h and termios.h)
 943 AC_CACHE_VAL(bash_cv_struct_winsize_header,
 944 [AC_TRY_COMPILE([#include <sys/types.h>
 945 #include <sys/ioctl.h>], [struct winsize x;],
 946   bash_cv_struct_winsize_header=ioctl_h,
 947   [AC_TRY_COMPILE([#include <sys/types.h>
 948 #include <termios.h>], [struct winsize x;],
 949   bash_cv_struct_winsize_header=termios_h, bash_cv_struct_winsize_header=other)
 950 ])])
 951 if test $bash_cv_struct_winsize_header = ioctl_h; then
 952   AC_MSG_RESULT(sys/ioctl.h)
 953   AC_DEFINE(STRUCT_WINSIZE_IN_SYS_IOCTL)
 954 elif test $bash_cv_struct_winsize_header = termios_h; then
 955   AC_MSG_RESULT(termios.h)
 956   AC_DEFINE(STRUCT_WINSIZE_IN_TERMIOS)
 957 else
 958   AC_MSG_RESULT(not found)
 959 fi
 960 ])
 961
 962 AC_DEFUN(BASH_HAVE_TIOCSTAT,
 963 [AC_MSG_CHECKING(for TIOCSTAT in sys/ioctl.h)
 964 AC_CACHE_VAL(bash_cv_tiocstat_in_ioctl,
 965 [AC_TRY_COMPILE([#include <sys/types.h>
 966 #include <sys/ioctl.h>], [int x = TIOCSTAT;],
 967   bash_cv_tiocstat_in_ioctl=yes,bash_cv_tiocstat_in_ioctl=no)])
 968 AC_MSG_RESULT($bash_cv_tiocstat_in_ioctl)
 969 if test $bash_cv_tiocstat_in_ioctl = yes; then
 970 AC_DEFINE(TIOCSTAT_IN_SYS_IOCTL)
 971 fi
 972 ])
 973
 974 AC_DEFUN(BASH_HAVE_FIONREAD,
 975 [AC_MSG_CHECKING(for FIONREAD in sys/ioctl.h)
 976 AC_CACHE_VAL(bash_cv_fionread_in_ioctl,
 977 [AC_TRY_COMPILE([#include <sys/types.h>
 978 #include <sys/ioctl.h>], [int x = FIONREAD;],
 979   bash_cv_fionread_in_ioctl=yes,bash_cv_fionread_in_ioctl=no)])
 980 AC_MSG_RESULT($bash_cv_fionread_in_ioctl)
 981 if test $bash_cv_fionread_in_ioctl = yes; then
 982 AC_DEFINE(FIONREAD_IN_SYS_IOCTL)
 983 fi
 984 ])
 985
 986 dnl
 987 dnl See if speed_t is declared in <sys/types.h>.  Some versions of linux
 988 dnl require a definition of speed_t each time <termcap.h> is included,
 989 dnl but you can only get speed_t if you include <termios.h> (on some
 990 dnl versions) or <sys/types.h> (on others).
 991 dnl
 992 AC_DEFUN(BASH_MISC_SPEED_T,
 993 [AC_MSG_CHECKING(for speed_t in sys/types.h)
 994 AC_CACHE_VAL(bash_cv_speed_t_in_sys_types,
 995 [AC_TRY_COMPILE([#include <sys/types.h>], [speed_t x;],
 996   bash_cv_speed_t_in_sys_types=yes,bash_cv_speed_t_in_sys_types=no)])
 997 AC_MSG_RESULT($bash_cv_speed_t_in_sys_types)
 998 if test $bash_cv_speed_t_in_sys_types = yes; then
 999 AC_DEFINE(SPEED_T_IN_SYS_TYPES)
1000 fi
1001 ])
1002
1003 AC_DEFUN(BASH_CHECK_GETPW_FUNCS,
1004 [AC_MSG_CHECKING(whether programs are able to redeclare getpw functions)
1005 AC_CACHE_VAL(bash_cv_can_redecl_getpw,
1006 [AC_TRY_COMPILE([#include <sys/types.h>
1007 #include <pwd.h>
1008 extern struct passwd *getpwent();
1009 extern struct passwd *getpwuid();
1010 extern struct passwd *getpwnam();],
1011 [struct passwd *z; z = getpwent(); z = getpwuid(0); z = getpwnam("root");],
1012   bash_cv_can_redecl_getpw=yes,bash_cv_can_redecl_getpw=no)])
1013 AC_MSG_RESULT($bash_cv_can_redecl_getpw)
1014 if test $bash_cv_can_redecl_getpw = no; then
1015 AC_DEFINE(HAVE_GETPW_DECLS)
1016 fi
1017 ])
1018
1019 AC_DEFUN(BASH_CHECK_DEV_FD,
1020 [AC_MSG_CHECKING(whether /dev/fd is available)
1021 AC_CACHE_VAL(bash_cv_dev_fd,
1022 [if test -d /dev/fd  && test -r /dev/fd/0; then
1023    bash_cv_dev_fd=standard
1024  elif test -d /proc/self/fd && test -r /proc/self/fd/0; then
1025    bash_cv_dev_fd=whacky
1026  else
1027    bash_cv_dev_fd=absent
1028  fi
1029 ])
1030 AC_MSG_RESULT($bash_cv_dev_fd)
1031 if test $bash_cv_dev_fd = "standard"; then
1032   AC_DEFINE(HAVE_DEV_FD)
1033   AC_DEFINE(DEV_FD_PREFIX, "/dev/fd/")
1034 elif test $bash_cv_dev_fd = "whacky"; then
1035   AC_DEFINE(HAVE_DEV_FD)
1036   AC_DEFINE(DEV_FD_PREFIX, "/proc/self/fd/")
1037 fi
1038 ])
1039
1040 dnl
1041 dnl Check for the presence of getpeername (the only networking function
1042 dnl bash currently requires) in libsocket.  If libsocket is present,
1043 dnl check for libnsl and add it to LIBS if it's there, since most
1044 dnl systems with libsocket require linking with libnsl as well.
1045 dnl This should only be called if getpeername was not found in libc.
1046 dnl
1047 AC_DEFUN(BASH_CHECK_SOCKLIB,
1048 [
1049 if test "X$bash_cv_have_socklib" = "X"; then
1050 _bash_needmsg=
1051 else
1052 AC_MSG_CHECKING(for socket library)
1053 _bash_needmsg=yes
1054 fi
1055 AC_CACHE_VAL(bash_cv_have_socklib,
1056 [AC_CHECK_LIB(socket, getpeername,
1057         bash_cv_have_socklib=yes, bash_cv_have_socklib=no, -lnsl)])
1058 if test "X$_bash_needmsg" = Xyes; then
1059   AC_MSG_RESULT($bash_cv_have_socklib)
1060   _bash_needmsg=
1061 fi
1062 if test $bash_cv_have_socklib = yes; then
1063   # check for libnsl, add it to LIBS if present
1064   if test "X$bash_cv_have_libnsl" = "X"; then
1065     _bash_needmsg=
1066   else
1067     AC_MSG_CHECKING(for libnsl)
1068     _bash_needmsg=yes
1069   fi
1070   AC_CACHE_VAL(bash_cv_have_libnsl,
1071            [AC_CHECK_LIB(nsl, t_open,
1072                  bash_cv_have_libnsl=yes, bash_cv_have_libnsl=no)])
1073   if test "X$_bash_needmsg" = Xyes; then
1074     AC_MSG_RESULT($bash_cv_have_libnsl)
1075     _bash_needmsg=
1076   fi
1077   if test $bash_cv_have_libnsl = yes; then
1078     LIBS="-lsocket -lnsl $LIBS"
1079   else
1080     LIBS="-lsocket $LIBS"
1081   fi
1082   AC_DEFINE(HAVE_LIBSOCKET)
1083   AC_DEFINE(HAVE_GETPEERNAME)
1084 fi
1085 ])
1086
1087 AC_DEFUN(BASH_DEFAULT_MAIL_DIR,
1088 [AC_MSG_CHECKING(for default mail directory)
1089 AC_CACHE_VAL(bash_cv_mail_dir,
1090 [if test -d /var/mail; then
1091    bash_cv_mail_dir=/var/mail
1092  elif test -d /usr/mail; then
1093    bash_cv_mail_dir=/usr/mail
1094  elif test -d /var/spool/mail; then
1095    bash_cv_mail_dir=/var/spool/mail
1096  elif test -d /usr/spool/mail; then
1097    bash_cv_mail_dir=/usr/spool/mail
1098  else
1099    bash_cv_mail_dir=unknown
1100  fi
1101 ])
1102 AC_MSG_RESULT($bash_cv_mail_dir)
1103 if test $bash_cv_mail_dir = "/var/mail"; then
1104    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/mail")
1105 elif test $bash_cv_mail_dir = "/usr/mail"; then
1106    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/mail")
1107 elif test $bash_cv_mail_dir = "/var/spool/mail"; then
1108    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/spool/mail")
1109 elif test $bash_cv_mail_dir = "/usr/spool/mail"; then
1110    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/spool/mail")
1111 else
1112    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "unknown")
1113 fi
1114 ])
1115
1116 dnl
1117 dnl Check if HPUX needs _KERNEL defined for RLIMIT_* definitions
1118 dnl
1119 AC_DEFUN(BASH_KERNEL_RLIMIT_CHECK,
1120 [AC_MSG_CHECKING([whether $host_os needs _KERNEL for RLIMIT defines])
1121 AC_CACHE_VAL(bash_cv_kernel_rlimit,
1122 [AC_TRY_COMPILE([
1123 #include <sys/types.h>
1124 #include <sys/resource.h>
1125 ],
1126 [
1127   int f;
1128   f = RLIMIT_DATA;
1129 ], bash_cv_kernel_rlimit=no,
1130 [AC_TRY_COMPILE([
1131 #include <sys/types.h>
1132 #define _KERNEL
1133 #include <sys/resource.h>
1134 #undef _KERNEL
1135 ],
1136 [
1137         int f;
1138         f = RLIMIT_DATA;
1139 ], bash_cv_kernel_rlimit=yes, bash_cv_kernel_rlimit=no)]
1140 )])
1141 AC_MSG_RESULT($bash_cv_kernel_rlimit)
1142 if test $bash_cv_kernel_rlimit = yes; then
1143 AC_DEFINE(RLIMIT_NEEDS_KERNEL)
1144 fi
1145 ])
1146
1147 AC_DEFUN(BASH_FUNC_STRCOLL,
1148 [
1149 AC_MSG_CHECKING(whether or not strcoll and strcmp differ)
1150 AC_CACHE_VAL(bash_cv_func_strcoll_broken,
1151 [AC_TRY_RUN([
1152 #include <stdio.h>
1153 #if defined (HAVE_LOCALE_H)
1154 #include <locale.h>
1155 #endif
1156
1157 main(c, v)
1158 int     c;
1159 char    *v[];
1160 {
1161         int     r1, r2;
1162         char    *deflocale, *defcoll;
1163
1164 #ifdef HAVE_SETLOCALE
1165         deflocale = setlocale(LC_ALL, "");
1166         defcoll = setlocale(LC_COLLATE, "");
1167 #endif
1168
1169 #ifdef HAVE_STRCOLL
1170         /* These two values are taken from tests/glob-test. */
1171         r1 = strcoll("abd", "aXd");
1172 #else
1173         r1 = 0;
1174 #endif
1175         r2 = strcmp("abd", "aXd");
1176
1177         /* These two should both be greater than 0.  It is permissible for
1178            a system to return different values, as long as the sign is the
1179            same. */
1180
1181         /* Exit with 1 (failure) if these two values are both > 0, since
1182            this tests whether strcoll(3) is broken with respect to strcmp(3)
1183            in the default locale. */
1184         exit (r1 > 0 && r2 > 0);
1185 }
1186 ], bash_cv_func_strcoll_broken=yes, bash_cv_func_strcoll_broken=no,
1187    [AC_MSG_WARN(cannot check strcoll if cross compiling -- defaulting to no)
1188     bash_cv_func_strcoll_broken=no]
1189 )])
1190 AC_MSG_RESULT($bash_cv_func_strcoll_broken)
1191 if test $bash_cv_func_strcoll_broken = yes; then
1192 AC_DEFINE(STRCOLL_BROKEN)
1193 fi
1194 ])
1195
1196 dnl
1197 dnl If available, use support for large files unless the user specified
1198 dnl one of the CPPFLAGS, LDFLAGS, or LIBS variables (<eggert@twinsun.com>
1199 dnl via GNU patch 2.5)
1200 dnl
1201 AC_DEFUN(BASH_LARGE_FILE_SUPPORT,
1202 [AC_MSG_CHECKING(whether large file support needs explicit enabling)
1203 ac_getconfs=''
1204 ac_result=yes
1205 ac_set=''
1206 ac_shellvars='CPPFLAGS LDFLAGS LIBS'
1207 for ac_shellvar in $ac_shellvars; do
1208   case $ac_shellvar in
1209   CPPFLAGS) ac_lfsvar=LFS_CFLAGS ac_lfs64var=LFS64_CFLAGS ;;
1210   *) ac_lfsvar=LFS_$ac_shellvar ac_lfs64var=LFS64_$ac_shellvar ;;
1211   esac
1212   eval test '"${'$ac_shellvar'+set}"' = set && ac_set=$ac_shellvar
1213   (getconf $ac_lfsvar) >/dev/null 2>&1 || { ac_result=no; break; }
1214   ac_getconf=`getconf $ac_lfsvar`
1215   ac_getconf64=`getconf $ac_lfs64var`
1216   ac_getconfs=$ac_getconfs$ac_getconf\ $ac_getconf64
1217   eval ac_test_$ac_shellvar="\$ac_getconf\ \$ac_getconf64"
1218 done
1219 case "$ac_result$ac_getconfs" in
1220 yes) ac_result=no ;;
1221 esac
1222 case "$ac_result$ac_set" in
1223 yes?*) ac_result="yes, but $ac_set is already set, so use its settings"
1224 esac
1225 AC_MSG_RESULT($ac_result)
1226 case $ac_result in
1227 yes)
1228   for ac_shellvar in $ac_shellvars; do
1229     eval $ac_shellvar=\$ac_test_$ac_shellvar
1230   done ;;
1231 esac
1232 ])
1233
1234 dnl
1235 dnl AC_SYS_RESTARTABLE_SYSCALLS tests only for restarted system calls
1236 dnl after a signal handler has been installed with signal().  Since
1237 dnl Bash uses sigaction() if it is available, we need to check whether
1238 dnl or not a signal handler installed with sigaction and SA_RESTART
1239 dnl causes system calls to be restarted after the signal is caught
1240 dnl
1241 AC_DEFUN(BASH_SYS_RESTARTABLE_SYSCALLS,
1242 [AC_REQUIRE([BASH_SIGNAL_CHECK])
1243 AC_CACHE_CHECK(for restartable system calls with posix sigaction,
1244 bash_cv_sys_restartable_syscalls,
1245 [AC_TRY_RUN(
1246 [/* Exit 0 (true) if wait returns something other than -1,
1247    i.e. the pid of the child, which means that wait was restarted
1248    after getting the signal.  */
1249 #include <sys/types.h>
1250 #include <signal.h>
1251 static int caught = 0;
1252 void ucatch (isig) int isig; { caught = 1; }
1253 main ()
1254 {
1255 #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
1256   exit (1);
1257 #else
1258   struct sigaction act, oact;
1259   int i, status;
1260
1261   act.sa_handler = ucatch;
1262   /* Might want to add SA_RESTART here, but bash's set_signal_handler
1263      does not. */
1264   act.sa_flags = 0;
1265   sigemptyset(&act.sa_mask);
1266   sigemptyset(&oact.sa_mask);
1267   i = fork ();
1268   /* A possible race condition here, but in practice it never happens. */
1269   if (i == 0) { sleep (3); kill (getppid (), SIGINT); sleep (3); exit (0); }
1270   sigaction(SIGINT, &act, &oact);
1271   status = wait(&i);
1272   if (status == -1) wait(&i);
1273   exit (status == -1);
1274 #endif
1275 }
1276 ], bash_cv_sys_restartable_syscalls=yes, bash_cv_sys_restartable_syscalls=no,
1277    AC_MSG_WARN(cannot check restartable syscalls if cross compiling))
1278 ])
1279 if test $bash_cv_sys_restartable_syscalls = yes; then
1280   AC_DEFINE(HAVE_RESTARTABLE_SYSCALLS)
1281 fi
1282 ])
1283 dnl
1284 dnl Check for 64-bit off_t -- used for malloc alignment
1285 dnl
1286 dnl C does not allow duplicate case labels, so the compile will fail if
1287 dnl sizeof(off_t) is > 4.
1288 dnl
1289 AC_DEFUN(BASH_CHECK_OFF_T_64,
1290 [AC_CACHE_CHECK(for 64-bit off_t, bash_cv_off_t_64,
1291 AC_TRY_COMPILE([
1292 #ifdef HAVE_UNISTD_H
1293 #include <unistd.h>
1294 #endif
1295 #include <sys/types.h>
1296 ],[
1297 switch (0) case 0: case (sizeof (off_t) <= 4):;
1298 ], bash_cv_off_t_64=no, bash_cv_off_t_64=yes))
1299 if test $bash_cv_off_t_64 = yes; then
1300         AC_DEFINE(HAVE_OFF_T_64)
1301 fi])