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