readline/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
   7 AC_DEFUN(BASH_C_LONG_LONG,
   8 [AC_CACHE_CHECK(for long long, ac_cv_c_long_long,
   9 [if test "$GCC" = yes; then
  10   ac_cv_c_long_long=yes
  11 else
  12 AC_TRY_RUN([
  13 #include <stdlib.h>
  14 int
  15 main()
  16 {
  17 long long foo = 0;
  18 exit(sizeof(long long) < sizeof(long));
  19 }
  20 ], ac_cv_c_long_long=yes, ac_cv_c_long_long=no)
  21 fi])
  22 if test $ac_cv_c_long_long = yes; then
  23   AC_DEFINE(HAVE_LONG_LONG, 1, [Define if the `long long' type works.])
  24 fi
  25 ])
  26
  27 dnl
  28 dnl This is very similar to AC_C_LONG_DOUBLE, with the fix for IRIX
  29 dnl (< changed to <=) added.
  30 dnl
  31 AC_DEFUN(BASH_C_LONG_DOUBLE,
  32 [AC_CACHE_CHECK(for long double, ac_cv_c_long_double,
  33 [if test "$GCC" = yes; then
  34   ac_cv_c_long_double=yes
  35 else
  36 AC_TRY_RUN([
  37 #include <stdlib.h>
  38 int
  39 main()
  40 {
  41   /* The Stardent Vistra knows sizeof(long double), but does not
  42      support it. */
  43   long double foo = 0.0;
  44   /* On Ultrix 4.3 cc, long double is 4 and double is 8.  */
  45   /* On IRIX 5.3, the compiler converts long double to double with a warning,
  46      but compiles this successfully. */
  47   exit(sizeof(long double) <= sizeof(double));
  48 }
  49 ], ac_cv_c_long_double=yes, ac_cv_c_long_double=no)
  50 fi])
  51 if test $ac_cv_c_long_double = yes; then
  52   AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define if the `long double' type works.])
  53 fi
  54 ])
  55
  56 dnl
  57 dnl Check for <inttypes.h>.  This is separated out so that it can be
  58 dnl AC_REQUIREd.
  59 dnl
  60 dnl BASH_HEADER_INTTYPES
  61 AC_DEFUN(BASH_HEADER_INTTYPES,
  62 [
  63  AC_CHECK_HEADERS(inttypes.h)
  64 ])
  65
  66 dnl
  67 dnl check for typedef'd symbols in header files, but allow the caller to
  68 dnl specify the include files to be checked in addition to the default
  69 dnl
  70 dnl This could be changed to use AC_COMPILE_IFELSE instead of AC_EGREP_CPP
  71 dnl
  72 dnl BASH_CHECK_TYPE(TYPE, HEADERS, DEFAULT[, VALUE-IF-FOUND])
  73 AC_DEFUN(BASH_CHECK_TYPE,
  74 [
  75 AC_REQUIRE([AC_HEADER_STDC])dnl
  76 AC_REQUIRE([BASH_HEADER_INTTYPES])
  77 AC_MSG_CHECKING(for $1)
  78 AC_CACHE_VAL(bash_cv_type_$1,
  79 [AC_EGREP_CPP($1, [#include <sys/types.h>
  80 #if STDC_HEADERS
  81 #include <stdlib.h>
  82 #include <stddef.h>
  83 #endif
  84 #if HAVE_INTTYPES_H
  85 #include <inttypes.h>
  86 #endif
  87 #if HAVE_STDINT_H
  88 #include <stdint.h>
  89 #endif
  90 $2
  91 ], bash_cv_type_$1=yes, bash_cv_type_$1=no)])
  92 AC_MSG_RESULT($bash_cv_type_$1)
  93 ifelse($#, 4, [if test $bash_cv_type_$1 = yes; then
  94         AC_DEFINE($4)
  95         fi])
  96 if test $bash_cv_type_$1 = no; then
  97   AC_DEFINE_UNQUOTED($1, $3)
  98 fi
  99 ])
 100
 101 dnl
 102 dnl BASH_CHECK_DECL(FUNC)
 103 dnl
 104 dnl Check for a declaration of FUNC in stdlib.h and inttypes.h like
 105 dnl AC_CHECK_DECL
 106 dnl
 107 AC_DEFUN(BASH_CHECK_DECL,
 108 [
 109 AC_REQUIRE([AC_HEADER_STDC])
 110 AC_REQUIRE([BASH_HEADER_INTTYPES])
 111 AC_CACHE_CHECK([for declaration of $1], bash_cv_decl_$1,
 112 [AC_TRY_LINK(
 113 [
 114 #if STDC_HEADERS
 115 #  include <stdlib.h>
 116 #endif
 117 #if HAVE_INTTYPES_H
 118 #  include <inttypes.h>
 119 #endif
 120 ],
 121 [return !$1;],
 122 bash_cv_decl_$1=yes, bash_cv_decl_$1=no)])
 123 bash_tr_func=HAVE_DECL_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 124 if test $bash_cv_decl_$1 = yes; then
 125   AC_DEFINE_UNQUOTED($bash_tr_func, 1)
 126 else
 127   AC_DEFINE_UNQUOTED($bash_tr_func, 0)
 128 fi
 129 ])
 130
 131 AC_DEFUN(BASH_DECL_PRINTF,
 132 [AC_MSG_CHECKING(for declaration of printf in <stdio.h>)
 133 AC_CACHE_VAL(bash_cv_printf_declared,
 134 [AC_TRY_RUN([
 135 #include <stdio.h>
 136 #ifdef __STDC__
 137 typedef int (*_bashfunc)(const char *, ...);
 138 #else
 139 typedef int (*_bashfunc)();
 140 #endif
 141 #include <stdlib.h>
 142 int
 143 main()
 144 {
 145 _bashfunc pf;
 146 pf = (_bashfunc) printf;
 147 exit(pf == 0);
 148 }
 149 ], bash_cv_printf_declared=yes, bash_cv_printf_declared=no,
 150    [AC_MSG_WARN(cannot check printf declaration if cross compiling -- defaulting to yes)
 151     bash_cv_printf_declared=yes]
 152 )])
 153 AC_MSG_RESULT($bash_cv_printf_declared)
 154 if test $bash_cv_printf_declared = yes; then
 155 AC_DEFINE(PRINTF_DECLARED)
 156 fi
 157 ])
 158
 159 AC_DEFUN(BASH_DECL_SBRK,
 160 [AC_MSG_CHECKING(for declaration of sbrk in <unistd.h>)
 161 AC_CACHE_VAL(bash_cv_sbrk_declared,
 162 [AC_EGREP_HEADER(sbrk, unistd.h,
 163  bash_cv_sbrk_declared=yes, bash_cv_sbrk_declared=no)])
 164 AC_MSG_RESULT($bash_cv_sbrk_declared)
 165 if test $bash_cv_sbrk_declared = yes; then
 166 AC_DEFINE(SBRK_DECLARED)
 167 fi
 168 ])
 169
 170 dnl
 171 dnl Check for sys_siglist[] or _sys_siglist[]
 172 dnl
 173 AC_DEFUN(BASH_DECL_UNDER_SYS_SIGLIST,
 174 [AC_MSG_CHECKING([for _sys_siglist in signal.h or unistd.h])
 175 AC_CACHE_VAL(bash_cv_decl_under_sys_siglist,
 176 [AC_TRY_COMPILE([
 177 #include <sys/types.h>
 178 #include <signal.h>
 179 #ifdef HAVE_UNISTD_H
 180 #include <unistd.h>
 181 #endif], [ char *msg = _sys_siglist[2]; ],
 182   bash_cv_decl_under_sys_siglist=yes, bash_cv_decl_under_sys_siglist=no,
 183   [AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)])])dnl
 184 AC_MSG_RESULT($bash_cv_decl_under_sys_siglist)
 185 if test $bash_cv_decl_under_sys_siglist = yes; then
 186 AC_DEFINE(UNDER_SYS_SIGLIST_DECLARED)
 187 fi
 188 ])
 189
 190 AC_DEFUN(BASH_UNDER_SYS_SIGLIST,
 191 [AC_REQUIRE([BASH_DECL_UNDER_SYS_SIGLIST])
 192 AC_MSG_CHECKING([for _sys_siglist in system C library])
 193 AC_CACHE_VAL(bash_cv_under_sys_siglist,
 194 [AC_TRY_RUN([
 195 #include <sys/types.h>
 196 #include <signal.h>
 197 #ifdef HAVE_UNISTD_H
 198 #include <unistd.h>
 199 #endif
 200 #include <stdlib.h>
 201 #ifndef UNDER_SYS_SIGLIST_DECLARED
 202 extern char *_sys_siglist[];
 203 #endif
 204 int
 205 main()
 206 {
 207 char *msg = (char *)_sys_siglist[2];
 208 exit(msg == 0);
 209 }],
 210         bash_cv_under_sys_siglist=yes, bash_cv_under_sys_siglist=no,
 211         [AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)
 212          bash_cv_under_sys_siglist=no])])
 213 AC_MSG_RESULT($bash_cv_under_sys_siglist)
 214 if test $bash_cv_under_sys_siglist = yes; then
 215 AC_DEFINE(HAVE_UNDER_SYS_SIGLIST)
 216 fi
 217 ])
 218
 219 AC_DEFUN(BASH_SYS_SIGLIST,
 220 [AC_REQUIRE([AC_DECL_SYS_SIGLIST])
 221 AC_MSG_CHECKING([for sys_siglist in system C library])
 222 AC_CACHE_VAL(bash_cv_sys_siglist,
 223 [AC_TRY_RUN([
 224 #include <sys/types.h>
 225 #include <signal.h>
 226 #ifdef HAVE_UNISTD_H
 227 #include <unistd.h>
 228 #endif
 229 #include <stdlib.h>
 230 #if !HAVE_DECL_SYS_SIGLIST
 231 extern char *sys_siglist[];
 232 #endif
 233 int
 234 main()
 235 {
 236 char *msg = sys_siglist[2];
 237 exit(msg == 0);
 238 }],
 239         bash_cv_sys_siglist=yes, bash_cv_sys_siglist=no,
 240         [AC_MSG_WARN(cannot check for sys_siglist if cross compiling -- defaulting to no)
 241          bash_cv_sys_siglist=no])])
 242 AC_MSG_RESULT($bash_cv_sys_siglist)
 243 if test $bash_cv_sys_siglist = yes; then
 244 AC_DEFINE(HAVE_SYS_SIGLIST)
 245 fi
 246 ])
 247
 248 dnl Check for the various permutations of sys_siglist and make sure we
 249 dnl compile in siglist.o if they're not defined
 250 AC_DEFUN(BASH_CHECK_SYS_SIGLIST, [
 251 AC_REQUIRE([BASH_SYS_SIGLIST])
 252 AC_REQUIRE([BASH_DECL_UNDER_SYS_SIGLIST])
 253 AC_REQUIRE([BASH_FUNC_STRSIGNAL])
 254 if test "$bash_cv_sys_siglist" = no && test "$bash_cv_under_sys_siglist" = no && test "$bash_cv_have_strsignal" = no; then
 255   SIGLIST_O=siglist.o
 256 else
 257   SIGLIST_O=
 258 fi
 259 AC_SUBST([SIGLIST_O])
 260 ])
 261
 262 dnl Check for sys_errlist[] and sys_nerr, check for declaration
 263 AC_DEFUN(BASH_SYS_ERRLIST,
 264 [AC_MSG_CHECKING([for sys_errlist and sys_nerr])
 265 AC_CACHE_VAL(bash_cv_sys_errlist,
 266 [AC_TRY_LINK([#include <errno.h>],
 267 [extern char *sys_errlist[];
 268  extern int sys_nerr;
 269  char *msg = sys_errlist[sys_nerr - 1];],
 270     bash_cv_sys_errlist=yes, bash_cv_sys_errlist=no)])dnl
 271 AC_MSG_RESULT($bash_cv_sys_errlist)
 272 if test $bash_cv_sys_errlist = yes; then
 273 AC_DEFINE(HAVE_SYS_ERRLIST)
 274 fi
 275 ])
 276
 277 dnl
 278 dnl Check if dup2() does not clear the close on exec flag
 279 dnl
 280 AC_DEFUN(BASH_FUNC_DUP2_CLOEXEC_CHECK,
 281 [AC_MSG_CHECKING(if dup2 fails to clear the close-on-exec flag)
 282 AC_CACHE_VAL(bash_cv_dup2_broken,
 283 [AC_TRY_RUN([
 284 #include <sys/types.h>
 285 #include <fcntl.h>
 286 #include <stdlib.h>
 287 int
 288 main()
 289 {
 290   int fd1, fd2, fl;
 291   fd1 = open("/dev/null", 2);
 292   if (fcntl(fd1, 2, 1) < 0)
 293     exit(1);
 294   fd2 = dup2(fd1, 1);
 295   if (fd2 < 0)
 296     exit(2);
 297   fl = fcntl(fd2, 1, 0);
 298   /* fl will be 1 if dup2 did not reset the close-on-exec flag. */
 299   exit(fl != 1);
 300 }
 301 ], bash_cv_dup2_broken=yes, bash_cv_dup2_broken=no,
 302     [AC_MSG_WARN(cannot check dup2 if cross compiling -- defaulting to no)
 303      bash_cv_dup2_broken=no])
 304 ])
 305 AC_MSG_RESULT($bash_cv_dup2_broken)
 306 if test $bash_cv_dup2_broken = yes; then
 307 AC_DEFINE(DUP2_BROKEN)
 308 fi
 309 ])
 310
 311 AC_DEFUN(BASH_FUNC_STRSIGNAL,
 312 [AC_MSG_CHECKING([for the existence of strsignal])
 313 AC_CACHE_VAL(bash_cv_have_strsignal,
 314 [AC_TRY_LINK([#include <sys/types.h>
 315 #include <signal.h>
 316 #include <string.h>],
 317 [char *s = (char *)strsignal(2);],
 318  bash_cv_have_strsignal=yes, bash_cv_have_strsignal=no)])
 319 AC_MSG_RESULT($bash_cv_have_strsignal)
 320 if test $bash_cv_have_strsignal = yes; then
 321 AC_DEFINE(HAVE_STRSIGNAL)
 322 fi
 323 ])
 324
 325 dnl Check to see if opendir will open non-directories (not a nice thing)
 326 AC_DEFUN(BASH_FUNC_OPENDIR_CHECK,
 327 [AC_REQUIRE([AC_HEADER_DIRENT])dnl
 328 AC_MSG_CHECKING(if opendir() opens non-directories)
 329 AC_CACHE_VAL(bash_cv_opendir_not_robust,
 330 [AC_TRY_RUN([
 331 #include <stdio.h>
 332 #include <sys/types.h>
 333 #include <fcntl.h>
 334 #ifdef HAVE_UNISTD_H
 335 # include <unistd.h>
 336 #endif /* HAVE_UNISTD_H */
 337 #ifdef HAVE_SYS_STAT_H
 338 #include <sys/stat.h>
 339 #endif
 340 #if defined(HAVE_DIRENT_H)
 341 # include <dirent.h>
 342 #else
 343 # define dirent direct
 344 # ifdef HAVE_SYS_NDIR_H
 345 #  include <sys/ndir.h>
 346 # endif /* SYSNDIR */
 347 # ifdef HAVE_SYS_DIR_H
 348 #  include <sys/dir.h>
 349 # endif /* SYSDIR */
 350 # ifdef HAVE_NDIR_H
 351 #  include <ndir.h>
 352 # endif
 353 #endif /* HAVE_DIRENT_H */
 354 #include <stdlib.h>
 355 int
 356 main()
 357 {
 358 DIR *dir;
 359 int fd, err;
 360 err = mkdir("bash-aclocal", 0700);
 361 if (err < 0) {
 362   perror("mkdir");
 363   exit(1);
 364 }
 365 unlink("bash-aclocal/not_a_directory");
 366 fd = open("bash-aclocal/not_a_directory", O_WRONLY|O_CREAT|O_EXCL, 0666);
 367 write(fd, "\n", 1);
 368 close(fd);
 369 dir = opendir("bash-aclocal/not_a_directory");
 370 unlink("bash-aclocal/not_a_directory");
 371 rmdir("bash-aclocal");
 372 exit (dir == 0);
 373 }], bash_cv_opendir_not_robust=yes,bash_cv_opendir_not_robust=no,
 374     [AC_MSG_WARN(cannot check opendir if cross compiling -- defaulting to no)
 375      bash_cv_opendir_not_robust=no]
 376 )])
 377 AC_MSG_RESULT($bash_cv_opendir_not_robust)
 378 if test $bash_cv_opendir_not_robust = yes; then
 379 AC_DEFINE(OPENDIR_NOT_ROBUST)
 380 fi
 381 ])
 382
 383 dnl
 384 AC_DEFUN(BASH_TYPE_SIGHANDLER,
 385 [AC_MSG_CHECKING([whether signal handlers are of type void])
 386 AC_CACHE_VAL(bash_cv_void_sighandler,
 387 [AC_TRY_COMPILE([#include <sys/types.h>
 388 #include <signal.h>
 389 #ifdef signal
 390 #undef signal
 391 #endif
 392 #ifdef __cplusplus
 393 extern "C"
 394 #endif
 395 void (*signal ()) ();],
 396 [int i;], bash_cv_void_sighandler=yes, bash_cv_void_sighandler=no)])dnl
 397 AC_MSG_RESULT($bash_cv_void_sighandler)
 398 if test $bash_cv_void_sighandler = yes; then
 399 AC_DEFINE(VOID_SIGHANDLER)
 400 fi
 401 ])
 402
 403 dnl
 404 dnl A signed 16-bit integer quantity
 405 dnl
 406 AC_DEFUN(BASH_TYPE_BITS16_T,
 407 [
 408 if test "$ac_cv_sizeof_short" = 2; then
 409   AC_CHECK_TYPE(bits16_t, short)
 410 elif test "$ac_cv_sizeof_char" = 2; then
 411   AC_CHECK_TYPE(bits16_t, char)
 412 else
 413   AC_CHECK_TYPE(bits16_t, short)
 414 fi
 415 ])
 416
 417 dnl
 418 dnl An unsigned 16-bit integer quantity
 419 dnl
 420 AC_DEFUN(BASH_TYPE_U_BITS16_T,
 421 [
 422 if test "$ac_cv_sizeof_short" = 2; then
 423   AC_CHECK_TYPE(u_bits16_t, unsigned short)
 424 elif test "$ac_cv_sizeof_char" = 2; then
 425   AC_CHECK_TYPE(u_bits16_t, unsigned char)
 426 else
 427   AC_CHECK_TYPE(u_bits16_t, unsigned short)
 428 fi
 429 ])
 430
 431 dnl
 432 dnl A signed 32-bit integer quantity
 433 dnl
 434 AC_DEFUN(BASH_TYPE_BITS32_T,
 435 [
 436 if test "$ac_cv_sizeof_int" = 4; then
 437   AC_CHECK_TYPE(bits32_t, int)
 438 elif test "$ac_cv_sizeof_long" = 4; then
 439   AC_CHECK_TYPE(bits32_t, long)
 440 else
 441   AC_CHECK_TYPE(bits32_t, int)
 442 fi
 443 ])
 444
 445 dnl
 446 dnl An unsigned 32-bit integer quantity
 447 dnl
 448 AC_DEFUN(BASH_TYPE_U_BITS32_T,
 449 [
 450 if test "$ac_cv_sizeof_int" = 4; then
 451   AC_CHECK_TYPE(u_bits32_t, unsigned int)
 452 elif test "$ac_cv_sizeof_long" = 4; then
 453   AC_CHECK_TYPE(u_bits32_t, unsigned long)
 454 else
 455   AC_CHECK_TYPE(u_bits32_t, unsigned int)
 456 fi
 457 ])
 458
 459 AC_DEFUN(BASH_TYPE_PTRDIFF_T,
 460 [
 461 if test "$ac_cv_sizeof_int" = "$ac_cv_sizeof_char_p"; then
 462   AC_CHECK_TYPE(ptrdiff_t, int)
 463 elif test "$ac_cv_sizeof_long" = "$ac_cv_sizeof_char_p"; then
 464   AC_CHECK_TYPE(ptrdiff_t, long)
 465 elif test "$ac_cv_type_long_long" = yes && test "$ac_cv_sizeof_long_long" = "$ac_cv_sizeof_char_p"; then
 466   AC_CHECK_TYPE(ptrdiff_t, [long long])
 467 else
 468   AC_CHECK_TYPE(ptrdiff_t, int)
 469 fi
 470 ])
 471
 472 dnl
 473 dnl A signed 64-bit quantity
 474 dnl
 475 AC_DEFUN(BASH_TYPE_BITS64_T,
 476 [
 477 if test "$ac_cv_sizeof_char_p" = 8; then
 478   AC_CHECK_TYPE(bits64_t, char *)
 479 elif test "$ac_cv_sizeof_double" = 8; then
 480   AC_CHECK_TYPE(bits64_t, double)
 481 elif test -n "$ac_cv_type_long_long" && test "$ac_cv_sizeof_long_long" = 8; then
 482   AC_CHECK_TYPE(bits64_t, [long long])
 483 elif test "$ac_cv_sizeof_long" = 8; then
 484   AC_CHECK_TYPE(bits64_t, long)
 485 else
 486   AC_CHECK_TYPE(bits64_t, double)
 487 fi
 488 ])
 489
 490 AC_DEFUN(BASH_TYPE_LONG_LONG,
 491 [
 492 AC_CACHE_CHECK([for long long], bash_cv_type_long_long,
 493 [AC_TRY_LINK([
 494 long long ll = 1; int i = 63;],
 495 [
 496 long long llm = (long long) -1;
 497 return ll << i | ll >> i | llm / ll | llm % ll;
 498 ], bash_cv_type_long_long='long long', bash_cv_type_long_long='long')])
 499 if test "$bash_cv_type_long_long" = 'long long'; then
 500   AC_DEFINE(HAVE_LONG_LONG, 1)
 501 fi
 502 ])
 503
 504 AC_DEFUN(BASH_TYPE_UNSIGNED_LONG_LONG,
 505 [
 506 AC_CACHE_CHECK([for unsigned long long], bash_cv_type_unsigned_long_long,
 507 [AC_TRY_LINK([
 508 unsigned long long ull = 1; int i = 63;],
 509 [
 510 unsigned long long ullmax = (unsigned long long) -1;
 511 return ull << i | ull >> i | ullmax / ull | ullmax % ull;
 512 ], bash_cv_type_unsigned_long_long='unsigned long long',
 513    bash_cv_type_unsigned_long_long='unsigned long')])
 514 if test "$bash_cv_type_unsigned_long_long" = 'unsigned long long'; then
 515   AC_DEFINE(HAVE_UNSIGNED_LONG_LONG, 1)
 516 fi
 517 ])
 518
 519 dnl
 520 dnl Type of struct rlimit fields: some systems (OSF/1, NetBSD, RISC/os 5.0)
 521 dnl have a rlim_t, others (4.4BSD based systems) use quad_t, others use
 522 dnl long and still others use int (HP-UX 9.01, SunOS 4.1.3).  To simplify
 523 dnl matters, this just checks for rlim_t, quad_t, or long.
 524 dnl
 525 AC_DEFUN(BASH_TYPE_RLIMIT,
 526 [AC_MSG_CHECKING(for size and type of struct rlimit fields)
 527 AC_CACHE_VAL(bash_cv_type_rlimit,
 528 [AC_TRY_COMPILE([#include <sys/types.h>
 529 #include <sys/resource.h>],
 530 [rlim_t xxx;], bash_cv_type_rlimit=rlim_t,[
 531 AC_TRY_RUN([
 532 #include <sys/types.h>
 533 #include <sys/time.h>
 534 #include <sys/resource.h>
 535 #include <stdlib.h>
 536 int
 537 main()
 538 {
 539 #ifdef HAVE_QUAD_T
 540   struct rlimit rl;
 541   if (sizeof(rl.rlim_cur) == sizeof(quad_t))
 542     exit(0);
 543 #endif
 544   exit(1);
 545 }], bash_cv_type_rlimit=quad_t, bash_cv_type_rlimit=long,
 546         [AC_MSG_WARN(cannot check quad_t if cross compiling -- defaulting to long)
 547          bash_cv_type_rlimit=long])])
 548 ])
 549 AC_MSG_RESULT($bash_cv_type_rlimit)
 550 if test $bash_cv_type_rlimit = quad_t; then
 551 AC_DEFINE(RLIMTYPE, quad_t)
 552 elif test $bash_cv_type_rlimit = rlim_t; then
 553 AC_DEFINE(RLIMTYPE, rlim_t)
 554 fi
 555 ])
 556
 557 AC_DEFUN(BASH_TYPE_SIG_ATOMIC_T,
 558 [AC_CACHE_CHECK([for sig_atomic_t in signal.h], ac_cv_have_sig_atomic_t,
 559 [AC_TRY_LINK([
 560 #include <signal.h>
 561 ],[ sig_atomic_t x; ],
 562 ac_cv_have_sig_atomic_t=yes, ac_cv_have_sig_atomic_t=no)])
 563 if test "$ac_cv_have_sig_atomic_t" = "no"
 564 then
 565     AC_CHECK_TYPE(sig_atomic_t,int)
 566 fi
 567 ])
 568
 569 AC_DEFUN(BASH_FUNC_LSTAT,
 570 [dnl Cannot use AC_CHECK_FUNCS(lstat) because Linux defines lstat() as an
 571 dnl inline function in <sys/stat.h>.
 572 AC_CACHE_CHECK([for lstat], bash_cv_func_lstat,
 573 [AC_TRY_LINK([
 574 #include <sys/types.h>
 575 #include <sys/stat.h>
 576 ],[ lstat(".",(struct stat *)0); ],
 577 bash_cv_func_lstat=yes, bash_cv_func_lstat=no)])
 578 if test $bash_cv_func_lstat = yes; then
 579   AC_DEFINE(HAVE_LSTAT)
 580 fi
 581 ])
 582
 583 AC_DEFUN(BASH_FUNC_INET_ATON,
 584 [
 585 AC_CACHE_CHECK([for inet_aton], bash_cv_func_inet_aton,
 586 [AC_TRY_LINK([
 587 #include <sys/types.h>
 588 #include <netinet/in.h>
 589 #include <arpa/inet.h>
 590 struct in_addr ap;], [ inet_aton("127.0.0.1", &ap); ],
 591 bash_cv_func_inet_aton=yes, bash_cv_func_inet_aton=no)])
 592 if test $bash_cv_func_inet_aton = yes; then
 593   AC_DEFINE(HAVE_INET_ATON)
 594 else
 595   AC_LIBOBJ(inet_aton)
 596 fi
 597 ])
 598
 599 AC_DEFUN(BASH_FUNC_GETENV,
 600 [AC_MSG_CHECKING(to see if getenv can be redefined)
 601 AC_CACHE_VAL(bash_cv_getenv_redef,
 602 [AC_TRY_RUN([
 603 #ifdef HAVE_UNISTD_H
 604 #  include <unistd.h>
 605 #endif
 606 #include <stdlib.h>
 607 #ifndef __STDC__
 608 #  ifndef const
 609 #    define const
 610 #  endif
 611 #endif
 612 char *
 613 getenv (name)
 614 #if defined (__linux__) || defined (__bsdi__) || defined (convex)
 615      const char *name;
 616 #else
 617      char const *name;
 618 #endif /* !__linux__ && !__bsdi__ && !convex */
 619 {
 620 return "42";
 621 }
 622 int
 623 main()
 624 {
 625 char *s;
 626 /* The next allows this program to run, but does not allow bash to link
 627    when it redefines getenv.  I'm not really interested in figuring out
 628    why not. */
 629 #if defined (NeXT)
 630 exit(1);
 631 #endif
 632 s = getenv("ABCDE");
 633 exit(s == 0);   /* force optimizer to leave getenv in */
 634 }
 635 ], bash_cv_getenv_redef=yes, bash_cv_getenv_redef=no,
 636    [AC_MSG_WARN(cannot check getenv redefinition if cross compiling -- defaulting to yes)
 637     bash_cv_getenv_redef=yes]
 638 )])
 639 AC_MSG_RESULT($bash_cv_getenv_redef)
 640 if test $bash_cv_getenv_redef = yes; then
 641 AC_DEFINE(CAN_REDEFINE_GETENV)
 642 fi
 643 ])
 644
 645 # We should check for putenv before calling this
 646 AC_DEFUN(BASH_FUNC_STD_PUTENV,
 647 [
 648 AC_REQUIRE([AC_HEADER_STDC])
 649 AC_REQUIRE([AC_C_PROTOTYPES])
 650 AC_CACHE_CHECK([for standard-conformant putenv declaration], bash_cv_std_putenv,
 651 [AC_TRY_LINK([
 652 #if STDC_HEADERS
 653 #include <stdlib.h>
 654 #include <stddef.h>
 655 #endif
 656 #ifndef __STDC__
 657 #  ifndef const
 658 #    define const
 659 #  endif
 660 #endif
 661 #ifdef PROTOTYPES
 662 extern int putenv (char *);
 663 #else
 664 extern int putenv ();
 665 #endif
 666 ],
 667 [return (putenv == 0);],
 668 bash_cv_std_putenv=yes, bash_cv_std_putenv=no
 669 )])
 670 if test $bash_cv_std_putenv = yes; then
 671 AC_DEFINE(HAVE_STD_PUTENV)
 672 fi
 673 ])
 674
 675 # We should check for unsetenv before calling this
 676 AC_DEFUN(BASH_FUNC_STD_UNSETENV,
 677 [
 678 AC_REQUIRE([AC_HEADER_STDC])
 679 AC_REQUIRE([AC_C_PROTOTYPES])
 680 AC_CACHE_CHECK([for standard-conformant unsetenv declaration], bash_cv_std_unsetenv,
 681 [AC_TRY_LINK([
 682 #if STDC_HEADERS
 683 #include <stdlib.h>
 684 #include <stddef.h>
 685 #endif
 686 #ifndef __STDC__
 687 #  ifndef const
 688 #    define const
 689 #  endif
 690 #endif
 691 #ifdef PROTOTYPES
 692 extern int unsetenv (const char *);
 693 #else
 694 extern int unsetenv ();
 695 #endif
 696 ],
 697 [return (unsetenv == 0);],
 698 bash_cv_std_unsetenv=yes, bash_cv_std_unsetenv=no
 699 )])
 700 if test $bash_cv_std_unsetenv = yes; then
 701 AC_DEFINE(HAVE_STD_UNSETENV)
 702 fi
 703 ])
 704
 705 AC_DEFUN(BASH_FUNC_ULIMIT_MAXFDS,
 706 [AC_MSG_CHECKING(whether ulimit can substitute for getdtablesize)
 707 AC_CACHE_VAL(bash_cv_ulimit_maxfds,
 708 [AC_TRY_RUN([
 709 #include <stdlib.h>
 710 #ifdef HAVE_ULIMIT_H
 711 #include <ulimit.h>
 712 #endif
 713 int
 714 main()
 715 {
 716 long maxfds = ulimit(4, 0L);
 717 exit (maxfds == -1L);
 718 }
 719 ], bash_cv_ulimit_maxfds=yes, bash_cv_ulimit_maxfds=no,
 720    [AC_MSG_WARN(cannot check ulimit if cross compiling -- defaulting to no)
 721     bash_cv_ulimit_maxfds=no]
 722 )])
 723 AC_MSG_RESULT($bash_cv_ulimit_maxfds)
 724 if test $bash_cv_ulimit_maxfds = yes; then
 725 AC_DEFINE(ULIMIT_MAXFDS)
 726 fi
 727 ])
 728
 729 AC_DEFUN(BASH_FUNC_GETCWD,
 730 [AC_MSG_CHECKING([if getcwd() will dynamically allocate memory with 0 size])
 731 AC_CACHE_VAL(bash_cv_getcwd_malloc,
 732 [AC_TRY_RUN([
 733 #include <stdio.h>
 734 #ifdef HAVE_UNISTD_H
 735 #include <unistd.h>
 736 #endif
 737 #include <stdlib.h>
 738
 739 int
 740 main()
 741 {
 742         char    *xpwd;
 743         xpwd = getcwd(0, 0);
 744         exit (xpwd == 0);
 745 }
 746 ], bash_cv_getcwd_malloc=yes, bash_cv_getcwd_malloc=no,
 747    [AC_MSG_WARN(cannot check whether getcwd allocates memory when cross-compiling -- defaulting to no)
 748     bash_cv_getcwd_malloc=no]
 749 )])
 750 AC_MSG_RESULT($bash_cv_getcwd_malloc)
 751 if test $bash_cv_getcwd_malloc = no; then
 752 AC_DEFINE(GETCWD_BROKEN)
 753 AC_LIBOBJ(getcwd)
 754 fi
 755 ])
 756
 757 dnl
 758 dnl This needs BASH_CHECK_SOCKLIB, but since that's not called on every
 759 dnl system, we can't use AC_PREREQ
 760 dnl
 761 AC_DEFUN(BASH_FUNC_GETHOSTBYNAME,
 762 [if test "X$bash_cv_have_gethostbyname" = "X"; then
 763 _bash_needmsg=yes
 764 else
 765 AC_MSG_CHECKING(for gethostbyname in socket library)
 766 _bash_needmsg=
 767 fi
 768 AC_CACHE_VAL(bash_cv_have_gethostbyname,
 769 [AC_TRY_LINK([#include <netdb.h>],
 770 [ struct hostent *hp;
 771   hp = gethostbyname("localhost");
 772 ], bash_cv_have_gethostbyname=yes, bash_cv_have_gethostbyname=no)]
 773 )
 774 if test "X$_bash_needmsg" = Xyes; then
 775     AC_MSG_CHECKING(for gethostbyname in socket library)
 776 fi
 777 AC_MSG_RESULT($bash_cv_have_gethostbyname)
 778 if test "$bash_cv_have_gethostbyname" = yes; then
 779 AC_DEFINE(HAVE_GETHOSTBYNAME)
 780 fi
 781 ])
 782
 783 AC_DEFUN(BASH_FUNC_FNMATCH_EXTMATCH,
 784 [AC_MSG_CHECKING(if fnmatch does extended pattern matching with FNM_EXTMATCH)
 785 AC_CACHE_VAL(bash_cv_fnm_extmatch,
 786 [AC_TRY_RUN([
 787 #include <fnmatch.h>
 788
 789 int
 790 main()
 791 {
 792 #ifdef FNM_EXTMATCH
 793   return (0);
 794 #else
 795   return (1);
 796 #endif
 797 }
 798 ], bash_cv_fnm_extmatch=yes, bash_cv_fnm_extmatch=no,
 799     [AC_MSG_WARN(cannot check FNM_EXTMATCH if cross compiling -- defaulting to no)
 800      bash_cv_fnm_extmatch=no])
 801 ])
 802 AC_MSG_RESULT($bash_cv_fnm_extmatch)
 803 if test $bash_cv_fnm_extmatch = yes; then
 804 AC_DEFINE(HAVE_LIBC_FNM_EXTMATCH)
 805 fi
 806 ])
 807
 808 AC_DEFUN(BASH_FUNC_POSIX_SETJMP,
 809 [AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE])
 810 AC_MSG_CHECKING(for presence of POSIX-style sigsetjmp/siglongjmp)
 811 AC_CACHE_VAL(bash_cv_func_sigsetjmp,
 812 [AC_TRY_RUN([
 813 #ifdef HAVE_UNISTD_H
 814 #include <unistd.h>
 815 #endif
 816 #include <sys/types.h>
 817 #include <signal.h>
 818 #include <setjmp.h>
 819 #include <stdlib.h>
 820
 821 int
 822 main()
 823 {
 824 #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
 825 exit (1);
 826 #else
 827
 828 int code;
 829 sigset_t set, oset;
 830 sigjmp_buf xx;
 831
 832 /* get the mask */
 833 sigemptyset(&set);
 834 sigemptyset(&oset);
 835 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &set);
 836 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset);
 837
 838 /* save it */
 839 code = sigsetjmp(xx, 1);
 840 if (code)
 841   exit(0);      /* could get sigmask and compare to oset here. */
 842
 843 /* change it */
 844 sigaddset(&set, SIGINT);
 845 sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL);
 846
 847 /* and siglongjmp */
 848 siglongjmp(xx, 10);
 849 exit(1);
 850 #endif
 851 }], bash_cv_func_sigsetjmp=present, bash_cv_func_sigsetjmp=missing,
 852     [AC_MSG_WARN(cannot check for sigsetjmp/siglongjmp if cross-compiling -- defaulting to missing)
 853      bash_cv_func_sigsetjmp=missing]
 854 )])
 855 AC_MSG_RESULT($bash_cv_func_sigsetjmp)
 856 if test $bash_cv_func_sigsetjmp = present; then
 857 AC_DEFINE(HAVE_POSIX_SIGSETJMP)
 858 fi
 859 ])
 860
 861 AC_DEFUN(BASH_FUNC_STRCOLL,
 862 [
 863 AC_MSG_CHECKING(whether or not strcoll and strcmp differ)
 864 AC_CACHE_VAL(bash_cv_func_strcoll_broken,
 865 [AC_TRY_RUN([
 866 #include <stdio.h>
 867 #if defined (HAVE_LOCALE_H)
 868 #include <locale.h>
 869 #endif
 870 #include <string.h>
 871 #include <stdlib.h>
 872
 873 int
 874 main(c, v)
 875 int     c;
 876 char    *v[];
 877 {
 878         int     r1, r2;
 879         char    *deflocale, *defcoll;
 880
 881 #ifdef HAVE_SETLOCALE
 882         deflocale = setlocale(LC_ALL, "");
 883         defcoll = setlocale(LC_COLLATE, "");
 884 #endif
 885
 886 #ifdef HAVE_STRCOLL
 887         /* These two values are taken from tests/glob-test. */
 888         r1 = strcoll("abd", "aXd");
 889 #else
 890         r1 = 0;
 891 #endif
 892         r2 = strcmp("abd", "aXd");
 893
 894         /* These two should both be greater than 0.  It is permissible for
 895            a system to return different values, as long as the sign is the
 896            same. */
 897
 898         /* Exit with 1 (failure) if these two values are both > 0, since
 899            this tests whether strcoll(3) is broken with respect to strcmp(3)
 900            in the default locale. */
 901         exit (r1 > 0 && r2 > 0);
 902 }
 903 ], bash_cv_func_strcoll_broken=yes, bash_cv_func_strcoll_broken=no,
 904    [AC_MSG_WARN(cannot check strcoll if cross compiling -- defaulting to no)
 905     bash_cv_func_strcoll_broken=no]
 906 )])
 907 AC_MSG_RESULT($bash_cv_func_strcoll_broken)
 908 if test $bash_cv_func_strcoll_broken = yes; then
 909 AC_DEFINE(STRCOLL_BROKEN)
 910 fi
 911 ])
 912
 913 AC_DEFUN(BASH_FUNC_PRINTF_A_FORMAT,
 914 [AC_MSG_CHECKING([for printf floating point output in hex notation])
 915 AC_CACHE_VAL(bash_cv_printf_a_format,
 916 [AC_TRY_RUN([
 917 #include <stdio.h>
 918 #include <string.h>
 919 #include <stdlib.h>
 920
 921 int
 922 main()
 923 {
 924         double y = 0.0;
 925         char abuf[1024];
 926
 927         sprintf(abuf, "%A", y);
 928         exit(strchr(abuf, 'P') == (char *)0);
 929 }
 930 ], bash_cv_printf_a_format=yes, bash_cv_printf_a_format=no,
 931    [AC_MSG_WARN(cannot check printf if cross compiling -- defaulting to no)
 932     bash_cv_printf_a_format=no]
 933 )])
 934 AC_MSG_RESULT($bash_cv_printf_a_format)
 935 if test $bash_cv_printf_a_format = yes; then
 936 AC_DEFINE(HAVE_PRINTF_A_FORMAT)
 937 fi
 938 ])
 939
 940 AC_DEFUN(BASH_STRUCT_TERMIOS_LDISC,
 941 [
 942 AC_CHECK_MEMBER(struct termios.c_line, AC_DEFINE(TERMIOS_LDISC), ,[
 943 #include <sys/types.h>
 944 #include <termios.h>
 945 ])
 946 ])
 947
 948 AC_DEFUN(BASH_STRUCT_TERMIO_LDISC,
 949 [
 950 AC_CHECK_MEMBER(struct termio.c_line, AC_DEFINE(TERMIO_LDISC), ,[
 951 #include <sys/types.h>
 952 #include <termio.h>
 953 ])
 954 ])
 955
 956 dnl
 957 dnl Like AC_STRUCT_ST_BLOCKS, but doesn't muck with LIBOBJS
 958 dnl
 959 dnl sets bash_cv_struct_stat_st_blocks
 960 dnl
 961 dnl unused for now; we'll see how AC_CHECK_MEMBERS works
 962 dnl
 963 AC_DEFUN(BASH_STRUCT_ST_BLOCKS,
 964 [
 965 AC_MSG_CHECKING([for struct stat.st_blocks])
 966 AC_CACHE_VAL(bash_cv_struct_stat_st_blocks,
 967 [AC_TRY_COMPILE(
 968 [
 969 #include <sys/types.h>
 970 #include <sys/stat.h>
 971 ],
 972 [
 973 int
 974 main()
 975 {
 976 static struct stat a;
 977 if (a.st_blocks) return 0;
 978 return 0;
 979 }
 980 ], bash_cv_struct_stat_st_blocks=yes, bash_cv_struct_stat_st_blocks=no)
 981 ])
 982 AC_MSG_RESULT($bash_cv_struct_stat_st_blocks)
 983 if test "$bash_cv_struct_stat_st_blocks" = "yes"; then
 984 AC_DEFINE(HAVE_STRUCT_STAT_ST_BLOCKS)
 985 fi
 986 ])
 987
 988 AC_DEFUN([BASH_CHECK_LIB_TERMCAP],
 989 [
 990 if test "X$bash_cv_termcap_lib" = "X"; then
 991 _bash_needmsg=yes
 992 else
 993 AC_MSG_CHECKING(which library has the termcap functions)
 994 _bash_needmsg=
 995 fi
 996 AC_CACHE_VAL(bash_cv_termcap_lib,
 997 [AC_CHECK_FUNC(tgetent, bash_cv_termcap_lib=libc,
 998   [AC_CHECK_LIB(termcap, tgetent, bash_cv_termcap_lib=libtermcap,
 999     [AC_CHECK_LIB(tinfo, tgetent, bash_cv_termcap_lib=libtinfo,
1000         [AC_CHECK_LIB(curses, tgetent, bash_cv_termcap_lib=libcurses,
1001             [AC_CHECK_LIB(ncurses, tgetent, bash_cv_termcap_lib=libncurses,
1002                 [AC_CHECK_LIB(ncursesw, tgetent, bash_cv_termcap_lib=libncursesw,
1003                     bash_cv_termcap_lib=gnutermcap)])])])])])])
1004 if test "X$_bash_needmsg" = "Xyes"; then
1005 AC_MSG_CHECKING(which library has the termcap functions)
1006 fi
1007 AC_MSG_RESULT(using $bash_cv_termcap_lib)
1008 if test $bash_cv_termcap_lib = gnutermcap && test -z "$prefer_curses"; then
1009 LDFLAGS="$LDFLAGS -L./lib/termcap"
1010 TERMCAP_LIB="./lib/termcap/libtermcap.a"
1011 TERMCAP_DEP="./lib/termcap/libtermcap.a"
1012 elif test $bash_cv_termcap_lib = libtermcap && test -z "$prefer_curses"; then
1013 TERMCAP_LIB=-ltermcap
1014 TERMCAP_DEP=
1015 elif test $bash_cv_termcap_lib = libtinfo; then
1016 TERMCAP_LIB=-ltinfo
1017 TERMCAP_DEP=
1018 elif test $bash_cv_termcap_lib = libncurses; then
1019 TERMCAP_LIB=-lncurses
1020 TERMCAP_DEP=
1021 elif test $bash_cv_termcap_lib = libc; then
1022 TERMCAP_LIB=
1023 TERMCAP_DEP=
1024 else
1025 TERMCAP_LIB=-lcurses
1026 TERMCAP_DEP=
1027 fi
1028 ])
1029
1030 dnl
1031 dnl Check for the presence of getpeername in libsocket.
1032 dnl If libsocket is present, check for libnsl and add it to LIBS if
1033 dnl it's there, since most systems with libsocket require linking
1034 dnl with libnsl as well.  This should only be called if getpeername
1035 dnl was not found in libc.
1036 dnl
1037 dnl NOTE: IF WE FIND GETPEERNAME, WE ASSUME THAT WE HAVE BIND/CONNECT
1038 dnl       AS WELL
1039 dnl
1040 AC_DEFUN(BASH_CHECK_LIB_SOCKET,
1041 [
1042 if test "X$bash_cv_have_socklib" = "X"; then
1043 _bash_needmsg=
1044 else
1045 AC_MSG_CHECKING(for socket library)
1046 _bash_needmsg=yes
1047 fi
1048 AC_CACHE_VAL(bash_cv_have_socklib,
1049 [AC_CHECK_LIB(socket, getpeername,
1050         bash_cv_have_socklib=yes, bash_cv_have_socklib=no, -lnsl)])
1051 if test "X$_bash_needmsg" = Xyes; then
1052   AC_MSG_RESULT($bash_cv_have_socklib)
1053   _bash_needmsg=
1054 fi
1055 if test $bash_cv_have_socklib = yes; then
1056   # check for libnsl, add it to LIBS if present
1057   if test "X$bash_cv_have_libnsl" = "X"; then
1058     _bash_needmsg=
1059   else
1060     AC_MSG_CHECKING(for libnsl)
1061     _bash_needmsg=yes
1062   fi
1063   AC_CACHE_VAL(bash_cv_have_libnsl,
1064            [AC_CHECK_LIB(nsl, t_open,
1065                  bash_cv_have_libnsl=yes, bash_cv_have_libnsl=no)])
1066   if test "X$_bash_needmsg" = Xyes; then
1067     AC_MSG_RESULT($bash_cv_have_libnsl)
1068     _bash_needmsg=
1069   fi
1070   if test $bash_cv_have_libnsl = yes; then
1071     LIBS="-lsocket -lnsl $LIBS"
1072   else
1073     LIBS="-lsocket $LIBS"
1074   fi
1075   AC_DEFINE(HAVE_LIBSOCKET)
1076   AC_DEFINE(HAVE_GETPEERNAME)
1077 fi
1078 ])
1079
1080 AC_DEFUN(BASH_STRUCT_DIRENT_D_INO,
1081 [AC_REQUIRE([AC_HEADER_DIRENT])
1082 AC_MSG_CHECKING(for struct dirent.d_ino)
1083 AC_CACHE_VAL(bash_cv_dirent_has_dino,
1084 [AC_TRY_COMPILE([
1085 #include <stdio.h>
1086 #include <sys/types.h>
1087 #ifdef HAVE_UNISTD_H
1088 # include <unistd.h>
1089 #endif /* HAVE_UNISTD_H */
1090 #if defined(HAVE_DIRENT_H)
1091 # include <dirent.h>
1092 #else
1093 # define dirent direct
1094 # ifdef HAVE_SYS_NDIR_H
1095 #  include <sys/ndir.h>
1096 # endif /* SYSNDIR */
1097 # ifdef HAVE_SYS_DIR_H
1098 #  include <sys/dir.h>
1099 # endif /* SYSDIR */
1100 # ifdef HAVE_NDIR_H
1101 #  include <ndir.h>
1102 # endif
1103 #endif /* HAVE_DIRENT_H */
1104 ],[
1105 struct dirent d; int z; z = d.d_ino;
1106 ], bash_cv_dirent_has_dino=yes, bash_cv_dirent_has_dino=no)])
1107 AC_MSG_RESULT($bash_cv_dirent_has_dino)
1108 if test $bash_cv_dirent_has_dino = yes; then
1109 AC_DEFINE(HAVE_STRUCT_DIRENT_D_INO)
1110 fi
1111 ])
1112
1113 AC_DEFUN(BASH_STRUCT_DIRENT_D_FILENO,
1114 [AC_REQUIRE([AC_HEADER_DIRENT])
1115 AC_MSG_CHECKING(for struct dirent.d_fileno)
1116 AC_CACHE_VAL(bash_cv_dirent_has_d_fileno,
1117 [AC_TRY_COMPILE([
1118 #include <stdio.h>
1119 #include <sys/types.h>
1120 #ifdef HAVE_UNISTD_H
1121 # include <unistd.h>
1122 #endif /* HAVE_UNISTD_H */
1123 #if defined(HAVE_DIRENT_H)
1124 # include <dirent.h>
1125 #else
1126 # define dirent direct
1127 # ifdef HAVE_SYS_NDIR_H
1128 #  include <sys/ndir.h>
1129 # endif /* SYSNDIR */
1130 # ifdef HAVE_SYS_DIR_H
1131 #  include <sys/dir.h>
1132 # endif /* SYSDIR */
1133 # ifdef HAVE_NDIR_H
1134 #  include <ndir.h>
1135 # endif
1136 #endif /* HAVE_DIRENT_H */
1137 ],[
1138 struct dirent d; int z; z = d.d_fileno;
1139 ], bash_cv_dirent_has_d_fileno=yes, bash_cv_dirent_has_d_fileno=no)])
1140 AC_MSG_RESULT($bash_cv_dirent_has_d_fileno)
1141 if test $bash_cv_dirent_has_d_fileno = yes; then
1142 AC_DEFINE(HAVE_STRUCT_DIRENT_D_FILENO)
1143 fi
1144 ])
1145
1146 AC_DEFUN(BASH_STRUCT_DIRENT_D_NAMLEN,
1147 [AC_REQUIRE([AC_HEADER_DIRENT])
1148 AC_MSG_CHECKING(for struct dirent.d_namlen)
1149 AC_CACHE_VAL(bash_cv_dirent_has_d_namlen,
1150 [AC_TRY_COMPILE([
1151 #include <stdio.h>
1152 #include <sys/types.h>
1153 #ifdef HAVE_UNISTD_H
1154 # include <unistd.h>
1155 #endif /* HAVE_UNISTD_H */
1156 #if defined(HAVE_DIRENT_H)
1157 # include <dirent.h>
1158 #else
1159 # define dirent direct
1160 # ifdef HAVE_SYS_NDIR_H
1161 #  include <sys/ndir.h>
1162 # endif /* SYSNDIR */
1163 # ifdef HAVE_SYS_DIR_H
1164 #  include <sys/dir.h>
1165 # endif /* SYSDIR */
1166 # ifdef HAVE_NDIR_H
1167 #  include <ndir.h>
1168 # endif
1169 #endif /* HAVE_DIRENT_H */
1170 ],[
1171 struct dirent d; int z; z = d.d_namlen;
1172 ], bash_cv_dirent_has_d_namlen=yes, bash_cv_dirent_has_d_namlen=no)])
1173 AC_MSG_RESULT($bash_cv_dirent_has_d_namlen)
1174 if test $bash_cv_dirent_has_d_namlen = yes; then
1175 AC_DEFINE(HAVE_STRUCT_DIRENT_D_NAMLEN)
1176 fi
1177 ])
1178
1179 AC_DEFUN(BASH_STRUCT_TIMEVAL,
1180 [AC_MSG_CHECKING(for struct timeval in sys/time.h and time.h)
1181 AC_CACHE_VAL(bash_cv_struct_timeval,
1182 [AC_COMPILE_IFELSE(
1183         [AC_LANG_PROGRAM(
1184                 [[#if HAVE_SYS_TIME_H
1185                   #include <sys/time.h>
1186                   #endif
1187                   #include <time.h>
1188                 ]],
1189                 [[static struct timeval x; x.tv_sec = x.tv_usec;]]
1190         )],
1191         bash_cv_struct_timeval=yes,
1192         bash_cv_struct_timeval=no)
1193 ])
1194 AC_MSG_RESULT($bash_cv_struct_timeval)
1195 if test $bash_cv_struct_timeval = yes; then
1196   AC_DEFINE(HAVE_TIMEVAL)
1197 fi
1198 ])
1199
1200 AC_DEFUN(BASH_STRUCT_TIMEZONE,
1201 [AC_MSG_CHECKING(for struct timezone in sys/time.h and time.h)
1202 AC_CACHE_VAL(bash_cv_struct_timezone,
1203 [
1204 AC_EGREP_HEADER(struct timezone, sys/time.h,
1205                 bash_cv_struct_timezone=yes,
1206                 AC_EGREP_HEADER(struct timezone, time.h,
1207                         bash_cv_struct_timezone=yes,
1208                         bash_cv_struct_timezone=no))
1209 ])
1210 AC_MSG_RESULT($bash_cv_struct_timezone)
1211 if test $bash_cv_struct_timezone = yes; then
1212   AC_DEFINE(HAVE_STRUCT_TIMEZONE)
1213 fi
1214 ])
1215
1216 AC_DEFUN(BASH_STRUCT_WINSIZE,
1217 [AC_MSG_CHECKING(for struct winsize in sys/ioctl.h and termios.h)
1218 AC_CACHE_VAL(bash_cv_struct_winsize_header,
1219 [AC_TRY_COMPILE([#include <sys/types.h>
1220 #include <sys/ioctl.h>], [struct winsize x;],
1221   bash_cv_struct_winsize_header=ioctl_h,
1222   [AC_TRY_COMPILE([#include <sys/types.h>
1223 #include <termios.h>], [struct winsize x;],
1224   bash_cv_struct_winsize_header=termios_h, bash_cv_struct_winsize_header=other)
1225 ])])
1226 if test $bash_cv_struct_winsize_header = ioctl_h; then
1227   AC_MSG_RESULT(sys/ioctl.h)
1228   AC_DEFINE(STRUCT_WINSIZE_IN_SYS_IOCTL)
1229 elif test $bash_cv_struct_winsize_header = termios_h; then
1230   AC_MSG_RESULT(termios.h)
1231   AC_DEFINE(STRUCT_WINSIZE_IN_TERMIOS)
1232 else
1233   AC_MSG_RESULT(not found)
1234 fi
1235 ])
1236
1237 dnl Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7)
1238 AC_DEFUN(BASH_SYS_SIGNAL_VINTAGE,
1239 [AC_REQUIRE([AC_TYPE_SIGNAL])
1240 AC_MSG_CHECKING(for type of signal functions)
1241 AC_CACHE_VAL(bash_cv_signal_vintage,
1242 [
1243   AC_TRY_LINK([#include <signal.h>],[
1244     sigset_t ss;
1245     struct sigaction sa;
1246     sigemptyset(&ss); sigsuspend(&ss);
1247     sigaction(SIGINT, &sa, (struct sigaction *) 0);
1248     sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0);
1249   ], bash_cv_signal_vintage=posix,
1250   [
1251     AC_TRY_LINK([#include <signal.h>], [
1252         int mask = sigmask(SIGINT);
1253         sigsetmask(mask); sigblock(mask); sigpause(mask);
1254     ], bash_cv_signal_vintage=4.2bsd,
1255     [
1256       AC_TRY_LINK([
1257         #include <signal.h>
1258         RETSIGTYPE foo() { }], [
1259                 int mask = sigmask(SIGINT);
1260                 sigset(SIGINT, foo); sigrelse(SIGINT);
1261                 sighold(SIGINT); sigpause(SIGINT);
1262         ], bash_cv_signal_vintage=svr3, bash_cv_signal_vintage=v7
1263     )]
1264   )]
1265 )
1266 ])
1267 AC_MSG_RESULT($bash_cv_signal_vintage)
1268 if test "$bash_cv_signal_vintage" = posix; then
1269 AC_DEFINE(HAVE_POSIX_SIGNALS)
1270 elif test "$bash_cv_signal_vintage" = "4.2bsd"; then
1271 AC_DEFINE(HAVE_BSD_SIGNALS)
1272 elif test "$bash_cv_signal_vintage" = svr3; then
1273 AC_DEFINE(HAVE_USG_SIGHOLD)
1274 fi
1275 ])
1276
1277 dnl Check if the pgrp of setpgrp() can't be the pid of a zombie process.
1278 AC_DEFUN(BASH_SYS_PGRP_SYNC,
1279 [AC_REQUIRE([AC_FUNC_GETPGRP])
1280 AC_MSG_CHECKING(whether pgrps need synchronization)
1281 AC_CACHE_VAL(bash_cv_pgrp_pipe,
1282 [AC_TRY_RUN([
1283 #ifdef HAVE_UNISTD_H
1284 #  include <unistd.h>
1285 #endif
1286 #ifdef HAVE_SYS_WAIT_H
1287 #  include <sys/wait.h>
1288 #endif
1289 #include <stdlib.h>
1290 int
1291 main()
1292 {
1293 # ifdef GETPGRP_VOID
1294 #  define getpgID()     getpgrp()
1295 # else
1296 #  define getpgID()     getpgrp(0)
1297 #  define setpgid(x,y)  setpgrp(x,y)
1298 # endif
1299         int pid1, pid2, fds[2];
1300         int status;
1301         char ok;
1302
1303         switch (pid1 = fork()) {
1304           case -1:
1305             exit(1);
1306           case 0:
1307             setpgid(0, getpid());
1308             exit(0);
1309         }
1310         setpgid(pid1, pid1);
1311
1312         sleep(2);       /* let first child die */
1313
1314         if (pipe(fds) < 0)
1315           exit(2);
1316
1317         switch (pid2 = fork()) {
1318           case -1:
1319             exit(3);
1320           case 0:
1321             setpgid(0, pid1);
1322             ok = getpgID() == pid1;
1323             write(fds[1], &ok, 1);
1324             exit(0);
1325         }
1326         setpgid(pid2, pid1);
1327
1328         close(fds[1]);
1329         if (read(fds[0], &ok, 1) != 1)
1330           exit(4);
1331         wait(&status);
1332         wait(&status);
1333         exit(ok ? 0 : 5);
1334 }
1335 ], bash_cv_pgrp_pipe=no,bash_cv_pgrp_pipe=yes,
1336    [AC_MSG_WARN(cannot check pgrp synchronization if cross compiling -- defaulting to no)
1337     bash_cv_pgrp_pipe=no])
1338 ])
1339 AC_MSG_RESULT($bash_cv_pgrp_pipe)
1340 if test $bash_cv_pgrp_pipe = yes; then
1341 AC_DEFINE(PGRP_PIPE)
1342 fi
1343 ])
1344
1345 AC_DEFUN(BASH_SYS_REINSTALL_SIGHANDLERS,
1346 [AC_REQUIRE([AC_TYPE_SIGNAL])
1347 AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE])
1348 AC_MSG_CHECKING([if signal handlers must be reinstalled when invoked])
1349 AC_CACHE_VAL(bash_cv_must_reinstall_sighandlers,
1350 [AC_TRY_RUN([
1351 #include <signal.h>
1352 #ifdef HAVE_UNISTD_H
1353 #include <unistd.h>
1354 #endif
1355 #include <stdlib.h>
1356
1357 typedef RETSIGTYPE sigfunc();
1358
1359 volatile int nsigint;
1360
1361 #ifdef HAVE_POSIX_SIGNALS
1362 sigfunc *
1363 set_signal_handler(sig, handler)
1364      int sig;
1365      sigfunc *handler;
1366 {
1367   struct sigaction act, oact;
1368   act.sa_handler = handler;
1369   act.sa_flags = 0;
1370   sigemptyset (&act.sa_mask);
1371   sigemptyset (&oact.sa_mask);
1372   sigaction (sig, &act, &oact);
1373   return (oact.sa_handler);
1374 }
1375 #else
1376 #define set_signal_handler(s, h) signal(s, h)
1377 #endif
1378
1379 RETSIGTYPE
1380 sigint(s)
1381 int s;
1382 {
1383   nsigint++;
1384 }
1385
1386 int
1387 main()
1388 {
1389         nsigint = 0;
1390         set_signal_handler(SIGINT, sigint);
1391         kill((int)getpid(), SIGINT);
1392         kill((int)getpid(), SIGINT);
1393         exit(nsigint != 2);
1394 }
1395 ], bash_cv_must_reinstall_sighandlers=no, bash_cv_must_reinstall_sighandlers=yes,
1396    [AC_MSG_WARN(cannot check signal handling if cross compiling -- defaulting to no)
1397     bash_cv_must_reinstall_sighandlers=no]
1398 )])
1399 AC_MSG_RESULT($bash_cv_must_reinstall_sighandlers)
1400 if test $bash_cv_must_reinstall_sighandlers = yes; then
1401 AC_DEFINE(MUST_REINSTALL_SIGHANDLERS)
1402 fi
1403 ])
1404
1405 dnl check that some necessary job control definitions are present
1406 AC_DEFUN(BASH_SYS_JOB_CONTROL_MISSING,
1407 [AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE])
1408 AC_MSG_CHECKING(for presence of necessary job control definitions)
1409 AC_CACHE_VAL(bash_cv_job_control_missing,
1410 [AC_TRY_COMPILE([
1411 #include <sys/types.h>
1412 #ifdef HAVE_SYS_WAIT_H
1413 #include <sys/wait.h>
1414 #endif
1415 #ifdef HAVE_UNISTD_H
1416 #include <unistd.h>
1417 #endif
1418 #include <signal.h>
1419
1420 /* add more tests in here as appropriate */
1421
1422 /* signal type */
1423 #if !defined (HAVE_POSIX_SIGNALS) && !defined (HAVE_BSD_SIGNALS)
1424 #error
1425 #endif
1426
1427 /* signals and tty control. */
1428 #if !defined (SIGTSTP) || !defined (SIGSTOP) || !defined (SIGCONT)
1429 #error
1430 #endif
1431
1432 /* process control */
1433 #if !defined (WNOHANG) || !defined (WUNTRACED)
1434 #error
1435 #endif
1436
1437 /* Posix systems have tcgetpgrp and waitpid. */
1438 #if defined (_POSIX_VERSION) && !defined (HAVE_TCGETPGRP)
1439 #error
1440 #endif
1441
1442 #if defined (_POSIX_VERSION) && !defined (HAVE_WAITPID)
1443 #error
1444 #endif
1445
1446 /* Other systems have TIOCSPGRP/TIOCGPRGP and wait3. */
1447 #if !defined (_POSIX_VERSION) && !defined (HAVE_WAIT3)
1448 #error
1449 #endif
1450
1451 ], , bash_cv_job_control_missing=present, bash_cv_job_control_missing=missing
1452 )])
1453 AC_MSG_RESULT($bash_cv_job_control_missing)
1454 if test $bash_cv_job_control_missing = missing; then
1455 AC_DEFINE(JOB_CONTROL_MISSING)
1456 fi
1457 ])
1458
1459 dnl check whether named pipes are present
1460 dnl this requires a previous check for mkfifo, but that is awkward to specify
1461 AC_DEFUN(BASH_SYS_NAMED_PIPES,
1462 [AC_MSG_CHECKING(for presence of named pipes)
1463 AC_CACHE_VAL(bash_cv_sys_named_pipes,
1464 [AC_TRY_RUN([
1465 #include <sys/types.h>
1466 #include <sys/stat.h>
1467 #ifdef HAVE_UNISTD_H
1468 #include <unistd.h>
1469 #endif
1470 #include <stdio.h>
1471 #include <stdlib.h>
1472
1473 /* Add more tests in here as appropriate. */
1474 int
1475 main()
1476 {
1477 int fd, err;
1478
1479 #if defined (HAVE_MKFIFO)
1480 exit (0);
1481 #endif
1482
1483 #if !defined (S_IFIFO) && (defined (_POSIX_VERSION) && !defined (S_ISFIFO))
1484 exit (1);
1485 #endif
1486
1487 #if defined (NeXT)
1488 exit (1);
1489 #endif
1490 err = mkdir("bash-aclocal", 0700);
1491 if (err < 0) {
1492   perror ("mkdir");
1493   exit(1);
1494 }
1495 fd = mknod ("bash-aclocal/sh-np-autoconf", 0666 | S_IFIFO, 0);
1496 if (fd == -1) {
1497   rmdir ("bash-aclocal");
1498   exit (1);
1499 }
1500 close(fd);
1501 unlink ("bash-aclocal/sh-np-autoconf");
1502 rmdir ("bash-aclocal");
1503 exit(0);
1504 }], bash_cv_sys_named_pipes=present, bash_cv_sys_named_pipes=missing,
1505     [AC_MSG_WARN(cannot check for named pipes if cross-compiling -- defaulting to missing)
1506      bash_cv_sys_named_pipes=missing]
1507 )])
1508 AC_MSG_RESULT($bash_cv_sys_named_pipes)
1509 if test $bash_cv_sys_named_pipes = missing; then
1510 AC_DEFINE(NAMED_PIPES_MISSING)
1511 fi
1512 ])
1513
1514 AC_DEFUN(BASH_SYS_DEFAULT_MAIL_DIR,
1515 [AC_MSG_CHECKING(for default mail directory)
1516 AC_CACHE_VAL(bash_cv_mail_dir,
1517 [if test -d /var/mail; then
1518    bash_cv_mail_dir=/var/mail
1519  elif test -d /var/spool/mail; then
1520    bash_cv_mail_dir=/var/spool/mail
1521  elif test -d /usr/mail; then
1522    bash_cv_mail_dir=/usr/mail
1523  elif test -d /usr/spool/mail; then
1524    bash_cv_mail_dir=/usr/spool/mail
1525  else
1526    bash_cv_mail_dir=unknown
1527  fi
1528 ])
1529 AC_MSG_RESULT($bash_cv_mail_dir)
1530 AC_DEFINE_UNQUOTED(DEFAULT_MAIL_DIRECTORY, "$bash_cv_mail_dir")
1531 ])
1532
1533 AC_DEFUN(BASH_HAVE_TIOCGWINSZ,
1534 [AC_MSG_CHECKING(for TIOCGWINSZ in sys/ioctl.h)
1535 AC_CACHE_VAL(bash_cv_tiocgwinsz_in_ioctl,
1536 [AC_TRY_COMPILE([#include <sys/types.h>
1537 #include <sys/ioctl.h>], [int x = TIOCGWINSZ;],
1538   bash_cv_tiocgwinsz_in_ioctl=yes,bash_cv_tiocgwinsz_in_ioctl=no)])
1539 AC_MSG_RESULT($bash_cv_tiocgwinsz_in_ioctl)
1540 if test $bash_cv_tiocgwinsz_in_ioctl = yes; then
1541 AC_DEFINE(GWINSZ_IN_SYS_IOCTL)
1542 fi
1543 ])
1544
1545 AC_DEFUN(BASH_HAVE_TIOCSTAT,
1546 [AC_MSG_CHECKING(for TIOCSTAT in sys/ioctl.h)
1547 AC_CACHE_VAL(bash_cv_tiocstat_in_ioctl,
1548 [AC_TRY_COMPILE([#include <sys/types.h>
1549 #include <sys/ioctl.h>], [int x = TIOCSTAT;],
1550   bash_cv_tiocstat_in_ioctl=yes,bash_cv_tiocstat_in_ioctl=no)])
1551 AC_MSG_RESULT($bash_cv_tiocstat_in_ioctl)
1552 if test $bash_cv_tiocstat_in_ioctl = yes; then
1553 AC_DEFINE(TIOCSTAT_IN_SYS_IOCTL)
1554 fi
1555 ])
1556
1557 AC_DEFUN(BASH_HAVE_FIONREAD,
1558 [AC_MSG_CHECKING(for FIONREAD in sys/ioctl.h)
1559 AC_CACHE_VAL(bash_cv_fionread_in_ioctl,
1560 [AC_TRY_COMPILE([#include <sys/types.h>
1561 #include <sys/ioctl.h>], [int x = FIONREAD;],
1562   bash_cv_fionread_in_ioctl=yes,bash_cv_fionread_in_ioctl=no)])
1563 AC_MSG_RESULT($bash_cv_fionread_in_ioctl)
1564 if test $bash_cv_fionread_in_ioctl = yes; then
1565 AC_DEFINE(FIONREAD_IN_SYS_IOCTL)
1566 fi
1567 ])
1568
1569 dnl
1570 dnl See if speed_t is declared in <sys/types.h>.  Some versions of linux
1571 dnl require a definition of speed_t each time <termcap.h> is included,
1572 dnl but you can only get speed_t if you include <termios.h> (on some
1573 dnl versions) or <sys/types.h> (on others).
1574 dnl
1575 AC_DEFUN(BASH_CHECK_SPEED_T,
1576 [AC_MSG_CHECKING(for speed_t in sys/types.h)
1577 AC_CACHE_VAL(bash_cv_speed_t_in_sys_types,
1578 [AC_TRY_COMPILE([#include <sys/types.h>], [speed_t x;],
1579   bash_cv_speed_t_in_sys_types=yes,bash_cv_speed_t_in_sys_types=no)])
1580 AC_MSG_RESULT($bash_cv_speed_t_in_sys_types)
1581 if test $bash_cv_speed_t_in_sys_types = yes; then
1582 AC_DEFINE(SPEED_T_IN_SYS_TYPES)
1583 fi
1584 ])
1585
1586 AC_DEFUN(BASH_CHECK_GETPW_FUNCS,
1587 [AC_MSG_CHECKING(whether getpw functions are declared in pwd.h)
1588 AC_CACHE_VAL(bash_cv_getpw_declared,
1589 [AC_EGREP_CPP(getpwuid,
1590 [
1591 #include <sys/types.h>
1592 #ifdef HAVE_UNISTD_H
1593 #  include <unistd.h>
1594 #endif
1595 #include <pwd.h>
1596 ],
1597 bash_cv_getpw_declared=yes,bash_cv_getpw_declared=no)])
1598 AC_MSG_RESULT($bash_cv_getpw_declared)
1599 if test $bash_cv_getpw_declared = yes; then
1600 AC_DEFINE(HAVE_GETPW_DECLS)
1601 fi
1602 ])
1603
1604 AC_DEFUN(BASH_CHECK_DEV_FD,
1605 [AC_MSG_CHECKING(whether /dev/fd is available)
1606 AC_CACHE_VAL(bash_cv_dev_fd,
1607 [bash_cv_dev_fd=""
1608 if test -d /dev/fd  && (exec test -r /dev/fd/0 < /dev/null) ; then
1609 # check for systems like FreeBSD 5 that only provide /dev/fd/[012]
1610    if (exec test -r /dev/fd/3 3</dev/null) ; then
1611      bash_cv_dev_fd=standard
1612    else
1613      bash_cv_dev_fd=absent
1614    fi
1615 fi
1616 if test -z "$bash_cv_dev_fd" ; then
1617   if test -d /proc/self/fd && (exec test -r /proc/self/fd/0 < /dev/null) ; then
1618     bash_cv_dev_fd=whacky
1619   else
1620     bash_cv_dev_fd=absent
1621   fi
1622 fi
1623 ])
1624 AC_MSG_RESULT($bash_cv_dev_fd)
1625 if test $bash_cv_dev_fd = "standard"; then
1626   AC_DEFINE(HAVE_DEV_FD)
1627   AC_DEFINE(DEV_FD_PREFIX, "/dev/fd/")
1628 elif test $bash_cv_dev_fd = "whacky"; then
1629   AC_DEFINE(HAVE_DEV_FD)
1630   AC_DEFINE(DEV_FD_PREFIX, "/proc/self/fd/")
1631 fi
1632 ])
1633
1634 AC_DEFUN(BASH_CHECK_DEV_STDIN,
1635 [AC_MSG_CHECKING(whether /dev/stdin stdout stderr are available)
1636 AC_CACHE_VAL(bash_cv_dev_stdin,
1637 [if (exec test -r /dev/stdin < /dev/null) ; then
1638    bash_cv_dev_stdin=present
1639  else
1640    bash_cv_dev_stdin=absent
1641  fi
1642 ])
1643 AC_MSG_RESULT($bash_cv_dev_stdin)
1644 if test $bash_cv_dev_stdin = "present"; then
1645   AC_DEFINE(HAVE_DEV_STDIN)
1646 fi
1647 ])
1648
1649 dnl
1650 dnl Check if HPUX needs _KERNEL defined for RLIMIT_* definitions
1651 dnl
1652 AC_DEFUN(BASH_CHECK_KERNEL_RLIMIT,
1653 [AC_MSG_CHECKING([whether $host_os needs _KERNEL for RLIMIT defines])
1654 AC_CACHE_VAL(bash_cv_kernel_rlimit,
1655 [AC_TRY_COMPILE([
1656 #include <sys/types.h>
1657 #include <sys/resource.h>
1658 ],
1659 [
1660   int f;
1661   f = RLIMIT_DATA;
1662 ], bash_cv_kernel_rlimit=no,
1663 [AC_TRY_COMPILE([
1664 #include <sys/types.h>
1665 #define _KERNEL
1666 #include <sys/resource.h>
1667 #undef _KERNEL
1668 ],
1669 [
1670         int f;
1671         f = RLIMIT_DATA;
1672 ], bash_cv_kernel_rlimit=yes, bash_cv_kernel_rlimit=no)]
1673 )])
1674 AC_MSG_RESULT($bash_cv_kernel_rlimit)
1675 if test $bash_cv_kernel_rlimit = yes; then
1676 AC_DEFINE(RLIMIT_NEEDS_KERNEL)
1677 fi
1678 ])
1679
1680 dnl
1681 dnl Check for 64-bit off_t -- used for malloc alignment
1682 dnl
1683 dnl C does not allow duplicate case labels, so the compile will fail if
1684 dnl sizeof(off_t) is > 4.
1685 dnl
1686 AC_DEFUN(BASH_CHECK_OFF_T_64,
1687 [AC_CACHE_CHECK(for 64-bit off_t, bash_cv_off_t_64,
1688 AC_TRY_COMPILE([
1689 #ifdef HAVE_UNISTD_H
1690 #include <unistd.h>
1691 #endif
1692 #include <sys/types.h>
1693 ],[
1694 switch (0) case 0: case (sizeof (off_t) <= 4):;
1695 ], bash_cv_off_t_64=no, bash_cv_off_t_64=yes))
1696 if test $bash_cv_off_t_64 = yes; then
1697         AC_DEFINE(HAVE_OFF_T_64)
1698 fi])
1699
1700 AC_DEFUN(BASH_CHECK_RTSIGS,
1701 [AC_MSG_CHECKING(for unusable real-time signals due to large values)
1702 AC_CACHE_VAL(bash_cv_unusable_rtsigs,
1703 [AC_TRY_RUN([
1704 #include <sys/types.h>
1705 #include <signal.h>
1706 #include <stdlib.h>
1707
1708 #ifndef NSIG
1709 #  define NSIG 64
1710 #endif
1711
1712 int
1713 main ()
1714 {
1715   int n_sigs = 2 * NSIG;
1716 #ifdef SIGRTMIN
1717   int rtmin = SIGRTMIN;
1718 #else
1719   int rtmin = 0;
1720 #endif
1721
1722   exit(rtmin < n_sigs);
1723 }], bash_cv_unusable_rtsigs=yes, bash_cv_unusable_rtsigs=no,
1724     [AC_MSG_WARN(cannot check real-time signals if cross compiling -- defaulting to yes)
1725      bash_cv_unusable_rtsigs=yes]
1726 )])
1727 AC_MSG_RESULT($bash_cv_unusable_rtsigs)
1728 if test $bash_cv_unusable_rtsigs = yes; then
1729 AC_DEFINE(UNUSABLE_RT_SIGNALS)
1730 fi
1731 ])
1732
1733 dnl
1734 dnl check for availability of multibyte characters and functions
1735 dnl
1736 dnl geez, I wish I didn't have to check for all of this stuff separately
1737 dnl
1738 AC_DEFUN(BASH_CHECK_MULTIBYTE,
1739 [
1740 AC_CHECK_HEADERS(wctype.h)
1741 AC_CHECK_HEADERS(wchar.h)
1742 AC_CHECK_HEADERS(langinfo.h)
1743
1744 AC_CHECK_HEADERS(mbstr.h)
1745
1746 AC_CHECK_FUNC(mbrlen, AC_DEFINE(HAVE_MBRLEN))
1747 AC_CHECK_FUNC(mbscasecmp, AC_DEFINE(HAVE_MBSCMP))
1748 AC_CHECK_FUNC(mbscmp, AC_DEFINE(HAVE_MBSCMP))
1749 AC_CHECK_FUNC(mbsnrtowcs, AC_DEFINE(HAVE_MBSNRTOWCS))
1750 AC_CHECK_FUNC(mbsrtowcs, AC_DEFINE(HAVE_MBSRTOWCS))
1751
1752 AC_REPLACE_FUNCS(mbschr)
1753
1754 AC_CHECK_FUNC(wcrtomb, AC_DEFINE(HAVE_WCRTOMB))
1755 AC_CHECK_FUNC(wcscoll, AC_DEFINE(HAVE_WCSCOLL))
1756 AC_CHECK_FUNC(wcsdup, AC_DEFINE(HAVE_WCSDUP))
1757 AC_CHECK_FUNC(wcwidth, AC_DEFINE(HAVE_WCWIDTH))
1758 AC_CHECK_FUNC(wctype, AC_DEFINE(HAVE_WCTYPE))
1759
1760 AC_REPLACE_FUNCS(wcswidth)
1761
1762 dnl checks for both mbrtowc and mbstate_t
1763 AC_FUNC_MBRTOWC
1764 if test $ac_cv_func_mbrtowc = yes; then
1765         AC_DEFINE(HAVE_MBSTATE_T)
1766 fi
1767
1768 AC_CHECK_FUNCS(iswlower iswupper towlower towupper iswctype)
1769
1770 AC_CACHE_CHECK([for nl_langinfo and CODESET], bash_cv_langinfo_codeset,
1771 [AC_TRY_LINK(
1772 [#include <langinfo.h>],
1773 [char* cs = nl_langinfo(CODESET);],
1774 bash_cv_langinfo_codeset=yes, bash_cv_langinfo_codeset=no)])
1775 if test $bash_cv_langinfo_codeset = yes; then
1776   AC_DEFINE(HAVE_LANGINFO_CODESET)
1777 fi
1778
1779 dnl check for wchar_t in <wchar.h>
1780 AC_CACHE_CHECK([for wchar_t in wchar.h], bash_cv_type_wchar_t,
1781 [AC_TRY_COMPILE(
1782 [#include <wchar.h>
1783 ],
1784 [
1785         wchar_t foo;
1786         foo = 0;
1787 ], bash_cv_type_wchar_t=yes, bash_cv_type_wchar_t=no)])
1788 if test $bash_cv_type_wchar_t = yes; then
1789         AC_DEFINE(HAVE_WCHAR_T, 1, [systems should define this type here])
1790 fi
1791
1792 dnl check for wctype_t in <wctype.h>
1793 AC_CACHE_CHECK([for wctype_t in wctype.h], bash_cv_type_wctype_t,
1794 [AC_TRY_COMPILE(
1795 [#include <wctype.h>],
1796 [
1797         wctype_t foo;
1798         foo = 0;
1799 ], bash_cv_type_wctype_t=yes, bash_cv_type_wctype_t=no)])
1800 if test $bash_cv_type_wctype_t = yes; then
1801         AC_DEFINE(HAVE_WCTYPE_T, 1, [systems should define this type here])
1802 fi
1803
1804 dnl check for wint_t in <wctype.h>
1805 AC_CACHE_CHECK([for wint_t in wctype.h], bash_cv_type_wint_t,
1806 [AC_TRY_COMPILE(
1807 [#include <wctype.h>],
1808 [
1809         wint_t foo;
1810         foo = 0;
1811 ], bash_cv_type_wint_t=yes, bash_cv_type_wint_t=no)])
1812 if test $bash_cv_type_wint_t = yes; then
1813         AC_DEFINE(HAVE_WINT_T, 1, [systems should define this type here])
1814 fi
1815
1816 dnl check for broken wcwidth
1817 AC_CACHE_CHECK([for wcwidth broken with unicode combining characters],
1818 bash_cv_wcwidth_broken,
1819 [AC_TRY_RUN([
1820 #include <unistd.h>
1821 #include <stdlib.h>
1822 #include <stdio.h>
1823
1824 #include <locale.h>
1825 #include <wchar.h>
1826
1827 int
1828 main(c, v)
1829 int     c;
1830 char    **v;
1831 {
1832         int     w;
1833
1834         setlocale(LC_ALL, "en_US.UTF-8");
1835         w = wcwidth (0x0301);
1836         exit (w == 0);  /* exit 0 if wcwidth broken */
1837 }
1838 ],
1839 bash_cv_wcwidth_broken=yes, bash_cv_wcwidth_broken=no, bash_cv_wcwidth_broken=no)])
1840 if test "$bash_cv_wcwidth_broken" = yes; then
1841         AC_DEFINE(WCWIDTH_BROKEN, 1, [wcwidth is usually not broken])
1842 fi
1843
1844 if test "$am_cv_func_iconv" = yes; then
1845         OLDLIBS="$LIBS"
1846         LIBS="$LIBS $LIBINTL $LIBICONV"
1847         AC_CHECK_FUNCS(locale_charset)
1848         LIBS="$OLDLIBS"
1849 fi
1850
1851 AC_CHECK_SIZEOF(wchar_t, 4)
1852
1853 ])
1854
1855 dnl need: prefix exec_prefix libdir includedir CC TERMCAP_LIB
1856 dnl require:
1857 dnl     AC_PROG_CC
1858 dnl     BASH_CHECK_LIB_TERMCAP
1859
1860 AC_DEFUN([RL_LIB_READLINE_VERSION],
1861 [
1862 AC_REQUIRE([BASH_CHECK_LIB_TERMCAP])
1863
1864 AC_MSG_CHECKING([version of installed readline library])
1865
1866 # What a pain in the ass this is.
1867
1868 # save cpp and ld options
1869 _save_CFLAGS="$CFLAGS"
1870 _save_LDFLAGS="$LDFLAGS"
1871 _save_LIBS="$LIBS"
1872
1873 # Don't set ac_cv_rl_prefix if the caller has already assigned a value.  This
1874 # allows the caller to do something like $_rl_prefix=$withval if the user
1875 # specifies --with-installed-readline=PREFIX as an argument to configure
1876
1877 if test -z "$ac_cv_rl_prefix"; then
1878 test "x$prefix" = xNONE && ac_cv_rl_prefix=$ac_default_prefix || ac_cv_rl_prefix=${prefix}
1879 fi
1880
1881 eval ac_cv_rl_includedir=${ac_cv_rl_prefix}/include
1882 eval ac_cv_rl_libdir=${ac_cv_rl_prefix}/lib
1883
1884 LIBS="$LIBS -lreadline ${TERMCAP_LIB}"
1885 CFLAGS="$CFLAGS -I${ac_cv_rl_includedir}"
1886 LDFLAGS="$LDFLAGS -L${ac_cv_rl_libdir}"
1887
1888 AC_CACHE_VAL(ac_cv_rl_version,
1889 [AC_TRY_RUN([
1890 #include <stdio.h>
1891 #include <readline/readline.h>
1892 #include <stdlib.h>
1893
1894 extern int rl_gnu_readline_p;
1895
1896 int
1897 main()
1898 {
1899         FILE *fp;
1900         fp = fopen("conftest.rlv", "w");
1901         if (fp == 0)
1902                 exit(1);
1903         if (rl_gnu_readline_p != 1)
1904                 fprintf(fp, "0.0\n");
1905         else
1906                 fprintf(fp, "%s\n", rl_library_version ? rl_library_version : "0.0");
1907         fclose(fp);
1908         exit(0);
1909 }
1910 ],
1911 ac_cv_rl_version=`cat conftest.rlv`,
1912 ac_cv_rl_version='0.0',
1913 ac_cv_rl_version='8.0')])
1914
1915 CFLAGS="$_save_CFLAGS"
1916 LDFLAGS="$_save_LDFLAGS"
1917 LIBS="$_save_LIBS"
1918
1919 RL_MAJOR=0
1920 RL_MINOR=0
1921
1922 # (
1923 case "$ac_cv_rl_version" in
1924 2*|3*|4*|5*|6*|7*|8*|9*)
1925         RL_MAJOR=`echo $ac_cv_rl_version | sed 's:\..*$::'`
1926         RL_MINOR=`echo $ac_cv_rl_version | sed -e 's:^.*\.::' -e 's:[[a-zA-Z]]*$::'`
1927         ;;
1928 esac
1929
1930 # (((
1931 case $RL_MAJOR in
1932 [[0-9][0-9]])   _RL_MAJOR=$RL_MAJOR ;;
1933 [[0-9]])        _RL_MAJOR=0$RL_MAJOR ;;
1934 *)              _RL_MAJOR=00 ;;
1935 esac
1936
1937 # (((
1938 case $RL_MINOR in
1939 [[0-9][0-9]])   _RL_MINOR=$RL_MINOR ;;
1940 [[0-9]])        _RL_MINOR=0$RL_MINOR ;;
1941 *)              _RL_MINOR=00 ;;
1942 esac
1943
1944 RL_VERSION="0x${_RL_MAJOR}${_RL_MINOR}"
1945
1946 # Readline versions greater than 4.2 have these defines in readline.h
1947
1948 if test $ac_cv_rl_version = '0.0' ; then
1949         AC_MSG_WARN([Could not test version of installed readline library.])
1950 elif test $RL_MAJOR -gt 4 || { test $RL_MAJOR = 4 && test $RL_MINOR -gt 2 ; } ; then
1951         # set these for use by the caller
1952         RL_PREFIX=$ac_cv_rl_prefix
1953         RL_LIBDIR=$ac_cv_rl_libdir
1954         RL_INCLUDEDIR=$ac_cv_rl_includedir
1955         AC_MSG_RESULT($ac_cv_rl_version)
1956 else
1957
1958 AC_DEFINE_UNQUOTED(RL_READLINE_VERSION, $RL_VERSION, [encoded version of the installed readline library])
1959 AC_DEFINE_UNQUOTED(RL_VERSION_MAJOR, $RL_MAJOR, [major version of installed readline library])
1960 AC_DEFINE_UNQUOTED(RL_VERSION_MINOR, $RL_MINOR, [minor version of installed readline library])
1961
1962 AC_SUBST(RL_VERSION)
1963 AC_SUBST(RL_MAJOR)
1964 AC_SUBST(RL_MINOR)
1965
1966 # set these for use by the caller
1967 RL_PREFIX=$ac_cv_rl_prefix
1968 RL_LIBDIR=$ac_cv_rl_libdir
1969 RL_INCLUDEDIR=$ac_cv_rl_includedir
1970
1971 AC_MSG_RESULT($ac_cv_rl_version)
1972
1973 fi
1974 ])
1975
1976 AC_DEFUN(BASH_FUNC_CTYPE_NONASCII,
1977 [
1978 AC_MSG_CHECKING(whether the ctype macros accept non-ascii characters)
1979 AC_CACHE_VAL(bash_cv_func_ctype_nonascii,
1980 [AC_TRY_RUN([
1981 #ifdef HAVE_LOCALE_H
1982 #include <locale.h>
1983 #endif
1984 #include <stdio.h>
1985 #include <ctype.h>
1986 #include <stdlib.h>
1987
1988 int
1989 main(c, v)
1990 int     c;
1991 char    *v[];
1992 {
1993         char    *deflocale;
1994         unsigned char x;
1995         int     r1, r2;
1996
1997 #ifdef HAVE_SETLOCALE
1998         /* We take a shot here.  If that locale is not known, try the
1999            system default.  We try this one because '\342' (226) is
2000            known to be a printable character in that locale. */
2001         deflocale = setlocale(LC_ALL, "en_US.ISO8859-1");
2002         if (deflocale == 0)
2003                 deflocale = setlocale(LC_ALL, "");
2004 #endif
2005
2006         x = '\342';
2007         r1 = isprint(x);
2008         x -= 128;
2009         r2 = isprint(x);
2010         exit (r1 == 0 || r2 == 0);
2011 }
2012 ], bash_cv_func_ctype_nonascii=yes, bash_cv_func_ctype_nonascii=no,
2013    [AC_MSG_WARN(cannot check ctype macros if cross compiling -- defaulting to no)
2014     bash_cv_func_ctype_nonascii=no]
2015 )])
2016 AC_MSG_RESULT($bash_cv_func_ctype_nonascii)
2017 if test $bash_cv_func_ctype_nonascii = yes; then
2018 AC_DEFINE(CTYPE_NON_ASCII)
2019 fi
2020 ])
2021
2022 AC_DEFUN(BASH_CHECK_WCONTINUED,
2023 [
2024 AC_MSG_CHECKING(whether WCONTINUED flag to waitpid is unavailable or available but broken)
2025 AC_CACHE_VAL(bash_cv_wcontinued_broken,
2026 [AC_TRY_RUN([
2027 #include <sys/types.h>
2028 #include <sys/wait.h>
2029 #include <unistd.h>
2030 #include <errno.h>
2031 #include <stdlib.h>
2032
2033 #ifndef errno
2034 extern int errno;
2035 #endif
2036 int
2037 main()
2038 {
2039         int     x;
2040
2041         x = waitpid(-1, (int *)0, WNOHANG|WCONTINUED);
2042         if (x == -1 && errno == EINVAL)
2043                 exit (1);
2044         else
2045                 exit (0);
2046 }
2047 ], bash_cv_wcontinued_broken=no,bash_cv_wcontinued_broken=yes,
2048    [AC_MSG_WARN(cannot check WCONTINUED if cross compiling -- defaulting to no)
2049     bash_cv_wcontinued_broken=no]
2050 )])
2051 AC_MSG_RESULT($bash_cv_wcontinued_broken)
2052 if test $bash_cv_wcontinued_broken = yes; then
2053 AC_DEFINE(WCONTINUED_BROKEN)
2054 fi
2055 ])
2056
2057 dnl
2058 dnl tests added for bashdb
2059 dnl
2060
2061
2062 AC_DEFUN([AM_PATH_LISPDIR],
2063  [AC_ARG_WITH(lispdir, AC_HELP_STRING([--with-lispdir], [override the default lisp directory]),
2064   [ lispdir="$withval"
2065     AC_MSG_CHECKING([where .elc files should go])
2066     AC_MSG_RESULT([$lispdir])],
2067   [
2068   # If set to t, that means we are running in a shell under Emacs.
2069   # If you have an Emacs named "t", then use the full path.
2070   test x"$EMACS" = xt && EMACS=
2071   AC_CHECK_PROGS(EMACS, emacs xemacs, no)
2072   if test $EMACS != "no"; then
2073     if test x${lispdir+set} != xset; then
2074       AC_CACHE_CHECK([where .elc files should go], [am_cv_lispdir], [dnl
2075         am_cv_lispdir=`$EMACS -batch -q -eval '(while load-path (princ (concat (car load-path) "\n")) (setq load-path (cdr load-path)))' | sed -n -e 's,/$,,' -e '/.*\/lib\/\(x\?emacs\/site-lisp\)$/{s,,${libdir}/\1,;p;q;}' -e '/.*\/share\/\(x\?emacs\/site-lisp\)$/{s,,${datadir}/\1,;p;q;}'`
2076         if test -z "$am_cv_lispdir"; then
2077           am_cv_lispdir='${datadir}/emacs/site-lisp'
2078         fi
2079       ])
2080       lispdir="$am_cv_lispdir"
2081     fi
2082   fi
2083  ])
2084  AC_SUBST(lispdir)
2085 ])
2086
2087 dnl From gnulib
2088 AC_DEFUN([BASH_FUNC_FPURGE],
2089 [
2090   AC_CHECK_FUNCS_ONCE([fpurge])
2091   AC_CHECK_FUNCS_ONCE([__fpurge])
2092   AC_CHECK_DECLS([fpurge], , , [#include <stdio.h>])
2093 ])
2094
2095 AC_DEFUN([BASH_FUNC_SNPRINTF],
2096 [
2097   AC_CHECK_FUNCS_ONCE([snprintf])
2098   if test X$ac_cv_func_snprintf = Xyes; then
2099     AC_CACHE_CHECK([for standard-conformant snprintf], [bash_cv_func_snprintf],
2100       [AC_TRY_RUN([
2101 #include <stdio.h>
2102 #include <stdlib.h>
2103
2104 int
2105 main()
2106 {
2107   int n;
2108   n = snprintf (0, 0, "%s", "0123456");
2109   exit(n != 7);
2110 }
2111 ], bash_cv_func_snprintf=yes, bash_cv_func_snprintf=no,
2112    [AC_MSG_WARN([cannot check standard snprintf if cross-compiling])
2113     bash_cv_func_snprintf=yes]
2114 )])
2115     if test $bash_cv_func_snprintf = no; then
2116       ac_cv_func_snprintf=no
2117     fi
2118   fi
2119   if test $ac_cv_func_snprintf = no; then
2120     AC_DEFINE(HAVE_SNPRINTF, 0,
2121       [Define if you have a standard-conformant snprintf function.])
2122   fi
2123 ])
2124
2125 AC_DEFUN([BASH_FUNC_VSNPRINTF],
2126 [
2127   AC_CHECK_FUNCS_ONCE([vsnprintf])
2128   if test X$ac_cv_func_vsnprintf = Xyes; then
2129     AC_CACHE_CHECK([for standard-conformant vsnprintf], [bash_cv_func_vsnprintf],
2130       [AC_TRY_RUN([
2131 #if HAVE_STDARG_H
2132 #include <stdarg.h>
2133 #else
2134 #include <varargs.h>
2135 #endif
2136 #include <stdio.h>
2137 #include <stdlib.h>
2138
2139 static int
2140 #if HAVE_STDARG_H
2141 foo(const char *fmt, ...)
2142 #else
2143 foo(format, va_alist)
2144      const char *format;
2145      va_dcl
2146 #endif
2147 {
2148   va_list args;
2149   int n;
2150
2151 #if HAVE_STDARG_H
2152   va_start(args, fmt);
2153 #else
2154   va_start(args);
2155 #endif
2156   n = vsnprintf(0, 0, fmt, args);
2157   va_end (args);
2158   return n;
2159 }
2160
2161 int
2162 main()
2163 {
2164   int n;
2165   n = foo("%s", "0123456");
2166   exit(n != 7);
2167 }
2168 ], bash_cv_func_vsnprintf=yes, bash_cv_func_vsnprintf=no,
2169    [AC_MSG_WARN([cannot check standard vsnprintf if cross-compiling])
2170     bash_cv_func_vsnprintf=yes]
2171 )])
2172     if test $bash_cv_func_vsnprintf = no; then
2173       ac_cv_func_vsnprintf=no
2174     fi
2175   fi
2176   if test $ac_cv_func_vsnprintf = no; then
2177     AC_DEFINE(HAVE_VSNPRINTF, 0,
2178       [Define if you have a standard-conformant vsnprintf function.])
2179   fi
2180 ])
2181
2182 AC_DEFUN(BASH_STRUCT_WEXITSTATUS_OFFSET,
2183 [AC_MSG_CHECKING(for offset of exit status in return status from wait)
2184 AC_CACHE_VAL(bash_cv_wexitstatus_offset,
2185 [AC_TRY_RUN([
2186 #include <stdlib.h>
2187 #include <unistd.h>
2188
2189 #include <sys/wait.h>
2190
2191 int
2192 main(c, v)
2193      int c;
2194      char **v;
2195 {
2196   pid_t pid, p;
2197   int s, i, n;
2198
2199   s = 0;
2200   pid = fork();
2201   if (pid == 0)
2202     exit (42);
2203
2204   /* wait for the process */
2205   p = wait(&s);
2206   if (p != pid)
2207     exit (255);
2208
2209   /* crack s */
2210   for (i = 0; i < (sizeof(s) * 8); i++)
2211     {
2212       n = (s >> i) & 0xff;
2213       if (n == 42)
2214         exit (i);
2215     }
2216
2217   exit (254);
2218 }
2219 ], bash_cv_wexitstatus_offset=0, bash_cv_wexitstatus_offset=$?,
2220    [AC_MSG_WARN(cannot check WEXITSTATUS offset if cross compiling -- defaulting to 0)
2221     bash_cv_wexitstatus_offset=0]
2222 )])
2223 if test "$bash_cv_wexitstatus_offset" -gt 32 ; then
2224   AC_MSG_WARN(bad exit status from test program -- defaulting to 0)
2225   bash_cv_wexitstatus_offset=0
2226 fi
2227 AC_MSG_RESULT($bash_cv_wexitstatus_offset)
2228 AC_DEFINE_UNQUOTED([WEXITSTATUS_OFFSET], [$bash_cv_wexitstatus_offset], [Offset of exit status in wait status word])
2229 ])
2230
2231 AC_DEFUN([BASH_FUNC_SBRK],
2232 [
2233   AC_MSG_CHECKING([for sbrk])
2234   AC_CACHE_VAL(ac_cv_func_sbrk,
2235   [AC_TRY_LINK([#include <unistd.h>],
2236   [ void *x = sbrk (4096); ],
2237   ac_cv_func_sbrk=yes, ac_cv_func_sbrk=no)])
2238   AC_MSG_RESULT($ac_cv_func_sbrk)
2239   if test X$ac_cv_func_sbrk = Xyes; then
2240     AC_CACHE_CHECK([for working sbrk], [bash_cv_func_sbrk],
2241       [AC_TRY_RUN([
2242 #include <stdlib.h>
2243 #include <unistd.h>
2244
2245 int
2246 main(int c, char **v)
2247 {
2248         void *x;
2249
2250         x = sbrk (4096);
2251         exit ((x == (void *)-1) ? 1 : 0);
2252 }
2253 ], bash_cv_func_sbrk=yes, bash_cv_func_snprintf=sbrk,
2254    [AC_MSG_WARN([cannot check working sbrk if cross-compiling])
2255     bash_cv_func_sbrk=yes]
2256 )])
2257     if test $bash_cv_func_sbrk = no; then
2258       ac_cv_func_sbrk=no
2259     fi
2260   fi
2261   if test $ac_cv_func_sbrk = yes; then
2262     AC_DEFINE(HAVE_SBRK, 1,
2263       [Define if you have a working sbrk function.])
2264   fi
2265 ])
2266
2267 AC_DEFUN(BASH_FUNC_FNMATCH_EQUIV_FALLBACK,
2268 [AC_MSG_CHECKING(whether fnmatch can be used to check bracket equivalence classes)
2269 AC_CACHE_VAL(bash_cv_fnmatch_equiv_fallback,
2270 [AC_TRY_RUN([
2271 #include <stdlib.h>
2272 #include <unistd.h>
2273 #include <stdio.h>
2274 #include <fnmatch.h>
2275 #include <locale.h>
2276
2277 char *pattern = "[[=a=]]";
2278
2279 /* char *string = "ä"; */
2280 unsigned char string[4] = { '\xc3', '\xa4', '\0' };
2281
2282 int
2283 main (int c, char **v)
2284 {
2285   setlocale (LC_ALL, "en_US.UTF-8");
2286   if (fnmatch (pattern, (const char *)string, 0) != FNM_NOMATCH)
2287     exit (0);
2288   exit (1);
2289 }
2290
2291 ], bash_cv_fnmatch_equiv_fallback=yes, bash_cv_fnmatch_equiv_fallback=no,
2292    [AC_MSG_WARN(cannot check fnmatch if cross compiling -- defaulting to no)
2293     bash_cv_fnmatch_equiv_fallback=no]
2294 )])
2295 AC_MSG_RESULT($bash_cv_fnmatch_equiv_fallback)
2296 if test "$bash_cv_fnmatch_equiv_fallback" = "yes" ; then
2297     bash_cv_fnmatch_equiv_value=1
2298 else
2299     bash_cv_fnmatch_equiv_value=0
2300 fi
2301 AC_DEFINE_UNQUOTED([FNMATCH_EQUIV_FALLBACK], [$bash_cv_fnmatch_equiv_value], [Whether fnmatch can be used for bracket equivalence classes])
2302 ])