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, err;
 320 err = mkdir("/tmp/bash-aclocal", 0700);
 321 if (err < 0) {
 322   perror("mkdir");
 323   exit(1);
 324 }
 325 unlink("/tmp/bash-aclocal/not_a_directory");
 326 fd = open("/tmp/bash-aclocal/not_a_directory", O_WRONLY|O_CREAT|O_EXCL, 0666);
 327 write(fd, "\n", 1);
 328 close(fd);
 329 dir = opendir("/tmp/bash-aclocal/not_a_directory");
 330 unlink("/tmp/bash-aclocal/not_a_directory");
 331 rmdir("/tmp/bash-aclocal");
 332 exit (dir == 0);
 333 }], bash_cv_opendir_not_robust=yes,bash_cv_opendir_not_robust=no,
 334     [AC_MSG_WARN(cannot check opendir if cross compiling -- defaulting to no)
 335      bash_cv_opendir_not_robust=no]
 336 )])
 337 AC_MSG_RESULT($bash_cv_opendir_not_robust)
 338 if test $bash_cv_opendir_not_robust = yes; then
 339 AC_DEFINE(OPENDIR_NOT_ROBUST)
 340 fi
 341 ])
 342
 343 dnl
 344 AC_DEFUN(BASH_TYPE_SIGHANDLER,
 345 [AC_MSG_CHECKING([whether signal handlers are of type void])
 346 AC_CACHE_VAL(bash_cv_void_sighandler,
 347 [AC_TRY_COMPILE([#include <sys/types.h>
 348 #include <signal.h>
 349 #ifdef signal
 350 #undef signal
 351 #endif
 352 #ifdef __cplusplus
 353 extern "C"
 354 #endif
 355 void (*signal ()) ();],
 356 [int i;], bash_cv_void_sighandler=yes, bash_cv_void_sighandler=no)])dnl
 357 AC_MSG_RESULT($bash_cv_void_sighandler)
 358 if test $bash_cv_void_sighandler = yes; then
 359 AC_DEFINE(VOID_SIGHANDLER)
 360 fi
 361 ])
 362
 363 dnl
 364 dnl A signed 16-bit integer quantity
 365 dnl
 366 AC_DEFUN(BASH_TYPE_BITS16_T,
 367 [
 368 if test "$ac_cv_sizeof_short" = 2; then
 369   AC_CHECK_TYPE(bits16_t, short)
 370 elif test "$ac_cv_sizeof_char" = 2; then
 371   AC_CHECK_TYPE(bits16_t, char)
 372 else
 373   AC_CHECK_TYPE(bits16_t, short)
 374 fi
 375 ])
 376
 377 dnl
 378 dnl An unsigned 16-bit integer quantity
 379 dnl
 380 AC_DEFUN(BASH_TYPE_U_BITS16_T,
 381 [
 382 if test "$ac_cv_sizeof_short" = 2; then
 383   AC_CHECK_TYPE(u_bits16_t, unsigned short)
 384 elif test "$ac_cv_sizeof_char" = 2; then
 385   AC_CHECK_TYPE(u_bits16_t, unsigned char)
 386 else
 387   AC_CHECK_TYPE(u_bits16_t, unsigned short)
 388 fi
 389 ])
 390
 391 dnl
 392 dnl A signed 32-bit integer quantity
 393 dnl
 394 AC_DEFUN(BASH_TYPE_BITS32_T,
 395 [
 396 if test "$ac_cv_sizeof_int" = 4; then
 397   AC_CHECK_TYPE(bits32_t, int)
 398 elif test "$ac_cv_sizeof_long" = 4; then
 399   AC_CHECK_TYPE(bits32_t, long)
 400 else
 401   AC_CHECK_TYPE(bits32_t, int)
 402 fi
 403 ])
 404
 405 dnl
 406 dnl An unsigned 32-bit integer quantity
 407 dnl
 408 AC_DEFUN(BASH_TYPE_U_BITS32_T,
 409 [
 410 if test "$ac_cv_sizeof_int" = 4; then
 411   AC_CHECK_TYPE(u_bits32_t, unsigned int)
 412 elif test "$ac_cv_sizeof_long" = 4; then
 413   AC_CHECK_TYPE(u_bits32_t, unsigned long)
 414 else
 415   AC_CHECK_TYPE(u_bits32_t, unsigned int)
 416 fi
 417 ])
 418
 419 AC_DEFUN(BASH_TYPE_PTRDIFF_T,
 420 [
 421 if test "$ac_cv_sizeof_int" = "$ac_cv_sizeof_char_p"; then
 422   AC_CHECK_TYPE(ptrdiff_t, int)
 423 elif test "$ac_cv_sizeof_long" = "$ac_cv_sizeof_char_p"; then
 424   AC_CHECK_TYPE(ptrdiff_t, long)
 425 else
 426   AC_CHECK_TYPE(ptrdiff_t, int)
 427 fi
 428 ])
 429
 430 dnl
 431 dnl A signed 64-bit quantity
 432 dnl
 433 AC_DEFUN(BASH_TYPE_BITS64_T,
 434 [
 435 if test "$ac_sv_sizeof_char_p" = 8; then
 436   AC_CHECK_TYPE(bits64_t, char *)
 437 elif test "$ac_cv_sizeof_double" = 8; then
 438   AC_CHECK_TYPE(bits64_t, double)
 439 elif test "$ac_cv_sizeof_long" = 8; then
 440   AC_CHECK_TYPE(bits64_t, long)
 441 else
 442   AC_CHECK_TYPE(bits64_t, double)
 443 fi
 444 ])
 445
 446 AC_DEFUN(BASH_FUNC_STRSIGNAL,
 447 [AC_MSG_CHECKING([for the existence of strsignal])
 448 AC_CACHE_VAL(bash_cv_have_strsignal,
 449 [AC_TRY_LINK([#include <sys/types.h>
 450 #include <signal.h>],
 451 [char *s = (char *)strsignal(2);],
 452  bash_cv_have_strsignal=yes, bash_cv_have_strsignal=no)])
 453 AC_MSG_RESULT($bash_cv_have_strsignal)
 454 if test $bash_cv_have_strsignal = yes; then
 455 AC_DEFINE(HAVE_STRSIGNAL)
 456 fi
 457 ])
 458
 459 AC_DEFUN(BASH_FUNC_LSTAT,
 460 [dnl Cannot use AC_CHECK_FUNCS(lstat) because Linux defines lstat() as an
 461 dnl inline function in <sys/stat.h>.
 462 AC_CACHE_CHECK([for lstat], bash_cv_func_lstat,
 463 [AC_TRY_LINK([
 464 #include <sys/types.h>
 465 #include <sys/stat.h>
 466 ],[ lstat(".",(struct stat *)0); ],
 467 bash_cv_func_lstat=yes, bash_cv_func_lstat=no)])
 468 if test $bash_cv_func_lstat = yes; then
 469   AC_DEFINE(HAVE_LSTAT)
 470 fi
 471 ])
 472
 473 AC_DEFUN(BASH_FUNC_INET_ATON,
 474 [
 475 AC_CACHE_CHECK([for inet_aton], bash_cv_func_inet_aton,
 476 [AC_TRY_LINK([
 477 #include <sys/types.h>
 478 #include <netinet/in.h>
 479 #include <arpa/inet.h>
 480 struct in_addr ap;], [ inet_aton("127.0.0.1", &ap); ],
 481 bash_cv_func_inet_aton=yes, bash_cv_func_inet_aton=no)])
 482 if test $bash_cv_func_inet_aton = yes; then
 483   AC_DEFINE(HAVE_INET_ATON)
 484 fi
 485 ])
 486
 487 AC_DEFUN(BASH_STRUCT_TERMIOS_LDISC,
 488 [AC_MSG_CHECKING([for a c_line member of struct termios])
 489 AC_CACHE_VAL(bash_cv_termios_ldisc,
 490 [AC_TRY_COMPILE([#include <sys/types.h>
 491 #include <termios.h>],[struct termios t; int i; i = t.c_line;],
 492   bash_cv_termios_ldisc=yes, bash_cv_termios_ldisc=no)])dnl
 493 AC_MSG_RESULT($bash_cv_termios_ldisc)
 494 if test $bash_cv_termios_ldisc = yes; then
 495 AC_DEFINE(TERMIOS_LDISC)
 496 fi
 497 ])
 498
 499 AC_DEFUN(BASH_STRUCT_TERMIO_LDISC,
 500 [AC_MSG_CHECKING([for a c_line member of struct termio])
 501 AC_CACHE_VAL(bash_cv_termio_ldisc,
 502 [AC_TRY_COMPILE([#include <sys/types.h>
 503 #include <termio.h>],[struct termio t; int i; i = t.c_line;],
 504   bash_cv_termio_ldisc=yes, bash_cv_termio_ldisc=no)])dnl
 505 AC_MSG_RESULT($bash_cv_termio_ldisc)
 506 if test $bash_cv_termio_ldisc = yes; then
 507 AC_DEFINE(TERMIO_LDISC)
 508 fi
 509 ])
 510
 511 AC_DEFUN(BASH_FUNC_GETENV,
 512 [AC_MSG_CHECKING(to see if getenv can be redefined)
 513 AC_CACHE_VAL(bash_cv_getenv_redef,
 514 [AC_TRY_RUN([
 515 #ifdef HAVE_UNISTD_H
 516 #  include <unistd.h>
 517 #endif
 518 #ifndef __STDC__
 519 #  ifndef const
 520 #    define const
 521 #  endif
 522 #endif
 523 char *
 524 getenv (name)
 525 #if defined (__linux__) || defined (__bsdi__) || defined (convex)
 526      const char *name;
 527 #else
 528      char const *name;
 529 #endif /* !__linux__ && !__bsdi__ && !convex */
 530 {
 531 return "42";
 532 }
 533 main()
 534 {
 535 char *s;
 536 /* The next allows this program to run, but does not allow bash to link
 537    when it redefines getenv.  I'm not really interested in figuring out
 538    why not. */
 539 #if defined (NeXT)
 540 exit(1);
 541 #endif
 542 s = getenv("ABCDE");
 543 exit(s == 0);   /* force optimizer to leave getenv in */
 544 }
 545 ], bash_cv_getenv_redef=yes, bash_cv_getenv_redef=no,
 546    [AC_MSG_WARN(cannot check getenv redefinition if cross compiling -- defaulting to yes)
 547     bash_cv_getenv_redef=yes]
 548 )])
 549 AC_MSG_RESULT($bash_cv_getenv_redef)
 550 if test $bash_cv_getenv_redef = yes; then
 551 AC_DEFINE(CAN_REDEFINE_GETENV)
 552 fi
 553 ])
 554
 555 AC_DEFUN(BASH_FUNC_PRINTF,
 556 [AC_MSG_CHECKING(for declaration of printf in <stdio.h>)
 557 AC_CACHE_VAL(bash_cv_printf_declared,
 558 [AC_TRY_RUN([
 559 #include <stdio.h>
 560 #ifdef __STDC__
 561 typedef int (*_bashfunc)(const char *, ...);
 562 #else
 563 typedef int (*_bashfunc)();
 564 #endif
 565 main()
 566 {
 567 _bashfunc pf;
 568 pf = (_bashfunc) printf;
 569 exit(pf == 0);
 570 }
 571 ], bash_cv_printf_declared=yes, bash_cv_printf_declared=no,
 572    [AC_MSG_WARN(cannot check printf declaration if cross compiling -- defaulting to yes)
 573     bash_cv_printf_declared=yes]
 574 )])
 575 AC_MSG_RESULT($bash_cv_printf_declared)
 576 if test $bash_cv_printf_declared = yes; then
 577 AC_DEFINE(PRINTF_DECLARED)
 578 fi
 579 ])
 580
 581 AC_DEFUN(BASH_FUNC_ULIMIT_MAXFDS,
 582 [AC_MSG_CHECKING(whether ulimit can substitute for getdtablesize)
 583 AC_CACHE_VAL(bash_cv_ulimit_maxfds,
 584 [AC_TRY_RUN([
 585 main()
 586 {
 587 long maxfds = ulimit(4, 0L);
 588 exit (maxfds == -1L);
 589 }
 590 ], bash_cv_ulimit_maxfds=yes, bash_cv_ulimit_maxfds=no,
 591    [AC_MSG_WARN(cannot check ulimit if cross compiling -- defaulting to no)
 592     bash_cv_ulimit_maxfds=no]
 593 )])
 594 AC_MSG_RESULT($bash_cv_ulimit_maxfds)
 595 if test $bash_cv_ulimit_maxfds = yes; then
 596 AC_DEFINE(ULIMIT_MAXFDS)
 597 fi
 598 ])
 599
 600 AC_DEFUN(BASH_CHECK_LIB_TERMCAP,
 601 [
 602 if test "X$bash_cv_termcap_lib" = "X"; then
 603 _bash_needmsg=yes
 604 else
 605 AC_MSG_CHECKING(which library has the termcap functions)
 606 _bash_needmsg=
 607 fi
 608 AC_CACHE_VAL(bash_cv_termcap_lib,
 609 [AC_CHECK_LIB(termcap, tgetent, bash_cv_termcap_lib=libtermcap,
 610     [AC_CHECK_LIB(curses, tgetent, bash_cv_termcap_lib=libcurses,
 611         [AC_CHECK_LIB(ncurses, tgetent, bash_cv_termcap_lib=libncurses,
 612             bash_cv_termcap_lib=gnutermcap)])])])
 613 if test "X$_bash_needmsg" = "Xyes"; then
 614 AC_MSG_CHECKING(which library has the termcap functions)
 615 fi
 616 AC_MSG_RESULT(using $bash_cv_termcap_lib)
 617 if test $bash_cv_termcap_lib = gnutermcap && test -z "$prefer_curses"; then
 618 LDFLAGS="$LDFLAGS -L./lib/termcap"
 619 TERMCAP_LIB="./lib/termcap/libtermcap.a"
 620 TERMCAP_DEP="./lib/termcap/libtermcap.a"
 621 elif test $bash_cv_termcap_lib = libtermcap && test -z "$prefer_curses"; then
 622 TERMCAP_LIB=-ltermcap
 623 TERMCAP_DEP=
 624 elif test $bash_cv_termcap_lib = libncurses; then
 625 TERMCAP_LIB=-lncurses
 626 TERMCAP_DEP=
 627 else
 628 TERMCAP_LIB=-lcurses
 629 TERMCAP_DEP=
 630 fi
 631 ])
 632
 633 AC_DEFUN(BASH_FUNC_GETCWD,
 634 [AC_MSG_CHECKING([if getcwd() calls popen()])
 635 AC_CACHE_VAL(bash_cv_getcwd_calls_popen,
 636 [AC_TRY_RUN([
 637 #include <stdio.h>
 638 #ifdef HAVE_UNISTD_H
 639 #include <unistd.h>
 640 #endif
 641
 642 #ifndef __STDC__
 643 #ifndef const
 644 #define const
 645 #endif
 646 #endif
 647
 648 int popen_called;
 649
 650 FILE *
 651 popen(command, type)
 652      const char *command;
 653      const char *type;
 654 {
 655         popen_called = 1;
 656         return (FILE *)NULL;
 657 }
 658
 659 FILE *_popen(command, type)
 660      const char *command;
 661      const char *type;
 662 {
 663   return (popen (command, type));
 664 }
 665
 666 int
 667 pclose(stream)
 668 FILE *stream;
 669 {
 670         return 0;
 671 }
 672
 673 int
 674 _pclose(stream)
 675 FILE *stream;
 676 {
 677         return 0;
 678 }
 679
 680 main()
 681 {
 682         char    lbuf[32];
 683         popen_called = 0;
 684         getcwd(lbuf, 32);
 685         exit (popen_called);
 686 }
 687 ], bash_cv_getcwd_calls_popen=no, bash_cv_getcwd_calls_popen=yes,
 688    [AC_MSG_WARN(cannot check whether getcwd calls popen if cross compiling -- defaulting to no)
 689     bash_cv_getcwd_calls_popen=no]
 690 )])
 691 AC_MSG_RESULT($bash_cv_getcwd_calls_popen)
 692 if test $bash_cv_getcwd_calls_popen = yes; then
 693 AC_DEFINE(GETCWD_BROKEN)
 694 fi
 695 ])
 696
 697 AC_DEFUN(BASH_STRUCT_DIRENT_D_INO,
 698 [AC_REQUIRE([AC_HEADER_DIRENT])
 699 AC_MSG_CHECKING(if struct dirent has a d_ino member)
 700 AC_CACHE_VAL(bash_cv_dirent_has_dino,
 701 [AC_TRY_COMPILE([
 702 #include <stdio.h>
 703 #include <sys/types.h>
 704 #ifdef HAVE_UNISTD_H
 705 # include <unistd.h>
 706 #endif /* HAVE_UNISTD_H */
 707 #if defined(HAVE_DIRENT_H)
 708 # include <dirent.h>
 709 #else
 710 # define dirent direct
 711 # ifdef HAVE_SYS_NDIR_H
 712 #  include <sys/ndir.h>
 713 # endif /* SYSNDIR */
 714 # ifdef HAVE_SYS_DIR_H
 715 #  include <sys/dir.h>
 716 # endif /* SYSDIR */
 717 # ifdef HAVE_NDIR_H
 718 #  include <ndir.h>
 719 # endif
 720 #endif /* HAVE_DIRENT_H */
 721 ],[
 722 struct dirent d; int z; z = d.d_ino;
 723 ], bash_cv_dirent_has_dino=yes, bash_cv_dirent_has_dino=no)])
 724 AC_MSG_RESULT($bash_cv_dirent_has_dino)
 725 if test $bash_cv_dirent_has_dino = yes; then
 726 AC_DEFINE(STRUCT_DIRENT_HAS_D_INO)
 727 fi
 728 ])
 729
 730 AC_DEFUN(BASH_STRUCT_DIRENT_D_FILENO,
 731 [AC_REQUIRE([AC_HEADER_DIRENT])
 732 AC_MSG_CHECKING(if struct dirent has a d_fileno member)
 733 AC_CACHE_VAL(bash_cv_dirent_has_d_fileno,
 734 [AC_TRY_COMPILE([
 735 #include <stdio.h>
 736 #include <sys/types.h>
 737 #ifdef HAVE_UNISTD_H
 738 # include <unistd.h>
 739 #endif /* HAVE_UNISTD_H */
 740 #if defined(HAVE_DIRENT_H)
 741 # include <dirent.h>
 742 #else
 743 # define dirent direct
 744 # ifdef HAVE_SYS_NDIR_H
 745 #  include <sys/ndir.h>
 746 # endif /* SYSNDIR */
 747 # ifdef HAVE_SYS_DIR_H
 748 #  include <sys/dir.h>
 749 # endif /* SYSDIR */
 750 # ifdef HAVE_NDIR_H
 751 #  include <ndir.h>
 752 # endif
 753 #endif /* HAVE_DIRENT_H */
 754 ],[
 755 struct dirent d; int z; z = d.d_fileno;
 756 ], bash_cv_dirent_has_d_fileno=yes, bash_cv_dirent_has_d_fileno=no)])
 757 AC_MSG_RESULT($bash_cv_dirent_has_d_fileno)
 758 if test $bash_cv_dirent_has_d_fileno = yes; then
 759 AC_DEFINE(STRUCT_DIRENT_HAS_D_FILENO)
 760 fi
 761 ])
 762
 763 AC_DEFUN(BASH_REINSTALL_SIGHANDLERS,
 764 [AC_REQUIRE([AC_TYPE_SIGNAL])
 765 AC_REQUIRE([BASH_SIGNAL_CHECK])
 766 AC_MSG_CHECKING([if signal handlers must be reinstalled when invoked])
 767 AC_CACHE_VAL(bash_cv_must_reinstall_sighandlers,
 768 [AC_TRY_RUN([
 769 #include <signal.h>
 770 #ifdef HAVE_UNISTD_H
 771 #include <unistd.h>
 772 #endif
 773
 774 typedef RETSIGTYPE sigfunc();
 775
 776 int nsigint;
 777
 778 #ifdef HAVE_POSIX_SIGNALS
 779 sigfunc *
 780 set_signal_handler(sig, handler)
 781      int sig;
 782      sigfunc *handler;
 783 {
 784   struct sigaction act, oact;
 785   act.sa_handler = handler;
 786   act.sa_flags = 0;
 787   sigemptyset (&act.sa_mask);
 788   sigemptyset (&oact.sa_mask);
 789   sigaction (sig, &act, &oact);
 790   return (oact.sa_handler);
 791 }
 792 #else
 793 #define set_signal_handler(s, h) signal(s, h)
 794 #endif
 795
 796 RETSIGTYPE
 797 sigint(s)
 798 int s;
 799 {
 800   nsigint++;
 801 }
 802
 803 main()
 804 {
 805         nsigint = 0;
 806         set_signal_handler(SIGINT, sigint);
 807         kill((int)getpid(), SIGINT);
 808         kill((int)getpid(), SIGINT);
 809         exit(nsigint != 2);
 810 }
 811 ], bash_cv_must_reinstall_sighandlers=no, bash_cv_must_reinstall_sighandlers=yes,
 812    [AC_MSG_WARN(cannot check signal handling if cross compiling -- defaulting to no)
 813     bash_cv_must_reinstall_sighandlers=no]
 814 )])
 815 AC_MSG_RESULT($bash_cv_must_reinstall_sighandlers)
 816 if test $bash_cv_must_reinstall_sighandlers = yes; then
 817 AC_DEFINE(MUST_REINSTALL_SIGHANDLERS)
 818 fi
 819 ])
 820
 821 AC_DEFUN(BASH_FUNC_SBRK_DECLARED,
 822 [AC_MSG_CHECKING(for declaration of sbrk in <unistd.h>)
 823 AC_CACHE_VAL(bash_cv_sbrk_declared,
 824 [AC_EGREP_HEADER(sbrk, unistd.h,
 825  bash_cv_sbrk_declared=yes, bash_cv_sbrk_declared=no)])
 826 AC_MSG_RESULT($bash_cv_sbrk_declared)
 827 if test $bash_cv_sbrk_declared = yes; then
 828 AC_DEFINE(SBRK_DECLARED)
 829 fi
 830 ])
 831
 832 dnl check that some necessary job control definitions are present
 833 AC_DEFUN(BASH_JOB_CONTROL_MISSING,
 834 [AC_REQUIRE([BASH_SIGNAL_CHECK])
 835 AC_MSG_CHECKING(for presence of necessary job control definitions)
 836 AC_CACHE_VAL(bash_cv_job_control_missing,
 837 [AC_TRY_RUN([
 838 #include <sys/types.h>
 839 #ifdef HAVE_SYS_WAIT_H
 840 #include <sys/wait.h>
 841 #endif
 842 #ifdef HAVE_UNISTD_H
 843 #include <unistd.h>
 844 #endif
 845 #include <signal.h>
 846
 847 /* Add more tests in here as appropriate. */
 848 main()
 849 {
 850 /* signal type */
 851 #if !defined (HAVE_POSIX_SIGNALS) && !defined (HAVE_BSD_SIGNALS)
 852 exit(1);
 853 #endif
 854
 855 /* signals and tty control. */
 856 #if !defined (SIGTSTP) || !defined (SIGSTOP) || !defined (SIGCONT)
 857 exit (1);
 858 #endif
 859
 860 /* process control */
 861 #if !defined (WNOHANG) || !defined (WUNTRACED)
 862 exit(1);
 863 #endif
 864
 865 /* Posix systems have tcgetpgrp and waitpid. */
 866 #if defined (_POSIX_VERSION) && !defined (HAVE_TCGETPGRP)
 867 exit(1);
 868 #endif
 869
 870 #if defined (_POSIX_VERSION) && !defined (HAVE_WAITPID)
 871 exit(1);
 872 #endif
 873
 874 /* Other systems have TIOCSPGRP/TIOCGPRGP and wait3. */
 875 #if !defined (_POSIX_VERSION) && !defined (HAVE_WAIT3)
 876 exit(1);
 877 #endif
 878
 879 exit(0);
 880 }], bash_cv_job_control_missing=present, bash_cv_job_control_missing=missing,
 881     [AC_MSG_WARN(cannot check job control if cross-compiling -- defaulting to missing)
 882      bash_cv_job_control_missing=missing]
 883 )])
 884 AC_MSG_RESULT($bash_cv_job_control_missing)
 885 if test $bash_cv_job_control_missing = missing; then
 886 AC_DEFINE(JOB_CONTROL_MISSING)
 887 fi
 888 ])
 889
 890 dnl check whether named pipes are present
 891 dnl this requires a previous check for mkfifo, but that is awkward to specify
 892 AC_DEFUN(BASH_SYS_NAMED_PIPES,
 893 [AC_MSG_CHECKING(for presence of named pipes)
 894 AC_CACHE_VAL(bash_cv_sys_named_pipes,
 895 [AC_TRY_RUN([
 896 #include <sys/types.h>
 897 #include <sys/stat.h>
 898 #ifdef HAVE_UNISTD_H
 899 #include <unistd.h>
 900 #endif
 901
 902 /* Add more tests in here as appropriate. */
 903 main()
 904 {
 905 int fd, err;
 906
 907 #if defined (HAVE_MKFIFO)
 908 exit (0);
 909 #endif
 910
 911 #if !defined (S_IFIFO) && (defined (_POSIX_VERSION) && !defined (S_ISFIFO))
 912 exit (1);
 913 #endif
 914
 915 #if defined (NeXT)
 916 exit (1);
 917 #endif
 918 err = mkdir("/tmp/bash-aclocal", 0700);
 919 if (err < 0) {
 920   perror ("mkdir");
 921   exit(1);
 922 }
 923 fd = mknod ("/tmp/bash-aclocal/sh-np-autoconf", 0666 | S_IFIFO, 0);
 924 if (fd == -1) {
 925   rmdir ("/tmp/bash-aclocal");
 926   exit (1);
 927 }
 928 close(fd);
 929 unlink ("/tmp/bash-aclocal/sh-np-autoconf");
 930 rmdir ("/tmp/bash-aclocal");
 931 exit(0);
 932 }], bash_cv_sys_named_pipes=present, bash_cv_sys_named_pipes=missing,
 933     [AC_MSG_WARN(cannot check for named pipes if cross-compiling -- defaulting to missing)
 934      bash_cv_sys_named_pipes=missing]
 935 )])
 936 AC_MSG_RESULT($bash_cv_sys_named_pipes)
 937 if test $bash_cv_sys_named_pipes = missing; then
 938 AC_DEFINE(NAMED_PIPES_MISSING)
 939 fi
 940 ])
 941
 942 AC_DEFUN(BASH_FUNC_POSIX_SETJMP,
 943 [AC_REQUIRE([BASH_SIGNAL_CHECK])
 944 AC_MSG_CHECKING(for presence of POSIX-style sigsetjmp/siglongjmp)
 945 AC_CACHE_VAL(bash_cv_func_sigsetjmp,
 946 [AC_TRY_RUN([
 947 #ifdef HAVE_UNISTD_H
 948 #include <unistd.h>
 949 #endif
 950 #include <sys/types.h>
 951 #include <signal.h>
 952 #include <setjmp.h>
 953
 954 main()
 955 {
 956 #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
 957 exit (1);
 958 #else
 959
 960 int code;
 961 sigset_t set, oset;
 962 sigjmp_buf xx;
 963
 964 /* get the mask */
 965 sigemptyset(&set);
 966 sigemptyset(&oset);
 967 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &set);
 968 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset);
 969
 970 /* save it */
 971 code = sigsetjmp(xx, 1);
 972 if (code)
 973   exit(0);      /* could get sigmask and compare to oset here. */
 974
 975 /* change it */
 976 sigaddset(&set, SIGINT);
 977 sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL);
 978
 979 /* and siglongjmp */
 980 siglongjmp(xx, 10);
 981 exit(1);
 982 #endif
 983 }], bash_cv_func_sigsetjmp=present, bash_cv_func_sigsetjmp=missing,
 984     [AC_MSG_WARN(cannot check for sigsetjmp/siglongjmp if cross-compiling -- defaulting to missing)
 985      bash_cv_func_sigsetjmp=missing]
 986 )])
 987 AC_MSG_RESULT($bash_cv_func_sigsetjmp)
 988 if test $bash_cv_func_sigsetjmp = present; then
 989 AC_DEFINE(HAVE_POSIX_SIGSETJMP)
 990 fi
 991 ])
 992
 993 AC_DEFUN(BASH_HAVE_TIOCGWINSZ,
 994 [AC_MSG_CHECKING(for TIOCGWINSZ in sys/ioctl.h)
 995 AC_CACHE_VAL(bash_cv_tiocgwinsz_in_ioctl,
 996 [AC_TRY_COMPILE([#include <sys/types.h>
 997 #include <sys/ioctl.h>], [int x = TIOCGWINSZ;],
 998   bash_cv_tiocgwinsz_in_ioctl=yes,bash_cv_tiocgwinsz_in_ioctl=no)])
 999 AC_MSG_RESULT($bash_cv_tiocgwinsz_in_ioctl)
1000 if test $bash_cv_tiocgwinsz_in_ioctl = yes; then
1001 AC_DEFINE(GWINSZ_IN_SYS_IOCTL)
1002 fi
1003 ])
1004
1005 AC_DEFUN(BASH_STRUCT_WINSIZE,
1006 [AC_MSG_CHECKING(for struct winsize in sys/ioctl.h and termios.h)
1007 AC_CACHE_VAL(bash_cv_struct_winsize_header,
1008 [AC_TRY_COMPILE([#include <sys/types.h>
1009 #include <sys/ioctl.h>], [struct winsize x;],
1010   bash_cv_struct_winsize_header=ioctl_h,
1011   [AC_TRY_COMPILE([#include <sys/types.h>
1012 #include <termios.h>], [struct winsize x;],
1013   bash_cv_struct_winsize_header=termios_h, bash_cv_struct_winsize_header=other)
1014 ])])
1015 if test $bash_cv_struct_winsize_header = ioctl_h; then
1016   AC_MSG_RESULT(sys/ioctl.h)
1017   AC_DEFINE(STRUCT_WINSIZE_IN_SYS_IOCTL)
1018 elif test $bash_cv_struct_winsize_header = termios_h; then
1019   AC_MSG_RESULT(termios.h)
1020   AC_DEFINE(STRUCT_WINSIZE_IN_TERMIOS)
1021 else
1022   AC_MSG_RESULT(not found)
1023 fi
1024 ])
1025
1026 AC_DEFUN(BASH_HAVE_TIOCSTAT,
1027 [AC_MSG_CHECKING(for TIOCSTAT in sys/ioctl.h)
1028 AC_CACHE_VAL(bash_cv_tiocstat_in_ioctl,
1029 [AC_TRY_COMPILE([#include <sys/types.h>
1030 #include <sys/ioctl.h>], [int x = TIOCSTAT;],
1031   bash_cv_tiocstat_in_ioctl=yes,bash_cv_tiocstat_in_ioctl=no)])
1032 AC_MSG_RESULT($bash_cv_tiocstat_in_ioctl)
1033 if test $bash_cv_tiocstat_in_ioctl = yes; then
1034 AC_DEFINE(TIOCSTAT_IN_SYS_IOCTL)
1035 fi
1036 ])
1037
1038 AC_DEFUN(BASH_HAVE_FIONREAD,
1039 [AC_MSG_CHECKING(for FIONREAD in sys/ioctl.h)
1040 AC_CACHE_VAL(bash_cv_fionread_in_ioctl,
1041 [AC_TRY_COMPILE([#include <sys/types.h>
1042 #include <sys/ioctl.h>], [int x = FIONREAD;],
1043   bash_cv_fionread_in_ioctl=yes,bash_cv_fionread_in_ioctl=no)])
1044 AC_MSG_RESULT($bash_cv_fionread_in_ioctl)
1045 if test $bash_cv_fionread_in_ioctl = yes; then
1046 AC_DEFINE(FIONREAD_IN_SYS_IOCTL)
1047 fi
1048 ])
1049
1050 dnl
1051 dnl See if speed_t is declared in <sys/types.h>.  Some versions of linux
1052 dnl require a definition of speed_t each time <termcap.h> is included,
1053 dnl but you can only get speed_t if you include <termios.h> (on some
1054 dnl versions) or <sys/types.h> (on others).
1055 dnl
1056 AC_DEFUN(BASH_MISC_SPEED_T,
1057 [AC_MSG_CHECKING(for speed_t in sys/types.h)
1058 AC_CACHE_VAL(bash_cv_speed_t_in_sys_types,
1059 [AC_TRY_COMPILE([#include <sys/types.h>], [speed_t x;],
1060   bash_cv_speed_t_in_sys_types=yes,bash_cv_speed_t_in_sys_types=no)])
1061 AC_MSG_RESULT($bash_cv_speed_t_in_sys_types)
1062 if test $bash_cv_speed_t_in_sys_types = yes; then
1063 AC_DEFINE(SPEED_T_IN_SYS_TYPES)
1064 fi
1065 ])
1066
1067 AC_DEFUN(BASH_CHECK_GETPW_FUNCS,
1068 [AC_MSG_CHECKING(whether programs are able to redeclare getpw functions)
1069 AC_CACHE_VAL(bash_cv_can_redecl_getpw,
1070 [AC_TRY_COMPILE([#include <sys/types.h>
1071 #include <pwd.h>
1072 extern struct passwd *getpwent();
1073 extern struct passwd *getpwuid();
1074 extern struct passwd *getpwnam();],
1075 [struct passwd *z; z = getpwent(); z = getpwuid(0); z = getpwnam("root");],
1076   bash_cv_can_redecl_getpw=yes,bash_cv_can_redecl_getpw=no)])
1077 AC_MSG_RESULT($bash_cv_can_redecl_getpw)
1078 if test $bash_cv_can_redecl_getpw = no; then
1079 AC_DEFINE(HAVE_GETPW_DECLS)
1080 fi
1081 ])
1082
1083 AC_DEFUN(BASH_CHECK_DEV_FD,
1084 [AC_MSG_CHECKING(whether /dev/fd is available)
1085 AC_CACHE_VAL(bash_cv_dev_fd,
1086 [if test -d /dev/fd  && test -r /dev/fd/0; then
1087    bash_cv_dev_fd=standard
1088  elif test -d /proc/self/fd && test -r /proc/self/fd/0; then
1089    bash_cv_dev_fd=whacky
1090  else
1091    bash_cv_dev_fd=absent
1092  fi
1093 ])
1094 AC_MSG_RESULT($bash_cv_dev_fd)
1095 if test $bash_cv_dev_fd = "standard"; then
1096   AC_DEFINE(HAVE_DEV_FD)
1097   AC_DEFINE(DEV_FD_PREFIX, "/dev/fd/")
1098 elif test $bash_cv_dev_fd = "whacky"; then
1099   AC_DEFINE(HAVE_DEV_FD)
1100   AC_DEFINE(DEV_FD_PREFIX, "/proc/self/fd/")
1101 fi
1102 ])
1103
1104 AC_DEFUN(BASH_CHECK_DEV_STDIN,
1105 [AC_MSG_CHECKING(whether /dev/stdin stdout stderr are available)
1106 AC_CACHE_VAL(bash_cv_dev_stdin,
1107 [if test -d /dev/fd && test -r /dev/stdin; then
1108    bash_cv_dev_stdin=present
1109  elif test -d /proc/self/fd && test -r /dev/stdin; then
1110    bash_cv_dev_stdin=present
1111  else
1112    bash_cv_dev_stdin=absent
1113  fi
1114 ])
1115 AC_MSG_RESULT($bash_cv_dev_stdin)
1116 if test $bash_cv_dev_stdin = "present"; then
1117   AC_DEFINE(HAVE_DEV_STDIN)
1118 fi
1119 ])
1120
1121 dnl
1122 dnl Check for the presence of getpeername in libsocket.
1123 dnl If libsocket is present, check for libnsl and add it to LIBS if
1124 dnl it's there, since most systems with libsocket require linking
1125 dnl with libnsl as well.  This should only be called if getpeername
1126 dnl was not found in libc.
1127 dnl
1128 dnl NOTE: IF WE FIND GETPEERNAME, WE ASSUME THAT WE HAVE BIND/CONNECT
1129 dnl       AS WELL
1130 dnl
1131 AC_DEFUN(BASH_CHECK_SOCKLIB,
1132 [
1133 if test "X$bash_cv_have_socklib" = "X"; then
1134 _bash_needmsg=
1135 else
1136 AC_MSG_CHECKING(for socket library)
1137 _bash_needmsg=yes
1138 fi
1139 AC_CACHE_VAL(bash_cv_have_socklib,
1140 [AC_CHECK_LIB(socket, getpeername,
1141         bash_cv_have_socklib=yes, bash_cv_have_socklib=no, -lnsl)])
1142 if test "X$_bash_needmsg" = Xyes; then
1143   AC_MSG_RESULT($bash_cv_have_socklib)
1144   _bash_needmsg=
1145 fi
1146 if test $bash_cv_have_socklib = yes; then
1147   # check for libnsl, add it to LIBS if present
1148   if test "X$bash_cv_have_libnsl" = "X"; then
1149     _bash_needmsg=
1150   else
1151     AC_MSG_CHECKING(for libnsl)
1152     _bash_needmsg=yes
1153   fi
1154   AC_CACHE_VAL(bash_cv_have_libnsl,
1155            [AC_CHECK_LIB(nsl, t_open,
1156                  bash_cv_have_libnsl=yes, bash_cv_have_libnsl=no)])
1157   if test "X$_bash_needmsg" = Xyes; then
1158     AC_MSG_RESULT($bash_cv_have_libnsl)
1159     _bash_needmsg=
1160   fi
1161   if test $bash_cv_have_libnsl = yes; then
1162     LIBS="-lsocket -lnsl $LIBS"
1163   else
1164     LIBS="-lsocket $LIBS"
1165   fi
1166   AC_DEFINE(HAVE_LIBSOCKET)
1167   AC_DEFINE(HAVE_GETPEERNAME)
1168 fi
1169 ])
1170
1171 dnl
1172 dnl This needs BASH_CHECK_SOCKLIB, but since that's not called on every
1173 dnl system, we can't use AC_PREREQ
1174 dnl
1175 AC_DEFUN(BASH_FUNC_GETHOSTBYNAME,
1176 [if test "X$bash_cv_have_gethostbyname" = "X"; then
1177 _bash_needmsg=yes
1178 else
1179 AC_MSG_CHECKING(for gethostbyname in socket library)
1180 _bash_needmsg=
1181 fi
1182 AC_CACHE_VAL(bash_cv_have_gethostbyname,
1183 [AC_TRY_LINK([#include <netdb.h>],
1184 [ struct hostent *hp;
1185   hp = gethostbyname("localhost");
1186 ], bash_cv_have_gethostbyname=yes, bash_cv_have_gethostbyname=no)]
1187 )
1188 if test "X$_bash_needmsg" = Xyes; then
1189     AC_MSG_CHECKING(for gethostbyname in socket library)
1190 fi
1191 AC_MSG_RESULT($bash_cv_have_gethostbyname)
1192 if test "$bash_cv_have_gethostbyname" = yes; then
1193 AC_DEFINE(HAVE_GETHOSTBYNAME)
1194 fi
1195 ])
1196
1197 AC_DEFUN(BASH_DEFAULT_MAIL_DIR,
1198 [AC_MSG_CHECKING(for default mail directory)
1199 AC_CACHE_VAL(bash_cv_mail_dir,
1200 [if test -d /var/mail; then
1201    bash_cv_mail_dir=/var/mail
1202  elif test -d /usr/mail; then
1203    bash_cv_mail_dir=/usr/mail
1204  elif test -d /var/spool/mail; then
1205    bash_cv_mail_dir=/var/spool/mail
1206  elif test -d /usr/spool/mail; then
1207    bash_cv_mail_dir=/usr/spool/mail
1208  else
1209    bash_cv_mail_dir=unknown
1210  fi
1211 ])
1212 AC_MSG_RESULT($bash_cv_mail_dir)
1213 if test $bash_cv_mail_dir = "/var/mail"; then
1214    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/mail")
1215 elif test $bash_cv_mail_dir = "/usr/mail"; then
1216    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/mail")
1217 elif test $bash_cv_mail_dir = "/var/spool/mail"; then
1218    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/spool/mail")
1219 elif test $bash_cv_mail_dir = "/usr/spool/mail"; then
1220    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/spool/mail")
1221 else
1222    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "unknown")
1223 fi
1224 ])
1225
1226 dnl
1227 dnl Check if HPUX needs _KERNEL defined for RLIMIT_* definitions
1228 dnl
1229 AC_DEFUN(BASH_KERNEL_RLIMIT_CHECK,
1230 [AC_MSG_CHECKING([whether $host_os needs _KERNEL for RLIMIT defines])
1231 AC_CACHE_VAL(bash_cv_kernel_rlimit,
1232 [AC_TRY_COMPILE([
1233 #include <sys/types.h>
1234 #include <sys/resource.h>
1235 ],
1236 [
1237   int f;
1238   f = RLIMIT_DATA;
1239 ], bash_cv_kernel_rlimit=no,
1240 [AC_TRY_COMPILE([
1241 #include <sys/types.h>
1242 #define _KERNEL
1243 #include <sys/resource.h>
1244 #undef _KERNEL
1245 ],
1246 [
1247         int f;
1248         f = RLIMIT_DATA;
1249 ], bash_cv_kernel_rlimit=yes, bash_cv_kernel_rlimit=no)]
1250 )])
1251 AC_MSG_RESULT($bash_cv_kernel_rlimit)
1252 if test $bash_cv_kernel_rlimit = yes; then
1253 AC_DEFINE(RLIMIT_NEEDS_KERNEL)
1254 fi
1255 ])
1256
1257 AC_DEFUN(BASH_FUNC_STRCOLL,
1258 [
1259 AC_MSG_CHECKING(whether or not strcoll and strcmp differ)
1260 AC_CACHE_VAL(bash_cv_func_strcoll_broken,
1261 [AC_TRY_RUN([
1262 #include <stdio.h>
1263 #if defined (HAVE_LOCALE_H)
1264 #include <locale.h>
1265 #endif
1266
1267 main(c, v)
1268 int     c;
1269 char    *v[];
1270 {
1271         int     r1, r2;
1272         char    *deflocale, *defcoll;
1273
1274 #ifdef HAVE_SETLOCALE
1275         deflocale = setlocale(LC_ALL, "");
1276         defcoll = setlocale(LC_COLLATE, "");
1277 #endif
1278
1279 #ifdef HAVE_STRCOLL
1280         /* These two values are taken from tests/glob-test. */
1281         r1 = strcoll("abd", "aXd");
1282 #else
1283         r1 = 0;
1284 #endif
1285         r2 = strcmp("abd", "aXd");
1286
1287         /* These two should both be greater than 0.  It is permissible for
1288            a system to return different values, as long as the sign is the
1289            same. */
1290
1291         /* Exit with 1 (failure) if these two values are both > 0, since
1292            this tests whether strcoll(3) is broken with respect to strcmp(3)
1293            in the default locale. */
1294         exit (r1 > 0 && r2 > 0);
1295 }
1296 ], bash_cv_func_strcoll_broken=yes, bash_cv_func_strcoll_broken=no,
1297    [AC_MSG_WARN(cannot check strcoll if cross compiling -- defaulting to no)
1298     bash_cv_func_strcoll_broken=no]
1299 )])
1300 AC_MSG_RESULT($bash_cv_func_strcoll_broken)
1301 if test $bash_cv_func_strcoll_broken = yes; then
1302 AC_DEFINE(STRCOLL_BROKEN)
1303 fi
1304 ])
1305
1306 dnl
1307 dnl If available, use support for large files unless the user specified
1308 dnl one of the CPPFLAGS, LDFLAGS, or LIBS variables (<eggert@twinsun.com>
1309 dnl via GNU patch 2.5)
1310 dnl
1311 AC_DEFUN(BASH_LARGE_FILE_SUPPORT,
1312 [AC_MSG_CHECKING(whether large file support needs explicit enabling)
1313 ac_getconfs=''
1314 ac_result=yes
1315 ac_set=''
1316 ac_shellvars='CPPFLAGS LDFLAGS LIBS'
1317 for ac_shellvar in $ac_shellvars; do
1318   case $ac_shellvar in
1319   CPPFLAGS) ac_lfsvar=LFS_CFLAGS ac_lfs64var=LFS64_CFLAGS ;;
1320   *) ac_lfsvar=LFS_$ac_shellvar ac_lfs64var=LFS64_$ac_shellvar ;;
1321   esac
1322   eval test '"${'$ac_shellvar'+set}"' = set && ac_set=$ac_shellvar
1323   (getconf $ac_lfsvar) >/dev/null 2>&1 || { ac_result=no; break; }
1324   ac_getconf=`getconf $ac_lfsvar`
1325   ac_getconf64=`getconf $ac_lfs64var`
1326   ac_getconfs=$ac_getconfs$ac_getconf\ $ac_getconf64
1327   eval ac_test_$ac_shellvar="\$ac_getconf\ \$ac_getconf64"
1328 done
1329 case "$ac_result$ac_getconfs" in
1330 yes) ac_result=no ;;
1331 esac
1332 case "$ac_result$ac_set" in
1333 yes?*) ac_result="yes, but $ac_set is already set, so use its settings"
1334 esac
1335 AC_MSG_RESULT($ac_result)
1336 case $ac_result in
1337 yes)
1338   for ac_shellvar in $ac_shellvars; do
1339     eval $ac_shellvar=\$ac_test_$ac_shellvar
1340   done ;;
1341 esac
1342 ])
1343
1344 dnl
1345 dnl AC_SYS_RESTARTABLE_SYSCALLS tests only for restarted system calls
1346 dnl after a signal handler has been installed with signal().  Since
1347 dnl Bash uses sigaction() if it is available, we need to check whether
1348 dnl or not a signal handler installed with sigaction and SA_RESTART
1349 dnl causes system calls to be restarted after the signal is caught
1350 dnl
1351 AC_DEFUN(BASH_SYS_RESTARTABLE_SYSCALLS,
1352 [AC_REQUIRE([BASH_SIGNAL_CHECK])
1353 AC_CACHE_CHECK(for restartable system calls with posix sigaction,
1354 bash_cv_sys_restartable_syscalls,
1355 [AC_TRY_RUN(
1356 [/* Exit 0 (true) if wait returns something other than -1,
1357    i.e. the pid of the child, which means that wait was restarted
1358    after getting the signal.  */
1359 #include <sys/types.h>
1360 #include <signal.h>
1361 static int caught = 0;
1362 void ucatch (isig) int isig; { caught = 1; }
1363 main ()
1364 {
1365 #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
1366   exit (1);
1367 #else
1368   struct sigaction act, oact;
1369   int i, status;
1370
1371   act.sa_handler = ucatch;
1372   /* Might want to add SA_RESTART here, but bash's set_signal_handler
1373      does not. */
1374   act.sa_flags = 0;
1375   sigemptyset(&act.sa_mask);
1376   sigemptyset(&oact.sa_mask);
1377   i = fork ();
1378   /* A possible race condition here, but in practice it never happens. */
1379   if (i == 0) { sleep (3); kill (getppid (), SIGINT); sleep (3); exit (0); }
1380   sigaction(SIGINT, &act, &oact);
1381   status = wait(&i);
1382   if (status == -1) wait(&i);
1383   exit (status == -1);
1384 #endif
1385 }
1386 ], bash_cv_sys_restartable_syscalls=yes, bash_cv_sys_restartable_syscalls=no,
1387    AC_MSG_WARN(cannot check restartable syscalls if cross compiling))
1388 ])
1389 if test $bash_cv_sys_restartable_syscalls = yes; then
1390   AC_DEFINE(HAVE_RESTARTABLE_SYSCALLS)
1391 fi
1392 ])
1393 dnl
1394 dnl Check for 64-bit off_t -- used for malloc alignment
1395 dnl
1396 dnl C does not allow duplicate case labels, so the compile will fail if
1397 dnl sizeof(off_t) is > 4.
1398 dnl
1399 AC_DEFUN(BASH_CHECK_OFF_T_64,
1400 [AC_CACHE_CHECK(for 64-bit off_t, bash_cv_off_t_64,
1401 AC_TRY_COMPILE([
1402 #ifdef HAVE_UNISTD_H
1403 #include <unistd.h>
1404 #endif
1405 #include <sys/types.h>
1406 ],[
1407 switch (0) case 0: case (sizeof (off_t) <= 4):;
1408 ], bash_cv_off_t_64=no, bash_cv_off_t_64=yes))
1409 if test $bash_cv_off_t_64 = yes; then
1410         AC_DEFINE(HAVE_OFF_T_64)
1411 fi])
1412
1413 AC_DEFUN(BASH_STRUCT_TIMEVAL,
1414 [AC_MSG_CHECKING(for struct timeval in sys/time.h and time.h)
1415 AC_CACHE_VAL(bash_cv_struct_timeval,
1416 [
1417 AC_EGREP_HEADER(struct timeval, sys/time.h,
1418                 bash_cv_struct_timeval=yes,
1419                 AC_EGREP_HEADER(struct timeval, time.h,
1420                         bash_cv_struct_timeval=yes,
1421                         bash_cv_struct_timeval=no))
1422 ])
1423 AC_MSG_RESULT($bash_cv_struct_timeval)
1424 if test $bash_cv_struct_timeval = yes; then
1425   AC_DEFINE(HAVE_TIMEVAL)
1426 fi
1427 ])