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 int
  14 main()
  15 {
  16 long long foo = 0;
  17 exit(sizeof(long long) < sizeof(long));
  18 }
  19 ], ac_cv_c_long_long=yes, ac_cv_c_long_long=no)
  20 fi])
  21 if test $ac_cv_c_long_long = yes; then
  22   AC_DEFINE(HAVE_LONG_LONG, 1, [Define if the `long long' type works.])
  23 fi
  24 ])
  25
  26 dnl
  27 dnl This is very similar to AC_C_LONG_DOUBLE, with the fix for IRIX
  28 dnl (< changed to <=) added.
  29 dnl
  30 AC_DEFUN(BASH_C_LONG_DOUBLE,
  31 [AC_CACHE_CHECK(for long double, ac_cv_c_long_double,
  32 [if test "$GCC" = yes; then
  33   ac_cv_c_long_double=yes
  34 else
  35 AC_TRY_RUN([
  36 int
  37 main()
  38 {
  39   /* The Stardent Vistra knows sizeof(long double), but does not
  40      support it. */
  41   long double foo = 0.0;
  42   /* On Ultrix 4.3 cc, long double is 4 and double is 8.  */
  43   /* On IRIX 5.3, the compiler converts long double to double with a warning,
  44      but compiles this successfully. */
  45   exit(sizeof(long double) <= sizeof(double));
  46 }
  47 ], ac_cv_c_long_double=yes, ac_cv_c_long_double=no)
  48 fi])
  49 if test $ac_cv_c_long_double = yes; then
  50   AC_DEFINE(HAVE_LONG_DOUBLE, 1, [Define if the `long double' type works.])
  51 fi
  52 ])
  53
  54 dnl
  55 dnl Check for <inttypes.h>.  This is separated out so that it can be
  56 dnl AC_REQUIREd.
  57 dnl
  58 dnl BASH_HEADER_INTTYPES
  59 AC_DEFUN(BASH_HEADER_INTTYPES,
  60 [
  61  AC_CHECK_HEADERS(inttypes.h)
  62 ])
  63
  64 dnl
  65 dnl check for typedef'd symbols in header files, but allow the caller to
  66 dnl specify the include files to be checked in addition to the default
  67 dnl
  68 dnl BASH_CHECK_TYPE(TYPE, HEADERS, DEFAULT[, VALUE-IF-FOUND])
  69 AC_DEFUN(BASH_CHECK_TYPE,
  70 [
  71 AC_REQUIRE([AC_HEADER_STDC])dnl
  72 AC_REQUIRE([BASH_HEADER_INTTYPES])
  73 AC_MSG_CHECKING(for $1)
  74 AC_CACHE_VAL(bash_cv_type_$1,
  75 [AC_EGREP_CPP($1, [#include <sys/types.h>
  76 #if STDC_HEADERS
  77 #include <stdlib.h>
  78 #include <stddef.h>
  79 #endif
  80 #if HAVE_INTTYPES_H
  81 #include <inttypes.h>
  82 #endif
  83 $2
  84 ], bash_cv_type_$1=yes, bash_cv_type_$1=no)])
  85 AC_MSG_RESULT($bash_cv_type_$1)
  86 ifelse($#, 4, [if test $bash_cv_type_$1 = yes; then
  87         AC_DEFINE($4)
  88         fi])
  89 if test $bash_cv_type_$1 = no; then
  90   AC_DEFINE_UNQUOTED($1, $3)
  91 fi
  92 ])
  93
  94 dnl
  95 dnl BASH_CHECK_DECL(FUNC)
  96 dnl
  97 dnl Check for a declaration of FUNC in stdlib.h and inttypes.h like
  98 dnl AC_CHECK_DECL
  99 dnl
 100 AC_DEFUN(BASH_CHECK_DECL,
 101 [
 102 AC_REQUIRE([AC_HEADER_STDC])
 103 AC_REQUIRE([BASH_HEADER_INTTYPES])
 104 AC_CACHE_CHECK([for declaration of $1], bash_cv_decl_$1,
 105 [AC_TRY_LINK(
 106 [
 107 #if STDC_HEADERS
 108 #  include <stdlib.h>
 109 #endif
 110 #if HAVE_INTTYPES_H
 111 #  include <inttypes.h>
 112 #endif
 113 ],
 114 [return !$1;],
 115 bash_cv_decl_$1=yes, bash_cv_decl_$1=no)])
 116 bash_tr_func=HAVE_DECL_`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 117 if test $bash_cv_decl_$1 = yes; then
 118   AC_DEFINE_UNQUOTED($bash_tr_func, 1)
 119 else
 120   AC_DEFINE_UNQUOTED($bash_tr_func, 0)
 121 fi
 122 ])
 123
 124 AC_DEFUN(BASH_DECL_PRINTF,
 125 [AC_MSG_CHECKING(for declaration of printf in <stdio.h>)
 126 AC_CACHE_VAL(bash_cv_printf_declared,
 127 [AC_TRY_RUN([
 128 #include <stdio.h>
 129 #ifdef __STDC__
 130 typedef int (*_bashfunc)(const char *, ...);
 131 #else
 132 typedef int (*_bashfunc)();
 133 #endif
 134 main()
 135 {
 136 _bashfunc pf;
 137 pf = (_bashfunc) printf;
 138 exit(pf == 0);
 139 }
 140 ], bash_cv_printf_declared=yes, bash_cv_printf_declared=no,
 141    [AC_MSG_WARN(cannot check printf declaration if cross compiling -- defaulting to yes)
 142     bash_cv_printf_declared=yes]
 143 )])
 144 AC_MSG_RESULT($bash_cv_printf_declared)
 145 if test $bash_cv_printf_declared = yes; then
 146 AC_DEFINE(PRINTF_DECLARED)
 147 fi
 148 ])
 149
 150 AC_DEFUN(BASH_DECL_SBRK,
 151 [AC_MSG_CHECKING(for declaration of sbrk in <unistd.h>)
 152 AC_CACHE_VAL(bash_cv_sbrk_declared,
 153 [AC_EGREP_HEADER(sbrk, unistd.h,
 154  bash_cv_sbrk_declared=yes, bash_cv_sbrk_declared=no)])
 155 AC_MSG_RESULT($bash_cv_sbrk_declared)
 156 if test $bash_cv_sbrk_declared = yes; then
 157 AC_DEFINE(SBRK_DECLARED)
 158 fi
 159 ])
 160
 161 dnl
 162 dnl Check for sys_siglist[] or _sys_siglist[]
 163 dnl
 164 AC_DEFUN(BASH_DECL_UNDER_SYS_SIGLIST,
 165 [AC_MSG_CHECKING([for _sys_siglist in signal.h or unistd.h])
 166 AC_CACHE_VAL(bash_cv_decl_under_sys_siglist,
 167 [AC_TRY_COMPILE([
 168 #include <sys/types.h>
 169 #include <signal.h>
 170 #ifdef HAVE_UNISTD_H
 171 #include <unistd.h>
 172 #endif], [ char *msg = _sys_siglist[2]; ],
 173   bash_cv_decl_under_sys_siglist=yes, bash_cv_decl_under_sys_siglist=no,
 174   [AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)])])dnl
 175 AC_MSG_RESULT($bash_cv_decl_under_sys_siglist)
 176 if test $bash_cv_decl_under_sys_siglist = yes; then
 177 AC_DEFINE(UNDER_SYS_SIGLIST_DECLARED)
 178 fi
 179 ])
 180
 181 AC_DEFUN(BASH_UNDER_SYS_SIGLIST,
 182 [AC_REQUIRE([BASH_DECL_UNDER_SYS_SIGLIST])
 183 AC_MSG_CHECKING([for _sys_siglist in system C library])
 184 AC_CACHE_VAL(bash_cv_under_sys_siglist,
 185 [AC_TRY_RUN([
 186 #include <sys/types.h>
 187 #include <signal.h>
 188 #ifdef HAVE_UNISTD_H
 189 #include <unistd.h>
 190 #endif
 191 #ifndef UNDER_SYS_SIGLIST_DECLARED
 192 extern char *_sys_siglist[];
 193 #endif
 194 main()
 195 {
 196 char *msg = (char *)_sys_siglist[2];
 197 exit(msg == 0);
 198 }],
 199         bash_cv_under_sys_siglist=yes, bash_cv_under_sys_siglist=no,
 200         [AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)
 201          bash_cv_under_sys_siglist=no])])
 202 AC_MSG_RESULT($bash_cv_under_sys_siglist)
 203 if test $bash_cv_under_sys_siglist = yes; then
 204 AC_DEFINE(HAVE_UNDER_SYS_SIGLIST)
 205 fi
 206 ])
 207
 208 AC_DEFUN(BASH_SYS_SIGLIST,
 209 [AC_REQUIRE([AC_DECL_SYS_SIGLIST])
 210 AC_MSG_CHECKING([for sys_siglist in system C library])
 211 AC_CACHE_VAL(bash_cv_sys_siglist,
 212 [AC_TRY_RUN([
 213 #include <sys/types.h>
 214 #include <signal.h>
 215 #ifdef HAVE_UNISTD_H
 216 #include <unistd.h>
 217 #endif
 218 #ifndef SYS_SIGLIST_DECLARED
 219 extern char *sys_siglist[];
 220 #endif
 221 main()
 222 {
 223 char *msg = sys_siglist[2];
 224 exit(msg == 0);
 225 }],
 226         bash_cv_sys_siglist=yes, bash_cv_sys_siglist=no,
 227         [AC_MSG_WARN(cannot check for sys_siglist if cross compiling -- defaulting to no)
 228          bash_cv_sys_siglist=no])])
 229 AC_MSG_RESULT($bash_cv_sys_siglist)
 230 if test $bash_cv_sys_siglist = yes; then
 231 AC_DEFINE(HAVE_SYS_SIGLIST)
 232 fi
 233 ])
 234
 235 dnl Check for the various permutations of sys_siglist and make sure we
 236 dnl compile in siglist.o if they're not defined
 237 AC_DEFUN(BASH_CHECK_SYS_SIGLIST, [
 238 AC_REQUIRE([BASH_SYS_SIGLIST])
 239 AC_REQUIRE([BASH_DECL_UNDER_SYS_SIGLIST])
 240 AC_REQUIRE([BASH_FUNC_STRSIGNAL])
 241 if test "$bash_cv_sys_siglist" = no && test "$bash_cv_under_sys_siglist" = no && test "$bash_cv_have_strsignal" = no; then
 242   SIGLIST_O=siglist.o
 243 else
 244   SIGLIST_O=
 245 fi
 246 AC_SUBST([SIGLIST_O])
 247 ])
 248
 249 dnl Check for sys_errlist[] and sys_nerr, check for declaration
 250 AC_DEFUN(BASH_SYS_ERRLIST,
 251 [AC_MSG_CHECKING([for sys_errlist and sys_nerr])
 252 AC_CACHE_VAL(bash_cv_sys_errlist,
 253 [AC_TRY_LINK([#include <errno.h>],
 254 [extern char *sys_errlist[];
 255  extern int sys_nerr;
 256  char *msg = sys_errlist[sys_nerr - 1];],
 257     bash_cv_sys_errlist=yes, bash_cv_sys_errlist=no)])dnl
 258 AC_MSG_RESULT($bash_cv_sys_errlist)
 259 if test $bash_cv_sys_errlist = yes; then
 260 AC_DEFINE(HAVE_SYS_ERRLIST)
 261 fi
 262 ])
 263
 264 dnl
 265 dnl Check if dup2() does not clear the close on exec flag
 266 dnl
 267 AC_DEFUN(BASH_FUNC_DUP2_CLOEXEC_CHECK,
 268 [AC_MSG_CHECKING(if dup2 fails to clear the close-on-exec flag)
 269 AC_CACHE_VAL(bash_cv_dup2_broken,
 270 [AC_TRY_RUN([
 271 #include <sys/types.h>
 272 #include <fcntl.h>
 273 main()
 274 {
 275   int fd1, fd2, fl;
 276   fd1 = open("/dev/null", 2);
 277   if (fcntl(fd1, 2, 1) < 0)
 278     exit(1);
 279   fd2 = dup2(fd1, 1);
 280   if (fd2 < 0)
 281     exit(2);
 282   fl = fcntl(fd2, 1, 0);
 283   /* fl will be 1 if dup2 did not reset the close-on-exec flag. */
 284   exit(fl != 1);
 285 }
 286 ], bash_cv_dup2_broken=yes, bash_cv_dup2_broken=no,
 287     [AC_MSG_WARN(cannot check dup2 if cross compiling -- defaulting to no)
 288      bash_cv_dup2_broken=no])
 289 ])
 290 AC_MSG_RESULT($bash_cv_dup2_broken)
 291 if test $bash_cv_dup2_broken = yes; then
 292 AC_DEFINE(DUP2_BROKEN)
 293 fi
 294 ])
 295
 296 AC_DEFUN(BASH_FUNC_STRSIGNAL,
 297 [AC_MSG_CHECKING([for the existence of strsignal])
 298 AC_CACHE_VAL(bash_cv_have_strsignal,
 299 [AC_TRY_LINK([#include <sys/types.h>
 300 #include <signal.h>],
 301 [char *s = (char *)strsignal(2);],
 302  bash_cv_have_strsignal=yes, bash_cv_have_strsignal=no)])
 303 AC_MSG_RESULT($bash_cv_have_strsignal)
 304 if test $bash_cv_have_strsignal = yes; then
 305 AC_DEFINE(HAVE_STRSIGNAL)
 306 fi
 307 ])
 308
 309 dnl Check to see if opendir will open non-directories (not a nice thing)
 310 AC_DEFUN(BASH_FUNC_OPENDIR_CHECK,
 311 [AC_REQUIRE([AC_HEADER_DIRENT])dnl
 312 AC_MSG_CHECKING(if opendir() opens non-directories)
 313 AC_CACHE_VAL(bash_cv_opendir_not_robust,
 314 [AC_TRY_RUN([
 315 #include <stdio.h>
 316 #include <sys/types.h>
 317 #include <fcntl.h>
 318 #ifdef HAVE_UNISTD_H
 319 # include <unistd.h>
 320 #endif /* HAVE_UNISTD_H */
 321 #if defined(HAVE_DIRENT_H)
 322 # include <dirent.h>
 323 #else
 324 # define dirent direct
 325 # ifdef HAVE_SYS_NDIR_H
 326 #  include <sys/ndir.h>
 327 # endif /* SYSNDIR */
 328 # ifdef HAVE_SYS_DIR_H
 329 #  include <sys/dir.h>
 330 # endif /* SYSDIR */
 331 # ifdef HAVE_NDIR_H
 332 #  include <ndir.h>
 333 # endif
 334 #endif /* HAVE_DIRENT_H */
 335 main()
 336 {
 337 DIR *dir;
 338 int fd, err;
 339 err = mkdir("/tmp/bash-aclocal", 0700);
 340 if (err < 0) {
 341   perror("mkdir");
 342   exit(1);
 343 }
 344 unlink("/tmp/bash-aclocal/not_a_directory");
 345 fd = open("/tmp/bash-aclocal/not_a_directory", O_WRONLY|O_CREAT|O_EXCL, 0666);
 346 write(fd, "\n", 1);
 347 close(fd);
 348 dir = opendir("/tmp/bash-aclocal/not_a_directory");
 349 unlink("/tmp/bash-aclocal/not_a_directory");
 350 rmdir("/tmp/bash-aclocal");
 351 exit (dir == 0);
 352 }], bash_cv_opendir_not_robust=yes,bash_cv_opendir_not_robust=no,
 353     [AC_MSG_WARN(cannot check opendir if cross compiling -- defaulting to no)
 354      bash_cv_opendir_not_robust=no]
 355 )])
 356 AC_MSG_RESULT($bash_cv_opendir_not_robust)
 357 if test $bash_cv_opendir_not_robust = yes; then
 358 AC_DEFINE(OPENDIR_NOT_ROBUST)
 359 fi
 360 ])
 361
 362 dnl
 363 AC_DEFUN(BASH_TYPE_SIGHANDLER,
 364 [AC_MSG_CHECKING([whether signal handlers are of type void])
 365 AC_CACHE_VAL(bash_cv_void_sighandler,
 366 [AC_TRY_COMPILE([#include <sys/types.h>
 367 #include <signal.h>
 368 #ifdef signal
 369 #undef signal
 370 #endif
 371 #ifdef __cplusplus
 372 extern "C"
 373 #endif
 374 void (*signal ()) ();],
 375 [int i;], bash_cv_void_sighandler=yes, bash_cv_void_sighandler=no)])dnl
 376 AC_MSG_RESULT($bash_cv_void_sighandler)
 377 if test $bash_cv_void_sighandler = yes; then
 378 AC_DEFINE(VOID_SIGHANDLER)
 379 fi
 380 ])
 381
 382 dnl
 383 dnl A signed 16-bit integer quantity
 384 dnl
 385 AC_DEFUN(BASH_TYPE_BITS16_T,
 386 [
 387 if test "$ac_cv_sizeof_short" = 2; then
 388   AC_CHECK_TYPE(bits16_t, short)
 389 elif test "$ac_cv_sizeof_char" = 2; then
 390   AC_CHECK_TYPE(bits16_t, char)
 391 else
 392   AC_CHECK_TYPE(bits16_t, short)
 393 fi
 394 ])
 395
 396 dnl
 397 dnl An unsigned 16-bit integer quantity
 398 dnl
 399 AC_DEFUN(BASH_TYPE_U_BITS16_T,
 400 [
 401 if test "$ac_cv_sizeof_short" = 2; then
 402   AC_CHECK_TYPE(u_bits16_t, unsigned short)
 403 elif test "$ac_cv_sizeof_char" = 2; then
 404   AC_CHECK_TYPE(u_bits16_t, unsigned char)
 405 else
 406   AC_CHECK_TYPE(u_bits16_t, unsigned short)
 407 fi
 408 ])
 409
 410 dnl
 411 dnl A signed 32-bit integer quantity
 412 dnl
 413 AC_DEFUN(BASH_TYPE_BITS32_T,
 414 [
 415 if test "$ac_cv_sizeof_int" = 4; then
 416   AC_CHECK_TYPE(bits32_t, int)
 417 elif test "$ac_cv_sizeof_long" = 4; then
 418   AC_CHECK_TYPE(bits32_t, long)
 419 else
 420   AC_CHECK_TYPE(bits32_t, int)
 421 fi
 422 ])
 423
 424 dnl
 425 dnl An unsigned 32-bit integer quantity
 426 dnl
 427 AC_DEFUN(BASH_TYPE_U_BITS32_T,
 428 [
 429 if test "$ac_cv_sizeof_int" = 4; then
 430   AC_CHECK_TYPE(u_bits32_t, unsigned int)
 431 elif test "$ac_cv_sizeof_long" = 4; then
 432   AC_CHECK_TYPE(u_bits32_t, unsigned long)
 433 else
 434   AC_CHECK_TYPE(u_bits32_t, unsigned int)
 435 fi
 436 ])
 437
 438 AC_DEFUN(BASH_TYPE_PTRDIFF_T,
 439 [
 440 if test "$ac_cv_sizeof_int" = "$ac_cv_sizeof_char_p"; then
 441   AC_CHECK_TYPE(ptrdiff_t, int)
 442 elif test "$ac_cv_sizeof_long" = "$ac_cv_sizeof_char_p"; then
 443   AC_CHECK_TYPE(ptrdiff_t, long)
 444 elif test "$ac_cv_type_long_long" = yes && test "$ac_cv_sizeof_long_long" = "$ac_cv_sizeof_char_p"; then
 445   AC_CHECK_TYPE(ptrdiff_t, [long long])
 446 else
 447   AC_CHECK_TYPE(ptrdiff_t, int)
 448 fi
 449 ])
 450
 451 dnl
 452 dnl A signed 64-bit quantity
 453 dnl
 454 AC_DEFUN(BASH_TYPE_BITS64_T,
 455 [
 456 if test "$ac_cv_sizeof_char_p" = 8; then
 457   AC_CHECK_TYPE(bits64_t, char *)
 458 elif test "$ac_cv_sizeof_double" = 8; then
 459   AC_CHECK_TYPE(bits64_t, double)
 460 elif test -n "$ac_cv_type_long_long" && test "$ac_cv_sizeof_long_long" = 8; then
 461   AC_CHECK_TYPE(bits64_t, [long long])
 462 elif test "$ac_cv_sizeof_long" = 8; then
 463   AC_CHECK_TYPE(bits64_t, long)
 464 else
 465   AC_CHECK_TYPE(bits64_t, double)
 466 fi
 467 ])
 468
 469 AC_DEFUN(BASH_TYPE_LONG_LONG,
 470 [
 471 AC_CACHE_CHECK([for long long], bash_cv_type_long_long,
 472 [AC_TRY_LINK([
 473 long long ll = 1; int i = 63;],
 474 [
 475 long long llm = (long long) -1;
 476 return ll << i | ll >> i | llm / ll | llm % ll;
 477 ], bash_cv_type_long_long='long long', bash_cv_type_long_long='long')])
 478 if test "$bash_cv_type_long_long" = 'long long'; then
 479   AC_DEFINE(HAVE_LONG_LONG, 1)
 480 fi
 481 ])
 482
 483 AC_DEFUN(BASH_TYPE_UNSIGNED_LONG_LONG,
 484 [
 485 AC_CACHE_CHECK([for unsigned long long], bash_cv_type_unsigned_long_long,
 486 [AC_TRY_LINK([
 487 unsigned long long ull = 1; int i = 63;],
 488 [
 489 unsigned long long ullmax = (unsigned long long) -1;
 490 return ull << i | ull >> i | ullmax / ull | ullmax % ull;
 491 ], bash_cv_type_unsigned_long_long='unsigned long long',
 492    bash_cv_type_unsigned_long_long='unsigned long')])
 493 if test "$bash_cv_type_unsigned_long_long" = 'unsigned long long'; then
 494   AC_DEFINE(HAVE_UNSIGNED_LONG_LONG, 1)
 495 fi
 496 ])
 497
 498 dnl
 499 dnl Type of struct rlimit fields: some systems (OSF/1, NetBSD, RISC/os 5.0)
 500 dnl have a rlim_t, others (4.4BSD based systems) use quad_t, others use
 501 dnl long and still others use int (HP-UX 9.01, SunOS 4.1.3).  To simplify
 502 dnl matters, this just checks for rlim_t, quad_t, or long.
 503 dnl
 504 AC_DEFUN(BASH_TYPE_RLIMIT,
 505 [AC_MSG_CHECKING(for size and type of struct rlimit fields)
 506 AC_CACHE_VAL(bash_cv_type_rlimit,
 507 [AC_TRY_COMPILE([#include <sys/types.h>
 508 #include <sys/resource.h>],
 509 [rlim_t xxx;], bash_cv_type_rlimit=rlim_t,[
 510 AC_TRY_RUN([
 511 #include <sys/types.h>
 512 #include <sys/time.h>
 513 #include <sys/resource.h>
 514 main()
 515 {
 516 #ifdef HAVE_QUAD_T
 517   struct rlimit rl;
 518   if (sizeof(rl.rlim_cur) == sizeof(quad_t))
 519     exit(0);
 520 #endif
 521   exit(1);
 522 }], bash_cv_type_rlimit=quad_t, bash_cv_type_rlimit=long,
 523         [AC_MSG_WARN(cannot check quad_t if cross compiling -- defaulting to long)
 524          bash_cv_type_rlimit=long])])
 525 ])
 526 AC_MSG_RESULT($bash_cv_type_rlimit)
 527 if test $bash_cv_type_rlimit = quad_t; then
 528 AC_DEFINE(RLIMTYPE, quad_t)
 529 elif test $bash_cv_type_rlimit = rlim_t; then
 530 AC_DEFINE(RLIMTYPE, rlim_t)
 531 fi
 532 ])
 533
 534 AC_DEFUN(BASH_FUNC_LSTAT,
 535 [dnl Cannot use AC_CHECK_FUNCS(lstat) because Linux defines lstat() as an
 536 dnl inline function in <sys/stat.h>.
 537 AC_CACHE_CHECK([for lstat], bash_cv_func_lstat,
 538 [AC_TRY_LINK([
 539 #include <sys/types.h>
 540 #include <sys/stat.h>
 541 ],[ lstat(".",(struct stat *)0); ],
 542 bash_cv_func_lstat=yes, bash_cv_func_lstat=no)])
 543 if test $bash_cv_func_lstat = yes; then
 544   AC_DEFINE(HAVE_LSTAT)
 545 fi
 546 ])
 547
 548 AC_DEFUN(BASH_FUNC_INET_ATON,
 549 [
 550 AC_CACHE_CHECK([for inet_aton], bash_cv_func_inet_aton,
 551 [AC_TRY_LINK([
 552 #include <sys/types.h>
 553 #include <netinet/in.h>
 554 #include <arpa/inet.h>
 555 struct in_addr ap;], [ inet_aton("127.0.0.1", &ap); ],
 556 bash_cv_func_inet_aton=yes, bash_cv_func_inet_aton=no)])
 557 if test $bash_cv_func_inet_aton = yes; then
 558   AC_DEFINE(HAVE_INET_ATON)
 559 else
 560   AC_LIBOBJ(inet_aton)
 561 fi
 562 ])
 563
 564 AC_DEFUN(BASH_FUNC_GETENV,
 565 [AC_MSG_CHECKING(to see if getenv can be redefined)
 566 AC_CACHE_VAL(bash_cv_getenv_redef,
 567 [AC_TRY_RUN([
 568 #ifdef HAVE_UNISTD_H
 569 #  include <unistd.h>
 570 #endif
 571 #ifndef __STDC__
 572 #  ifndef const
 573 #    define const
 574 #  endif
 575 #endif
 576 char *
 577 getenv (name)
 578 #if defined (__linux__) || defined (__bsdi__) || defined (convex)
 579      const char *name;
 580 #else
 581      char const *name;
 582 #endif /* !__linux__ && !__bsdi__ && !convex */
 583 {
 584 return "42";
 585 }
 586 main()
 587 {
 588 char *s;
 589 /* The next allows this program to run, but does not allow bash to link
 590    when it redefines getenv.  I'm not really interested in figuring out
 591    why not. */
 592 #if defined (NeXT)
 593 exit(1);
 594 #endif
 595 s = getenv("ABCDE");
 596 exit(s == 0);   /* force optimizer to leave getenv in */
 597 }
 598 ], bash_cv_getenv_redef=yes, bash_cv_getenv_redef=no,
 599    [AC_MSG_WARN(cannot check getenv redefinition if cross compiling -- defaulting to yes)
 600     bash_cv_getenv_redef=yes]
 601 )])
 602 AC_MSG_RESULT($bash_cv_getenv_redef)
 603 if test $bash_cv_getenv_redef = yes; then
 604 AC_DEFINE(CAN_REDEFINE_GETENV)
 605 fi
 606 ])
 607
 608 AC_DEFUN(BASH_FUNC_ULIMIT_MAXFDS,
 609 [AC_MSG_CHECKING(whether ulimit can substitute for getdtablesize)
 610 AC_CACHE_VAL(bash_cv_ulimit_maxfds,
 611 [AC_TRY_RUN([
 612 main()
 613 {
 614 long maxfds = ulimit(4, 0L);
 615 exit (maxfds == -1L);
 616 }
 617 ], bash_cv_ulimit_maxfds=yes, bash_cv_ulimit_maxfds=no,
 618    [AC_MSG_WARN(cannot check ulimit if cross compiling -- defaulting to no)
 619     bash_cv_ulimit_maxfds=no]
 620 )])
 621 AC_MSG_RESULT($bash_cv_ulimit_maxfds)
 622 if test $bash_cv_ulimit_maxfds = yes; then
 623 AC_DEFINE(ULIMIT_MAXFDS)
 624 fi
 625 ])
 626
 627 AC_DEFUN(BASH_FUNC_GETCWD,
 628 [AC_MSG_CHECKING([if getcwd() calls popen()])
 629 AC_CACHE_VAL(bash_cv_getcwd_calls_popen,
 630 [AC_TRY_RUN([
 631 #include <stdio.h>
 632 #ifdef HAVE_UNISTD_H
 633 #include <unistd.h>
 634 #endif
 635
 636 #ifndef __STDC__
 637 #ifndef const
 638 #define const
 639 #endif
 640 #endif
 641
 642 int popen_called;
 643
 644 FILE *
 645 popen(command, type)
 646      const char *command;
 647      const char *type;
 648 {
 649         popen_called = 1;
 650         return (FILE *)NULL;
 651 }
 652
 653 FILE *_popen(command, type)
 654      const char *command;
 655      const char *type;
 656 {
 657   return (popen (command, type));
 658 }
 659
 660 int
 661 pclose(stream)
 662 FILE *stream;
 663 {
 664         return 0;
 665 }
 666
 667 int
 668 _pclose(stream)
 669 FILE *stream;
 670 {
 671         return 0;
 672 }
 673
 674 main()
 675 {
 676         char    lbuf[32];
 677         popen_called = 0;
 678         getcwd(lbuf, 32);
 679         exit (popen_called);
 680 }
 681 ], bash_cv_getcwd_calls_popen=no, bash_cv_getcwd_calls_popen=yes,
 682    [AC_MSG_WARN(cannot check whether getcwd calls popen if cross compiling -- defaulting to no)
 683     bash_cv_getcwd_calls_popen=no]
 684 )])
 685 AC_MSG_RESULT($bash_cv_getcwd_calls_popen)
 686 if test $bash_cv_getcwd_calls_popen = yes; then
 687 AC_DEFINE(GETCWD_BROKEN)
 688 AC_LIBOBJ(getcwd)
 689 fi
 690 ])
 691
 692 dnl
 693 dnl This needs BASH_CHECK_SOCKLIB, but since that's not called on every
 694 dnl system, we can't use AC_PREREQ
 695 dnl
 696 AC_DEFUN(BASH_FUNC_GETHOSTBYNAME,
 697 [if test "X$bash_cv_have_gethostbyname" = "X"; then
 698 _bash_needmsg=yes
 699 else
 700 AC_MSG_CHECKING(for gethostbyname in socket library)
 701 _bash_needmsg=
 702 fi
 703 AC_CACHE_VAL(bash_cv_have_gethostbyname,
 704 [AC_TRY_LINK([#include <netdb.h>],
 705 [ struct hostent *hp;
 706   hp = gethostbyname("localhost");
 707 ], bash_cv_have_gethostbyname=yes, bash_cv_have_gethostbyname=no)]
 708 )
 709 if test "X$_bash_needmsg" = Xyes; then
 710     AC_MSG_CHECKING(for gethostbyname in socket library)
 711 fi
 712 AC_MSG_RESULT($bash_cv_have_gethostbyname)
 713 if test "$bash_cv_have_gethostbyname" = yes; then
 714 AC_DEFINE(HAVE_GETHOSTBYNAME)
 715 fi
 716 ])
 717
 718 AC_DEFUN(BASH_FUNC_FNMATCH_EXTMATCH,
 719 [AC_MSG_CHECKING(if fnmatch does extended pattern matching with FNM_EXTMATCH)
 720 AC_CACHE_VAL(bash_cv_fnm_extmatch,
 721 [AC_TRY_RUN([
 722 #include <fnmatch.h>
 723
 724 main()
 725 {
 726 #ifdef FNM_EXTMATCH
 727   exit (0);
 728 #else
 729   exit (1);
 730 #endif
 731 }
 732 ], bash_cv_fnm_extmatch=yes, bash_cv_fnm_extmatch=no,
 733     [AC_MSG_WARN(cannot check FNM_EXTMATCH if cross compiling -- defaulting to no)
 734      bash_cv_fnm_extmatch=no])
 735 ])
 736 AC_MSG_RESULT($bash_cv_fnm_extmatch)
 737 if test $bash_cv_fnm_extmatch = yes; then
 738 AC_DEFINE(HAVE_LIBC_FNM_EXTMATCH)
 739 fi
 740 ])
 741
 742 AC_DEFUN(BASH_FUNC_POSIX_SETJMP,
 743 [AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE])
 744 AC_MSG_CHECKING(for presence of POSIX-style sigsetjmp/siglongjmp)
 745 AC_CACHE_VAL(bash_cv_func_sigsetjmp,
 746 [AC_TRY_RUN([
 747 #ifdef HAVE_UNISTD_H
 748 #include <unistd.h>
 749 #endif
 750 #include <sys/types.h>
 751 #include <signal.h>
 752 #include <setjmp.h>
 753
 754 main()
 755 {
 756 #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
 757 exit (1);
 758 #else
 759
 760 int code;
 761 sigset_t set, oset;
 762 sigjmp_buf xx;
 763
 764 /* get the mask */
 765 sigemptyset(&set);
 766 sigemptyset(&oset);
 767 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &set);
 768 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset);
 769
 770 /* save it */
 771 code = sigsetjmp(xx, 1);
 772 if (code)
 773   exit(0);      /* could get sigmask and compare to oset here. */
 774
 775 /* change it */
 776 sigaddset(&set, SIGINT);
 777 sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL);
 778
 779 /* and siglongjmp */
 780 siglongjmp(xx, 10);
 781 exit(1);
 782 #endif
 783 }], bash_cv_func_sigsetjmp=present, bash_cv_func_sigsetjmp=missing,
 784     [AC_MSG_WARN(cannot check for sigsetjmp/siglongjmp if cross-compiling -- defaulting to missing)
 785      bash_cv_func_sigsetjmp=missing]
 786 )])
 787 AC_MSG_RESULT($bash_cv_func_sigsetjmp)
 788 if test $bash_cv_func_sigsetjmp = present; then
 789 AC_DEFINE(HAVE_POSIX_SIGSETJMP)
 790 fi
 791 ])
 792
 793 AC_DEFUN(BASH_FUNC_STRCOLL,
 794 [
 795 AC_MSG_CHECKING(whether or not strcoll and strcmp differ)
 796 AC_CACHE_VAL(bash_cv_func_strcoll_broken,
 797 [AC_TRY_RUN([
 798 #include <stdio.h>
 799 #if defined (HAVE_LOCALE_H)
 800 #include <locale.h>
 801 #endif
 802
 803 main(c, v)
 804 int     c;
 805 char    *v[];
 806 {
 807         int     r1, r2;
 808         char    *deflocale, *defcoll;
 809
 810 #ifdef HAVE_SETLOCALE
 811         deflocale = setlocale(LC_ALL, "");
 812         defcoll = setlocale(LC_COLLATE, "");
 813 #endif
 814
 815 #ifdef HAVE_STRCOLL
 816         /* These two values are taken from tests/glob-test. */
 817         r1 = strcoll("abd", "aXd");
 818 #else
 819         r1 = 0;
 820 #endif
 821         r2 = strcmp("abd", "aXd");
 822
 823         /* These two should both be greater than 0.  It is permissible for
 824            a system to return different values, as long as the sign is the
 825            same. */
 826
 827         /* Exit with 1 (failure) if these two values are both > 0, since
 828            this tests whether strcoll(3) is broken with respect to strcmp(3)
 829            in the default locale. */
 830         exit (r1 > 0 && r2 > 0);
 831 }
 832 ], bash_cv_func_strcoll_broken=yes, bash_cv_func_strcoll_broken=no,
 833    [AC_MSG_WARN(cannot check strcoll if cross compiling -- defaulting to no)
 834     bash_cv_func_strcoll_broken=no]
 835 )])
 836 AC_MSG_RESULT($bash_cv_func_strcoll_broken)
 837 if test $bash_cv_func_strcoll_broken = yes; then
 838 AC_DEFINE(STRCOLL_BROKEN)
 839 fi
 840 ])
 841
 842 AC_DEFUN(BASH_FUNC_PRINTF_A_FORMAT,
 843 [AC_MSG_CHECKING([for printf floating point output in hex notation])
 844 AC_CACHE_VAL(bash_cv_printf_a_format,
 845 [AC_TRY_RUN([
 846 #include <stdio.h>
 847 #include <string.h>
 848
 849 int
 850 main()
 851 {
 852         double y = 0.0;
 853         char abuf[1024];
 854
 855         sprintf(abuf, "%A", y);
 856         exit(strchr(abuf, 'P') == (char *)0);
 857 }
 858 ], bash_cv_printf_a_format=yes, bash_cv_printf_a_format=no,
 859    [AC_MSG_WARN(cannot check printf if cross compiling -- defaulting to no)
 860     bash_cv_printf_a_format=no]
 861 )])
 862 AC_MSG_RESULT($bash_cv_printf_a_format)
 863 if test $bash_cv_printf_a_format = yes; then
 864 AC_DEFINE(HAVE_PRINTF_A_FORMAT)
 865 fi
 866 ])
 867
 868 AC_DEFUN(BASH_STRUCT_TERMIOS_LDISC,
 869 [
 870 AC_CHECK_MEMBER(struct termios.c_line, AC_DEFINE(TERMIOS_LDISC), ,[
 871 #include <sys/types.h>
 872 #include <termios.h>
 873 ])
 874 ])
 875
 876 AC_DEFUN(BASH_STRUCT_TERMIO_LDISC,
 877 [
 878 AC_CHECK_MEMBER(struct termio.c_line, AC_DEFINE(TERMIO_LDISC), ,[
 879 #include <sys/types.h>
 880 #include <termio.h>
 881 ])
 882 ])
 883
 884 dnl
 885 dnl Like AC_STRUCT_ST_BLOCKS, but doesn't muck with LIBOBJS
 886 dnl
 887 dnl sets bash_cv_struct_stat_st_blocks
 888 dnl
 889 dnl unused for now; we'll see how AC_CHECK_MEMBERS works
 890 dnl
 891 AC_DEFUN(BASH_STRUCT_ST_BLOCKS,
 892 [
 893 AC_MSG_CHECKING([for struct stat.st_blocks])
 894 AC_CACHE_VAL(bash_cv_struct_stat_st_blocks,
 895 [AC_TRY_COMPILE(
 896 [
 897 #include <sys/types.h>
 898 #include <sys/stat.h>
 899 ],
 900 [
 901 main()
 902 {
 903 static struct stat a;
 904 if (a.st_blocks) return 0;
 905 return 0;
 906 }
 907 ], bash_cv_struct_stat_st_blocks=yes, bash_cv_struct_stat_st_blocks=no)
 908 ])
 909 AC_MSG_RESULT($bash_cv_struct_stat_st_blocks)
 910 if test "$bash_cv_struct_stat_st_blocks" = "yes"; then
 911 AC_DEFINE(HAVE_STRUCT_STAT_ST_BLOCKS)
 912 fi
 913 ])
 914
 915 AC_DEFUN(BASH_CHECK_LIB_TERMCAP,
 916 [
 917 if test "X$bash_cv_termcap_lib" = "X"; then
 918 _bash_needmsg=yes
 919 else
 920 AC_MSG_CHECKING(which library has the termcap functions)
 921 _bash_needmsg=
 922 fi
 923 AC_CACHE_VAL(bash_cv_termcap_lib,
 924 [AC_CHECK_LIB(termcap, tgetent, bash_cv_termcap_lib=libtermcap,
 925     [AC_CHECK_LIB(tinfo, tgetent, bash_cv_termcal_lib=libtinfo,
 926         [AC_CHECK_LIB(curses, tgetent, bash_cv_termcap_lib=libcurses,
 927             [AC_CHECK_LIB(ncurses, tgetent, bash_cv_termcap_lib=libncurses,
 928                 bash_cv_termcap_lib=gnutermcap)])])])])
 929 if test "X$_bash_needmsg" = "Xyes"; then
 930 AC_MSG_CHECKING(which library has the termcap functions)
 931 fi
 932 AC_MSG_RESULT(using $bash_cv_termcap_lib)
 933 if test $bash_cv_termcap_lib = gnutermcap && test -z "$prefer_curses"; then
 934 LDFLAGS="$LDFLAGS -L./lib/termcap"
 935 TERMCAP_LIB="./lib/termcap/libtermcap.a"
 936 TERMCAP_DEP="./lib/termcap/libtermcap.a"
 937 elif test $bash_cv_termcap_lib = libtermcap && test -z "$prefer_curses"; then
 938 TERMCAP_LIB=-ltermcap
 939 TERMCAP_DEP=
 940 elif test $bash_cv_termcap_lib = libtinfo; then
 941 TERMCAP_LIB=-ltinfo
 942 TERMCAP_DEP=
 943 elif test $bash_cv_termcap_lib = libncurses; then
 944 TERMCAP_LIB=-lncurses
 945 TERMCAP_DEP=
 946 else
 947 TERMCAP_LIB=-lcurses
 948 TERMCAP_DEP=
 949 fi
 950 ])
 951
 952 dnl
 953 dnl Check for the presence of getpeername in libsocket.
 954 dnl If libsocket is present, check for libnsl and add it to LIBS if
 955 dnl it's there, since most systems with libsocket require linking
 956 dnl with libnsl as well.  This should only be called if getpeername
 957 dnl was not found in libc.
 958 dnl
 959 dnl NOTE: IF WE FIND GETPEERNAME, WE ASSUME THAT WE HAVE BIND/CONNECT
 960 dnl       AS WELL
 961 dnl
 962 AC_DEFUN(BASH_CHECK_LIB_SOCKET,
 963 [
 964 if test "X$bash_cv_have_socklib" = "X"; then
 965 _bash_needmsg=
 966 else
 967 AC_MSG_CHECKING(for socket library)
 968 _bash_needmsg=yes
 969 fi
 970 AC_CACHE_VAL(bash_cv_have_socklib,
 971 [AC_CHECK_LIB(socket, getpeername,
 972         bash_cv_have_socklib=yes, bash_cv_have_socklib=no, -lnsl)])
 973 if test "X$_bash_needmsg" = Xyes; then
 974   AC_MSG_RESULT($bash_cv_have_socklib)
 975   _bash_needmsg=
 976 fi
 977 if test $bash_cv_have_socklib = yes; then
 978   # check for libnsl, add it to LIBS if present
 979   if test "X$bash_cv_have_libnsl" = "X"; then
 980     _bash_needmsg=
 981   else
 982     AC_MSG_CHECKING(for libnsl)
 983     _bash_needmsg=yes
 984   fi
 985   AC_CACHE_VAL(bash_cv_have_libnsl,
 986            [AC_CHECK_LIB(nsl, t_open,
 987                  bash_cv_have_libnsl=yes, bash_cv_have_libnsl=no)])
 988   if test "X$_bash_needmsg" = Xyes; then
 989     AC_MSG_RESULT($bash_cv_have_libnsl)
 990     _bash_needmsg=
 991   fi
 992   if test $bash_cv_have_libnsl = yes; then
 993     LIBS="-lsocket -lnsl $LIBS"
 994   else
 995     LIBS="-lsocket $LIBS"
 996   fi
 997   AC_DEFINE(HAVE_LIBSOCKET)
 998   AC_DEFINE(HAVE_GETPEERNAME)
 999 fi
1000 ])
1001
1002 AC_DEFUN(BASH_STRUCT_DIRENT_D_INO,
1003 [AC_REQUIRE([AC_HEADER_DIRENT])
1004 AC_MSG_CHECKING(if struct dirent has a d_ino member)
1005 AC_CACHE_VAL(bash_cv_dirent_has_dino,
1006 [AC_TRY_COMPILE([
1007 #include <stdio.h>
1008 #include <sys/types.h>
1009 #ifdef HAVE_UNISTD_H
1010 # include <unistd.h>
1011 #endif /* HAVE_UNISTD_H */
1012 #if defined(HAVE_DIRENT_H)
1013 # include <dirent.h>
1014 #else
1015 # define dirent direct
1016 # ifdef HAVE_SYS_NDIR_H
1017 #  include <sys/ndir.h>
1018 # endif /* SYSNDIR */
1019 # ifdef HAVE_SYS_DIR_H
1020 #  include <sys/dir.h>
1021 # endif /* SYSDIR */
1022 # ifdef HAVE_NDIR_H
1023 #  include <ndir.h>
1024 # endif
1025 #endif /* HAVE_DIRENT_H */
1026 ],[
1027 struct dirent d; int z; z = d.d_ino;
1028 ], bash_cv_dirent_has_dino=yes, bash_cv_dirent_has_dino=no)])
1029 AC_MSG_RESULT($bash_cv_dirent_has_dino)
1030 if test $bash_cv_dirent_has_dino = yes; then
1031 AC_DEFINE(STRUCT_DIRENT_HAS_D_INO)
1032 fi
1033 ])
1034
1035 AC_DEFUN(BASH_STRUCT_DIRENT_D_FILENO,
1036 [AC_REQUIRE([AC_HEADER_DIRENT])
1037 AC_MSG_CHECKING(if struct dirent has a d_fileno member)
1038 AC_CACHE_VAL(bash_cv_dirent_has_d_fileno,
1039 [AC_TRY_COMPILE([
1040 #include <stdio.h>
1041 #include <sys/types.h>
1042 #ifdef HAVE_UNISTD_H
1043 # include <unistd.h>
1044 #endif /* HAVE_UNISTD_H */
1045 #if defined(HAVE_DIRENT_H)
1046 # include <dirent.h>
1047 #else
1048 # define dirent direct
1049 # ifdef HAVE_SYS_NDIR_H
1050 #  include <sys/ndir.h>
1051 # endif /* SYSNDIR */
1052 # ifdef HAVE_SYS_DIR_H
1053 #  include <sys/dir.h>
1054 # endif /* SYSDIR */
1055 # ifdef HAVE_NDIR_H
1056 #  include <ndir.h>
1057 # endif
1058 #endif /* HAVE_DIRENT_H */
1059 ],[
1060 struct dirent d; int z; z = d.d_fileno;
1061 ], bash_cv_dirent_has_d_fileno=yes, bash_cv_dirent_has_d_fileno=no)])
1062 AC_MSG_RESULT($bash_cv_dirent_has_d_fileno)
1063 if test $bash_cv_dirent_has_d_fileno = yes; then
1064 AC_DEFINE(STRUCT_DIRENT_HAS_D_FILENO)
1065 fi
1066 ])
1067
1068 AC_DEFUN(BASH_STRUCT_TIMEVAL,
1069 [AC_MSG_CHECKING(for struct timeval in sys/time.h and time.h)
1070 AC_CACHE_VAL(bash_cv_struct_timeval,
1071 [
1072 AC_EGREP_HEADER(struct timeval, sys/time.h,
1073                 bash_cv_struct_timeval=yes,
1074                 AC_EGREP_HEADER(struct timeval, time.h,
1075                         bash_cv_struct_timeval=yes,
1076                         bash_cv_struct_timeval=no))
1077 ])
1078 AC_MSG_RESULT($bash_cv_struct_timeval)
1079 if test $bash_cv_struct_timeval = yes; then
1080   AC_DEFINE(HAVE_TIMEVAL)
1081 fi
1082 ])
1083
1084 AC_DEFUN(BASH_STRUCT_WINSIZE,
1085 [AC_MSG_CHECKING(for struct winsize in sys/ioctl.h and termios.h)
1086 AC_CACHE_VAL(bash_cv_struct_winsize_header,
1087 [AC_TRY_COMPILE([#include <sys/types.h>
1088 #include <sys/ioctl.h>], [struct winsize x;],
1089   bash_cv_struct_winsize_header=ioctl_h,
1090   [AC_TRY_COMPILE([#include <sys/types.h>
1091 #include <termios.h>], [struct winsize x;],
1092   bash_cv_struct_winsize_header=termios_h, bash_cv_struct_winsize_header=other)
1093 ])])
1094 if test $bash_cv_struct_winsize_header = ioctl_h; then
1095   AC_MSG_RESULT(sys/ioctl.h)
1096   AC_DEFINE(STRUCT_WINSIZE_IN_SYS_IOCTL)
1097 elif test $bash_cv_struct_winsize_header = termios_h; then
1098   AC_MSG_RESULT(termios.h)
1099   AC_DEFINE(STRUCT_WINSIZE_IN_TERMIOS)
1100 else
1101   AC_MSG_RESULT(not found)
1102 fi
1103 ])
1104
1105 dnl Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7)
1106 AC_DEFUN(BASH_SYS_SIGNAL_VINTAGE,
1107 [AC_REQUIRE([AC_TYPE_SIGNAL])
1108 AC_MSG_CHECKING(for type of signal functions)
1109 AC_CACHE_VAL(bash_cv_signal_vintage,
1110 [
1111   AC_TRY_LINK([#include <signal.h>],[
1112     sigset_t ss;
1113     struct sigaction sa;
1114     sigemptyset(&ss); sigsuspend(&ss);
1115     sigaction(SIGINT, &sa, (struct sigaction *) 0);
1116     sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0);
1117   ], bash_cv_signal_vintage=posix,
1118   [
1119     AC_TRY_LINK([#include <signal.h>], [
1120         int mask = sigmask(SIGINT);
1121         sigsetmask(mask); sigblock(mask); sigpause(mask);
1122     ], bash_cv_signal_vintage=4.2bsd,
1123     [
1124       AC_TRY_LINK([
1125         #include <signal.h>
1126         RETSIGTYPE foo() { }], [
1127                 int mask = sigmask(SIGINT);
1128                 sigset(SIGINT, foo); sigrelse(SIGINT);
1129                 sighold(SIGINT); sigpause(SIGINT);
1130         ], bash_cv_signal_vintage=svr3, bash_cv_signal_vintage=v7
1131     )]
1132   )]
1133 )
1134 ])
1135 AC_MSG_RESULT($bash_cv_signal_vintage)
1136 if test "$bash_cv_signal_vintage" = posix; then
1137 AC_DEFINE(HAVE_POSIX_SIGNALS)
1138 elif test "$bash_cv_signal_vintage" = "4.2bsd"; then
1139 AC_DEFINE(HAVE_BSD_SIGNALS)
1140 elif test "$bash_cv_signal_vintage" = svr3; then
1141 AC_DEFINE(HAVE_USG_SIGHOLD)
1142 fi
1143 ])
1144
1145 dnl Check if the pgrp of setpgrp() can't be the pid of a zombie process.
1146 AC_DEFUN(BASH_SYS_PGRP_SYNC,
1147 [AC_REQUIRE([AC_FUNC_GETPGRP])
1148 AC_MSG_CHECKING(whether pgrps need synchronization)
1149 AC_CACHE_VAL(bash_cv_pgrp_pipe,
1150 [AC_TRY_RUN([
1151 #ifdef HAVE_UNISTD_H
1152 #  include <unistd.h>
1153 #endif
1154 main()
1155 {
1156 # ifdef GETPGRP_VOID
1157 #  define getpgID()     getpgrp()
1158 # else
1159 #  define getpgID()     getpgrp(0)
1160 #  define setpgid(x,y)  setpgrp(x,y)
1161 # endif
1162         int pid1, pid2, fds[2];
1163         int status;
1164         char ok;
1165
1166         switch (pid1 = fork()) {
1167           case -1:
1168             exit(1);
1169           case 0:
1170             setpgid(0, getpid());
1171             exit(0);
1172         }
1173         setpgid(pid1, pid1);
1174
1175         sleep(2);       /* let first child die */
1176
1177         if (pipe(fds) < 0)
1178           exit(2);
1179
1180         switch (pid2 = fork()) {
1181           case -1:
1182             exit(3);
1183           case 0:
1184             setpgid(0, pid1);
1185             ok = getpgID() == pid1;
1186             write(fds[1], &ok, 1);
1187             exit(0);
1188         }
1189         setpgid(pid2, pid1);
1190
1191         close(fds[1]);
1192         if (read(fds[0], &ok, 1) != 1)
1193           exit(4);
1194         wait(&status);
1195         wait(&status);
1196         exit(ok ? 0 : 5);
1197 }
1198 ], bash_cv_pgrp_pipe=no,bash_cv_pgrp_pipe=yes,
1199    [AC_MSG_WARN(cannot check pgrp synchronization if cross compiling -- defaulting to no)
1200     bash_cv_pgrp_pipe=no])
1201 ])
1202 AC_MSG_RESULT($bash_cv_pgrp_pipe)
1203 if test $bash_cv_pgrp_pipe = yes; then
1204 AC_DEFINE(PGRP_PIPE)
1205 fi
1206 ])
1207
1208 AC_DEFUN(BASH_SYS_REINSTALL_SIGHANDLERS,
1209 [AC_REQUIRE([AC_TYPE_SIGNAL])
1210 AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE])
1211 AC_MSG_CHECKING([if signal handlers must be reinstalled when invoked])
1212 AC_CACHE_VAL(bash_cv_must_reinstall_sighandlers,
1213 [AC_TRY_RUN([
1214 #include <signal.h>
1215 #ifdef HAVE_UNISTD_H
1216 #include <unistd.h>
1217 #endif
1218
1219 typedef RETSIGTYPE sigfunc();
1220
1221 int nsigint;
1222
1223 #ifdef HAVE_POSIX_SIGNALS
1224 sigfunc *
1225 set_signal_handler(sig, handler)
1226      int sig;
1227      sigfunc *handler;
1228 {
1229   struct sigaction act, oact;
1230   act.sa_handler = handler;
1231   act.sa_flags = 0;
1232   sigemptyset (&act.sa_mask);
1233   sigemptyset (&oact.sa_mask);
1234   sigaction (sig, &act, &oact);
1235   return (oact.sa_handler);
1236 }
1237 #else
1238 #define set_signal_handler(s, h) signal(s, h)
1239 #endif
1240
1241 RETSIGTYPE
1242 sigint(s)
1243 int s;
1244 {
1245   nsigint++;
1246 }
1247
1248 main()
1249 {
1250         nsigint = 0;
1251         set_signal_handler(SIGINT, sigint);
1252         kill((int)getpid(), SIGINT);
1253         kill((int)getpid(), SIGINT);
1254         exit(nsigint != 2);
1255 }
1256 ], bash_cv_must_reinstall_sighandlers=no, bash_cv_must_reinstall_sighandlers=yes,
1257    [AC_MSG_WARN(cannot check signal handling if cross compiling -- defaulting to no)
1258     bash_cv_must_reinstall_sighandlers=no]
1259 )])
1260 AC_MSG_RESULT($bash_cv_must_reinstall_sighandlers)
1261 if test $bash_cv_must_reinstall_sighandlers = yes; then
1262 AC_DEFINE(MUST_REINSTALL_SIGHANDLERS)
1263 fi
1264 ])
1265
1266 dnl check that some necessary job control definitions are present
1267 AC_DEFUN(BASH_SYS_JOB_CONTROL_MISSING,
1268 [AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE])
1269 AC_MSG_CHECKING(for presence of necessary job control definitions)
1270 AC_CACHE_VAL(bash_cv_job_control_missing,
1271 [AC_TRY_RUN([
1272 #include <sys/types.h>
1273 #ifdef HAVE_SYS_WAIT_H
1274 #include <sys/wait.h>
1275 #endif
1276 #ifdef HAVE_UNISTD_H
1277 #include <unistd.h>
1278 #endif
1279 #include <signal.h>
1280
1281 /* Add more tests in here as appropriate. */
1282 main()
1283 {
1284 /* signal type */
1285 #if !defined (HAVE_POSIX_SIGNALS) && !defined (HAVE_BSD_SIGNALS)
1286 exit(1);
1287 #endif
1288
1289 /* signals and tty control. */
1290 #if !defined (SIGTSTP) || !defined (SIGSTOP) || !defined (SIGCONT)
1291 exit (1);
1292 #endif
1293
1294 /* process control */
1295 #if !defined (WNOHANG) || !defined (WUNTRACED)
1296 exit(1);
1297 #endif
1298
1299 /* Posix systems have tcgetpgrp and waitpid. */
1300 #if defined (_POSIX_VERSION) && !defined (HAVE_TCGETPGRP)
1301 exit(1);
1302 #endif
1303
1304 #if defined (_POSIX_VERSION) && !defined (HAVE_WAITPID)
1305 exit(1);
1306 #endif
1307
1308 /* Other systems have TIOCSPGRP/TIOCGPRGP and wait3. */
1309 #if !defined (_POSIX_VERSION) && !defined (HAVE_WAIT3)
1310 exit(1);
1311 #endif
1312
1313 exit(0);
1314 }], bash_cv_job_control_missing=present, bash_cv_job_control_missing=missing,
1315     [AC_MSG_WARN(cannot check job control if cross-compiling -- defaulting to missing)
1316      bash_cv_job_control_missing=missing]
1317 )])
1318 AC_MSG_RESULT($bash_cv_job_control_missing)
1319 if test $bash_cv_job_control_missing = missing; then
1320 AC_DEFINE(JOB_CONTROL_MISSING)
1321 fi
1322 ])
1323
1324 dnl check whether named pipes are present
1325 dnl this requires a previous check for mkfifo, but that is awkward to specify
1326 AC_DEFUN(BASH_SYS_NAMED_PIPES,
1327 [AC_MSG_CHECKING(for presence of named pipes)
1328 AC_CACHE_VAL(bash_cv_sys_named_pipes,
1329 [AC_TRY_RUN([
1330 #include <sys/types.h>
1331 #include <sys/stat.h>
1332 #ifdef HAVE_UNISTD_H
1333 #include <unistd.h>
1334 #endif
1335
1336 /* Add more tests in here as appropriate. */
1337 main()
1338 {
1339 int fd, err;
1340
1341 #if defined (HAVE_MKFIFO)
1342 exit (0);
1343 #endif
1344
1345 #if !defined (S_IFIFO) && (defined (_POSIX_VERSION) && !defined (S_ISFIFO))
1346 exit (1);
1347 #endif
1348
1349 #if defined (NeXT)
1350 exit (1);
1351 #endif
1352 err = mkdir("/tmp/bash-aclocal", 0700);
1353 if (err < 0) {
1354   perror ("mkdir");
1355   exit(1);
1356 }
1357 fd = mknod ("/tmp/bash-aclocal/sh-np-autoconf", 0666 | S_IFIFO, 0);
1358 if (fd == -1) {
1359   rmdir ("/tmp/bash-aclocal");
1360   exit (1);
1361 }
1362 close(fd);
1363 unlink ("/tmp/bash-aclocal/sh-np-autoconf");
1364 rmdir ("/tmp/bash-aclocal");
1365 exit(0);
1366 }], bash_cv_sys_named_pipes=present, bash_cv_sys_named_pipes=missing,
1367     [AC_MSG_WARN(cannot check for named pipes if cross-compiling -- defaulting to missing)
1368      bash_cv_sys_named_pipes=missing]
1369 )])
1370 AC_MSG_RESULT($bash_cv_sys_named_pipes)
1371 if test $bash_cv_sys_named_pipes = missing; then
1372 AC_DEFINE(NAMED_PIPES_MISSING)
1373 fi
1374 ])
1375
1376 AC_DEFUN(BASH_SYS_DEFAULT_MAIL_DIR,
1377 [AC_MSG_CHECKING(for default mail directory)
1378 AC_CACHE_VAL(bash_cv_mail_dir,
1379 [if test -d /var/mail; then
1380    bash_cv_mail_dir=/var/mail
1381  elif test -d /usr/mail; then
1382    bash_cv_mail_dir=/usr/mail
1383  elif test -d /var/spool/mail; then
1384    bash_cv_mail_dir=/var/spool/mail
1385  elif test -d /usr/spool/mail; then
1386    bash_cv_mail_dir=/usr/spool/mail
1387  else
1388    bash_cv_mail_dir=unknown
1389  fi
1390 ])
1391 AC_MSG_RESULT($bash_cv_mail_dir)
1392 if test $bash_cv_mail_dir = "/var/mail"; then
1393    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/mail")
1394 elif test $bash_cv_mail_dir = "/usr/mail"; then
1395    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/mail")
1396 elif test $bash_cv_mail_dir = "/var/spool/mail"; then
1397    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/spool/mail")
1398 elif test $bash_cv_mail_dir = "/usr/spool/mail"; then
1399    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/spool/mail")
1400 else
1401    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "unknown")
1402 fi
1403 ])
1404
1405 AC_DEFUN(BASH_HAVE_TIOCGWINSZ,
1406 [AC_MSG_CHECKING(for TIOCGWINSZ in sys/ioctl.h)
1407 AC_CACHE_VAL(bash_cv_tiocgwinsz_in_ioctl,
1408 [AC_TRY_COMPILE([#include <sys/types.h>
1409 #include <sys/ioctl.h>], [int x = TIOCGWINSZ;],
1410   bash_cv_tiocgwinsz_in_ioctl=yes,bash_cv_tiocgwinsz_in_ioctl=no)])
1411 AC_MSG_RESULT($bash_cv_tiocgwinsz_in_ioctl)
1412 if test $bash_cv_tiocgwinsz_in_ioctl = yes; then
1413 AC_DEFINE(GWINSZ_IN_SYS_IOCTL)
1414 fi
1415 ])
1416
1417 AC_DEFUN(BASH_HAVE_TIOCSTAT,
1418 [AC_MSG_CHECKING(for TIOCSTAT in sys/ioctl.h)
1419 AC_CACHE_VAL(bash_cv_tiocstat_in_ioctl,
1420 [AC_TRY_COMPILE([#include <sys/types.h>
1421 #include <sys/ioctl.h>], [int x = TIOCSTAT;],
1422   bash_cv_tiocstat_in_ioctl=yes,bash_cv_tiocstat_in_ioctl=no)])
1423 AC_MSG_RESULT($bash_cv_tiocstat_in_ioctl)
1424 if test $bash_cv_tiocstat_in_ioctl = yes; then
1425 AC_DEFINE(TIOCSTAT_IN_SYS_IOCTL)
1426 fi
1427 ])
1428
1429 AC_DEFUN(BASH_HAVE_FIONREAD,
1430 [AC_MSG_CHECKING(for FIONREAD in sys/ioctl.h)
1431 AC_CACHE_VAL(bash_cv_fionread_in_ioctl,
1432 [AC_TRY_COMPILE([#include <sys/types.h>
1433 #include <sys/ioctl.h>], [int x = FIONREAD;],
1434   bash_cv_fionread_in_ioctl=yes,bash_cv_fionread_in_ioctl=no)])
1435 AC_MSG_RESULT($bash_cv_fionread_in_ioctl)
1436 if test $bash_cv_fionread_in_ioctl = yes; then
1437 AC_DEFINE(FIONREAD_IN_SYS_IOCTL)
1438 fi
1439 ])
1440
1441 dnl
1442 dnl See if speed_t is declared in <sys/types.h>.  Some versions of linux
1443 dnl require a definition of speed_t each time <termcap.h> is included,
1444 dnl but you can only get speed_t if you include <termios.h> (on some
1445 dnl versions) or <sys/types.h> (on others).
1446 dnl
1447 AC_DEFUN(BASH_CHECK_SPEED_T,
1448 [AC_MSG_CHECKING(for speed_t in sys/types.h)
1449 AC_CACHE_VAL(bash_cv_speed_t_in_sys_types,
1450 [AC_TRY_COMPILE([#include <sys/types.h>], [speed_t x;],
1451   bash_cv_speed_t_in_sys_types=yes,bash_cv_speed_t_in_sys_types=no)])
1452 AC_MSG_RESULT($bash_cv_speed_t_in_sys_types)
1453 if test $bash_cv_speed_t_in_sys_types = yes; then
1454 AC_DEFINE(SPEED_T_IN_SYS_TYPES)
1455 fi
1456 ])
1457
1458 AC_DEFUN(BASH_CHECK_GETPW_FUNCS,
1459 [AC_MSG_CHECKING(whether getpw functions are declared in pwd.h)
1460 AC_CACHE_VAL(bash_cv_getpw_declared,
1461 [AC_EGREP_CPP(getpwuid,
1462 [
1463 #include <sys/types.h>
1464 #ifdef HAVE_UNISTD_H
1465 #  include <unistd.h>
1466 #endif
1467 #include <pwd.h>
1468 ],
1469 bash_cv_getpw_declared=yes,bash_cv_getpw_declared=no)])
1470 AC_MSG_RESULT($bash_cv_getpw_declared)
1471 if test $bash_cv_getpw_declared = yes; then
1472 AC_DEFINE(HAVE_GETPW_DECLS)
1473 fi
1474 ])
1475
1476 AC_DEFUN(BASH_CHECK_DEV_FD,
1477 [AC_MSG_CHECKING(whether /dev/fd is available)
1478 AC_CACHE_VAL(bash_cv_dev_fd,
1479 [if test -d /dev/fd  && test -r /dev/fd/0; then
1480    bash_cv_dev_fd=standard
1481  elif test -d /proc/self/fd && test -r /proc/self/fd/0; then
1482    bash_cv_dev_fd=whacky
1483  else
1484    bash_cv_dev_fd=absent
1485  fi
1486 ])
1487 AC_MSG_RESULT($bash_cv_dev_fd)
1488 if test $bash_cv_dev_fd = "standard"; then
1489   AC_DEFINE(HAVE_DEV_FD)
1490   AC_DEFINE(DEV_FD_PREFIX, "/dev/fd/")
1491 elif test $bash_cv_dev_fd = "whacky"; then
1492   AC_DEFINE(HAVE_DEV_FD)
1493   AC_DEFINE(DEV_FD_PREFIX, "/proc/self/fd/")
1494 fi
1495 ])
1496
1497 AC_DEFUN(BASH_CHECK_DEV_STDIN,
1498 [AC_MSG_CHECKING(whether /dev/stdin stdout stderr are available)
1499 AC_CACHE_VAL(bash_cv_dev_stdin,
1500 [if test -d /dev/fd && test -r /dev/stdin; then
1501    bash_cv_dev_stdin=present
1502  elif test -d /proc/self/fd && test -r /dev/stdin; then
1503    bash_cv_dev_stdin=present
1504  else
1505    bash_cv_dev_stdin=absent
1506  fi
1507 ])
1508 AC_MSG_RESULT($bash_cv_dev_stdin)
1509 if test $bash_cv_dev_stdin = "present"; then
1510   AC_DEFINE(HAVE_DEV_STDIN)
1511 fi
1512 ])
1513
1514 dnl
1515 dnl Check if HPUX needs _KERNEL defined for RLIMIT_* definitions
1516 dnl
1517 AC_DEFUN(BASH_CHECK_KERNEL_RLIMIT,
1518 [AC_MSG_CHECKING([whether $host_os needs _KERNEL for RLIMIT defines])
1519 AC_CACHE_VAL(bash_cv_kernel_rlimit,
1520 [AC_TRY_COMPILE([
1521 #include <sys/types.h>
1522 #include <sys/resource.h>
1523 ],
1524 [
1525   int f;
1526   f = RLIMIT_DATA;
1527 ], bash_cv_kernel_rlimit=no,
1528 [AC_TRY_COMPILE([
1529 #include <sys/types.h>
1530 #define _KERNEL
1531 #include <sys/resource.h>
1532 #undef _KERNEL
1533 ],
1534 [
1535         int f;
1536         f = RLIMIT_DATA;
1537 ], bash_cv_kernel_rlimit=yes, bash_cv_kernel_rlimit=no)]
1538 )])
1539 AC_MSG_RESULT($bash_cv_kernel_rlimit)
1540 if test $bash_cv_kernel_rlimit = yes; then
1541 AC_DEFINE(RLIMIT_NEEDS_KERNEL)
1542 fi
1543 ])
1544
1545 dnl
1546 dnl Check for 64-bit off_t -- used for malloc alignment
1547 dnl
1548 dnl C does not allow duplicate case labels, so the compile will fail if
1549 dnl sizeof(off_t) is > 4.
1550 dnl
1551 AC_DEFUN(BASH_CHECK_OFF_T_64,
1552 [AC_CACHE_CHECK(for 64-bit off_t, bash_cv_off_t_64,
1553 AC_TRY_COMPILE([
1554 #ifdef HAVE_UNISTD_H
1555 #include <unistd.h>
1556 #endif
1557 #include <sys/types.h>
1558 ],[
1559 switch (0) case 0: case (sizeof (off_t) <= 4):;
1560 ], bash_cv_off_t_64=no, bash_cv_off_t_64=yes))
1561 if test $bash_cv_off_t_64 = yes; then
1562         AC_DEFINE(HAVE_OFF_T_64)
1563 fi])
1564
1565 AC_DEFUN(BASH_CHECK_RTSIGS,
1566 [AC_MSG_CHECKING(for unusable real-time signals due to large values)
1567 AC_CACHE_VAL(bash_cv_unusable_rtsigs,
1568 [AC_TRY_RUN([
1569 #include <sys/types.h>
1570 #include <signal.h>
1571
1572 #ifndef NSIG
1573 #  define NSIG 64
1574 #endif
1575
1576 main ()
1577 {
1578   int n_sigs = 2 * NSIG;
1579 #ifdef SIGRTMIN
1580   int rtmin = SIGRTMIN;
1581 #else
1582   int rtmin = 0;
1583 #endif
1584
1585   exit(rtmin < n_sigs);
1586 }], bash_cv_unusable_rtsigs=yes, bash_cv_unusable_rtsigs=no,
1587     [AC_MSG_WARN(cannot check real-time signals if cross compiling -- defaulting to yes)
1588      bash_cv_unusable_rtsigs=yes]
1589 )])
1590 AC_MSG_RESULT($bash_cv_unusable_rtsigs)
1591 if test $bash_cv_unusable_rtsigs = yes; then
1592 AC_DEFINE(UNUSABLE_RT_SIGNALS)
1593 fi
1594 ])
1595
1596 dnl need: prefix exec_prefix libdir includedir CC TERMCAP_LIB
1597 dnl require:
1598 dnl     AC_PROG_CC
1599 dnl     BASH_CHECK_LIB_TERMCAP
1600
1601 AC_DEFUN(RL_LIB_READLINE_VERSION,
1602 [
1603 AC_REQUIRE([BASH_CHECK_LIB_TERMCAP])
1604
1605 AC_MSG_CHECKING([version of installed readline library])
1606
1607 # What a pain in the ass this is.
1608
1609 # save cpp and ld options
1610 _save_CFLAGS="$CFLAGS"
1611 _save_LDFLAGS="$LDFLAGS"
1612 _save_LIBS="$LIBS"
1613
1614 # Don't set ac_cv_rl_prefix if the caller has already assigned a value.  This
1615 # allows the caller to do something like $_rl_prefix=$withval if the user
1616 # specifies --with-installed-readline=PREFIX as an argument to configure
1617
1618 if test -z "$ac_cv_rl_prefix"; then
1619 test "x$prefix" = xNONE && ac_cv_rl_prefix=$ac_default_prefix || ac_cv_rl_prefix=${prefix}
1620 fi
1621
1622 eval ac_cv_rl_includedir=${ac_cv_rl_prefix}/include
1623 eval ac_cv_rl_libdir=${ac_cv_rl_prefix}/lib
1624
1625 LIBS="$LIBS -lreadline ${TERMCAP_LIB}"
1626 CFLAGS="$CFLAGS -I${ac_cv_rl_includedir}"
1627 LDFLAGS="$LDFLAGS -L${ac_cv_rl_libdir}"
1628
1629 AC_TRY_RUN([
1630 #include <stdio.h>
1631 #include <readline/readline.h>
1632
1633 main()
1634 {
1635         FILE *fp;
1636         fp = fopen("conftest.rlv", "w");
1637         if (fp == 0) exit(1);
1638         fprintf(fp, "%s\n", rl_library_version ? rl_library_version : "0.0");
1639         fclose(fp);
1640         exit(0);
1641 }
1642 ],
1643 ac_cv_rl_version=`cat conftest.rlv`,
1644 ac_cv_rl_version='0.0',
1645 ac_cv_rl_version='4.2')
1646
1647 CFLAGS="$_save_CFLAGS"
1648 LDFLAGS="$_save_LDFLAGS"
1649 LIBS="$_save_LIBS"
1650
1651 RL_MAJOR=0
1652 RL_MINOR=0
1653
1654 # (
1655 case "$ac_cv_rl_version" in
1656 2*|3*|4*|5*|6*|7*|8*|9*)
1657         RL_MAJOR=`echo $ac_cv_rl_version | sed 's:\..*$::'`
1658         RL_MINOR=`echo $ac_cv_rl_version | sed -e 's:^.*\.::' -e 's:[a-zA-Z]*$::'`
1659         ;;
1660 esac
1661
1662 # (((
1663 case $RL_MAJOR in
1664 [[0-9][0-9]])   _RL_MAJOR=$RL_MAJOR ;;
1665 [[0-9]])        _RL_MAJOR=0$RL_MAJOR ;;
1666 *)              _RL_MAJOR=00 ;;
1667 esac
1668
1669 # (((
1670 case $RL_MINOR in
1671 [[0-9][0-9]])   _RL_MINOR=$RL_MINOR ;;
1672 [[0-9]])        _RL_MINOR=0$RL_MINOR ;;
1673 *)              _RL_MINOR=00 ;;
1674 esac
1675
1676 RL_VERSION="0x${_RL_MAJOR}${_RL_MINOR}"
1677
1678 # Readline versions greater than 4.2 have these defines in readline.h
1679
1680 if test $ac_cv_rl_version = '0.0' ; then
1681         AC_MSG_WARN([Could not test version of installed readline library.])
1682 elif test $RL_MAJOR -gt 4 || { test $RL_MAJOR = 4 && test $RL_MINOR -gt 2 ; } ; then
1683         # set these for use by the caller
1684         RL_PREFIX=$ac_cv_rl_prefix
1685         RL_LIBDIR=$ac_cv_rl_libdir
1686         RL_INCLUDEDIR=$ac_cv_rl_includedir
1687         AC_MSG_RESULT($ac_cv_rl_version)
1688 else
1689
1690 AC_DEFINE_UNQUOTED(RL_READLINE_VERSION, $RL_VERSION, [encoded version of the installed readline library])
1691 AC_DEFINE_UNQUOTED(RL_VERSION_MAJOR, $RL_MAJOR, [major version of installed readline library])
1692 AC_DEFINE_UNQUOTED(RL_VERSION_MINOR, $RL_MINOR, [minor version of installed readline library])
1693
1694 AC_SUBST(RL_VERSION)
1695 AC_SUBST(RL_MAJOR)
1696 AC_SUBST(RL_MINOR)
1697
1698 # set these for use by the caller
1699 RL_PREFIX=$ac_cv_rl_prefix
1700 RL_LIBDIR=$ac_cv_rl_libdir
1701 RL_INCLUDEDIR=$ac_cv_rl_includedir
1702
1703 AC_MSG_RESULT($ac_cv_rl_version)
1704
1705 fi
1706 ])