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 #if !HAVE_DECL_SYS_SIGLIST
 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("bash-aclocal", 0700);
 340 if (err < 0) {
 341   perror("mkdir");
 342   exit(1);
 343 }
 344 unlink("bash-aclocal/not_a_directory");
 345 fd = open("bash-aclocal/not_a_directory", O_WRONLY|O_CREAT|O_EXCL, 0666);
 346 write(fd, "\n", 1);
 347 close(fd);
 348 dir = opendir("bash-aclocal/not_a_directory");
 349 unlink("bash-aclocal/not_a_directory");
 350 rmdir("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 # We should check for putenv before calling this
 609 AC_DEFUN(BASH_FUNC_STD_PUTENV,
 610 [
 611 AC_REQUIRE([AC_HEADER_STDC])
 612 AC_REQUIRE([AC_C_PROTOTYPES])
 613 AC_CACHE_CHECK([for standard-conformant putenv declaration], bash_cv_std_putenv,
 614 [AC_TRY_LINK([
 615 #if STDC_HEADERS
 616 #include <stdlib.h>
 617 #include <stddef.h>
 618 #endif
 619 #ifndef __STDC__
 620 #  ifndef const
 621 #    define const
 622 #  endif
 623 #endif
 624 #ifdef PROTOTYPES
 625 extern int putenv (char *);
 626 #else
 627 extern int putenv ();
 628 #endif
 629 ],
 630 [return (putenv == 0);],
 631 bash_cv_std_putenv=yes, bash_cv_std_putenv=no
 632 )])
 633 if test $bash_cv_std_putenv = yes; then
 634 AC_DEFINE(HAVE_STD_PUTENV)
 635 fi
 636 ])
 637
 638 # We should check for unsetenv before calling this
 639 AC_DEFUN(BASH_FUNC_STD_UNSETENV,
 640 [
 641 AC_REQUIRE([AC_HEADER_STDC])
 642 AC_REQUIRE([AC_C_PROTOTYPES])
 643 AC_CACHE_CHECK([for standard-conformant unsetenv declaration], bash_cv_std_unsetenv,
 644 [AC_TRY_LINK([
 645 #if STDC_HEADERS
 646 #include <stdlib.h>
 647 #include <stddef.h>
 648 #endif
 649 #ifndef __STDC__
 650 #  ifndef const
 651 #    define const
 652 #  endif
 653 #endif
 654 #ifdef PROTOTYPES
 655 extern int unsetenv (const char *);
 656 #else
 657 extern int unsetenv ();
 658 #endif
 659 ],
 660 [return (unsetenv == 0);],
 661 bash_cv_std_unsetenv=yes, bash_cv_std_unsetenv=no
 662 )])
 663 if test $bash_cv_std_unsetenv = yes; then
 664 AC_DEFINE(HAVE_STD_UNSETENV)
 665 fi
 666 ])
 667
 668 AC_DEFUN(BASH_FUNC_ULIMIT_MAXFDS,
 669 [AC_MSG_CHECKING(whether ulimit can substitute for getdtablesize)
 670 AC_CACHE_VAL(bash_cv_ulimit_maxfds,
 671 [AC_TRY_RUN([
 672 main()
 673 {
 674 long maxfds = ulimit(4, 0L);
 675 exit (maxfds == -1L);
 676 }
 677 ], bash_cv_ulimit_maxfds=yes, bash_cv_ulimit_maxfds=no,
 678    [AC_MSG_WARN(cannot check ulimit if cross compiling -- defaulting to no)
 679     bash_cv_ulimit_maxfds=no]
 680 )])
 681 AC_MSG_RESULT($bash_cv_ulimit_maxfds)
 682 if test $bash_cv_ulimit_maxfds = yes; then
 683 AC_DEFINE(ULIMIT_MAXFDS)
 684 fi
 685 ])
 686
 687 AC_DEFUN(BASH_FUNC_GETCWD,
 688 [AC_MSG_CHECKING([if getcwd() will dynamically allocate memory with 0 size])
 689 AC_CACHE_VAL(bash_cv_getcwd_malloc,
 690 [AC_TRY_RUN([
 691 #include <stdio.h>
 692 #ifdef HAVE_UNISTD_H
 693 #include <unistd.h>
 694 #endif
 695
 696 main()
 697 {
 698         char    *xpwd;
 699         xpwd = getcwd(0, 0);
 700         exit (xpwd == 0);
 701 }
 702 ], bash_cv_getcwd_malloc=yes, bash_cv_getcwd_malloc=no,
 703    [AC_MSG_WARN(cannot check whether getcwd allocates memory when cross-compiling -- defaulting to no)
 704     bash_cv_getcwd_malloc=no]
 705 )])
 706 AC_MSG_RESULT($bash_cv_getcwd_malloc)
 707 if test $bash_cv_getcwd_malloc = no; then
 708 AC_DEFINE(GETCWD_BROKEN)
 709 AC_LIBOBJ(getcwd)
 710 fi
 711 ])
 712
 713 dnl
 714 dnl This needs BASH_CHECK_SOCKLIB, but since that's not called on every
 715 dnl system, we can't use AC_PREREQ
 716 dnl
 717 AC_DEFUN(BASH_FUNC_GETHOSTBYNAME,
 718 [if test "X$bash_cv_have_gethostbyname" = "X"; then
 719 _bash_needmsg=yes
 720 else
 721 AC_MSG_CHECKING(for gethostbyname in socket library)
 722 _bash_needmsg=
 723 fi
 724 AC_CACHE_VAL(bash_cv_have_gethostbyname,
 725 [AC_TRY_LINK([#include <netdb.h>],
 726 [ struct hostent *hp;
 727   hp = gethostbyname("localhost");
 728 ], bash_cv_have_gethostbyname=yes, bash_cv_have_gethostbyname=no)]
 729 )
 730 if test "X$_bash_needmsg" = Xyes; then
 731     AC_MSG_CHECKING(for gethostbyname in socket library)
 732 fi
 733 AC_MSG_RESULT($bash_cv_have_gethostbyname)
 734 if test "$bash_cv_have_gethostbyname" = yes; then
 735 AC_DEFINE(HAVE_GETHOSTBYNAME)
 736 fi
 737 ])
 738
 739 AC_DEFUN(BASH_FUNC_FNMATCH_EXTMATCH,
 740 [AC_MSG_CHECKING(if fnmatch does extended pattern matching with FNM_EXTMATCH)
 741 AC_CACHE_VAL(bash_cv_fnm_extmatch,
 742 [AC_TRY_RUN([
 743 #include <fnmatch.h>
 744
 745 main()
 746 {
 747 #ifdef FNM_EXTMATCH
 748   exit (0);
 749 #else
 750   exit (1);
 751 #endif
 752 }
 753 ], bash_cv_fnm_extmatch=yes, bash_cv_fnm_extmatch=no,
 754     [AC_MSG_WARN(cannot check FNM_EXTMATCH if cross compiling -- defaulting to no)
 755      bash_cv_fnm_extmatch=no])
 756 ])
 757 AC_MSG_RESULT($bash_cv_fnm_extmatch)
 758 if test $bash_cv_fnm_extmatch = yes; then
 759 AC_DEFINE(HAVE_LIBC_FNM_EXTMATCH)
 760 fi
 761 ])
 762
 763 AC_DEFUN(BASH_FUNC_POSIX_SETJMP,
 764 [AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE])
 765 AC_MSG_CHECKING(for presence of POSIX-style sigsetjmp/siglongjmp)
 766 AC_CACHE_VAL(bash_cv_func_sigsetjmp,
 767 [AC_TRY_RUN([
 768 #ifdef HAVE_UNISTD_H
 769 #include <unistd.h>
 770 #endif
 771 #include <sys/types.h>
 772 #include <signal.h>
 773 #include <setjmp.h>
 774
 775 main()
 776 {
 777 #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
 778 exit (1);
 779 #else
 780
 781 int code;
 782 sigset_t set, oset;
 783 sigjmp_buf xx;
 784
 785 /* get the mask */
 786 sigemptyset(&set);
 787 sigemptyset(&oset);
 788 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &set);
 789 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset);
 790
 791 /* save it */
 792 code = sigsetjmp(xx, 1);
 793 if (code)
 794   exit(0);      /* could get sigmask and compare to oset here. */
 795
 796 /* change it */
 797 sigaddset(&set, SIGINT);
 798 sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL);
 799
 800 /* and siglongjmp */
 801 siglongjmp(xx, 10);
 802 exit(1);
 803 #endif
 804 }], bash_cv_func_sigsetjmp=present, bash_cv_func_sigsetjmp=missing,
 805     [AC_MSG_WARN(cannot check for sigsetjmp/siglongjmp if cross-compiling -- defaulting to missing)
 806      bash_cv_func_sigsetjmp=missing]
 807 )])
 808 AC_MSG_RESULT($bash_cv_func_sigsetjmp)
 809 if test $bash_cv_func_sigsetjmp = present; then
 810 AC_DEFINE(HAVE_POSIX_SIGSETJMP)
 811 fi
 812 ])
 813
 814 AC_DEFUN(BASH_FUNC_STRCOLL,
 815 [
 816 AC_MSG_CHECKING(whether or not strcoll and strcmp differ)
 817 AC_CACHE_VAL(bash_cv_func_strcoll_broken,
 818 [AC_TRY_RUN([
 819 #include <stdio.h>
 820 #if defined (HAVE_LOCALE_H)
 821 #include <locale.h>
 822 #endif
 823
 824 main(c, v)
 825 int     c;
 826 char    *v[];
 827 {
 828         int     r1, r2;
 829         char    *deflocale, *defcoll;
 830
 831 #ifdef HAVE_SETLOCALE
 832         deflocale = setlocale(LC_ALL, "");
 833         defcoll = setlocale(LC_COLLATE, "");
 834 #endif
 835
 836 #ifdef HAVE_STRCOLL
 837         /* These two values are taken from tests/glob-test. */
 838         r1 = strcoll("abd", "aXd");
 839 #else
 840         r1 = 0;
 841 #endif
 842         r2 = strcmp("abd", "aXd");
 843
 844         /* These two should both be greater than 0.  It is permissible for
 845            a system to return different values, as long as the sign is the
 846            same. */
 847
 848         /* Exit with 1 (failure) if these two values are both > 0, since
 849            this tests whether strcoll(3) is broken with respect to strcmp(3)
 850            in the default locale. */
 851         exit (r1 > 0 && r2 > 0);
 852 }
 853 ], bash_cv_func_strcoll_broken=yes, bash_cv_func_strcoll_broken=no,
 854    [AC_MSG_WARN(cannot check strcoll if cross compiling -- defaulting to no)
 855     bash_cv_func_strcoll_broken=no]
 856 )])
 857 AC_MSG_RESULT($bash_cv_func_strcoll_broken)
 858 if test $bash_cv_func_strcoll_broken = yes; then
 859 AC_DEFINE(STRCOLL_BROKEN)
 860 fi
 861 ])
 862
 863 AC_DEFUN(BASH_FUNC_PRINTF_A_FORMAT,
 864 [AC_MSG_CHECKING([for printf floating point output in hex notation])
 865 AC_CACHE_VAL(bash_cv_printf_a_format,
 866 [AC_TRY_RUN([
 867 #include <stdio.h>
 868 #include <string.h>
 869
 870 int
 871 main()
 872 {
 873         double y = 0.0;
 874         char abuf[1024];
 875
 876         sprintf(abuf, "%A", y);
 877         exit(strchr(abuf, 'P') == (char *)0);
 878 }
 879 ], bash_cv_printf_a_format=yes, bash_cv_printf_a_format=no,
 880    [AC_MSG_WARN(cannot check printf if cross compiling -- defaulting to no)
 881     bash_cv_printf_a_format=no]
 882 )])
 883 AC_MSG_RESULT($bash_cv_printf_a_format)
 884 if test $bash_cv_printf_a_format = yes; then
 885 AC_DEFINE(HAVE_PRINTF_A_FORMAT)
 886 fi
 887 ])
 888
 889 AC_DEFUN(BASH_STRUCT_TERMIOS_LDISC,
 890 [
 891 AC_CHECK_MEMBER(struct termios.c_line, AC_DEFINE(TERMIOS_LDISC), ,[
 892 #include <sys/types.h>
 893 #include <termios.h>
 894 ])
 895 ])
 896
 897 AC_DEFUN(BASH_STRUCT_TERMIO_LDISC,
 898 [
 899 AC_CHECK_MEMBER(struct termio.c_line, AC_DEFINE(TERMIO_LDISC), ,[
 900 #include <sys/types.h>
 901 #include <termio.h>
 902 ])
 903 ])
 904
 905 dnl
 906 dnl Like AC_STRUCT_ST_BLOCKS, but doesn't muck with LIBOBJS
 907 dnl
 908 dnl sets bash_cv_struct_stat_st_blocks
 909 dnl
 910 dnl unused for now; we'll see how AC_CHECK_MEMBERS works
 911 dnl
 912 AC_DEFUN(BASH_STRUCT_ST_BLOCKS,
 913 [
 914 AC_MSG_CHECKING([for struct stat.st_blocks])
 915 AC_CACHE_VAL(bash_cv_struct_stat_st_blocks,
 916 [AC_TRY_COMPILE(
 917 [
 918 #include <sys/types.h>
 919 #include <sys/stat.h>
 920 ],
 921 [
 922 main()
 923 {
 924 static struct stat a;
 925 if (a.st_blocks) return 0;
 926 return 0;
 927 }
 928 ], bash_cv_struct_stat_st_blocks=yes, bash_cv_struct_stat_st_blocks=no)
 929 ])
 930 AC_MSG_RESULT($bash_cv_struct_stat_st_blocks)
 931 if test "$bash_cv_struct_stat_st_blocks" = "yes"; then
 932 AC_DEFINE(HAVE_STRUCT_STAT_ST_BLOCKS)
 933 fi
 934 ])
 935
 936 AC_DEFUN([BASH_CHECK_LIB_TERMCAP],
 937 [
 938 if test "X$bash_cv_termcap_lib" = "X"; then
 939 _bash_needmsg=yes
 940 else
 941 AC_MSG_CHECKING(which library has the termcap functions)
 942 _bash_needmsg=
 943 fi
 944 AC_CACHE_VAL(bash_cv_termcap_lib,
 945 [AC_CHECK_FUNC(tgetent, bash_cv_termcap_lib=libc,
 946   [AC_CHECK_LIB(termcap, tgetent, bash_cv_termcap_lib=libtermcap,
 947     [AC_CHECK_LIB(tinfo, tgetent, bash_cv_termcap_lib=libtinfo,
 948         [AC_CHECK_LIB(curses, tgetent, bash_cv_termcap_lib=libcurses,
 949             [AC_CHECK_LIB(ncurses, tgetent, bash_cv_termcap_lib=libncurses,
 950                 bash_cv_termcap_lib=gnutermcap)])])])])])
 951 if test "X$_bash_needmsg" = "Xyes"; then
 952 AC_MSG_CHECKING(which library has the termcap functions)
 953 fi
 954 AC_MSG_RESULT(using $bash_cv_termcap_lib)
 955 if test $bash_cv_termcap_lib = gnutermcap && test -z "$prefer_curses"; then
 956 LDFLAGS="$LDFLAGS -L./lib/termcap"
 957 TERMCAP_LIB="./lib/termcap/libtermcap.a"
 958 TERMCAP_DEP="./lib/termcap/libtermcap.a"
 959 elif test $bash_cv_termcap_lib = libtermcap && test -z "$prefer_curses"; then
 960 TERMCAP_LIB=-ltermcap
 961 TERMCAP_DEP=
 962 elif test $bash_cv_termcap_lib = libtinfo; then
 963 TERMCAP_LIB=-ltinfo
 964 TERMCAP_DEP=
 965 elif test $bash_cv_termcap_lib = libncurses; then
 966 TERMCAP_LIB=-lncurses
 967 TERMCAP_DEP=
 968 elif test $bash_cv_termcap_lib = libc; then
 969 TERMCAP_LIB=
 970 TERMCAP_DEP=
 971 else
 972 TERMCAP_LIB=-lcurses
 973 TERMCAP_DEP=
 974 fi
 975 ])
 976
 977 dnl
 978 dnl Check for the presence of getpeername in libsocket.
 979 dnl If libsocket is present, check for libnsl and add it to LIBS if
 980 dnl it's there, since most systems with libsocket require linking
 981 dnl with libnsl as well.  This should only be called if getpeername
 982 dnl was not found in libc.
 983 dnl
 984 dnl NOTE: IF WE FIND GETPEERNAME, WE ASSUME THAT WE HAVE BIND/CONNECT
 985 dnl       AS WELL
 986 dnl
 987 AC_DEFUN(BASH_CHECK_LIB_SOCKET,
 988 [
 989 if test "X$bash_cv_have_socklib" = "X"; then
 990 _bash_needmsg=
 991 else
 992 AC_MSG_CHECKING(for socket library)
 993 _bash_needmsg=yes
 994 fi
 995 AC_CACHE_VAL(bash_cv_have_socklib,
 996 [AC_CHECK_LIB(socket, getpeername,
 997         bash_cv_have_socklib=yes, bash_cv_have_socklib=no, -lnsl)])
 998 if test "X$_bash_needmsg" = Xyes; then
 999   AC_MSG_RESULT($bash_cv_have_socklib)
1000   _bash_needmsg=
1001 fi
1002 if test $bash_cv_have_socklib = yes; then
1003   # check for libnsl, add it to LIBS if present
1004   if test "X$bash_cv_have_libnsl" = "X"; then
1005     _bash_needmsg=
1006   else
1007     AC_MSG_CHECKING(for libnsl)
1008     _bash_needmsg=yes
1009   fi
1010   AC_CACHE_VAL(bash_cv_have_libnsl,
1011            [AC_CHECK_LIB(nsl, t_open,
1012                  bash_cv_have_libnsl=yes, bash_cv_have_libnsl=no)])
1013   if test "X$_bash_needmsg" = Xyes; then
1014     AC_MSG_RESULT($bash_cv_have_libnsl)
1015     _bash_needmsg=
1016   fi
1017   if test $bash_cv_have_libnsl = yes; then
1018     LIBS="-lsocket -lnsl $LIBS"
1019   else
1020     LIBS="-lsocket $LIBS"
1021   fi
1022   AC_DEFINE(HAVE_LIBSOCKET)
1023   AC_DEFINE(HAVE_GETPEERNAME)
1024 fi
1025 ])
1026
1027 AC_DEFUN(BASH_STRUCT_DIRENT_D_INO,
1028 [AC_REQUIRE([AC_HEADER_DIRENT])
1029 AC_MSG_CHECKING(for struct dirent.d_ino)
1030 AC_CACHE_VAL(bash_cv_dirent_has_dino,
1031 [AC_TRY_COMPILE([
1032 #include <stdio.h>
1033 #include <sys/types.h>
1034 #ifdef HAVE_UNISTD_H
1035 # include <unistd.h>
1036 #endif /* HAVE_UNISTD_H */
1037 #if defined(HAVE_DIRENT_H)
1038 # include <dirent.h>
1039 #else
1040 # define dirent direct
1041 # ifdef HAVE_SYS_NDIR_H
1042 #  include <sys/ndir.h>
1043 # endif /* SYSNDIR */
1044 # ifdef HAVE_SYS_DIR_H
1045 #  include <sys/dir.h>
1046 # endif /* SYSDIR */
1047 # ifdef HAVE_NDIR_H
1048 #  include <ndir.h>
1049 # endif
1050 #endif /* HAVE_DIRENT_H */
1051 ],[
1052 struct dirent d; int z; z = d.d_ino;
1053 ], bash_cv_dirent_has_dino=yes, bash_cv_dirent_has_dino=no)])
1054 AC_MSG_RESULT($bash_cv_dirent_has_dino)
1055 if test $bash_cv_dirent_has_dino = yes; then
1056 AC_DEFINE(HAVE_STRUCT_DIRENT_D_INO)
1057 fi
1058 ])
1059
1060 AC_DEFUN(BASH_STRUCT_DIRENT_D_FILENO,
1061 [AC_REQUIRE([AC_HEADER_DIRENT])
1062 AC_MSG_CHECKING(for struct dirent.d_fileno)
1063 AC_CACHE_VAL(bash_cv_dirent_has_d_fileno,
1064 [AC_TRY_COMPILE([
1065 #include <stdio.h>
1066 #include <sys/types.h>
1067 #ifdef HAVE_UNISTD_H
1068 # include <unistd.h>
1069 #endif /* HAVE_UNISTD_H */
1070 #if defined(HAVE_DIRENT_H)
1071 # include <dirent.h>
1072 #else
1073 # define dirent direct
1074 # ifdef HAVE_SYS_NDIR_H
1075 #  include <sys/ndir.h>
1076 # endif /* SYSNDIR */
1077 # ifdef HAVE_SYS_DIR_H
1078 #  include <sys/dir.h>
1079 # endif /* SYSDIR */
1080 # ifdef HAVE_NDIR_H
1081 #  include <ndir.h>
1082 # endif
1083 #endif /* HAVE_DIRENT_H */
1084 ],[
1085 struct dirent d; int z; z = d.d_fileno;
1086 ], bash_cv_dirent_has_d_fileno=yes, bash_cv_dirent_has_d_fileno=no)])
1087 AC_MSG_RESULT($bash_cv_dirent_has_d_fileno)
1088 if test $bash_cv_dirent_has_d_fileno = yes; then
1089 AC_DEFINE(HAVE_STRUCT_DIRENT_D_FILENO)
1090 fi
1091 ])
1092
1093 AC_DEFUN(BASH_STRUCT_DIRENT_D_NAMLEN,
1094 [AC_REQUIRE([AC_HEADER_DIRENT])
1095 AC_MSG_CHECKING(for struct dirent.d_namlen)
1096 AC_CACHE_VAL(bash_cv_dirent_has_d_namlen,
1097 [AC_TRY_COMPILE([
1098 #include <stdio.h>
1099 #include <sys/types.h>
1100 #ifdef HAVE_UNISTD_H
1101 # include <unistd.h>
1102 #endif /* HAVE_UNISTD_H */
1103 #if defined(HAVE_DIRENT_H)
1104 # include <dirent.h>
1105 #else
1106 # define dirent direct
1107 # ifdef HAVE_SYS_NDIR_H
1108 #  include <sys/ndir.h>
1109 # endif /* SYSNDIR */
1110 # ifdef HAVE_SYS_DIR_H
1111 #  include <sys/dir.h>
1112 # endif /* SYSDIR */
1113 # ifdef HAVE_NDIR_H
1114 #  include <ndir.h>
1115 # endif
1116 #endif /* HAVE_DIRENT_H */
1117 ],[
1118 struct dirent d; int z; z = d.d_namlen;
1119 ], bash_cv_dirent_has_d_namlen=yes, bash_cv_dirent_has_d_namlen=no)])
1120 AC_MSG_RESULT($bash_cv_dirent_has_d_namlen)
1121 if test $bash_cv_dirent_has_d_namlen = yes; then
1122 AC_DEFINE(HAVE_STRUCT_DIRENT_D_NAMLEN)
1123 fi
1124 ])
1125
1126 AC_DEFUN(BASH_STRUCT_TIMEVAL,
1127 [AC_MSG_CHECKING(for struct timeval in sys/time.h and time.h)
1128 AC_CACHE_VAL(bash_cv_struct_timeval,
1129 [
1130 AC_EGREP_HEADER(struct timeval, sys/time.h,
1131                 bash_cv_struct_timeval=yes,
1132                 AC_EGREP_HEADER(struct timeval, time.h,
1133                         bash_cv_struct_timeval=yes,
1134                         bash_cv_struct_timeval=no))
1135 ])
1136 AC_MSG_RESULT($bash_cv_struct_timeval)
1137 if test $bash_cv_struct_timeval = yes; then
1138   AC_DEFINE(HAVE_TIMEVAL)
1139 fi
1140 ])
1141
1142 AC_DEFUN(BASH_STRUCT_TIMEZONE,
1143 [AC_MSG_CHECKING(for struct timezone in sys/time.h and time.h)
1144 AC_CACHE_VAL(bash_cv_struct_timezone,
1145 [
1146 AC_EGREP_HEADER(struct timezone, sys/time.h,
1147                 bash_cv_struct_timezone=yes,
1148                 AC_EGREP_HEADER(struct timezone, time.h,
1149                         bash_cv_struct_timezone=yes,
1150                         bash_cv_struct_timezone=no))
1151 ])
1152 AC_MSG_RESULT($bash_cv_struct_timezone)
1153 if test $bash_cv_struct_timezone = yes; then
1154   AC_DEFINE(HAVE_STRUCT_TIMEZONE)
1155 fi
1156 ])
1157
1158 AC_DEFUN(BASH_STRUCT_WINSIZE,
1159 [AC_MSG_CHECKING(for struct winsize in sys/ioctl.h and termios.h)
1160 AC_CACHE_VAL(bash_cv_struct_winsize_header,
1161 [AC_TRY_COMPILE([#include <sys/types.h>
1162 #include <sys/ioctl.h>], [struct winsize x;],
1163   bash_cv_struct_winsize_header=ioctl_h,
1164   [AC_TRY_COMPILE([#include <sys/types.h>
1165 #include <termios.h>], [struct winsize x;],
1166   bash_cv_struct_winsize_header=termios_h, bash_cv_struct_winsize_header=other)
1167 ])])
1168 if test $bash_cv_struct_winsize_header = ioctl_h; then
1169   AC_MSG_RESULT(sys/ioctl.h)
1170   AC_DEFINE(STRUCT_WINSIZE_IN_SYS_IOCTL)
1171 elif test $bash_cv_struct_winsize_header = termios_h; then
1172   AC_MSG_RESULT(termios.h)
1173   AC_DEFINE(STRUCT_WINSIZE_IN_TERMIOS)
1174 else
1175   AC_MSG_RESULT(not found)
1176 fi
1177 ])
1178
1179 dnl Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7)
1180 AC_DEFUN(BASH_SYS_SIGNAL_VINTAGE,
1181 [AC_REQUIRE([AC_TYPE_SIGNAL])
1182 AC_MSG_CHECKING(for type of signal functions)
1183 AC_CACHE_VAL(bash_cv_signal_vintage,
1184 [
1185   AC_TRY_LINK([#include <signal.h>],[
1186     sigset_t ss;
1187     struct sigaction sa;
1188     sigemptyset(&ss); sigsuspend(&ss);
1189     sigaction(SIGINT, &sa, (struct sigaction *) 0);
1190     sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0);
1191   ], bash_cv_signal_vintage=posix,
1192   [
1193     AC_TRY_LINK([#include <signal.h>], [
1194         int mask = sigmask(SIGINT);
1195         sigsetmask(mask); sigblock(mask); sigpause(mask);
1196     ], bash_cv_signal_vintage=4.2bsd,
1197     [
1198       AC_TRY_LINK([
1199         #include <signal.h>
1200         RETSIGTYPE foo() { }], [
1201                 int mask = sigmask(SIGINT);
1202                 sigset(SIGINT, foo); sigrelse(SIGINT);
1203                 sighold(SIGINT); sigpause(SIGINT);
1204         ], bash_cv_signal_vintage=svr3, bash_cv_signal_vintage=v7
1205     )]
1206   )]
1207 )
1208 ])
1209 AC_MSG_RESULT($bash_cv_signal_vintage)
1210 if test "$bash_cv_signal_vintage" = posix; then
1211 AC_DEFINE(HAVE_POSIX_SIGNALS)
1212 elif test "$bash_cv_signal_vintage" = "4.2bsd"; then
1213 AC_DEFINE(HAVE_BSD_SIGNALS)
1214 elif test "$bash_cv_signal_vintage" = svr3; then
1215 AC_DEFINE(HAVE_USG_SIGHOLD)
1216 fi
1217 ])
1218
1219 dnl Check if the pgrp of setpgrp() can't be the pid of a zombie process.
1220 AC_DEFUN(BASH_SYS_PGRP_SYNC,
1221 [AC_REQUIRE([AC_FUNC_GETPGRP])
1222 AC_MSG_CHECKING(whether pgrps need synchronization)
1223 AC_CACHE_VAL(bash_cv_pgrp_pipe,
1224 [AC_TRY_RUN([
1225 #ifdef HAVE_UNISTD_H
1226 #  include <unistd.h>
1227 #endif
1228 main()
1229 {
1230 # ifdef GETPGRP_VOID
1231 #  define getpgID()     getpgrp()
1232 # else
1233 #  define getpgID()     getpgrp(0)
1234 #  define setpgid(x,y)  setpgrp(x,y)
1235 # endif
1236         int pid1, pid2, fds[2];
1237         int status;
1238         char ok;
1239
1240         switch (pid1 = fork()) {
1241           case -1:
1242             exit(1);
1243           case 0:
1244             setpgid(0, getpid());
1245             exit(0);
1246         }
1247         setpgid(pid1, pid1);
1248
1249         sleep(2);       /* let first child die */
1250
1251         if (pipe(fds) < 0)
1252           exit(2);
1253
1254         switch (pid2 = fork()) {
1255           case -1:
1256             exit(3);
1257           case 0:
1258             setpgid(0, pid1);
1259             ok = getpgID() == pid1;
1260             write(fds[1], &ok, 1);
1261             exit(0);
1262         }
1263         setpgid(pid2, pid1);
1264
1265         close(fds[1]);
1266         if (read(fds[0], &ok, 1) != 1)
1267           exit(4);
1268         wait(&status);
1269         wait(&status);
1270         exit(ok ? 0 : 5);
1271 }
1272 ], bash_cv_pgrp_pipe=no,bash_cv_pgrp_pipe=yes,
1273    [AC_MSG_WARN(cannot check pgrp synchronization if cross compiling -- defaulting to no)
1274     bash_cv_pgrp_pipe=no])
1275 ])
1276 AC_MSG_RESULT($bash_cv_pgrp_pipe)
1277 if test $bash_cv_pgrp_pipe = yes; then
1278 AC_DEFINE(PGRP_PIPE)
1279 fi
1280 ])
1281
1282 AC_DEFUN(BASH_SYS_REINSTALL_SIGHANDLERS,
1283 [AC_REQUIRE([AC_TYPE_SIGNAL])
1284 AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE])
1285 AC_MSG_CHECKING([if signal handlers must be reinstalled when invoked])
1286 AC_CACHE_VAL(bash_cv_must_reinstall_sighandlers,
1287 [AC_TRY_RUN([
1288 #include <signal.h>
1289 #ifdef HAVE_UNISTD_H
1290 #include <unistd.h>
1291 #endif
1292
1293 typedef RETSIGTYPE sigfunc();
1294
1295 int nsigint;
1296
1297 #ifdef HAVE_POSIX_SIGNALS
1298 sigfunc *
1299 set_signal_handler(sig, handler)
1300      int sig;
1301      sigfunc *handler;
1302 {
1303   struct sigaction act, oact;
1304   act.sa_handler = handler;
1305   act.sa_flags = 0;
1306   sigemptyset (&act.sa_mask);
1307   sigemptyset (&oact.sa_mask);
1308   sigaction (sig, &act, &oact);
1309   return (oact.sa_handler);
1310 }
1311 #else
1312 #define set_signal_handler(s, h) signal(s, h)
1313 #endif
1314
1315 RETSIGTYPE
1316 sigint(s)
1317 int s;
1318 {
1319   nsigint++;
1320 }
1321
1322 main()
1323 {
1324         nsigint = 0;
1325         set_signal_handler(SIGINT, sigint);
1326         kill((int)getpid(), SIGINT);
1327         kill((int)getpid(), SIGINT);
1328         exit(nsigint != 2);
1329 }
1330 ], bash_cv_must_reinstall_sighandlers=no, bash_cv_must_reinstall_sighandlers=yes,
1331    [AC_MSG_WARN(cannot check signal handling if cross compiling -- defaulting to no)
1332     bash_cv_must_reinstall_sighandlers=no]
1333 )])
1334 AC_MSG_RESULT($bash_cv_must_reinstall_sighandlers)
1335 if test $bash_cv_must_reinstall_sighandlers = yes; then
1336 AC_DEFINE(MUST_REINSTALL_SIGHANDLERS)
1337 fi
1338 ])
1339
1340 dnl check that some necessary job control definitions are present
1341 AC_DEFUN(BASH_SYS_JOB_CONTROL_MISSING,
1342 [AC_REQUIRE([BASH_SYS_SIGNAL_VINTAGE])
1343 AC_MSG_CHECKING(for presence of necessary job control definitions)
1344 AC_CACHE_VAL(bash_cv_job_control_missing,
1345 [AC_TRY_RUN([
1346 #include <sys/types.h>
1347 #ifdef HAVE_SYS_WAIT_H
1348 #include <sys/wait.h>
1349 #endif
1350 #ifdef HAVE_UNISTD_H
1351 #include <unistd.h>
1352 #endif
1353 #include <signal.h>
1354
1355 /* Add more tests in here as appropriate. */
1356 main()
1357 {
1358 /* signal type */
1359 #if !defined (HAVE_POSIX_SIGNALS) && !defined (HAVE_BSD_SIGNALS)
1360 exit(1);
1361 #endif
1362
1363 /* signals and tty control. */
1364 #if !defined (SIGTSTP) || !defined (SIGSTOP) || !defined (SIGCONT)
1365 exit (1);
1366 #endif
1367
1368 /* process control */
1369 #if !defined (WNOHANG) || !defined (WUNTRACED)
1370 exit(1);
1371 #endif
1372
1373 /* Posix systems have tcgetpgrp and waitpid. */
1374 #if defined (_POSIX_VERSION) && !defined (HAVE_TCGETPGRP)
1375 exit(1);
1376 #endif
1377
1378 #if defined (_POSIX_VERSION) && !defined (HAVE_WAITPID)
1379 exit(1);
1380 #endif
1381
1382 /* Other systems have TIOCSPGRP/TIOCGPRGP and wait3. */
1383 #if !defined (_POSIX_VERSION) && !defined (HAVE_WAIT3)
1384 exit(1);
1385 #endif
1386
1387 exit(0);
1388 }], bash_cv_job_control_missing=present, bash_cv_job_control_missing=missing,
1389     [AC_MSG_WARN(cannot check job control if cross-compiling -- defaulting to missing)
1390      bash_cv_job_control_missing=missing]
1391 )])
1392 AC_MSG_RESULT($bash_cv_job_control_missing)
1393 if test $bash_cv_job_control_missing = missing; then
1394 AC_DEFINE(JOB_CONTROL_MISSING)
1395 fi
1396 ])
1397
1398 dnl check whether named pipes are present
1399 dnl this requires a previous check for mkfifo, but that is awkward to specify
1400 AC_DEFUN(BASH_SYS_NAMED_PIPES,
1401 [AC_MSG_CHECKING(for presence of named pipes)
1402 AC_CACHE_VAL(bash_cv_sys_named_pipes,
1403 [AC_TRY_RUN([
1404 #include <sys/types.h>
1405 #include <sys/stat.h>
1406 #ifdef HAVE_UNISTD_H
1407 #include <unistd.h>
1408 #endif
1409
1410 /* Add more tests in here as appropriate. */
1411 main()
1412 {
1413 int fd, err;
1414
1415 #if defined (HAVE_MKFIFO)
1416 exit (0);
1417 #endif
1418
1419 #if !defined (S_IFIFO) && (defined (_POSIX_VERSION) && !defined (S_ISFIFO))
1420 exit (1);
1421 #endif
1422
1423 #if defined (NeXT)
1424 exit (1);
1425 #endif
1426 err = mkdir("bash-aclocal", 0700);
1427 if (err < 0) {
1428   perror ("mkdir");
1429   exit(1);
1430 }
1431 fd = mknod ("bash-aclocal/sh-np-autoconf", 0666 | S_IFIFO, 0);
1432 if (fd == -1) {
1433   rmdir ("bash-aclocal");
1434   exit (1);
1435 }
1436 close(fd);
1437 unlink ("bash-aclocal/sh-np-autoconf");
1438 rmdir ("bash-aclocal");
1439 exit(0);
1440 }], bash_cv_sys_named_pipes=present, bash_cv_sys_named_pipes=missing,
1441     [AC_MSG_WARN(cannot check for named pipes if cross-compiling -- defaulting to missing)
1442      bash_cv_sys_named_pipes=missing]
1443 )])
1444 AC_MSG_RESULT($bash_cv_sys_named_pipes)
1445 if test $bash_cv_sys_named_pipes = missing; then
1446 AC_DEFINE(NAMED_PIPES_MISSING)
1447 fi
1448 ])
1449
1450 AC_DEFUN(BASH_SYS_DEFAULT_MAIL_DIR,
1451 [AC_MSG_CHECKING(for default mail directory)
1452 AC_CACHE_VAL(bash_cv_mail_dir,
1453 [if test -d /var/mail; then
1454    bash_cv_mail_dir=/var/mail
1455  elif test -d /var/spool/mail; then
1456    bash_cv_mail_dir=/var/spool/mail
1457  elif test -d /usr/mail; then
1458    bash_cv_mail_dir=/usr/mail
1459  elif test -d /usr/spool/mail; then
1460    bash_cv_mail_dir=/usr/spool/mail
1461  else
1462    bash_cv_mail_dir=unknown
1463  fi
1464 ])
1465 AC_MSG_RESULT($bash_cv_mail_dir)
1466 AC_DEFINE_UNQUOTED(DEFAULT_MAIL_DIRECTORY, "$bash_cv_mail_dir")
1467 ])
1468
1469 AC_DEFUN(BASH_HAVE_TIOCGWINSZ,
1470 [AC_MSG_CHECKING(for TIOCGWINSZ in sys/ioctl.h)
1471 AC_CACHE_VAL(bash_cv_tiocgwinsz_in_ioctl,
1472 [AC_TRY_COMPILE([#include <sys/types.h>
1473 #include <sys/ioctl.h>], [int x = TIOCGWINSZ;],
1474   bash_cv_tiocgwinsz_in_ioctl=yes,bash_cv_tiocgwinsz_in_ioctl=no)])
1475 AC_MSG_RESULT($bash_cv_tiocgwinsz_in_ioctl)
1476 if test $bash_cv_tiocgwinsz_in_ioctl = yes; then
1477 AC_DEFINE(GWINSZ_IN_SYS_IOCTL)
1478 fi
1479 ])
1480
1481 AC_DEFUN(BASH_HAVE_TIOCSTAT,
1482 [AC_MSG_CHECKING(for TIOCSTAT in sys/ioctl.h)
1483 AC_CACHE_VAL(bash_cv_tiocstat_in_ioctl,
1484 [AC_TRY_COMPILE([#include <sys/types.h>
1485 #include <sys/ioctl.h>], [int x = TIOCSTAT;],
1486   bash_cv_tiocstat_in_ioctl=yes,bash_cv_tiocstat_in_ioctl=no)])
1487 AC_MSG_RESULT($bash_cv_tiocstat_in_ioctl)
1488 if test $bash_cv_tiocstat_in_ioctl = yes; then
1489 AC_DEFINE(TIOCSTAT_IN_SYS_IOCTL)
1490 fi
1491 ])
1492
1493 AC_DEFUN(BASH_HAVE_FIONREAD,
1494 [AC_MSG_CHECKING(for FIONREAD in sys/ioctl.h)
1495 AC_CACHE_VAL(bash_cv_fionread_in_ioctl,
1496 [AC_TRY_COMPILE([#include <sys/types.h>
1497 #include <sys/ioctl.h>], [int x = FIONREAD;],
1498   bash_cv_fionread_in_ioctl=yes,bash_cv_fionread_in_ioctl=no)])
1499 AC_MSG_RESULT($bash_cv_fionread_in_ioctl)
1500 if test $bash_cv_fionread_in_ioctl = yes; then
1501 AC_DEFINE(FIONREAD_IN_SYS_IOCTL)
1502 fi
1503 ])
1504
1505 dnl
1506 dnl See if speed_t is declared in <sys/types.h>.  Some versions of linux
1507 dnl require a definition of speed_t each time <termcap.h> is included,
1508 dnl but you can only get speed_t if you include <termios.h> (on some
1509 dnl versions) or <sys/types.h> (on others).
1510 dnl
1511 AC_DEFUN(BASH_CHECK_SPEED_T,
1512 [AC_MSG_CHECKING(for speed_t in sys/types.h)
1513 AC_CACHE_VAL(bash_cv_speed_t_in_sys_types,
1514 [AC_TRY_COMPILE([#include <sys/types.h>], [speed_t x;],
1515   bash_cv_speed_t_in_sys_types=yes,bash_cv_speed_t_in_sys_types=no)])
1516 AC_MSG_RESULT($bash_cv_speed_t_in_sys_types)
1517 if test $bash_cv_speed_t_in_sys_types = yes; then
1518 AC_DEFINE(SPEED_T_IN_SYS_TYPES)
1519 fi
1520 ])
1521
1522 AC_DEFUN(BASH_CHECK_GETPW_FUNCS,
1523 [AC_MSG_CHECKING(whether getpw functions are declared in pwd.h)
1524 AC_CACHE_VAL(bash_cv_getpw_declared,
1525 [AC_EGREP_CPP(getpwuid,
1526 [
1527 #include <sys/types.h>
1528 #ifdef HAVE_UNISTD_H
1529 #  include <unistd.h>
1530 #endif
1531 #include <pwd.h>
1532 ],
1533 bash_cv_getpw_declared=yes,bash_cv_getpw_declared=no)])
1534 AC_MSG_RESULT($bash_cv_getpw_declared)
1535 if test $bash_cv_getpw_declared = yes; then
1536 AC_DEFINE(HAVE_GETPW_DECLS)
1537 fi
1538 ])
1539
1540 AC_DEFUN(BASH_CHECK_DEV_FD,
1541 [AC_MSG_CHECKING(whether /dev/fd is available)
1542 AC_CACHE_VAL(bash_cv_dev_fd,
1543 [bash_cv_dev_fd=""
1544 if test -d /dev/fd  && (exec test -r /dev/fd/0 < /dev/null) ; then
1545 # check for systems like FreeBSD 5 that only provide /dev/fd/[012]
1546    if (exec test -r /dev/fd/3 3</dev/null) ; then
1547      bash_cv_dev_fd=standard
1548    else
1549      bash_cv_dev_fd=absent
1550    fi
1551 fi
1552 if test -z "$bash_cv_dev_fd" ; then
1553   if test -d /proc/self/fd && (exec test -r /proc/self/fd/0 < /dev/null) ; then
1554     bash_cv_dev_fd=whacky
1555   else
1556     bash_cv_dev_fd=absent
1557   fi
1558 fi
1559 ])
1560 AC_MSG_RESULT($bash_cv_dev_fd)
1561 if test $bash_cv_dev_fd = "standard"; then
1562   AC_DEFINE(HAVE_DEV_FD)
1563   AC_DEFINE(DEV_FD_PREFIX, "/dev/fd/")
1564 elif test $bash_cv_dev_fd = "whacky"; then
1565   AC_DEFINE(HAVE_DEV_FD)
1566   AC_DEFINE(DEV_FD_PREFIX, "/proc/self/fd/")
1567 fi
1568 ])
1569
1570 AC_DEFUN(BASH_CHECK_DEV_STDIN,
1571 [AC_MSG_CHECKING(whether /dev/stdin stdout stderr are available)
1572 AC_CACHE_VAL(bash_cv_dev_stdin,
1573 [if test -d /dev/fd && (exec test -r /dev/stdin < /dev/null) ; then
1574    bash_cv_dev_stdin=present
1575  elif test -d /proc/self/fd && (exec test -r /dev/stdin < /dev/null) ; then
1576    bash_cv_dev_stdin=present
1577  else
1578    bash_cv_dev_stdin=absent
1579  fi
1580 ])
1581 AC_MSG_RESULT($bash_cv_dev_stdin)
1582 if test $bash_cv_dev_stdin = "present"; then
1583   AC_DEFINE(HAVE_DEV_STDIN)
1584 fi
1585 ])
1586
1587 dnl
1588 dnl Check if HPUX needs _KERNEL defined for RLIMIT_* definitions
1589 dnl
1590 AC_DEFUN(BASH_CHECK_KERNEL_RLIMIT,
1591 [AC_MSG_CHECKING([whether $host_os needs _KERNEL for RLIMIT defines])
1592 AC_CACHE_VAL(bash_cv_kernel_rlimit,
1593 [AC_TRY_COMPILE([
1594 #include <sys/types.h>
1595 #include <sys/resource.h>
1596 ],
1597 [
1598   int f;
1599   f = RLIMIT_DATA;
1600 ], bash_cv_kernel_rlimit=no,
1601 [AC_TRY_COMPILE([
1602 #include <sys/types.h>
1603 #define _KERNEL
1604 #include <sys/resource.h>
1605 #undef _KERNEL
1606 ],
1607 [
1608         int f;
1609         f = RLIMIT_DATA;
1610 ], bash_cv_kernel_rlimit=yes, bash_cv_kernel_rlimit=no)]
1611 )])
1612 AC_MSG_RESULT($bash_cv_kernel_rlimit)
1613 if test $bash_cv_kernel_rlimit = yes; then
1614 AC_DEFINE(RLIMIT_NEEDS_KERNEL)
1615 fi
1616 ])
1617
1618 dnl
1619 dnl Check for 64-bit off_t -- used for malloc alignment
1620 dnl
1621 dnl C does not allow duplicate case labels, so the compile will fail if
1622 dnl sizeof(off_t) is > 4.
1623 dnl
1624 AC_DEFUN(BASH_CHECK_OFF_T_64,
1625 [AC_CACHE_CHECK(for 64-bit off_t, bash_cv_off_t_64,
1626 AC_TRY_COMPILE([
1627 #ifdef HAVE_UNISTD_H
1628 #include <unistd.h>
1629 #endif
1630 #include <sys/types.h>
1631 ],[
1632 switch (0) case 0: case (sizeof (off_t) <= 4):;
1633 ], bash_cv_off_t_64=no, bash_cv_off_t_64=yes))
1634 if test $bash_cv_off_t_64 = yes; then
1635         AC_DEFINE(HAVE_OFF_T_64)
1636 fi])
1637
1638 AC_DEFUN(BASH_CHECK_RTSIGS,
1639 [AC_MSG_CHECKING(for unusable real-time signals due to large values)
1640 AC_CACHE_VAL(bash_cv_unusable_rtsigs,
1641 [AC_TRY_RUN([
1642 #include <sys/types.h>
1643 #include <signal.h>
1644
1645 #ifndef NSIG
1646 #  define NSIG 64
1647 #endif
1648
1649 main ()
1650 {
1651   int n_sigs = 2 * NSIG;
1652 #ifdef SIGRTMIN
1653   int rtmin = SIGRTMIN;
1654 #else
1655   int rtmin = 0;
1656 #endif
1657
1658   exit(rtmin < n_sigs);
1659 }], bash_cv_unusable_rtsigs=yes, bash_cv_unusable_rtsigs=no,
1660     [AC_MSG_WARN(cannot check real-time signals if cross compiling -- defaulting to yes)
1661      bash_cv_unusable_rtsigs=yes]
1662 )])
1663 AC_MSG_RESULT($bash_cv_unusable_rtsigs)
1664 if test $bash_cv_unusable_rtsigs = yes; then
1665 AC_DEFINE(UNUSABLE_RT_SIGNALS)
1666 fi
1667 ])
1668
1669 dnl
1670 dnl check for availability of multibyte characters and functions
1671 dnl
1672 dnl geez, I wish I didn't have to check for all of this stuff separately
1673 dnl
1674 AC_DEFUN(BASH_CHECK_MULTIBYTE,
1675 [
1676 AC_CHECK_HEADERS(wctype.h)
1677 AC_CHECK_HEADERS(wchar.h)
1678 AC_CHECK_HEADERS(langinfo.h)
1679
1680 AC_CHECK_FUNC(mbrlen, AC_DEFINE(HAVE_MBRLEN))
1681 AC_CHECK_FUNC(mbscmp, AC_DEFINE(HAVE_MBSCMP))
1682 AC_CHECK_FUNC(mbsrtowcs, AC_DEFINE(HAVE_MBSRTOWCS))
1683
1684 AC_CHECK_FUNC(wcrtomb, AC_DEFINE(HAVE_WCRTOMB))
1685 AC_CHECK_FUNC(wcscoll, AC_DEFINE(HAVE_WCSCOLL))
1686 AC_CHECK_FUNC(wcsdup, AC_DEFINE(HAVE_WCSDUP))
1687 AC_CHECK_FUNC(wcwidth, AC_DEFINE(HAVE_WCWIDTH))
1688 AC_CHECK_FUNC(wctype, AC_DEFINE(HAVE_WCTYPE))
1689
1690 dnl checks for both mbrtowc and mbstate_t
1691 AC_FUNC_MBRTOWC
1692 if test $ac_cv_func_mbrtowc = yes; then
1693         AC_DEFINE(HAVE_MBSTATE_T)
1694 fi
1695
1696 AC_CHECK_FUNCS(iswlower iswupper towlower towupper iswctype)
1697
1698 AC_CACHE_CHECK([for nl_langinfo and CODESET], bash_cv_langinfo_codeset,
1699 [AC_TRY_LINK(
1700 [#include <langinfo.h>],
1701 [char* cs = nl_langinfo(CODESET);],
1702 bash_cv_langinfo_codeset=yes, bash_cv_langinfo_codeset=no)])
1703 if test $bash_cv_langinfo_codeset = yes; then
1704   AC_DEFINE(HAVE_LANGINFO_CODESET)
1705 fi
1706
1707 dnl check for wchar_t in <wchar.h>
1708 AC_CACHE_CHECK([for wchar_t in wchar.h], bash_cv_type_wchar_t,
1709 [AC_TRY_COMPILE(
1710 [#include <wchar.h>
1711 ],
1712 [
1713         wchar_t foo;
1714         foo = 0;
1715 ], bash_cv_type_wchar_t=yes, bash_cv_type_wchar_t=no)])
1716 if test $bash_cv_type_wchar_t = yes; then
1717         AC_DEFINE(HAVE_WCHAR_T, 1, [systems should define this type here])
1718 fi
1719
1720 dnl check for wctype_t in <wctype.h>
1721 AC_CACHE_CHECK([for wctype_t in wctype.h], bash_cv_type_wctype_t,
1722 [AC_TRY_COMPILE(
1723 [#include <wctype.h>],
1724 [
1725         wctype_t foo;
1726         foo = 0;
1727 ], bash_cv_type_wctype_t=yes, bash_cv_type_wctype_t=no)])
1728 if test $bash_cv_type_wctype_t = yes; then
1729         AC_DEFINE(HAVE_WCTYPE_T, 1, [systems should define this type here])
1730 fi
1731
1732 dnl check for wint_t in <wctype.h>
1733 AC_CACHE_CHECK([for wint_t in wctype.h], bash_cv_type_wint_t,
1734 [AC_TRY_COMPILE(
1735 [#include <wctype.h>],
1736 [
1737         wint_t foo;
1738         foo = 0;
1739 ], bash_cv_type_wint_t=yes, bash_cv_type_wint_t=no)])
1740 if test $bash_cv_type_wint_t = yes; then
1741         AC_DEFINE(HAVE_WINT_T, 1, [systems should define this type here])
1742 fi
1743
1744 ])
1745
1746 dnl need: prefix exec_prefix libdir includedir CC TERMCAP_LIB
1747 dnl require:
1748 dnl     AC_PROG_CC
1749 dnl     BASH_CHECK_LIB_TERMCAP
1750
1751 AC_DEFUN([RL_LIB_READLINE_VERSION],
1752 [
1753 AC_REQUIRE([BASH_CHECK_LIB_TERMCAP])
1754
1755 AC_MSG_CHECKING([version of installed readline library])
1756
1757 # What a pain in the ass this is.
1758
1759 # save cpp and ld options
1760 _save_CFLAGS="$CFLAGS"
1761 _save_LDFLAGS="$LDFLAGS"
1762 _save_LIBS="$LIBS"
1763
1764 # Don't set ac_cv_rl_prefix if the caller has already assigned a value.  This
1765 # allows the caller to do something like $_rl_prefix=$withval if the user
1766 # specifies --with-installed-readline=PREFIX as an argument to configure
1767
1768 if test -z "$ac_cv_rl_prefix"; then
1769 test "x$prefix" = xNONE && ac_cv_rl_prefix=$ac_default_prefix || ac_cv_rl_prefix=${prefix}
1770 fi
1771
1772 eval ac_cv_rl_includedir=${ac_cv_rl_prefix}/include
1773 eval ac_cv_rl_libdir=${ac_cv_rl_prefix}/lib
1774
1775 LIBS="$LIBS -lreadline ${TERMCAP_LIB}"
1776 CFLAGS="$CFLAGS -I${ac_cv_rl_includedir}"
1777 LDFLAGS="$LDFLAGS -L${ac_cv_rl_libdir}"
1778
1779 AC_CACHE_VAL(ac_cv_rl_version,
1780 [AC_TRY_RUN([
1781 #include <stdio.h>
1782 #include <readline/readline.h>
1783
1784 extern int rl_gnu_readline_p;
1785
1786 main()
1787 {
1788         FILE *fp;
1789         fp = fopen("conftest.rlv", "w");
1790         if (fp == 0)
1791                 exit(1);
1792         if (rl_gnu_readline_p != 1)
1793                 fprintf(fp, "0.0\n");
1794         else
1795                 fprintf(fp, "%s\n", rl_library_version ? rl_library_version : "0.0");
1796         fclose(fp);
1797         exit(0);
1798 }
1799 ],
1800 ac_cv_rl_version=`cat conftest.rlv`,
1801 ac_cv_rl_version='0.0',
1802 ac_cv_rl_version='4.2')])
1803
1804 CFLAGS="$_save_CFLAGS"
1805 LDFLAGS="$_save_LDFLAGS"
1806 LIBS="$_save_LIBS"
1807
1808 RL_MAJOR=0
1809 RL_MINOR=0
1810
1811 # (
1812 case "$ac_cv_rl_version" in
1813 2*|3*|4*|5*|6*|7*|8*|9*)
1814         RL_MAJOR=`echo $ac_cv_rl_version | sed 's:\..*$::'`
1815         RL_MINOR=`echo $ac_cv_rl_version | sed -e 's:^.*\.::' -e 's:[[a-zA-Z]]*$::'`
1816         ;;
1817 esac
1818
1819 # (((
1820 case $RL_MAJOR in
1821 [[0-9][0-9]])   _RL_MAJOR=$RL_MAJOR ;;
1822 [[0-9]])        _RL_MAJOR=0$RL_MAJOR ;;
1823 *)              _RL_MAJOR=00 ;;
1824 esac
1825
1826 # (((
1827 case $RL_MINOR in
1828 [[0-9][0-9]])   _RL_MINOR=$RL_MINOR ;;
1829 [[0-9]])        _RL_MINOR=0$RL_MINOR ;;
1830 *)              _RL_MINOR=00 ;;
1831 esac
1832
1833 RL_VERSION="0x${_RL_MAJOR}${_RL_MINOR}"
1834
1835 # Readline versions greater than 4.2 have these defines in readline.h
1836
1837 if test $ac_cv_rl_version = '0.0' ; then
1838         AC_MSG_WARN([Could not test version of installed readline library.])
1839 elif test $RL_MAJOR -gt 4 || { test $RL_MAJOR = 4 && test $RL_MINOR -gt 2 ; } ; then
1840         # set these for use by the caller
1841         RL_PREFIX=$ac_cv_rl_prefix
1842         RL_LIBDIR=$ac_cv_rl_libdir
1843         RL_INCLUDEDIR=$ac_cv_rl_includedir
1844         AC_MSG_RESULT($ac_cv_rl_version)
1845 else
1846
1847 AC_DEFINE_UNQUOTED(RL_READLINE_VERSION, $RL_VERSION, [encoded version of the installed readline library])
1848 AC_DEFINE_UNQUOTED(RL_VERSION_MAJOR, $RL_MAJOR, [major version of installed readline library])
1849 AC_DEFINE_UNQUOTED(RL_VERSION_MINOR, $RL_MINOR, [minor version of installed readline library])
1850
1851 AC_SUBST(RL_VERSION)
1852 AC_SUBST(RL_MAJOR)
1853 AC_SUBST(RL_MINOR)
1854
1855 # set these for use by the caller
1856 RL_PREFIX=$ac_cv_rl_prefix
1857 RL_LIBDIR=$ac_cv_rl_libdir
1858 RL_INCLUDEDIR=$ac_cv_rl_includedir
1859
1860 AC_MSG_RESULT($ac_cv_rl_version)
1861
1862 fi
1863 ])
1864
1865 AC_DEFUN(BASH_FUNC_CTYPE_NONASCII,
1866 [
1867 AC_MSG_CHECKING(whether the ctype macros accept non-ascii characters)
1868 AC_CACHE_VAL(bash_cv_func_ctype_nonascii,
1869 [AC_TRY_RUN([
1870 #ifdef HAVE_LOCALE_H
1871 #include <locale.h>
1872 #endif
1873 #include <stdio.h>
1874 #include <ctype.h>
1875
1876 main(c, v)
1877 int     c;
1878 char    *v[];
1879 {
1880         char    *deflocale;
1881         unsigned char x;
1882         int     r1, r2;
1883
1884 #ifdef HAVE_SETLOCALE
1885         /* We take a shot here.  If that locale is not known, try the
1886            system default.  We try this one because '\342' (226) is
1887            known to be a printable character in that locale. */
1888         deflocale = setlocale(LC_ALL, "en_US.ISO8859-1");
1889         if (deflocale == 0)
1890                 deflocale = setlocale(LC_ALL, "");
1891 #endif
1892
1893         x = '\342';
1894         r1 = isprint(x);
1895         x -= 128;
1896         r2 = isprint(x);
1897         exit (r1 == 0 || r2 == 0);
1898 }
1899 ], bash_cv_func_ctype_nonascii=yes, bash_cv_func_ctype_nonascii=no,
1900    [AC_MSG_WARN(cannot check ctype macros if cross compiling -- defaulting to no)
1901     bash_cv_func_ctype_nonascii=no]
1902 )])
1903 AC_MSG_RESULT($bash_cv_func_ctype_nonascii)
1904 if test $bash_cv_func_ctype_nonascii = yes; then
1905 AC_DEFINE(CTYPE_NON_ASCII)
1906 fi
1907 ])
1908
1909 AC_DEFUN(BASH_CHECK_WCONTINUED,
1910 [
1911 AC_MSG_CHECKING(whether WCONTINUED flag to waitpid is unavailable or available but broken)
1912 AC_CACHE_VAL(bash_cv_wcontinued_broken,
1913 [AC_TRY_RUN([
1914 #include <sys/types.h>
1915 #include <sys/wait.h>
1916 #include <unistd.h>
1917 #include <errno.h>
1918
1919 #ifndef errno
1920 extern int errno;
1921 #endif
1922 main()
1923 {
1924         int     x;
1925
1926         x = waitpid(-1, (int *)0, WNOHANG|WCONTINUED);
1927         if (x == -1 && errno == EINVAL)
1928                 exit (1);
1929         else
1930                 exit (0);
1931 }
1932 ], bash_cv_wcontinued_broken=no,bash_cv_wcontinued_broken=yes,
1933    [AC_MSG_WARN(cannot check WCONTINUED if cross compiling -- defaulting to no)
1934     bash_cv_wcontinued_broken=no]
1935 )])
1936 AC_MSG_RESULT($bash_cv_wcontinued_broken)
1937 if test $bash_cv_wcontinued_broken = yes; then
1938 AC_DEFINE(WCONTINUED_BROKEN)
1939 fi
1940 ])
1941
1942 dnl
1943 dnl tests added for bashdb
1944 dnl
1945
1946
1947 AC_DEFUN([AM_PATH_LISPDIR],
1948  [AC_ARG_WITH(lispdir, AC_HELP_STRING([--with-lispdir], [override the default lisp directory]),
1949   [ lispdir="$withval"
1950     AC_MSG_CHECKING([where .elc files should go])
1951     AC_MSG_RESULT([$lispdir])],
1952   [
1953   # If set to t, that means we are running in a shell under Emacs.
1954   # If you have an Emacs named "t", then use the full path.
1955   test x"$EMACS" = xt && EMACS=
1956   AC_CHECK_PROGS(EMACS, emacs xemacs, no)
1957   if test $EMACS != "no"; then
1958     if test x${lispdir+set} != xset; then
1959       AC_CACHE_CHECK([where .elc files should go], [am_cv_lispdir], [dnl
1960         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;}'`
1961         if test -z "$am_cv_lispdir"; then
1962           am_cv_lispdir='${datadir}/emacs/site-lisp'
1963         fi
1964       ])
1965       lispdir="$am_cv_lispdir"
1966     fi
1967   fi
1968  ])
1969  AC_SUBST(lispdir)
1970 ])
1971
1972 dnl
1973 dnl tests added for gettext
1974 dnl
1975 # codeset.m4 serial AM1 (gettext-0.10.40)
1976 dnl Copyright (C) 2000-2002 Free Software Foundation, Inc.
1977 dnl This file is free software, distributed under the terms of the GNU
1978 dnl General Public License.  As a special exception to the GNU General
1979 dnl Public License, this file may be distributed as part of a program
1980 dnl that contains a configuration script generated by Autoconf, under
1981 dnl the same distribution terms as the rest of that program.
1982
1983 dnl From Bruno Haible.
1984
1985 AC_DEFUN([AM_LANGINFO_CODESET],
1986 [
1987   AC_CACHE_CHECK([for nl_langinfo and CODESET], am_cv_langinfo_codeset,
1988     [AC_TRY_LINK([#include <langinfo.h>],
1989       [char* cs = nl_langinfo(CODESET);],
1990       am_cv_langinfo_codeset=yes,
1991       am_cv_langinfo_codeset=no)
1992     ])
1993   if test $am_cv_langinfo_codeset = yes; then
1994     AC_DEFINE(HAVE_LANGINFO_CODESET, 1,
1995       [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
1996   fi
1997 ])
1998 # gettext.m4 serial 20 (gettext-0.12)
1999 dnl Copyright (C) 1995-2003 Free Software Foundation, Inc.
2000 dnl This file is free software, distributed under the terms of the GNU
2001 dnl General Public License.  As a special exception to the GNU General
2002 dnl Public License, this file may be distributed as part of a program
2003 dnl that contains a configuration script generated by Autoconf, under
2004 dnl the same distribution terms as the rest of that program.
2005 dnl
2006 dnl This file can can be used in projects which are not available under
2007 dnl the GNU General Public License or the GNU Library General Public
2008 dnl License but which still want to provide support for the GNU gettext
2009 dnl functionality.
2010 dnl Please note that the actual code of the GNU gettext library is covered
2011 dnl by the GNU Library General Public License, and the rest of the GNU
2012 dnl gettext package package is covered by the GNU General Public License.
2013 dnl They are *not* in the public domain.
2014
2015 dnl Authors:
2016 dnl   Ulrich Drepper <drepper@cygnus.com>, 1995-2000.
2017 dnl   Bruno Haible <haible@clisp.cons.org>, 2000-2003.
2018
2019 dnl Macro to add for using GNU gettext.
2020
2021 dnl Usage: AM_GNU_GETTEXT([INTLSYMBOL], [NEEDSYMBOL], [INTLDIR]).
2022 dnl INTLSYMBOL can be one of 'external', 'no-libtool', 'use-libtool'. The
2023 dnl    default (if it is not specified or empty) is 'no-libtool'.
2024 dnl    INTLSYMBOL should be 'external' for packages with no intl directory,
2025 dnl    and 'no-libtool' or 'use-libtool' for packages with an intl directory.
2026 dnl    If INTLSYMBOL is 'use-libtool', then a libtool library
2027 dnl    $(top_builddir)/intl/libintl.la will be created (shared and/or static,
2028 dnl    depending on --{enable,disable}-{shared,static} and on the presence of
2029 dnl    AM-DISABLE-SHARED). If INTLSYMBOL is 'no-libtool', a static library
2030 dnl    $(top_builddir)/intl/libintl.a will be created.
2031 dnl If NEEDSYMBOL is specified and is 'need-ngettext', then GNU gettext
2032 dnl    implementations (in libc or libintl) without the ngettext() function
2033 dnl    will be ignored.  If NEEDSYMBOL is specified and is
2034 dnl    'need-formatstring-macros', then GNU gettext implementations that don't
2035 dnl    support the ISO C 99 <inttypes.h> formatstring macros will be ignored.
2036 dnl INTLDIR is used to find the intl libraries.  If empty,
2037 dnl    the value `$(top_builddir)/intl/' is used.
2038 dnl
2039 dnl The result of the configuration is one of three cases:
2040 dnl 1) GNU gettext, as included in the intl subdirectory, will be compiled
2041 dnl    and used.
2042 dnl    Catalog format: GNU --> install in $(datadir)
2043 dnl    Catalog extension: .mo after installation, .gmo in source tree
2044 dnl 2) GNU gettext has been found in the system's C library.
2045 dnl    Catalog format: GNU --> install in $(datadir)
2046 dnl    Catalog extension: .mo after installation, .gmo in source tree
2047 dnl 3) No internationalization, always use English msgid.
2048 dnl    Catalog format: none
2049 dnl    Catalog extension: none
2050 dnl If INTLSYMBOL is 'external', only cases 2 and 3 can occur.
2051 dnl The use of .gmo is historical (it was needed to avoid overwriting the
2052 dnl GNU format catalogs when building on a platform with an X/Open gettext),
2053 dnl but we keep it in order not to force irrelevant filename changes on the
2054 dnl maintainers.
2055 dnl
2056 AC_DEFUN([AM_GNU_GETTEXT],
2057 [
2058   dnl Argument checking.
2059   ifelse([$1], [], , [ifelse([$1], [external], , [ifelse([$1], [no-libtool], , [ifelse([$1], [use-libtool], ,
2060     [errprint([ERROR: invalid first argument to AM_GNU_GETTEXT
2061 ])])])])])
2062   ifelse([$2], [], , [ifelse([$2], [need-ngettext], , [ifelse([$2], [need-formatstring-macros], ,
2063     [errprint([ERROR: invalid second argument to AM_GNU_GETTEXT
2064 ])])])])
2065   define(gt_included_intl, ifelse([$1], [external], [no], [yes]))
2066   define(gt_libtool_suffix_prefix, ifelse([$1], [use-libtool], [l], []))
2067
2068   AC_REQUIRE([AM_PO_SUBDIRS])dnl
2069   ifelse(gt_included_intl, yes, [
2070     AC_REQUIRE([AM_INTL_SUBDIR])dnl
2071   ])
2072
2073   dnl Prerequisites of AC_LIB_LINKFLAGS_BODY.
2074   AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
2075   AC_REQUIRE([AC_LIB_RPATH])
2076
2077   dnl Sometimes libintl requires libiconv, so first search for libiconv.
2078   dnl Ideally we would do this search only after the
2079   dnl      if test "$USE_NLS" = "yes"; then
2080   dnl        if test "$gt_cv_func_gnugettext_libc" != "yes"; then
2081   dnl tests. But if configure.in invokes AM_ICONV after AM_GNU_GETTEXT
2082   dnl the configure script would need to contain the same shell code
2083   dnl again, outside any 'if'. There are two solutions:
2084   dnl - Invoke AM_ICONV_LINKFLAGS_BODY here, outside any 'if'.
2085   dnl - Control the expansions in more detail using AC_PROVIDE_IFELSE.
2086   dnl Since AC_PROVIDE_IFELSE is only in autoconf >= 2.52 and not
2087   dnl documented, we avoid it.
2088   ifelse(gt_included_intl, yes, , [
2089     AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY])
2090   ])
2091
2092   dnl Set USE_NLS.
2093   AM_NLS
2094
2095   ifelse(gt_included_intl, yes, [
2096     BUILD_INCLUDED_LIBINTL=no
2097     USE_INCLUDED_LIBINTL=no
2098   ])
2099   LIBINTL=
2100   LTLIBINTL=
2101   POSUB=
2102
2103   dnl If we use NLS figure out what method
2104   if test "$USE_NLS" = "yes"; then
2105     gt_use_preinstalled_gnugettext=no
2106     ifelse(gt_included_intl, yes, [
2107       AC_MSG_CHECKING([whether included gettext is requested])
2108       AC_ARG_WITH(included-gettext,
2109         [  --with-included-gettext use the GNU gettext library included here],
2110         nls_cv_force_use_gnu_gettext=$withval,
2111         nls_cv_force_use_gnu_gettext=no)
2112       AC_MSG_RESULT($nls_cv_force_use_gnu_gettext)
2113
2114       nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext"
2115       if test "$nls_cv_force_use_gnu_gettext" != "yes"; then
2116     ])
2117         dnl User does not insist on using GNU NLS library.  Figure out what
2118         dnl to use.  If GNU gettext is available we use this.  Else we have
2119         dnl to fall back to GNU NLS library.
2120
2121         dnl Add a version number to the cache macros.
2122         define([gt_api_version], ifelse([$2], [need-formatstring-macros], 3, ifelse([$2], [need-ngettext], 2, 1)))
2123         define([gt_cv_func_gnugettext_libc], [gt_cv_func_gnugettext]gt_api_version[_libc])
2124         define([gt_cv_func_gnugettext_libintl], [gt_cv_func_gnugettext]gt_api_version[_libintl])
2125
2126         AC_CACHE_CHECK([for GNU gettext in libc], gt_cv_func_gnugettext_libc,
2127          [AC_TRY_LINK([#include <libintl.h>
2128 ]ifelse([$2], [need-formatstring-macros],
2129 [#ifndef __GNU_GETTEXT_SUPPORTED_REVISION
2130 #define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1)
2131 #endif
2132 changequote(,)dnl
2133 typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1];
2134 changequote([,])dnl
2135 ], [])[extern int _nl_msg_cat_cntr;
2136 extern int *_nl_domain_bindings;],
2137             [bindtextdomain ("", "");
2138 return (int) gettext ("")]ifelse([$2], [need-ngettext], [ + (int) ngettext ("", "", 0)], [])[ + _nl_msg_cat_cntr + *_nl_domain_bindings],
2139             gt_cv_func_gnugettext_libc=yes,
2140             gt_cv_func_gnugettext_libc=no)])
2141
2142         if test "$gt_cv_func_gnugettext_libc" != "yes"; then
2143           dnl Sometimes libintl requires libiconv, so first search for libiconv.
2144           ifelse(gt_included_intl, yes, , [
2145             AM_ICONV_LINK
2146           ])
2147           dnl Search for libintl and define LIBINTL, LTLIBINTL and INCINTL
2148           dnl accordingly. Don't use AC_LIB_LINKFLAGS_BODY([intl],[iconv])
2149           dnl because that would add "-liconv" to LIBINTL and LTLIBINTL
2150           dnl even if libiconv doesn't exist.
2151           AC_LIB_LINKFLAGS_BODY([intl])
2152           AC_CACHE_CHECK([for GNU gettext in libintl],
2153             gt_cv_func_gnugettext_libintl,
2154            [gt_save_CPPFLAGS="$CPPFLAGS"
2155             CPPFLAGS="$CPPFLAGS $INCINTL"
2156             gt_save_LIBS="$LIBS"
2157             LIBS="$LIBS $LIBINTL"
2158             dnl Now see whether libintl exists and does not depend on libiconv.
2159             AC_TRY_LINK([#include <libintl.h>
2160 ]ifelse([$2], [need-formatstring-macros],
2161 [#ifndef __GNU_GETTEXT_SUPPORTED_REVISION
2162 #define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1)
2163 #endif
2164 changequote(,)dnl
2165 typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1];
2166 changequote([,])dnl
2167 ], [])[extern int _nl_msg_cat_cntr;
2168 extern
2169 #ifdef __cplusplus
2170 "C"
2171 #endif
2172 const char *_nl_expand_alias ();],
2173               [bindtextdomain ("", "");
2174 return (int) gettext ("")]ifelse([$2], [need-ngettext], [ + (int) ngettext ("", "", 0)], [])[ + _nl_msg_cat_cntr + *_nl_expand_alias (0)],
2175               gt_cv_func_gnugettext_libintl=yes,
2176               gt_cv_func_gnugettext_libintl=no)
2177             dnl Now see whether libintl exists and depends on libiconv.
2178             if test "$gt_cv_func_gnugettext_libintl" != yes && test -n "$LIBICONV"; then
2179               LIBS="$LIBS $LIBICONV"
2180               AC_TRY_LINK([#include <libintl.h>
2181 ]ifelse([$2], [need-formatstring-macros],
2182 [#ifndef __GNU_GETTEXT_SUPPORTED_REVISION
2183 #define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1)
2184 #endif
2185 changequote(,)dnl
2186 typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1];
2187 changequote([,])dnl
2188 ], [])[extern int _nl_msg_cat_cntr;
2189 extern
2190 #ifdef __cplusplus
2191 "C"
2192 #endif
2193 const char *_nl_expand_alias ();],
2194                 [bindtextdomain ("", "");
2195 return (int) gettext ("")]ifelse([$2], [need-ngettext], [ + (int) ngettext ("", "", 0)], [])[ + _nl_msg_cat_cntr + *_nl_expand_alias (0)],
2196                [LIBINTL="$LIBINTL $LIBICONV"
2197                 LTLIBINTL="$LTLIBINTL $LTLIBICONV"
2198                 gt_cv_func_gnugettext_libintl=yes
2199                ])
2200             fi
2201             CPPFLAGS="$gt_save_CPPFLAGS"
2202             LIBS="$gt_save_LIBS"])
2203         fi
2204
2205         dnl If an already present or preinstalled GNU gettext() is found,
2206         dnl use it.  But if this macro is used in GNU gettext, and GNU
2207         dnl gettext is already preinstalled in libintl, we update this
2208         dnl libintl.  (Cf. the install rule in intl/Makefile.in.)
2209         if test "$gt_cv_func_gnugettext_libc" = "yes" \
2210            || { test "$gt_cv_func_gnugettext_libintl" = "yes" \
2211                 && test "$PACKAGE" != gettext-runtime \
2212                 && test "$PACKAGE" != gettext-tools; }; then
2213           gt_use_preinstalled_gnugettext=yes
2214         else
2215           dnl Reset the values set by searching for libintl.
2216           LIBINTL=
2217           LTLIBINTL=
2218           INCINTL=
2219         fi
2220
2221     ifelse(gt_included_intl, yes, [
2222         if test "$gt_use_preinstalled_gnugettext" != "yes"; then
2223           dnl GNU gettext is not found in the C library.
2224           dnl Fall back on included GNU gettext library.
2225           nls_cv_use_gnu_gettext=yes
2226         fi
2227       fi
2228
2229       if test "$nls_cv_use_gnu_gettext" = "yes"; then
2230         dnl Mark actions used to generate GNU NLS library.
2231         BUILD_INCLUDED_LIBINTL=yes
2232         USE_INCLUDED_LIBINTL=yes
2233         LIBINTL="ifelse([$3],[],\${top_builddir}/intl,[$3])/libintl.[]gt_libtool_suffix_prefix[]a $LIBICONV"
2234         LTLIBINTL="ifelse([$3],[],\${top_builddir}/intl,[$3])/libintl.[]gt_libtool_suffix_prefix[]a $LTLIBICONV"
2235         LIBS=`echo " $LIBS " | sed -e 's/ -lintl / /' -e 's/^ //' -e 's/ $//'`
2236       fi
2237
2238       if test "$gt_use_preinstalled_gnugettext" = "yes" \
2239          || test "$nls_cv_use_gnu_gettext" = "yes"; then
2240         dnl Mark actions to use GNU gettext tools.
2241         CATOBJEXT=.gmo
2242       fi
2243     ])
2244
2245     if test "$gt_use_preinstalled_gnugettext" = "yes" \
2246        || test "$nls_cv_use_gnu_gettext" = "yes"; then
2247       AC_DEFINE(ENABLE_NLS, 1,
2248         [Define to 1 if translation of program messages to the user's native language
2249    is requested.])
2250     else
2251       USE_NLS=no
2252     fi
2253   fi
2254
2255   AC_MSG_CHECKING([whether to use NLS])
2256   AC_MSG_RESULT([$USE_NLS])
2257   if test "$USE_NLS" = "yes"; then
2258     AC_MSG_CHECKING([where the gettext function comes from])
2259     if test "$gt_use_preinstalled_gnugettext" = "yes"; then
2260       if test "$gt_cv_func_gnugettext_libintl" = "yes"; then
2261         gt_source="external libintl"
2262       else
2263         gt_source="libc"
2264       fi
2265     else
2266       gt_source="included intl directory"
2267     fi
2268     AC_MSG_RESULT([$gt_source])
2269   fi
2270
2271   if test "$USE_NLS" = "yes"; then
2272
2273     if test "$gt_use_preinstalled_gnugettext" = "yes"; then
2274       if test "$gt_cv_func_gnugettext_libintl" = "yes"; then
2275         AC_MSG_CHECKING([how to link with libintl])
2276         AC_MSG_RESULT([$LIBINTL])
2277         AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCINTL])
2278       fi
2279
2280       dnl For backward compatibility. Some packages may be using this.
2281       AC_DEFINE(HAVE_GETTEXT, 1,
2282        [Define if the GNU gettext() function is already present or preinstalled.])
2283       AC_DEFINE(HAVE_DCGETTEXT, 1,
2284        [Define if the GNU dcgettext() function is already present or preinstalled.])
2285     fi
2286
2287     dnl We need to process the po/ directory.
2288     POSUB=po
2289   fi
2290
2291   ifelse(gt_included_intl, yes, [
2292     dnl If this is used in GNU gettext we have to set BUILD_INCLUDED_LIBINTL
2293     dnl to 'yes' because some of the testsuite requires it.
2294     if test "$PACKAGE" = gettext-runtime || test "$PACKAGE" = gettext-tools; then
2295       BUILD_INCLUDED_LIBINTL=yes
2296     fi
2297
2298     dnl Make all variables we use known to autoconf.
2299     AC_SUBST(BUILD_INCLUDED_LIBINTL)
2300     AC_SUBST(USE_INCLUDED_LIBINTL)
2301     AC_SUBST(CATOBJEXT)
2302
2303     dnl For backward compatibility. Some configure.ins may be using this.
2304     nls_cv_header_intl=
2305     nls_cv_header_libgt=
2306
2307     dnl For backward compatibility. Some Makefiles may be using this.
2308     DATADIRNAME=share
2309     AC_SUBST(DATADIRNAME)
2310
2311     dnl For backward compatibility. Some Makefiles may be using this.
2312     INSTOBJEXT=.mo
2313     AC_SUBST(INSTOBJEXT)
2314
2315     dnl For backward compatibility. Some Makefiles may be using this.
2316     GENCAT=gencat
2317     AC_SUBST(GENCAT)
2318
2319     dnl For backward compatibility. Some Makefiles may be using this.
2320     if test "$USE_INCLUDED_LIBINTL" = yes; then
2321       INTLOBJS="\$(GETTOBJS)"
2322     fi
2323     AC_SUBST(INTLOBJS)
2324
2325     dnl Enable libtool support if the surrounding package wishes it.
2326     INTL_LIBTOOL_SUFFIX_PREFIX=gt_libtool_suffix_prefix
2327     AC_SUBST(INTL_LIBTOOL_SUFFIX_PREFIX)
2328   ])
2329
2330   dnl For backward compatibility. Some Makefiles may be using this.
2331   INTLLIBS="$LIBINTL"
2332   AC_SUBST(INTLLIBS)
2333
2334   dnl Make all documented variables known to autoconf.
2335   AC_SUBST(LIBINTL)
2336   AC_SUBST(LTLIBINTL)
2337   AC_SUBST(POSUB)
2338 ])
2339
2340
2341 dnl Checks for all prerequisites of the intl subdirectory,
2342 dnl except for INTL_LIBTOOL_SUFFIX_PREFIX (and possibly LIBTOOL), INTLOBJS,
2343 dnl            USE_INCLUDED_LIBINTL, BUILD_INCLUDED_LIBINTL.
2344 AC_DEFUN([AM_INTL_SUBDIR],
2345 [
2346   AC_REQUIRE([AC_PROG_INSTALL])dnl
2347   AC_REQUIRE([AM_MKINSTALLDIRS])dnl
2348   AC_REQUIRE([AC_PROG_CC])dnl
2349   AC_REQUIRE([AC_CANONICAL_HOST])dnl
2350   AC_REQUIRE([AC_PROG_RANLIB])dnl
2351   AC_REQUIRE([AC_ISC_POSIX])dnl
2352   AC_REQUIRE([AC_HEADER_STDC])dnl
2353   AC_REQUIRE([AC_C_CONST])dnl
2354   AC_REQUIRE([AC_C_INLINE])dnl
2355   AC_REQUIRE([AC_TYPE_OFF_T])dnl
2356   AC_REQUIRE([AC_TYPE_SIZE_T])dnl
2357   AC_REQUIRE([AC_FUNC_ALLOCA])dnl
2358   AC_REQUIRE([AC_FUNC_MMAP])dnl
2359   AC_REQUIRE([jm_GLIBC21])dnl
2360   AC_REQUIRE([gt_INTDIV0])dnl
2361   AC_REQUIRE([jm_AC_TYPE_UINTMAX_T])dnl
2362   AC_REQUIRE([gt_HEADER_INTTYPES_H])dnl
2363   AC_REQUIRE([gt_INTTYPES_PRI])dnl
2364
2365   AC_CHECK_HEADERS([argz.h limits.h locale.h nl_types.h malloc.h stddef.h \
2366 stdlib.h string.h unistd.h sys/param.h])
2367   AC_CHECK_FUNCS([feof_unlocked fgets_unlocked getc_unlocked getcwd getegid \
2368 geteuid getgid getuid mempcpy munmap putenv setenv setlocale localeconv stpcpy \
2369 strcasecmp strdup strtoul tsearch __argz_count __argz_stringify __argz_next \
2370 __fsetlocking])
2371
2372   AM_ICONV
2373   AM_LANGINFO_CODESET
2374   if test $ac_cv_header_locale_h = yes; then
2375     AM_LC_MESSAGES
2376   fi
2377
2378   dnl intl/plural.c is generated from intl/plural.y. It requires bison,
2379   dnl because plural.y uses bison specific features. It requires at least
2380   dnl bison-1.26 because earlier versions generate a plural.c that doesn't
2381   dnl compile.
2382   dnl bison is only needed for the maintainer (who touches plural.y). But in
2383   dnl order to avoid separate Makefiles or --enable-maintainer-mode, we put
2384   dnl the rule in general Makefile. Now, some people carelessly touch the
2385   dnl files or have a broken "make" program, hence the plural.c rule will
2386   dnl sometimes fire. To avoid an error, defines BISON to ":" if it is not
2387   dnl present or too old.
2388   AC_CHECK_PROGS([INTLBISON], [bison])
2389   if test -z "$INTLBISON"; then
2390     ac_verc_fail=yes
2391   else
2392     dnl Found it, now check the version.
2393     AC_MSG_CHECKING([version of bison])
2394 changequote(<<,>>)dnl
2395     ac_prog_version=`$INTLBISON --version 2>&1 | sed -n 's/^.*GNU Bison.* \([0-9]*\.[0-9.]*\).*$/\1/p'`
2396     case $ac_prog_version in
2397       '') ac_prog_version="v. ?.??, bad"; ac_verc_fail=yes;;
2398       1.2[6-9]* | 1.[3-9][0-9]* | [2-9].*)
2399 changequote([,])dnl
2400          ac_prog_version="$ac_prog_version, ok"; ac_verc_fail=no;;
2401       *) ac_prog_version="$ac_prog_version, bad"; ac_verc_fail=yes;;
2402     esac
2403     AC_MSG_RESULT([$ac_prog_version])
2404   fi
2405   if test $ac_verc_fail = yes; then
2406     INTLBISON=:
2407   fi
2408 ])
2409
2410
2411 dnl Usage: AM_GNU_GETTEXT_VERSION([gettext-version])
2412 AC_DEFUN([AM_GNU_GETTEXT_VERSION], [])
2413 # glibc21.m4 serial 2 (fileutils-4.1.3, gettext-0.10.40)
2414 dnl Copyright (C) 2000-2002 Free Software Foundation, Inc.
2415 dnl This file is free software, distributed under the terms of the GNU
2416 dnl General Public License.  As a special exception to the GNU General
2417 dnl Public License, this file may be distributed as part of a program
2418 dnl that contains a configuration script generated by Autoconf, under
2419 dnl the same distribution terms as the rest of that program.
2420
2421 # Test for the GNU C Library, version 2.1 or newer.
2422 # From Bruno Haible.
2423
2424 AC_DEFUN([jm_GLIBC21],
2425   [
2426     AC_CACHE_CHECK(whether we are using the GNU C Library 2.1 or newer,
2427       ac_cv_gnu_library_2_1,
2428       [AC_EGREP_CPP([Lucky GNU user],
2429         [
2430 #include <features.h>
2431 #ifdef __GNU_LIBRARY__
2432  #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2)
2433   Lucky GNU user
2434  #endif
2435 #endif
2436         ],
2437         ac_cv_gnu_library_2_1=yes,
2438         ac_cv_gnu_library_2_1=no)
2439       ]
2440     )
2441     AC_SUBST(GLIBC21)
2442     GLIBC21="$ac_cv_gnu_library_2_1"
2443   ]
2444 )
2445 # iconv.m4 serial AM4 (gettext-0.11.3)
2446 dnl Copyright (C) 2000-2002 Free Software Foundation, Inc.
2447 dnl This file is free software, distributed under the terms of the GNU
2448 dnl General Public License.  As a special exception to the GNU General
2449 dnl Public License, this file may be distributed as part of a program
2450 dnl that contains a configuration script generated by Autoconf, under
2451 dnl the same distribution terms as the rest of that program.
2452
2453 dnl From Bruno Haible.
2454
2455 AC_DEFUN([AM_ICONV_LINKFLAGS_BODY],
2456 [
2457   dnl Prerequisites of AC_LIB_LINKFLAGS_BODY.
2458   AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
2459   AC_REQUIRE([AC_LIB_RPATH])
2460
2461   dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV
2462   dnl accordingly.
2463   AC_LIB_LINKFLAGS_BODY([iconv])
2464 ])
2465
2466 AC_DEFUN([AM_ICONV_LINK],
2467 [
2468   dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and
2469   dnl those with the standalone portable GNU libiconv installed).
2470
2471   dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV
2472   dnl accordingly.
2473   AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY])
2474
2475   dnl Add $INCICONV to CPPFLAGS before performing the following checks,
2476   dnl because if the user has installed libiconv and not disabled its use
2477   dnl via --without-libiconv-prefix, he wants to use it. The first
2478   dnl AC_TRY_LINK will then fail, the second AC_TRY_LINK will succeed.
2479   am_save_CPPFLAGS="$CPPFLAGS"
2480   AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV])
2481
2482   AC_CACHE_CHECK(for iconv, am_cv_func_iconv, [
2483     am_cv_func_iconv="no, consider installing GNU libiconv"
2484     am_cv_lib_iconv=no
2485     AC_TRY_LINK([#include <stdlib.h>
2486 #include <iconv.h>],
2487       [iconv_t cd = iconv_open("","");
2488        iconv(cd,NULL,NULL,NULL,NULL);
2489        iconv_close(cd);],
2490       am_cv_func_iconv=yes)
2491     if test "$am_cv_func_iconv" != yes; then
2492       am_save_LIBS="$LIBS"
2493       LIBS="$LIBS $LIBICONV"
2494       AC_TRY_LINK([#include <stdlib.h>
2495 #include <iconv.h>],
2496         [iconv_t cd = iconv_open("","");
2497          iconv(cd,NULL,NULL,NULL,NULL);
2498          iconv_close(cd);],
2499         am_cv_lib_iconv=yes
2500         am_cv_func_iconv=yes)
2501       LIBS="$am_save_LIBS"
2502     fi
2503   ])
2504   if test "$am_cv_func_iconv" = yes; then
2505     AC_DEFINE(HAVE_ICONV, 1, [Define if you have the iconv() function.])
2506   fi
2507   if test "$am_cv_lib_iconv" = yes; then
2508     AC_MSG_CHECKING([how to link with libiconv])
2509     AC_MSG_RESULT([$LIBICONV])
2510   else
2511     dnl If $LIBICONV didn't lead to a usable library, we don't need $INCICONV
2512     dnl either.
2513     CPPFLAGS="$am_save_CPPFLAGS"
2514     LIBICONV=
2515     LTLIBICONV=
2516   fi
2517   AC_SUBST(LIBICONV)
2518   AC_SUBST(LTLIBICONV)
2519 ])
2520
2521 AC_DEFUN([AM_ICONV],
2522 [
2523   AM_ICONV_LINK
2524   if test "$am_cv_func_iconv" = yes; then
2525     AC_MSG_CHECKING([for iconv declaration])
2526     AC_CACHE_VAL(am_cv_proto_iconv, [
2527       AC_TRY_COMPILE([
2528 #include <stdlib.h>
2529 #include <iconv.h>
2530 extern
2531 #ifdef __cplusplus
2532 "C"
2533 #endif
2534 #if defined(__STDC__) || defined(__cplusplus)
2535 size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);
2536 #else
2537 size_t iconv();
2538 #endif
2539 ], [], am_cv_proto_iconv_arg1="", am_cv_proto_iconv_arg1="const")
2540       am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"])
2541     am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'`
2542     AC_MSG_RESULT([$]{ac_t:-
2543          }[$]am_cv_proto_iconv)
2544     AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg1,
2545       [Define as const if the declaration of iconv() needs const.])
2546   fi
2547 ])
2548 # intdiv0.m4 serial 1 (gettext-0.11.3)
2549 dnl Copyright (C) 2002 Free Software Foundation, Inc.
2550 dnl This file is free software, distributed under the terms of the GNU
2551 dnl General Public License.  As a special exception to the GNU General
2552 dnl Public License, this file may be distributed as part of a program
2553 dnl that contains a configuration script generated by Autoconf, under
2554 dnl the same distribution terms as the rest of that program.
2555
2556 dnl From Bruno Haible.
2557
2558 AC_DEFUN([gt_INTDIV0],
2559 [
2560   AC_REQUIRE([AC_PROG_CC])dnl
2561   AC_REQUIRE([AC_CANONICAL_HOST])dnl
2562
2563   AC_CACHE_CHECK([whether integer division by zero raises SIGFPE],
2564     gt_cv_int_divbyzero_sigfpe,
2565     [
2566       AC_TRY_RUN([
2567 #include <stdlib.h>
2568 #include <signal.h>
2569
2570 static void
2571 #ifdef __cplusplus
2572 sigfpe_handler (int sig)
2573 #else
2574 sigfpe_handler (sig) int sig;
2575 #endif
2576 {
2577   /* Exit with code 0 if SIGFPE, with code 1 if any other signal.  */
2578   exit (sig != SIGFPE);
2579 }
2580
2581 int x = 1;
2582 int y = 0;
2583 int z;
2584 int nan;
2585
2586 int main ()
2587 {
2588   signal (SIGFPE, sigfpe_handler);
2589 /* IRIX and AIX (when "xlc -qcheck" is used) yield signal SIGTRAP.  */
2590 #if (defined (__sgi) || defined (_AIX)) && defined (SIGTRAP)
2591   signal (SIGTRAP, sigfpe_handler);
2592 #endif
2593 /* Linux/SPARC yields signal SIGILL.  */
2594 #if defined (__sparc__) && defined (__linux__)
2595   signal (SIGILL, sigfpe_handler);
2596 #endif
2597
2598   z = x / y;
2599   nan = y / y;
2600   exit (1);
2601 }
2602 ], gt_cv_int_divbyzero_sigfpe=yes, gt_cv_int_divbyzero_sigfpe=no,
2603         [
2604           # Guess based on the CPU.
2605           case "$host_cpu" in
2606             alpha* | i[34567]86 | m68k | s390*)
2607               gt_cv_int_divbyzero_sigfpe="guessing yes";;
2608             *)
2609               gt_cv_int_divbyzero_sigfpe="guessing no";;
2610           esac
2611         ])
2612     ])
2613   case "$gt_cv_int_divbyzero_sigfpe" in
2614     *yes) value=1;;
2615     *) value=0;;
2616   esac
2617   AC_DEFINE_UNQUOTED(INTDIV0_RAISES_SIGFPE, $value,
2618     [Define if integer division by zero raises signal SIGFPE.])
2619 ])
2620 # inttypes.m4 serial 1 (gettext-0.11.4)
2621 dnl Copyright (C) 1997-2002 Free Software Foundation, Inc.
2622 dnl This file is free software, distributed under the terms of the GNU
2623 dnl General Public License.  As a special exception to the GNU General
2624 dnl Public License, this file may be distributed as part of a program
2625 dnl that contains a configuration script generated by Autoconf, under
2626 dnl the same distribution terms as the rest of that program.
2627
2628 dnl From Paul Eggert.
2629
2630 # Define HAVE_INTTYPES_H if <inttypes.h> exists and doesn't clash with
2631 # <sys/types.h>.
2632
2633 AC_DEFUN([gt_HEADER_INTTYPES_H],
2634 [
2635   AC_CACHE_CHECK([for inttypes.h], gt_cv_header_inttypes_h,
2636   [
2637     AC_TRY_COMPILE(
2638       [#include <sys/types.h>
2639 #include <inttypes.h>],
2640       [], gt_cv_header_inttypes_h=yes, gt_cv_header_inttypes_h=no)
2641   ])
2642   if test $gt_cv_header_inttypes_h = yes; then
2643     AC_DEFINE_UNQUOTED(HAVE_INTTYPES_H, 1,
2644       [Define if <inttypes.h> exists and doesn't clash with <sys/types.h>.])
2645   fi
2646 ])
2647 # inttypes_h.m4 serial 5 (gettext-0.12)
2648 dnl Copyright (C) 1997-2003 Free Software Foundation, Inc.
2649 dnl This file is free software, distributed under the terms of the GNU
2650 dnl General Public License.  As a special exception to the GNU General
2651 dnl Public License, this file may be distributed as part of a program
2652 dnl that contains a configuration script generated by Autoconf, under
2653 dnl the same distribution terms as the rest of that program.
2654
2655 dnl From Paul Eggert.
2656
2657 # Define HAVE_INTTYPES_H_WITH_UINTMAX if <inttypes.h> exists,
2658 # doesn't clash with <sys/types.h>, and declares uintmax_t.
2659
2660 AC_DEFUN([jm_AC_HEADER_INTTYPES_H],
2661 [
2662   AC_CACHE_CHECK([for inttypes.h], jm_ac_cv_header_inttypes_h,
2663   [AC_TRY_COMPILE(
2664     [#include <sys/types.h>
2665 #include <inttypes.h>],
2666     [uintmax_t i = (uintmax_t) -1;],
2667     jm_ac_cv_header_inttypes_h=yes,
2668     jm_ac_cv_header_inttypes_h=no)])
2669   if test $jm_ac_cv_header_inttypes_h = yes; then
2670     AC_DEFINE_UNQUOTED(HAVE_INTTYPES_H_WITH_UINTMAX, 1,
2671       [Define if <inttypes.h> exists, doesn't clash with <sys/types.h>,
2672        and declares uintmax_t. ])
2673   fi
2674 ])
2675 # inttypes-pri.m4 serial 1 (gettext-0.11.4)
2676 dnl Copyright (C) 1997-2002 Free Software Foundation, Inc.
2677 dnl This file is free software, distributed under the terms of the GNU
2678 dnl General Public License.  As a special exception to the GNU General
2679 dnl Public License, this file may be distributed as part of a program
2680 dnl that contains a configuration script generated by Autoconf, under
2681 dnl the same distribution terms as the rest of that program.
2682
2683 dnl From Bruno Haible.
2684
2685 # Define PRI_MACROS_BROKEN if <inttypes.h> exists and defines the PRI*
2686 # macros to non-string values.  This is the case on AIX 4.3.3.
2687
2688 AC_DEFUN([gt_INTTYPES_PRI],
2689 [
2690   AC_REQUIRE([gt_HEADER_INTTYPES_H])
2691   if test $gt_cv_header_inttypes_h = yes; then
2692     AC_CACHE_CHECK([whether the inttypes.h PRIxNN macros are broken],
2693       gt_cv_inttypes_pri_broken,
2694       [
2695         AC_TRY_COMPILE([#include <inttypes.h>
2696 #ifdef PRId32
2697 char *p = PRId32;
2698 #endif
2699 ], [], gt_cv_inttypes_pri_broken=no, gt_cv_inttypes_pri_broken=yes)
2700       ])
2701   fi
2702   if test "$gt_cv_inttypes_pri_broken" = yes; then
2703     AC_DEFINE_UNQUOTED(PRI_MACROS_BROKEN, 1,
2704       [Define if <inttypes.h> exists and defines unusable PRI* macros.])
2705   fi
2706 ])
2707 # isc-posix.m4 serial 2 (gettext-0.11.2)
2708 dnl Copyright (C) 1995-2002 Free Software Foundation, Inc.
2709 dnl This file is free software, distributed under the terms of the GNU
2710 dnl General Public License.  As a special exception to the GNU General
2711 dnl Public License, this file may be distributed as part of a program
2712 dnl that contains a configuration script generated by Autoconf, under
2713 dnl the same distribution terms as the rest of that program.
2714
2715 # This file is not needed with autoconf-2.53 and newer.  Remove it in 2005.
2716
2717 # This test replaces the one in autoconf.
2718 # Currently this macro should have the same name as the autoconf macro
2719 # because gettext's gettext.m4 (distributed in the automake package)
2720 # still uses it.  Otherwise, the use in gettext.m4 makes autoheader
2721 # give these diagnostics:
2722 #   configure.in:556: AC_TRY_COMPILE was called before AC_ISC_POSIX
2723 #   configure.in:556: AC_TRY_RUN was called before AC_ISC_POSIX
2724
2725 undefine([AC_ISC_POSIX])
2726
2727 AC_DEFUN([AC_ISC_POSIX],
2728   [
2729     dnl This test replaces the obsolescent AC_ISC_POSIX kludge.
2730     AC_CHECK_LIB(cposix, strerror, [LIBS="$LIBS -lcposix"])
2731   ]
2732 )
2733 # lcmessage.m4 serial 3 (gettext-0.11.3)
2734 dnl Copyright (C) 1995-2002 Free Software Foundation, Inc.
2735 dnl This file is free software, distributed under the terms of the GNU
2736 dnl General Public License.  As a special exception to the GNU General
2737 dnl Public License, this file may be distributed as part of a program
2738 dnl that contains a configuration script generated by Autoconf, under
2739 dnl the same distribution terms as the rest of that program.
2740 dnl
2741 dnl This file can can be used in projects which are not available under
2742 dnl the GNU General Public License or the GNU Library General Public
2743 dnl License but which still want to provide support for the GNU gettext
2744 dnl functionality.
2745 dnl Please note that the actual code of the GNU gettext library is covered
2746 dnl by the GNU Library General Public License, and the rest of the GNU
2747 dnl gettext package package is covered by the GNU General Public License.
2748 dnl They are *not* in the public domain.
2749
2750 dnl Authors:
2751 dnl   Ulrich Drepper <drepper@cygnus.com>, 1995.
2752
2753 # Check whether LC_MESSAGES is available in <locale.h>.
2754
2755 AC_DEFUN([AM_LC_MESSAGES],
2756 [
2757   AC_CACHE_CHECK([for LC_MESSAGES], am_cv_val_LC_MESSAGES,
2758     [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
2759        am_cv_val_LC_MESSAGES=yes, am_cv_val_LC_MESSAGES=no)])
2760   if test $am_cv_val_LC_MESSAGES = yes; then
2761     AC_DEFINE(HAVE_LC_MESSAGES, 1,
2762       [Define if your <locale.h> file defines LC_MESSAGES.])
2763   fi
2764 ])
2765 # lib-ld.m4 serial 2 (gettext-0.12)
2766 dnl Copyright (C) 1996-2003 Free Software Foundation, Inc.
2767 dnl This file is free software, distributed under the terms of the GNU
2768 dnl General Public License.  As a special exception to the GNU General
2769 dnl Public License, this file may be distributed as part of a program
2770 dnl that contains a configuration script generated by Autoconf, under
2771 dnl the same distribution terms as the rest of that program.
2772
2773 dnl Subroutines of libtool.m4,
2774 dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision
2775 dnl with libtool.m4.
2776
2777 dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no.
2778 AC_DEFUN([AC_LIB_PROG_LD_GNU],
2779 [AC_CACHE_CHECK([if the linker ($LD) is GNU ld], acl_cv_prog_gnu_ld,
2780 [# I'd rather use --version here, but apparently some GNU ld's only accept -v.
2781 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
2782   acl_cv_prog_gnu_ld=yes
2783 else
2784   acl_cv_prog_gnu_ld=no
2785 fi])
2786 with_gnu_ld=$acl_cv_prog_gnu_ld
2787 ])
2788
2789 dnl From libtool-1.4. Sets the variable LD.
2790 AC_DEFUN([AC_LIB_PROG_LD],
2791 [AC_ARG_WITH(gnu-ld,
2792 [  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]],
2793 test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)
2794 AC_REQUIRE([AC_PROG_CC])dnl
2795 AC_REQUIRE([AC_CANONICAL_HOST])dnl
2796 # Prepare PATH_SEPARATOR.
2797 # The user is always right.
2798 if test "${PATH_SEPARATOR+set}" != set; then
2799   echo "#! /bin/sh" >conf$$.sh
2800   echo  "exit 0"   >>conf$$.sh
2801   chmod +x conf$$.sh
2802   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
2803     PATH_SEPARATOR=';'
2804   else
2805     PATH_SEPARATOR=:
2806   fi
2807   rm -f conf$$.sh
2808 fi
2809 ac_prog=ld
2810 if test "$GCC" = yes; then
2811   # Check if gcc -print-prog-name=ld gives a path.
2812   AC_MSG_CHECKING([for ld used by GCC])
2813   case $host in
2814   *-*-mingw*)
2815     # gcc leaves a trailing carriage return which upsets mingw
2816     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
2817   *)
2818     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
2819   esac
2820   case $ac_prog in
2821     # Accept absolute paths.
2822     [[\\/]* | [A-Za-z]:[\\/]*)]
2823       [re_direlt='/[^/][^/]*/\.\./']
2824       # Canonicalize the path of ld
2825       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
2826       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
2827         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
2828       done
2829       test -z "$LD" && LD="$ac_prog"
2830       ;;
2831   "")
2832     # If it fails, then pretend we aren't using GCC.
2833     ac_prog=ld
2834     ;;
2835   *)
2836     # If it is relative, then search for the first ld in PATH.
2837     with_gnu_ld=unknown
2838     ;;
2839   esac
2840 elif test "$with_gnu_ld" = yes; then
2841   AC_MSG_CHECKING([for GNU ld])
2842 else
2843   AC_MSG_CHECKING([for non-GNU ld])
2844 fi
2845 AC_CACHE_VAL(acl_cv_path_LD,
2846 [if test -z "$LD"; then
2847   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
2848   for ac_dir in $PATH; do
2849     test -z "$ac_dir" && ac_dir=.
2850     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
2851       acl_cv_path_LD="$ac_dir/$ac_prog"
2852       # Check to see if the program is GNU ld.  I'd rather use --version,
2853       # but apparently some GNU ld's only accept -v.
2854       # Break only if it was the GNU/non-GNU ld that we prefer.
2855       if "$acl_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
2856         test "$with_gnu_ld" != no && break
2857       else
2858         test "$with_gnu_ld" != yes && break
2859       fi
2860     fi
2861   done
2862   IFS="$ac_save_ifs"
2863 else
2864   acl_cv_path_LD="$LD" # Let the user override the test with a path.
2865 fi])
2866 LD="$acl_cv_path_LD"
2867 if test -n "$LD"; then
2868   AC_MSG_RESULT($LD)
2869 else
2870   AC_MSG_RESULT(no)
2871 fi
2872 test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
2873 AC_LIB_PROG_LD_GNU
2874 ])
2875 # lib-link.m4 serial 4 (gettext-0.12)
2876 dnl Copyright (C) 2001-2003 Free Software Foundation, Inc.
2877 dnl This file is free software, distributed under the terms of the GNU
2878 dnl General Public License.  As a special exception to the GNU General
2879 dnl Public License, this file may be distributed as part of a program
2880 dnl that contains a configuration script generated by Autoconf, under
2881 dnl the same distribution terms as the rest of that program.
2882
2883 dnl From Bruno Haible.
2884
2885 dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and
2886 dnl the libraries corresponding to explicit and implicit dependencies.
2887 dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and
2888 dnl augments the CPPFLAGS variable.
2889 AC_DEFUN([AC_LIB_LINKFLAGS],
2890 [
2891   AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
2892   AC_REQUIRE([AC_LIB_RPATH])
2893   define([Name],[translit([$1],[./-], [___])])
2894   define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
2895                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
2896   AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [
2897     AC_LIB_LINKFLAGS_BODY([$1], [$2])
2898     ac_cv_lib[]Name[]_libs="$LIB[]NAME"
2899     ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME"
2900     ac_cv_lib[]Name[]_cppflags="$INC[]NAME"
2901   ])
2902   LIB[]NAME="$ac_cv_lib[]Name[]_libs"
2903   LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs"
2904   INC[]NAME="$ac_cv_lib[]Name[]_cppflags"
2905   AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
2906   AC_SUBST([LIB]NAME)
2907   AC_SUBST([LTLIB]NAME)
2908   dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the
2909   dnl results of this search when this library appears as a dependency.
2910   HAVE_LIB[]NAME=yes
2911   undefine([Name])
2912   undefine([NAME])
2913 ])
2914
2915 dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode)
2916 dnl searches for libname and the libraries corresponding to explicit and
2917 dnl implicit dependencies, together with the specified include files and
2918 dnl the ability to compile and link the specified testcode. If found, it
2919 dnl sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} and
2920 dnl LTLIB${NAME} variables and augments the CPPFLAGS variable, and
2921 dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs
2922 dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty.
2923 AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],
2924 [
2925   AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
2926   AC_REQUIRE([AC_LIB_RPATH])
2927   define([Name],[translit([$1],[./-], [___])])
2928   define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
2929                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
2930
2931   dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME
2932   dnl accordingly.
2933   AC_LIB_LINKFLAGS_BODY([$1], [$2])
2934
2935   dnl Add $INC[]NAME to CPPFLAGS before performing the following checks,
2936   dnl because if the user has installed lib[]Name and not disabled its use
2937   dnl via --without-lib[]Name-prefix, he wants to use it.
2938   ac_save_CPPFLAGS="$CPPFLAGS"
2939   AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
2940
2941   AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [
2942     ac_save_LIBS="$LIBS"
2943     LIBS="$LIBS $LIB[]NAME"
2944     AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no])
2945     LIBS="$ac_save_LIBS"
2946   ])
2947   if test "$ac_cv_lib[]Name" = yes; then
2948     HAVE_LIB[]NAME=yes
2949     AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the $1 library.])
2950     AC_MSG_CHECKING([how to link with lib[]$1])
2951     AC_MSG_RESULT([$LIB[]NAME])
2952   else
2953     HAVE_LIB[]NAME=no
2954     dnl If $LIB[]NAME didn't lead to a usable library, we don't need
2955     dnl $INC[]NAME either.
2956     CPPFLAGS="$ac_save_CPPFLAGS"
2957     LIB[]NAME=
2958     LTLIB[]NAME=
2959   fi
2960   AC_SUBST([HAVE_LIB]NAME)
2961   AC_SUBST([LIB]NAME)
2962   AC_SUBST([LTLIB]NAME)
2963   undefine([Name])
2964   undefine([NAME])
2965 ])
2966
2967 dnl Determine the platform dependent parameters needed to use rpath:
2968 dnl libext, shlibext, hardcode_libdir_flag_spec, hardcode_libdir_separator,
2969 dnl hardcode_direct, hardcode_minus_L.
2970 AC_DEFUN([AC_LIB_RPATH],
2971 [
2972   AC_REQUIRE([AC_PROG_CC])                dnl we use $CC, $GCC, $LDFLAGS
2973   AC_REQUIRE([AC_LIB_PROG_LD])            dnl we use $LD, $with_gnu_ld
2974   AC_REQUIRE([AC_CANONICAL_HOST])         dnl we use $host
2975   AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir
2976   AC_CACHE_CHECK([for shared library run path origin], acl_cv_rpath, [
2977     CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
2978     ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
2979     . ./conftest.sh
2980     rm -f ./conftest.sh
2981     acl_cv_rpath=done
2982   ])
2983   wl="$acl_cv_wl"
2984   libext="$acl_cv_libext"
2985   shlibext="$acl_cv_shlibext"
2986   hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"
2987   hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"
2988   hardcode_direct="$acl_cv_hardcode_direct"
2989   hardcode_minus_L="$acl_cv_hardcode_minus_L"
2990   dnl Determine whether the user wants rpath handling at all.
2991   AC_ARG_ENABLE(rpath,
2992     [  --disable-rpath         do not hardcode runtime library paths],
2993     :, enable_rpath=yes)
2994 ])
2995
2996 dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and
2997 dnl the libraries corresponding to explicit and implicit dependencies.
2998 dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables.
2999 AC_DEFUN([AC_LIB_LINKFLAGS_BODY],
3000 [
3001   define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
3002                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
3003   dnl By default, look in $includedir and $libdir.
3004   use_additional=yes
3005   AC_LIB_WITH_FINAL_PREFIX([
3006     eval additional_includedir=\"$includedir\"
3007     eval additional_libdir=\"$libdir\"
3008   ])
3009   AC_LIB_ARG_WITH([lib$1-prefix],
3010 [  --with-lib$1-prefix[=DIR]  search for lib$1 in DIR/include and DIR/lib
3011   --without-lib$1-prefix     don't search for lib$1 in includedir and libdir],
3012 [
3013     if test "X$withval" = "Xno"; then
3014       use_additional=no
3015     else
3016       if test "X$withval" = "X"; then
3017         AC_LIB_WITH_FINAL_PREFIX([
3018           eval additional_includedir=\"$includedir\"
3019           eval additional_libdir=\"$libdir\"
3020         ])
3021       else
3022         additional_includedir="$withval/include"
3023         additional_libdir="$withval/lib"
3024       fi
3025     fi
3026 ])
3027   dnl Search the library and its dependencies in $additional_libdir and
3028   dnl $LDFLAGS. Using breadth-first-seach.
3029   LIB[]NAME=
3030   LTLIB[]NAME=
3031   INC[]NAME=
3032   rpathdirs=
3033   ltrpathdirs=
3034   names_already_handled=
3035   names_next_round='$1 $2'
3036   while test -n "$names_next_round"; do
3037     names_this_round="$names_next_round"
3038     names_next_round=
3039     for name in $names_this_round; do
3040       already_handled=
3041       for n in $names_already_handled; do
3042         if test "$n" = "$name"; then
3043           already_handled=yes
3044           break
3045         fi
3046       done
3047       if test -z "$already_handled"; then
3048         names_already_handled="$names_already_handled $name"
3049         dnl See if it was already located by an earlier AC_LIB_LINKFLAGS
3050         dnl or AC_LIB_HAVE_LINKFLAGS call.
3051         uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
3052         eval value=\"\$HAVE_LIB$uppername\"
3053         if test -n "$value"; then
3054           if test "$value" = yes; then
3055             eval value=\"\$LIB$uppername\"
3056             test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value"
3057             eval value=\"\$LTLIB$uppername\"
3058             test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value"
3059           else
3060             dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined
3061             dnl that this library doesn't exist. So just drop it.
3062             :
3063           fi
3064         else
3065           dnl Search the library lib$name in $additional_libdir and $LDFLAGS
3066           dnl and the already constructed $LIBNAME/$LTLIBNAME.
3067           found_dir=
3068           found_la=
3069           found_so=
3070           found_a=
3071           if test $use_additional = yes; then
3072             if test -n "$shlibext" && test -f "$additional_libdir/lib$name.$shlibext"; then
3073               found_dir="$additional_libdir"
3074               found_so="$additional_libdir/lib$name.$shlibext"
3075               if test -f "$additional_libdir/lib$name.la"; then
3076                 found_la="$additional_libdir/lib$name.la"
3077               fi
3078             else
3079               if test -f "$additional_libdir/lib$name.$libext"; then
3080                 found_dir="$additional_libdir"
3081                 found_a="$additional_libdir/lib$name.$libext"
3082                 if test -f "$additional_libdir/lib$name.la"; then
3083                   found_la="$additional_libdir/lib$name.la"
3084                 fi
3085               fi
3086             fi
3087           fi
3088           if test "X$found_dir" = "X"; then
3089             for x in $LDFLAGS $LTLIB[]NAME; do
3090               AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
3091               case "$x" in
3092                 -L*)
3093                   dir=`echo "X$x" | sed -e 's/^X-L//'`
3094                   if test -n "$shlibext" && test -f "$dir/lib$name.$shlibext"; then
3095                     found_dir="$dir"
3096                     found_so="$dir/lib$name.$shlibext"
3097                     if test -f "$dir/lib$name.la"; then
3098                       found_la="$dir/lib$name.la"
3099                     fi
3100                   else
3101                     if test -f "$dir/lib$name.$libext"; then
3102                       found_dir="$dir"
3103                       found_a="$dir/lib$name.$libext"
3104                       if test -f "$dir/lib$name.la"; then
3105                         found_la="$dir/lib$name.la"
3106                       fi
3107                     fi
3108                   fi
3109                   ;;
3110               esac
3111               if test "X$found_dir" != "X"; then
3112                 break
3113               fi
3114             done
3115           fi
3116           if test "X$found_dir" != "X"; then
3117             dnl Found the library.
3118             LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name"
3119             if test "X$found_so" != "X"; then
3120               dnl Linking with a shared library. We attempt to hardcode its
3121               dnl directory into the executable's runpath, unless it's the
3122               dnl standard /usr/lib.
3123               if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/lib"; then
3124                 dnl No hardcoding is needed.
3125                 LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
3126               else
3127                 dnl Use an explicit option to hardcode DIR into the resulting
3128                 dnl binary.
3129                 dnl Potentially add DIR to ltrpathdirs.
3130                 dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
3131                 haveit=
3132                 for x in $ltrpathdirs; do
3133                   if test "X$x" = "X$found_dir"; then
3134                     haveit=yes
3135                     break
3136                   fi
3137                 done
3138                 if test -z "$haveit"; then
3139                   ltrpathdirs="$ltrpathdirs $found_dir"
3140                 fi
3141                 dnl The hardcoding into $LIBNAME is system dependent.
3142                 if test "$hardcode_direct" = yes; then
3143                   dnl Using DIR/libNAME.so during linking hardcodes DIR into the
3144                   dnl resulting binary.
3145                   LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
3146                 else
3147                   if test -n "$hardcode_libdir_flag_spec" && test "$hardcode_minus_L" = no; then
3148                     dnl Use an explicit option to hardcode DIR into the resulting
3149                     dnl binary.
3150                     LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
3151                     dnl Potentially add DIR to rpathdirs.
3152                     dnl The rpathdirs will be appended to $LIBNAME at the end.
3153                     haveit=
3154                     for x in $rpathdirs; do
3155                       if test "X$x" = "X$found_dir"; then
3156                         haveit=yes
3157                         break
3158                       fi
3159                     done
3160                     if test -z "$haveit"; then
3161                       rpathdirs="$rpathdirs $found_dir"
3162                     fi
3163                   else
3164                     dnl Rely on "-L$found_dir".
3165                     dnl But don't add it if it's already contained in the LDFLAGS
3166                     dnl or the already constructed $LIBNAME
3167                     haveit=
3168                     for x in $LDFLAGS $LIB[]NAME; do
3169                       AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
3170                       if test "X$x" = "X-L$found_dir"; then
3171                         haveit=yes
3172                         break
3173                       fi
3174                     done
3175                     if test -z "$haveit"; then
3176                       LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir"
3177                     fi
3178                     if test "$hardcode_minus_L" != no; then
3179                       dnl FIXME: Not sure whether we should use
3180                       dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
3181                       dnl here.
3182                       LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
3183                     else
3184                       dnl We cannot use $hardcode_runpath_var and LD_RUN_PATH
3185                       dnl here, because this doesn't fit in flags passed to the
3186                       dnl compiler. So give up. No hardcoding. This affects only
3187                       dnl very old systems.
3188                       dnl FIXME: Not sure whether we should use
3189                       dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
3190                       dnl here.
3191                       LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
3192                     fi
3193                   fi
3194                 fi
3195               fi
3196             else
3197               if test "X$found_a" != "X"; then
3198                 dnl Linking with a static library.
3199                 LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a"
3200               else
3201                 dnl We shouldn't come here, but anyway it's good to have a
3202                 dnl fallback.
3203                 LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name"
3204               fi
3205             fi
3206             dnl Assume the include files are nearby.
3207             additional_includedir=
3208             case "$found_dir" in
3209               */lib | */lib/)
3210                 basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e 's,/lib/*$,,'`
3211                 additional_includedir="$basedir/include"
3212                 ;;
3213             esac
3214             if test "X$additional_includedir" != "X"; then
3215               dnl Potentially add $additional_includedir to $INCNAME.
3216               dnl But don't add it
3217               dnl   1. if it's the standard /usr/include,
3218               dnl   2. if it's /usr/local/include and we are using GCC on Linux,
3219               dnl   3. if it's already present in $CPPFLAGS or the already
3220               dnl      constructed $INCNAME,
3221               dnl   4. if it doesn't exist as a directory.
3222               if test "X$additional_includedir" != "X/usr/include"; then
3223                 haveit=
3224                 if test "X$additional_includedir" = "X/usr/local/include"; then
3225                   if test -n "$GCC"; then
3226                     case $host_os in
3227                       linux*) haveit=yes;;
3228                     esac
3229                   fi
3230                 fi
3231                 if test -z "$haveit"; then
3232                   for x in $CPPFLAGS $INC[]NAME; do
3233                     AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
3234                     if test "X$x" = "X-I$additional_includedir"; then
3235                       haveit=yes
3236                       break
3237                     fi
3238                   done
3239                   if test -z "$haveit"; then
3240                     if test -d "$additional_includedir"; then
3241                       dnl Really add $additional_includedir to $INCNAME.
3242                       INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir"
3243                     fi
3244                   fi
3245                 fi
3246               fi
3247             fi
3248             dnl Look for dependencies.
3249             if test -n "$found_la"; then
3250               dnl Read the .la file. It defines the variables
3251               dnl dlname, library_names, old_library, dependency_libs, current,
3252               dnl age, revision, installed, dlopen, dlpreopen, libdir.
3253               save_libdir="$libdir"
3254               case "$found_la" in
3255                 */* | *\\*) . "$found_la" ;;
3256                 *) . "./$found_la" ;;
3257               esac
3258               libdir="$save_libdir"
3259               dnl We use only dependency_libs.
3260               for dep in $dependency_libs; do
3261                 case "$dep" in
3262                   -L*)
3263                     additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
3264                     dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME.
3265                     dnl But don't add it
3266                     dnl   1. if it's the standard /usr/lib,
3267                     dnl   2. if it's /usr/local/lib and we are using GCC on Linux,
3268                     dnl   3. if it's already present in $LDFLAGS or the already
3269                     dnl      constructed $LIBNAME,
3270                     dnl   4. if it doesn't exist as a directory.
3271                     if test "X$additional_libdir" != "X/usr/lib"; then
3272                       haveit=
3273                       if test "X$additional_libdir" = "X/usr/local/lib"; then
3274                         if test -n "$GCC"; then
3275                           case $host_os in
3276                             linux*) haveit=yes;;
3277                           esac
3278                         fi
3279                       fi
3280                       if test -z "$haveit"; then
3281                         haveit=
3282                         for x in $LDFLAGS $LIB[]NAME; do
3283                           AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
3284                           if test "X$x" = "X-L$additional_libdir"; then
3285                             haveit=yes
3286                             break
3287                           fi
3288                         done
3289                         if test -z "$haveit"; then
3290                           if test -d "$additional_libdir"; then
3291                             dnl Really add $additional_libdir to $LIBNAME.
3292                             LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir"
3293                           fi
3294                         fi
3295                         haveit=
3296                         for x in $LDFLAGS $LTLIB[]NAME; do
3297                           AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
3298                           if test "X$x" = "X-L$additional_libdir"; then
3299                             haveit=yes
3300                             break
3301                           fi
3302                         done
3303                         if test -z "$haveit"; then
3304                           if test -d "$additional_libdir"; then
3305                             dnl Really add $additional_libdir to $LTLIBNAME.
3306                             LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir"
3307                           fi
3308                         fi
3309                       fi
3310                     fi
3311                     ;;
3312                   -R*)
3313                     dir=`echo "X$dep" | sed -e 's/^X-R//'`
3314                     if test "$enable_rpath" != no; then
3315                       dnl Potentially add DIR to rpathdirs.
3316                       dnl The rpathdirs will be appended to $LIBNAME at the end.
3317                       haveit=
3318                       for x in $rpathdirs; do
3319                         if test "X$x" = "X$dir"; then
3320                           haveit=yes
3321                           break
3322                         fi
3323                       done
3324                       if test -z "$haveit"; then
3325                         rpathdirs="$rpathdirs $dir"
3326                       fi
3327                       dnl Potentially add DIR to ltrpathdirs.
3328                       dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
3329                       haveit=
3330                       for x in $ltrpathdirs; do
3331                         if test "X$x" = "X$dir"; then
3332                           haveit=yes
3333                           break
3334                         fi
3335                       done
3336                       if test -z "$haveit"; then
3337                         ltrpathdirs="$ltrpathdirs $dir"
3338                       fi
3339                     fi
3340                     ;;
3341                   -l*)
3342                     dnl Handle this in the next round.
3343                     names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
3344                     ;;
3345                   *.la)
3346                     dnl Handle this in the next round. Throw away the .la's
3347                     dnl directory; it is already contained in a preceding -L
3348                     dnl option.
3349                     names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
3350                     ;;
3351                   *)
3352                     dnl Most likely an immediate library name.
3353                     LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep"
3354                     LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep"
3355                     ;;
3356                 esac
3357               done
3358             fi
3359           else
3360             dnl Didn't find the library; assume it is in the system directories
3361             dnl known to the linker and runtime loader. (All the system
3362             dnl directories known to the linker should also be known to the
3363             dnl runtime loader, otherwise the system is severely misconfigured.)
3364             LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
3365             LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name"
3366           fi
3367         fi
3368       fi
3369     done
3370   done
3371   if test "X$rpathdirs" != "X"; then
3372     if test -n "$hardcode_libdir_separator"; then
3373       dnl Weird platform: only the last -rpath option counts, the user must
3374       dnl pass all path elements in one option. We can arrange that for a
3375       dnl single library, but not when more than one $LIBNAMEs are used.
3376       alldirs=
3377       for found_dir in $rpathdirs; do
3378         alldirs="${alldirs}${alldirs:+$hardcode_libdir_separator}$found_dir"
3379       done
3380       dnl Note: hardcode_libdir_flag_spec uses $libdir and $wl.
3381       acl_save_libdir="$libdir"
3382       libdir="$alldirs"
3383       eval flag=\"$hardcode_libdir_flag_spec\"
3384       libdir="$acl_save_libdir"
3385       LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
3386     else
3387       dnl The -rpath options are cumulative.
3388       for found_dir in $rpathdirs; do
3389         acl_save_libdir="$libdir"
3390         libdir="$found_dir"
3391         eval flag=\"$hardcode_libdir_flag_spec\"
3392         libdir="$acl_save_libdir"
3393         LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
3394       done
3395     fi
3396   fi
3397   if test "X$ltrpathdirs" != "X"; then
3398     dnl When using libtool, the option that works for both libraries and
3399     dnl executables is -R. The -R options are cumulative.
3400     for found_dir in $ltrpathdirs; do
3401       LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir"
3402     done
3403   fi
3404 ])
3405
3406 dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR,
3407 dnl unless already present in VAR.
3408 dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes
3409 dnl contains two or three consecutive elements that belong together.
3410 AC_DEFUN([AC_LIB_APPENDTOVAR],
3411 [
3412   for element in [$2]; do
3413     haveit=
3414     for x in $[$1]; do
3415       AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
3416       if test "X$x" = "X$element"; then
3417         haveit=yes
3418         break
3419       fi
3420     done
3421     if test -z "$haveit"; then
3422       [$1]="${[$1]}${[$1]:+ }$element"
3423     fi
3424   done
3425 ])
3426 # lib-prefix.m4 serial 2 (gettext-0.12)
3427 dnl Copyright (C) 2001-2003 Free Software Foundation, Inc.
3428 dnl This file is free software, distributed under the terms of the GNU
3429 dnl General Public License.  As a special exception to the GNU General
3430 dnl Public License, this file may be distributed as part of a program
3431 dnl that contains a configuration script generated by Autoconf, under
3432 dnl the same distribution terms as the rest of that program.
3433
3434 dnl From Bruno Haible.
3435
3436 dnl AC_LIB_ARG_WITH is synonymous to AC_ARG_WITH in autoconf-2.13, and
3437 dnl similar to AC_ARG_WITH in autoconf 2.52...2.57 except that is doesn't
3438 dnl require excessive bracketing.
3439 ifdef([AC_HELP_STRING],
3440 [AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[[$2]],[$3],[$4])])],
3441 [AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[$2],[$3],[$4])])])
3442
3443 dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed
3444 dnl to access previously installed libraries. The basic assumption is that
3445 dnl a user will want packages to use other packages he previously installed
3446 dnl with the same --prefix option.
3447 dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate
3448 dnl libraries, but is otherwise very convenient.
3449 AC_DEFUN([AC_LIB_PREFIX],
3450 [
3451   AC_BEFORE([$0], [AC_LIB_LINKFLAGS])
3452   AC_REQUIRE([AC_PROG_CC])
3453   AC_REQUIRE([AC_CANONICAL_HOST])
3454   AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
3455   dnl By default, look in $includedir and $libdir.
3456   use_additional=yes
3457   AC_LIB_WITH_FINAL_PREFIX([
3458     eval additional_includedir=\"$includedir\"
3459     eval additional_libdir=\"$libdir\"
3460   ])
3461   AC_LIB_ARG_WITH([lib-prefix],
3462 [  --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib
3463   --without-lib-prefix    don't search for libraries in includedir and libdir],
3464 [
3465     if test "X$withval" = "Xno"; then
3466       use_additional=no
3467     else
3468       if test "X$withval" = "X"; then
3469         AC_LIB_WITH_FINAL_PREFIX([
3470           eval additional_includedir=\"$includedir\"
3471           eval additional_libdir=\"$libdir\"
3472         ])
3473       else
3474         additional_includedir="$withval/include"
3475         additional_libdir="$withval/lib"
3476       fi
3477     fi
3478 ])
3479   if test $use_additional = yes; then
3480     dnl Potentially add $additional_includedir to $CPPFLAGS.
3481     dnl But don't add it
3482     dnl   1. if it's the standard /usr/include,
3483     dnl   2. if it's already present in $CPPFLAGS,
3484     dnl   3. if it's /usr/local/include and we are using GCC on Linux,
3485     dnl   4. if it doesn't exist as a directory.
3486     if test "X$additional_includedir" != "X/usr/include"; then
3487       haveit=
3488       for x in $CPPFLAGS; do
3489         AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
3490         if test "X$x" = "X-I$additional_includedir"; then
3491           haveit=yes
3492           break
3493         fi
3494       done
3495       if test -z "$haveit"; then
3496         if test "X$additional_includedir" = "X/usr/local/include"; then
3497           if test -n "$GCC"; then
3498             case $host_os in
3499               linux*) haveit=yes;;
3500             esac
3501           fi
3502         fi
3503         if test -z "$haveit"; then
3504           if test -d "$additional_includedir"; then
3505             dnl Really add $additional_includedir to $CPPFLAGS.
3506             CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir"
3507           fi
3508         fi
3509       fi
3510     fi
3511     dnl Potentially add $additional_libdir to $LDFLAGS.
3512     dnl But don't add it
3513     dnl   1. if it's the standard /usr/lib,
3514     dnl   2. if it's already present in $LDFLAGS,
3515     dnl   3. if it's /usr/local/lib and we are using GCC on Linux,
3516     dnl   4. if it doesn't exist as a directory.
3517     if test "X$additional_libdir" != "X/usr/lib"; then
3518       haveit=
3519       for x in $LDFLAGS; do
3520         AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
3521         if test "X$x" = "X-L$additional_libdir"; then
3522           haveit=yes
3523           break
3524         fi
3525       done
3526       if test -z "$haveit"; then
3527         if test "X$additional_libdir" = "X/usr/local/lib"; then
3528           if test -n "$GCC"; then
3529             case $host_os in
3530               linux*) haveit=yes;;
3531             esac
3532           fi
3533         fi
3534         if test -z "$haveit"; then
3535           if test -d "$additional_libdir"; then
3536             dnl Really add $additional_libdir to $LDFLAGS.
3537             LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir"
3538           fi
3539         fi
3540       fi
3541     fi
3542   fi
3543 ])
3544
3545 dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix,
3546 dnl acl_final_exec_prefix, containing the values to which $prefix and
3547 dnl $exec_prefix will expand at the end of the configure script.
3548 AC_DEFUN([AC_LIB_PREPARE_PREFIX],
3549 [
3550   dnl Unfortunately, prefix and exec_prefix get only finally determined
3551   dnl at the end of configure.
3552   if test "X$prefix" = "XNONE"; then
3553     acl_final_prefix="$ac_default_prefix"
3554   else
3555     acl_final_prefix="$prefix"
3556   fi
3557   if test "X$exec_prefix" = "XNONE"; then
3558     acl_final_exec_prefix='${prefix}'
3559   else
3560     acl_final_exec_prefix="$exec_prefix"
3561   fi
3562   acl_save_prefix="$prefix"
3563   prefix="$acl_final_prefix"
3564   eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"
3565   prefix="$acl_save_prefix"
3566 ])
3567
3568 dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the
3569 dnl variables prefix and exec_prefix bound to the values they will have
3570 dnl at the end of the configure script.
3571 AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX],
3572 [
3573   acl_save_prefix="$prefix"
3574   prefix="$acl_final_prefix"
3575   acl_save_exec_prefix="$exec_prefix"
3576   exec_prefix="$acl_final_exec_prefix"
3577   $1
3578   exec_prefix="$acl_save_exec_prefix"
3579   prefix="$acl_save_prefix"
3580 ])
3581 # nls.m4 serial 1 (gettext-0.12)
3582 dnl Copyright (C) 1995-2003 Free Software Foundation, Inc.
3583 dnl This file is free software, distributed under the terms of the GNU
3584 dnl General Public License.  As a special exception to the GNU General
3585 dnl Public License, this file may be distributed as part of a program
3586 dnl that contains a configuration script generated by Autoconf, under
3587 dnl the same distribution terms as the rest of that program.
3588 dnl
3589 dnl This file can can be used in projects which are not available under
3590 dnl the GNU General Public License or the GNU Library General Public
3591 dnl License but which still want to provide support for the GNU gettext
3592 dnl functionality.
3593 dnl Please note that the actual code of the GNU gettext library is covered
3594 dnl by the GNU Library General Public License, and the rest of the GNU
3595 dnl gettext package package is covered by the GNU General Public License.
3596 dnl They are *not* in the public domain.
3597
3598 dnl Authors:
3599 dnl   Ulrich Drepper <drepper@cygnus.com>, 1995-2000.
3600 dnl   Bruno Haible <haible@clisp.cons.org>, 2000-2003.
3601
3602 AC_DEFUN([AM_NLS],
3603 [
3604   AC_MSG_CHECKING([whether NLS is requested])
3605   dnl Default is enabled NLS
3606   AC_ARG_ENABLE(nls,
3607     [  --disable-nls           do not use Native Language Support],
3608     USE_NLS=$enableval, USE_NLS=yes)
3609   AC_MSG_RESULT($USE_NLS)
3610   AC_SUBST(USE_NLS)
3611 ])
3612
3613 AC_DEFUN([AM_MKINSTALLDIRS],
3614 [
3615   dnl If the AC_CONFIG_AUX_DIR macro for autoconf is used we possibly
3616   dnl find the mkinstalldirs script in another subdir but $(top_srcdir).
3617   dnl Try to locate it.
3618   MKINSTALLDIRS=
3619   if test -n "$ac_aux_dir"; then
3620     case "$ac_aux_dir" in
3621       /*) MKINSTALLDIRS="$ac_aux_dir/mkinstalldirs" ;;
3622       *) MKINSTALLDIRS="\$(top_builddir)/$ac_aux_dir/mkinstalldirs" ;;
3623     esac
3624   fi
3625   if test -z "$MKINSTALLDIRS"; then
3626     MKINSTALLDIRS="\$(top_srcdir)/mkinstalldirs"
3627   fi
3628   AC_SUBST(MKINSTALLDIRS)
3629 ])
3630 # po.m4 serial 1 (gettext-0.12)
3631 dnl Copyright (C) 1995-2003 Free Software Foundation, Inc.
3632 dnl This file is free software, distributed under the terms of the GNU
3633 dnl General Public License.  As a special exception to the GNU General
3634 dnl Public License, this file may be distributed as part of a program
3635 dnl that contains a configuration script generated by Autoconf, under
3636 dnl the same distribution terms as the rest of that program.
3637 dnl
3638 dnl This file can can be used in projects which are not available under
3639 dnl the GNU General Public License or the GNU Library General Public
3640 dnl License but which still want to provide support for the GNU gettext
3641 dnl functionality.
3642 dnl Please note that the actual code of the GNU gettext library is covered
3643 dnl by the GNU Library General Public License, and the rest of the GNU
3644 dnl gettext package package is covered by the GNU General Public License.
3645 dnl They are *not* in the public domain.
3646
3647 dnl Authors:
3648 dnl   Ulrich Drepper <drepper@cygnus.com>, 1995-2000.
3649 dnl   Bruno Haible <haible@clisp.cons.org>, 2000-2003.
3650
3651 dnl Checks for all prerequisites of the po subdirectory.
3652 AC_DEFUN([AM_PO_SUBDIRS],
3653 [
3654   AC_REQUIRE([AC_PROG_MAKE_SET])dnl
3655   AC_REQUIRE([AC_PROG_INSTALL])dnl
3656   AC_REQUIRE([AM_MKINSTALLDIRS])dnl
3657   AC_REQUIRE([AM_NLS])dnl
3658
3659   dnl Perform the following tests also if --disable-nls has been given,
3660   dnl because they are needed for "make dist" to work.
3661
3662   dnl Search for GNU msgfmt in the PATH.
3663   dnl The first test excludes Solaris msgfmt and early GNU msgfmt versions.
3664   dnl The second test excludes FreeBSD msgfmt.
3665   AM_PATH_PROG_WITH_TEST(MSGFMT, msgfmt,
3666     [$ac_dir/$ac_word --statistics /dev/null >/dev/null 2>&1 &&
3667      (if $ac_dir/$ac_word --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)],
3668     :)
3669   AC_PATH_PROG(GMSGFMT, gmsgfmt, $MSGFMT)
3670
3671   dnl Search for GNU xgettext 0.12 or newer in the PATH.
3672   dnl The first test excludes Solaris xgettext and early GNU xgettext versions.
3673   dnl The second test excludes FreeBSD xgettext.
3674   AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext,
3675     [$ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null >/dev/null 2>&1 &&
3676      (if $ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)],
3677     :)
3678   dnl Remove leftover from FreeBSD xgettext call.
3679   rm -f messages.po
3680
3681   dnl Search for GNU msgmerge 0.11 or newer in the PATH.
3682   AM_PATH_PROG_WITH_TEST(MSGMERGE, msgmerge,
3683     [$ac_dir/$ac_word --update -q /dev/null /dev/null >/dev/null 2>&1], :)
3684
3685   dnl This could go away some day; the PATH_PROG_WITH_TEST already does it.
3686   dnl Test whether we really found GNU msgfmt.
3687   if test "$GMSGFMT" != ":"; then
3688     dnl If it is no GNU msgfmt we define it as : so that the
3689     dnl Makefiles still can work.
3690     if $GMSGFMT --statistics /dev/null >/dev/null 2>&1 &&
3691        (if $GMSGFMT --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then
3692       : ;
3693     else
3694       GMSGFMT=`echo "$GMSGFMT" | sed -e 's,^.*/,,'`
3695       AC_MSG_RESULT(
3696         [found $GMSGFMT program is not GNU msgfmt; ignore it])
3697       GMSGFMT=":"
3698     fi
3699   fi
3700
3701   dnl This could go away some day; the PATH_PROG_WITH_TEST already does it.
3702   dnl Test whether we really found GNU xgettext.
3703   if test "$XGETTEXT" != ":"; then
3704     dnl If it is no GNU xgettext we define it as : so that the
3705     dnl Makefiles still can work.
3706     if $XGETTEXT --omit-header --copyright-holder= --msgid-bugs-address= /dev/null >/dev/null 2>&1 &&
3707        (if $XGETTEXT --omit-header --copyright-holder= --msgid-bugs-address= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then
3708       : ;
3709     else
3710       AC_MSG_RESULT(
3711         [found xgettext program is not GNU xgettext; ignore it])
3712       XGETTEXT=":"
3713     fi
3714     dnl Remove leftover from FreeBSD xgettext call.
3715     rm -f messages.po
3716   fi
3717
3718   AC_OUTPUT_COMMANDS([
3719     for ac_file in $CONFIG_FILES; do
3720       # Support "outfile[:infile[:infile...]]"
3721       case "$ac_file" in
3722         *:*) ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
3723       esac
3724       # PO directories have a Makefile.in generated from Makefile.in.in.
3725       case "$ac_file" in */Makefile.in)
3726         # Adjust a relative srcdir.
3727         ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'`
3728         ac_dir_suffix="/`echo "$ac_dir"|sed 's%^\./%%'`"
3729         ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'`
3730         # In autoconf-2.13 it is called $ac_given_srcdir.
3731         # In autoconf-2.50 it is called $srcdir.
3732         test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir"
3733         case "$ac_given_srcdir" in
3734           .)  top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;;
3735           /*) top_srcdir="$ac_given_srcdir" ;;
3736           *)  top_srcdir="$ac_dots$ac_given_srcdir" ;;
3737         esac
3738         if test -f "$ac_given_srcdir/$ac_dir/POTFILES.in"; then
3739           rm -f "$ac_dir/POTFILES"
3740           test -n "$as_me" && echo "$as_me: creating $ac_dir/POTFILES" || echo "creating $ac_dir/POTFILES"
3741           cat "$ac_given_srcdir/$ac_dir/POTFILES.in" | sed -e "/^#/d" -e "/^[   ]*\$/d" -e "s,.*,     $top_srcdir/& \\\\," | sed -e "\$s/\(.*\) \\\\/\1/" > "$ac_dir/POTFILES"
3742           POMAKEFILEDEPS="POTFILES.in"
3743           # ALL_LINGUAS, POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES depend
3744           # on $ac_dir but don't depend on user-specified configuration
3745           # parameters.
3746           if test -f "$ac_given_srcdir/$ac_dir/LINGUAS"; then
3747             # The LINGUAS file contains the set of available languages.
3748             if test -n "$OBSOLETE_ALL_LINGUAS"; then
3749               test -n "$as_me" && echo "$as_me: setting ALL_LINGUAS in configure.in is obsolete" || echo "setting ALL_LINGUAS in configure.in is obsolete"
3750             fi
3751             ALL_LINGUAS_=`sed -e "/^#/d" "$ac_given_srcdir/$ac_dir/LINGUAS"`
3752             # Hide the ALL_LINGUAS assigment from automake.
3753             eval 'ALL_LINGUAS''=$ALL_LINGUAS_'
3754             POMAKEFILEDEPS="$POMAKEFILEDEPS LINGUAS"
3755           else
3756             # The set of available languages was given in configure.in.
3757             eval 'ALL_LINGUAS''=$OBSOLETE_ALL_LINGUAS'
3758           fi
3759           case "$ac_given_srcdir" in
3760             .) srcdirpre= ;;
3761             *) srcdirpre='$(srcdir)/' ;;
3762           esac
3763           POFILES=
3764           GMOFILES=
3765           UPDATEPOFILES=
3766           DUMMYPOFILES=
3767           for lang in $ALL_LINGUAS; do
3768             POFILES="$POFILES $srcdirpre$lang.po"
3769             GMOFILES="$GMOFILES $srcdirpre$lang.gmo"
3770             UPDATEPOFILES="$UPDATEPOFILES $lang.po-update"
3771             DUMMYPOFILES="$DUMMYPOFILES $lang.nop"
3772           done
3773           # CATALOGS depends on both $ac_dir and the user's LINGUAS
3774           # environment variable.
3775           INST_LINGUAS=
3776           if test -n "$ALL_LINGUAS"; then
3777             for presentlang in $ALL_LINGUAS; do
3778               useit=no
3779               if test "%UNSET%" != "$LINGUAS"; then
3780                 desiredlanguages="$LINGUAS"
3781               else
3782                 desiredlanguages="$ALL_LINGUAS"
3783               fi
3784               for desiredlang in $desiredlanguages; do
3785                 # Use the presentlang catalog if desiredlang is
3786                 #   a. equal to presentlang, or
3787                 #   b. a variant of presentlang (because in this case,
3788                 #      presentlang can be used as a fallback for messages
3789                 #      which are not translated in the desiredlang catalog).
3790                 case "$desiredlang" in
3791                   "$presentlang"*) useit=yes;;
3792                 esac
3793               done
3794               if test $useit = yes; then
3795                 INST_LINGUAS="$INST_LINGUAS $presentlang"
3796               fi
3797             done
3798           fi
3799           CATALOGS=
3800           if test -n "$INST_LINGUAS"; then
3801             for lang in $INST_LINGUAS; do
3802               CATALOGS="$CATALOGS $lang.gmo"
3803             done
3804           fi
3805           test -n "$as_me" && echo "$as_me: creating $ac_dir/Makefile" || echo "creating $ac_dir/Makefile"
3806           sed -e "/^POTFILES =/r $ac_dir/POTFILES" -e "/^# Makevars/r $ac_given_srcdir/$ac_dir/Makevars" -e "s|@POFILES@|$POFILES|g" -e "s|@GMOFILES@|$GMOFILES|g" -e "s|@UPDATEPOFILES@|$UPDATEPOFILES|g" -e "s|@DUMMYPOFILES@|$DUMMYPOFILES|g" -e "s|@CATALOGS@|$CATALOGS|g" -e "s|@POMAKEFILEDEPS@|$POMAKEFILEDEPS|g" "$ac_dir/Makefile.in" > "$ac_dir/Makefile"
3807           for f in "$ac_given_srcdir/$ac_dir"/Rules-*; do
3808             if test -f "$f"; then
3809               case "$f" in
3810                 *.orig | *.bak | *~) ;;
3811                 *) cat "$f" >> "$ac_dir/Makefile" ;;
3812               esac
3813             fi
3814           done
3815         fi
3816         ;;
3817       esac
3818     done],
3819    [# Capture the value of obsolete ALL_LINGUAS because we need it to compute
3820     # POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES, CATALOGS. But hide it
3821     # from automake.
3822     eval 'OBSOLETE_ALL_LINGUAS''="$ALL_LINGUAS"'
3823     # Capture the value of LINGUAS because we need it to compute CATALOGS.
3824     LINGUAS="${LINGUAS-%UNSET%}"
3825    ])
3826 ])
3827 # progtest.m4 serial 3 (gettext-0.12)
3828 dnl Copyright (C) 1996-2003 Free Software Foundation, Inc.
3829 dnl This file is free software, distributed under the terms of the GNU
3830 dnl General Public License.  As a special exception to the GNU General
3831 dnl Public License, this file may be distributed as part of a program
3832 dnl that contains a configuration script generated by Autoconf, under
3833 dnl the same distribution terms as the rest of that program.
3834 dnl
3835 dnl This file can can be used in projects which are not available under
3836 dnl the GNU General Public License or the GNU Library General Public
3837 dnl License but which still want to provide support for the GNU gettext
3838 dnl functionality.
3839 dnl Please note that the actual code of the GNU gettext library is covered
3840 dnl by the GNU Library General Public License, and the rest of the GNU
3841 dnl gettext package package is covered by the GNU General Public License.
3842 dnl They are *not* in the public domain.
3843
3844 dnl Authors:
3845 dnl   Ulrich Drepper <drepper@cygnus.com>, 1996.
3846
3847 # Search path for a program which passes the given test.
3848
3849 dnl AM_PATH_PROG_WITH_TEST(VARIABLE, PROG-TO-CHECK-FOR,
3850 dnl   TEST-PERFORMED-ON-FOUND_PROGRAM [, VALUE-IF-NOT-FOUND [, PATH]])
3851 AC_DEFUN([AM_PATH_PROG_WITH_TEST],
3852 [
3853 # Prepare PATH_SEPARATOR.
3854 # The user is always right.
3855 if test "${PATH_SEPARATOR+set}" != set; then
3856   echo "#! /bin/sh" >conf$$.sh
3857   echo  "exit 0"   >>conf$$.sh
3858   chmod +x conf$$.sh
3859   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
3860     PATH_SEPARATOR=';'
3861   else
3862     PATH_SEPARATOR=:
3863   fi
3864   rm -f conf$$.sh
3865 fi
3866
3867 # Find out how to test for executable files. Don't use a zero-byte file,
3868 # as systems may use methods other than mode bits to determine executability.
3869 cat >conf$$.file <<_ASEOF
3870 #! /bin/sh
3871 exit 0
3872 _ASEOF
3873 chmod +x conf$$.file
3874 if test -x conf$$.file >/dev/null 2>&1; then
3875   ac_executable_p="test -x"
3876 else
3877   ac_executable_p="test -f"
3878 fi
3879 rm -f conf$$.file
3880
3881 # Extract the first word of "$2", so it can be a program name with args.
3882 set dummy $2; ac_word=[$]2
3883 AC_MSG_CHECKING([for $ac_word])
3884 AC_CACHE_VAL(ac_cv_path_$1,
3885 [case "[$]$1" in
3886   [[\\/]]* | ?:[[\\/]]*)
3887     ac_cv_path_$1="[$]$1" # Let the user override the test with a path.
3888     ;;
3889   *)
3890     ac_save_IFS="$IFS"; IFS=$PATH_SEPARATOR
3891     for ac_dir in ifelse([$5], , $PATH, [$5]); do
3892       IFS="$ac_save_IFS"
3893       test -z "$ac_dir" && ac_dir=.
3894       for ac_exec_ext in '' $ac_executable_extensions; do
3895         if $ac_executable_p "$ac_dir/$ac_word$ac_exec_ext"; then
3896           if [$3]; then
3897             ac_cv_path_$1="$ac_dir/$ac_word$ac_exec_ext"
3898             break 2
3899           fi
3900         fi
3901       done
3902     done
3903     IFS="$ac_save_IFS"
3904 dnl If no 4th arg is given, leave the cache variable unset,
3905 dnl so AC_PATH_PROGS will keep looking.
3906 ifelse([$4], , , [  test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4"
3907 ])dnl
3908     ;;
3909 esac])dnl
3910 $1="$ac_cv_path_$1"
3911 if test ifelse([$4], , [-n "[$]$1"], ["[$]$1" != "$4"]); then
3912   AC_MSG_RESULT([$]$1)
3913 else
3914   AC_MSG_RESULT(no)
3915 fi
3916 AC_SUBST($1)dnl
3917 ])
3918 # stdint_h.m4 serial 3 (gettext-0.12)
3919 dnl Copyright (C) 1997-2003 Free Software Foundation, Inc.
3920 dnl This file is free software, distributed under the terms of the GNU
3921 dnl General Public License.  As a special exception to the GNU General
3922 dnl Public License, this file may be distributed as part of a program
3923 dnl that contains a configuration script generated by Autoconf, under
3924 dnl the same distribution terms as the rest of that program.
3925
3926 dnl From Paul Eggert.
3927
3928 # Define HAVE_STDINT_H_WITH_UINTMAX if <stdint.h> exists,
3929 # doesn't clash with <sys/types.h>, and declares uintmax_t.
3930
3931 AC_DEFUN([jm_AC_HEADER_STDINT_H],
3932 [
3933   AC_CACHE_CHECK([for stdint.h], jm_ac_cv_header_stdint_h,
3934   [AC_TRY_COMPILE(
3935     [#include <sys/types.h>
3936 #include <stdint.h>],
3937     [uintmax_t i = (uintmax_t) -1;],
3938     jm_ac_cv_header_stdint_h=yes,
3939     jm_ac_cv_header_stdint_h=no)])
3940   if test $jm_ac_cv_header_stdint_h = yes; then
3941     AC_DEFINE_UNQUOTED(HAVE_STDINT_H_WITH_UINTMAX, 1,
3942       [Define if <stdint.h> exists, doesn't clash with <sys/types.h>,
3943        and declares uintmax_t. ])
3944   fi
3945 ])
3946 # uintmax_t.m4 serial 7 (gettext-0.12)
3947 dnl Copyright (C) 1997-2003 Free Software Foundation, Inc.
3948 dnl This file is free software, distributed under the terms of the GNU
3949 dnl General Public License.  As a special exception to the GNU General
3950 dnl Public License, this file may be distributed as part of a program
3951 dnl that contains a configuration script generated by Autoconf, under
3952 dnl the same distribution terms as the rest of that program.
3953
3954 dnl From Paul Eggert.
3955
3956 AC_PREREQ(2.13)
3957
3958 # Define uintmax_t to 'unsigned long' or 'unsigned long long'
3959 # if it is not already defined in <stdint.h> or <inttypes.h>.
3960
3961 AC_DEFUN([jm_AC_TYPE_UINTMAX_T],
3962 [
3963   AC_REQUIRE([jm_AC_HEADER_INTTYPES_H])
3964   AC_REQUIRE([jm_AC_HEADER_STDINT_H])
3965   if test $jm_ac_cv_header_inttypes_h = no && test $jm_ac_cv_header_stdint_h = no; then
3966     AC_REQUIRE([jm_AC_TYPE_UNSIGNED_LONG_LONG])
3967     test $ac_cv_type_unsigned_long_long = yes \
3968       && ac_type='unsigned long long' \
3969       || ac_type='unsigned long'
3970     AC_DEFINE_UNQUOTED(uintmax_t, $ac_type,
3971       [Define to unsigned long or unsigned long long
3972        if <stdint.h> and <inttypes.h> don't define.])
3973   else
3974     AC_DEFINE(HAVE_UINTMAX_T, 1,
3975       [Define if you have the 'uintmax_t' type in <stdint.h> or <inttypes.h>.])
3976   fi
3977 ])
3978 # ulonglong.m4 serial 2 (fileutils-4.0.32, gettext-0.10.40)
3979 dnl Copyright (C) 1999-2002 Free Software Foundation, Inc.
3980 dnl This file is free software, distributed under the terms of the GNU
3981 dnl General Public License.  As a special exception to the GNU General
3982 dnl Public License, this file may be distributed as part of a program
3983 dnl that contains a configuration script generated by Autoconf, under
3984 dnl the same distribution terms as the rest of that program.
3985
3986 dnl From Paul Eggert.
3987
3988 AC_DEFUN([jm_AC_TYPE_UNSIGNED_LONG_LONG],
3989 [
3990   AC_CACHE_CHECK([for unsigned long long], ac_cv_type_unsigned_long_long,
3991   [AC_TRY_LINK([unsigned long long ull = 1; int i = 63;],
3992     [unsigned long long ullmax = (unsigned long long) -1;
3993      return ull << i | ull >> i | ullmax / ull | ullmax % ull;],
3994     ac_cv_type_unsigned_long_long=yes,
3995     ac_cv_type_unsigned_long_long=no)])
3996   if test $ac_cv_type_unsigned_long_long = yes; then
3997     AC_DEFINE(HAVE_UNSIGNED_LONG_LONG, 1,
3998       [Define if you have the unsigned long long type.])
3999   fi
4000 ])
4001
4002 dnl From gnulib
4003 AC_DEFUN([BASH_FUNC_FPURGE],
4004 [
4005   AC_CHECK_FUNCS_ONCE([fpurge])
4006   AC_CHECK_FUNCS_ONCE([__fpurge])
4007   AC_CHECK_DECLS([fpurge], , , [#include <stdio.h>])
4008 ])