home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / readline.zip / readline-2.1 / aclocal.m4 < prev    next >
M4 Source File  |  1997-05-21  |  28KB  |  1,097 lines
  1. dnl
  2. dnl Bash specific tests
  3. dnl
  4. dnl Some derived from PDKSH 5.1.3 autoconf tests
  5. dnl
  6. dnl
  7. dnl Check if dup2() does not clear the close on exec flag
  8. dnl
  9. AC_DEFUN(BASH_DUP2_CLOEXEC_CHECK,
  10. [AC_MSG_CHECKING(if dup2 fails to clear the close-on-exec flag)
  11. AC_CACHE_VAL(bash_cv_dup2_broken,
  12. [AC_TRY_RUN([
  13. #include <sys/types.h>
  14. #include <fcntl.h>
  15. main()
  16. {
  17.   int fd1, fd2, fl;
  18.   fd1 = open("/dev/null", 2);
  19.   if (fcntl(fd1, 2, 1) < 0)
  20.     exit(1);
  21.   fd2 = dup2(fd1, 1);
  22.   if (fd2 < 0)
  23.     exit(2);
  24.   fl = fcntl(fd2, 1, 0);
  25.   /* fl will be 1 if dup2 did not reset the close-on-exec flag. */
  26.   exit(fl != 1);
  27. }
  28. ], bash_cv_dup2_broken=yes, bash_cv_dup2_broken=no,
  29.     AC_MSG_ERROR(cannot check dup2 if cross compiling))
  30. ])
  31. AC_MSG_RESULT($bash_cv_dup2_broken)
  32. if test $bash_cv_dup2_broken = yes; then
  33. AC_DEFINE(DUP2_BROKEN)
  34. fi
  35. ])
  36.  
  37. dnl Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7)
  38. AC_DEFUN(BASH_SIGNAL_CHECK,
  39. [AC_REQUIRE([AC_TYPE_SIGNAL])
  40. AC_MSG_CHECKING(for type of signal functions)
  41. AC_CACHE_VAL(bash_cv_signal_vintage,
  42. [
  43.   AC_TRY_LINK([#include <signal.h>],[
  44.     sigset_t ss;
  45.     struct sigaction sa;
  46.     sigemptyset(&ss); sigsuspend(&ss);
  47.     sigaction(SIGINT, &sa, (struct sigaction *) 0);
  48.     sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0);
  49.   ], bash_cv_signal_vintage=posix,
  50.   [
  51.     AC_TRY_LINK([#include <signal.h>], [
  52.     int mask = sigmask(SIGINT);
  53.     sigsetmask(mask); sigblock(mask); sigpause(mask);
  54.     ], bash_cv_signal_vintage=4.2bsd,
  55.     [
  56.       AC_TRY_LINK([
  57.     #include <signal.h>
  58.     RETSIGTYPE foo() { }], [
  59.         int mask = sigmask(SIGINT);
  60.         sigset(SIGINT, foo); sigrelse(SIGINT);
  61.         sighold(SIGINT); sigpause(SIGINT);
  62.         ], bash_cv_signal_vintage=svr3, bash_cv_signal_vintage=v7
  63.     )]
  64.   )]
  65. )
  66. ])
  67. AC_MSG_RESULT($bash_cv_signal_vintage)
  68. if test "$bash_cv_signal_vintage" = posix; then
  69. AC_DEFINE(HAVE_POSIX_SIGNALS)
  70. elif test "$bash_cv_signal_vintage" = "4.2bsd"; then
  71. AC_DEFINE(HAVE_BSD_SIGNALS)
  72. elif test "$bash_cv_signal_vintage" = svr3; then
  73. AC_DEFINE(HAVE_USG_SIGHOLD)
  74. fi
  75. ])
  76.  
  77. dnl Check if the pgrp of setpgrp() can't be the pid of a zombie process.
  78. AC_DEFUN(BASH_PGRP_SYNC,
  79. [AC_REQUIRE([AC_FUNC_GETPGRP])
  80. AC_MSG_CHECKING(whether pgrps need synchronization)
  81. AC_CACHE_VAL(bash_cv_pgrp_pipe,
  82. [AC_TRY_RUN([
  83. #ifdef HAVE_UNISTD_H
  84. #  include <unistd.h>
  85. #endif
  86. main()
  87. {
  88. # ifdef GETPGRP_VOID
  89. #  define getpgID()    getpgrp()
  90. # else
  91. #  define getpgID()    getpgrp(0)
  92. #  define setpgid(x,y)    setpgrp(x,y)
  93. # endif
  94.     int pid1, pid2, fds[2];
  95.     int status;
  96.     char ok;
  97.  
  98.     switch (pid1 = fork()) {
  99.       case -1:
  100.         exit(1);
  101.       case 0:
  102.         setpgid(0, getpid());
  103.         exit(0);
  104.     }
  105.     setpgid(pid1, pid1);
  106.  
  107.     sleep(2);    /* let first child die */
  108.  
  109.     if (pipe(fds) < 0)
  110.       exit(2);
  111.  
  112.     switch (pid2 = fork()) {
  113.       case -1:
  114.         exit(3);
  115.       case 0:
  116.         setpgid(0, pid1);
  117.         ok = getpgID() == pid1;
  118.         write(fds[1], &ok, 1);
  119.         exit(0);
  120.     }
  121.     setpgid(pid2, pid1);
  122.  
  123.     close(fds[1]);
  124.     if (read(fds[0], &ok, 1) != 1)
  125.       exit(4);
  126.     wait(&status);
  127.     wait(&status);
  128.     exit(ok ? 0 : 5);
  129. }
  130. ], bash_cv_pgrp_pipe=no,bash_cv_pgrp_pipe=yes,
  131.    AC_MSG_ERROR(cannot check pgrp synchronization if cross compiling))
  132. ])
  133. AC_MSG_RESULT($bash_cv_pgrp_pipe)
  134. if test $bash_cv_pgrp_pipe = yes; then
  135. AC_DEFINE(PGRP_PIPE)
  136. fi
  137. ])
  138.  
  139. dnl
  140. dnl check for typedef'd symbols in header files, but allow the caller to
  141. dnl specify the include files to be checked in addition to the default
  142. dnl 
  143. dnl BASH_CHECK_TYPE(TYPE, HEADERS, DEFAULT[, VALUE-IF-FOUND])
  144. AC_DEFUN(BASH_CHECK_TYPE,
  145. [AC_REQUIRE([AC_HEADER_STDC])dnl
  146. AC_MSG_CHECKING(for $1)
  147. AC_CACHE_VAL(bash_cv_type_$1,
  148. [AC_EGREP_CPP($1, [#include <sys/types.h>
  149. #if STDC_HEADERS
  150. #include <stdlib.h>
  151. #endif
  152. $2
  153. ], bash_cv_type_$1=yes, bash_cv_type_$1=no)])
  154. AC_MSG_RESULT($bash_cv_type_$1)
  155. ifelse($#, 4, [if test $bash_cv_type_$1 = yes; then
  156.     AC_DEFINE($4)
  157.     fi])
  158. if test $bash_cv_type_$1 = no; then
  159.   AC_DEFINE($1, $3)
  160. fi
  161. ])
  162.  
  163. dnl
  164. dnl Type of struct rlimit fields: some systems (OSF/1, NetBSD, RISC/os 5.0)
  165. dnl have a rlim_t, others (4.4BSD based systems) use quad_t, others use
  166. dnl long and still others use int (HP-UX 9.01, SunOS 4.1.3).  To simplify
  167. dnl matters, this just checks for rlim_t, quad_t, or long.
  168. dnl
  169. AC_DEFUN(BASH_RLIMIT_TYPE,
  170. [AC_MSG_CHECKING(for size and type of struct rlimit fields)
  171. AC_CACHE_VAL(bash_cv_type_rlimit,
  172. [AC_TRY_COMPILE([#include <sys/types.h>],
  173. [rlim_t xxx;], bash_cv_type_rlimit=rlim_t,[
  174. AC_TRY_RUN([
  175. #include <sys/types.h>
  176. #include <sys/time.h>
  177. #include <sys/resource.h>
  178. main()
  179. {
  180. #ifdef HAVE_QUAD_T
  181.   struct rlimit rl;
  182.   if (sizeof(rl.rlim_cur) == sizeof(quad_t))
  183.     exit(0);
  184. #endif
  185.   exit(1);
  186. }], bash_cv_type_rlimit=quad_t, bash_cv_type_rlimit=long,
  187.         AC_MSG_ERROR(cannot check quad_t if cross compiling))])
  188. ])
  189. AC_MSG_RESULT($bash_cv_type_rlimit)
  190. if test $bash_cv_type_rlimit = quad_t; then
  191. AC_DEFINE(RLIMTYPE, quad_t)
  192. elif test $bash_cv_type_rlimit = rlim_t; then
  193. AC_DEFINE(RLIMTYPE, rlim_t)
  194. fi
  195. ])
  196.  
  197. dnl
  198. dnl Check for sys_siglist[] or _sys_siglist[]
  199. dnl
  200. AC_DEFUN(BASH_UNDER_SYS_SIGLIST,
  201. [AC_MSG_CHECKING([for _sys_siglist in system C library])
  202. AC_CACHE_VAL(bash_cv_under_sys_siglist,
  203. [AC_TRY_RUN([
  204. #include <sys/types.h>
  205. #include <signal.h>
  206. #ifdef HAVE_UNISTD_H
  207. #include <unistd.h>
  208. #endif
  209. #ifndef _sys_siglist
  210. extern char *_sys_siglist[];
  211. #endif
  212. main()
  213. {
  214. char *msg = _sys_siglist[2];
  215. exit(msg == 0);
  216. }],
  217. bash_cv_under_sys_siglist=yes, bash_cv_under_sys_siglist=no,
  218. AC_MSG_ERROR(cannot check for _sys_siglist[] if cross compiling))])dnl
  219. AC_MSG_RESULT($bash_cv_under_sys_siglist)
  220. if test $bash_cv_under_sys_siglist = yes; then
  221. AC_DEFINE(HAVE_UNDER_SYS_SIGLIST)
  222. fi
  223. ])
  224.  
  225. AC_DEFUN(BASH_SYS_SIGLIST,
  226. [AC_REQUIRE([AC_DECL_SYS_SIGLIST])
  227. AC_MSG_CHECKING([for sys_siglist in system C library])
  228. AC_CACHE_VAL(bash_cv_sys_siglist,
  229. [AC_TRY_RUN([
  230. #include <sys/types.h>
  231. #include <signal.h>
  232. #ifdef HAVE_UNISTD_H
  233. #include <unistd.h>
  234. #endif
  235. #ifndef SYS_SIGLIST_DECLARED
  236. extern char *sys_siglist[];
  237. #endif
  238. main()
  239. {
  240. char *msg = sys_siglist[2];
  241. exit(msg == 0);
  242. }],
  243. bash_cv_sys_siglist=yes, bash_cv_sys_siglist=no,
  244. AC_MSG_ERROR(cannot check for sys_siglist if cross compiling))])dnl
  245. AC_MSG_RESULT($bash_cv_sys_siglist)
  246. if test $bash_cv_sys_siglist = yes; then
  247. AC_DEFINE(HAVE_SYS_SIGLIST)
  248. fi
  249. ])
  250.  
  251. dnl Check for sys_errlist[] and sys_nerr, check for declaration
  252. AC_DEFUN(BASH_SYS_ERRLIST,
  253. [AC_MSG_CHECKING([for sys_errlist and sys_nerr])
  254. AC_CACHE_VAL(bash_cv_sys_errlist,
  255. [AC_TRY_LINK([#include <errno.h>],
  256. [extern char *sys_errlist[];
  257.  extern int sys_nerr;
  258.  char *msg = sys_errlist[sys_nerr - 1];],
  259.     bash_cv_sys_errlist=yes, bash_cv_sys_errlist=no)])dnl
  260. AC_MSG_RESULT($bash_cv_sys_errlist)
  261. if test $bash_cv_sys_errlist = yes; then
  262. AC_DEFINE(HAVE_SYS_ERRLIST)
  263. fi
  264. ])
  265.  
  266. dnl Check to see if opendir will open non-directories (not a nice thing)
  267. AC_DEFUN(BASH_FUNC_OPENDIR_CHECK,
  268. [AC_REQUIRE([AC_HEADER_DIRENT])dnl
  269. AC_MSG_CHECKING(if opendir() opens non-directories)
  270. AC_CACHE_VAL(bash_cv_opendir_not_robust,
  271. [AC_TRY_RUN([
  272. #include <stdio.h>
  273. #include <sys/types.h>
  274. #include <fcntl.h>
  275. #ifdef HAVE_UNISTD_H
  276. # include <unistd.h>
  277. #endif /* HAVE_UNISTD_H */
  278. #if defined(HAVE_DIRENT_H)
  279. # include <dirent.h>
  280. #else
  281. # define dirent direct
  282. # ifdef HAVE_SYS_NDIR_H
  283. #  include <sys/ndir.h>
  284. # endif /* SYSNDIR */
  285. # ifdef HAVE_SYS_DIR_H
  286. #  include <sys/dir.h>
  287. # endif /* SYSDIR */
  288. # ifdef HAVE_NDIR_H
  289. #  include <ndir.h>
  290. # endif
  291. #endif /* HAVE_DIRENT_H */
  292. main()
  293. {
  294. DIR *dir;
  295. int fd;
  296. unlink("/tmp/not_a_directory");
  297. fd = open("/tmp/not_a_directory", O_WRONLY|O_CREAT, 0666);
  298. write(fd, "\n", 1);
  299. close(fd);
  300. dir = opendir("/tmp/not_a_directory");
  301. unlink("/tmp/not_a_directory");
  302. exit (dir == 0);
  303. }], bash_cv_opendir_not_robust=yes,bash_cv_opendir_not_robust=no,
  304.     AC_MSG_ERROR(cannot check opendir if cross compiling))])
  305. AC_MSG_RESULT($bash_cv_opendir_not_robust)
  306. if test $bash_cv_opendir_not_robust = yes; then
  307. AC_DEFINE(OPENDIR_NOT_ROBUST)
  308. fi
  309. ])
  310.  
  311. dnl
  312. AC_DEFUN(BASH_TYPE_SIGHANDLER,
  313. [AC_MSG_CHECKING([whether signal handlers are of type void])
  314. AC_CACHE_VAL(bash_cv_void_sighandler,
  315. [AC_TRY_COMPILE([#include <sys/types.h>
  316. #include <signal.h>
  317. #ifdef signal
  318. #undef signal
  319. #endif
  320. #ifdef __cplusplus
  321. extern "C"
  322. #endif
  323. void (*signal ()) ();],
  324. [int i;], bash_cv_void_sighandler=yes, bash_cv_void_sighandler=no)])dnl
  325. AC_MSG_RESULT($bash_cv_void_sighandler)
  326. if test $bash_cv_void_sighandler = yes; then
  327. AC_DEFINE(VOID_SIGHANDLER)
  328. fi
  329. ])
  330.  
  331. AC_DEFUN(BASH_FUNC_STRSIGNAL,
  332. [AC_MSG_CHECKING([for the existance of strsignal])
  333. AC_CACHE_VAL(bash_cv_have_strsignal,
  334. [AC_TRY_LINK([#include <sys/types.h>
  335. #include <signal.h>],
  336. [char *s = (char *)strsignal(2);],
  337.  bash_cv_have_strsignal=yes, bash_cv_have_strsignal=no)])
  338. AC_MSG_RESULT($bash_cv_have_strsignal)
  339. if test $bash_cv_have_strsignal = yes; then
  340. AC_DEFINE(HAVE_STRSIGNAL)
  341. fi
  342. ])
  343.  
  344. AC_DEFUN(BASH_FUNC_LSTAT,
  345. [dnl Cannot use AC_CHECK_FUNCS(lstat) because Linux defines lstat() as an
  346. dnl inline function in <sys/stat.h>.
  347. AC_CACHE_CHECK([for lstat], bash_cv_func_lstat,
  348. [AC_TRY_LINK([
  349. #include <sys/types.h>
  350. #include <sys/stat.h>
  351. ],[ lstat("",(struct stat *)0); ],
  352. bash_cv_func_lstat=yes, bash_cv_func_lstat=no)])
  353. if test $bash_cv_func_lstat = yes; then
  354.   AC_DEFINE(HAVE_LSTAT)
  355. fi
  356. ])
  357.  
  358. AC_DEFUN(BASH_STRUCT_TERMIOS_LDISC,
  359. [AC_MSG_CHECKING([for a c_line member of struct termios])
  360. AC_CACHE_VAL(bash_cv_termios_ldisc,
  361. [AC_TRY_COMPILE([#include <sys/types.h>
  362. #include <termios.h>],[struct termios t; int i; i = t.c_line;],
  363.   bash_cv_termios_ldisc=yes, bash_cv_termios_ldisc=no)])dnl
  364. AC_MSG_RESULT($bash_cv_termios_ldisc)
  365. if test $bash_cv_termios_ldisc = yes; then
  366. AC_DEFINE(TERMIOS_LDISC)
  367. fi
  368. ])
  369.  
  370. AC_DEFUN(BASH_STRUCT_TERMIO_LDISC,
  371. [AC_MSG_CHECKING([for a c_line member of struct termio])
  372. AC_CACHE_VAL(bash_cv_termio_ldisc,
  373. [AC_TRY_COMPILE([#include <sys/types.h>
  374. #include <termio.h>],[struct termio t; int i; i = t.c_line;],
  375.   bash_cv_termio_ldisc=yes, bash_cv_termio_ldisc=no)])dnl
  376. AC_MSG_RESULT($bash_cv_termio_ldisc)
  377. if test $bash_cv_termio_ldisc = yes; then
  378. AC_DEFINE(TERMIO_LDISC)
  379. fi
  380. ])
  381.  
  382. AC_DEFUN(BASH_FUNC_GETENV,
  383. [AC_MSG_CHECKING(to see if getenv can be redefined)
  384. AC_CACHE_VAL(bash_cv_getenv_redef,
  385. [AC_TRY_RUN([
  386. #ifdef HAVE_UNISTD_H
  387. #  include <unistd.h>
  388. #endif
  389. #ifndef __STDC__
  390. #  ifndef const
  391. #    define const
  392. #  endif
  393. #endif
  394. char *
  395. getenv (name)
  396. #if defined (__linux__) || defined (__bsdi__) || defined (convex)
  397.      const char *name;
  398. #else
  399.      char const *name;
  400. #endif /* !__linux__ && !__bsdi__ && !convex */
  401. {
  402. return "42";
  403. }
  404. main()
  405. {
  406. char *s;
  407. /* The next allows this program to run, but does not allow bash to link
  408.    when it redefines getenv.  I'm not really interested in figuring out
  409.    why not. */
  410. #if defined (NeXT)
  411. exit(1);
  412. #endif
  413. s = getenv("ABCDE");
  414. exit(s == 0);    /* force optimizer to leave getenv in */
  415. }
  416. ], bash_cv_getenv_redef=yes, bash_cv_getenv_redef=no,
  417. AC_MSG_ERROR(cannot check getenv redefinition if cross compiling))])
  418. AC_MSG_RESULT($bash_cv_getenv_redef)
  419. if test $bash_cv_getenv_redef = yes; then
  420. AC_DEFINE(CAN_REDEFINE_GETENV)
  421. fi
  422. ])
  423.  
  424. AC_DEFUN(BASH_FUNC_PRINTF,
  425. [AC_MSG_CHECKING(for declaration of printf in <stdio.h>)
  426. AC_CACHE_VAL(bash_cv_printf_declared,
  427. [AC_TRY_RUN([
  428. #include <stdio.h>
  429. #ifdef __STDC__
  430. typedef int (*_bashfunc)(const char *, ...);
  431. #else
  432. typedef int (*_bashfunc)();
  433. #endif
  434. main()
  435. {
  436. _bashfunc pf;
  437. pf = printf;
  438. exit(pf == 0);
  439. }
  440. ],bash_cv_printf_declared=yes, bash_cv_printf_declared=no,
  441. AC_MSG_ERROR(cannot check printf declaration if cross compiling))])
  442. AC_MSG_RESULT($bash_cv_printf_declared)
  443. if test $bash_cv_printf_declared = yes; then
  444. AC_DEFINE(PRINTF_DECLARED)
  445. fi
  446. ])
  447.  
  448. AC_DEFUN(BASH_FUNC_ULIMIT_MAXFDS,
  449. [AC_MSG_CHECKING(whether ulimit can substitute for getdtablesize)
  450. AC_CACHE_VAL(bash_cv_ulimit_maxfds,
  451. [AC_TRY_RUN([
  452. main()
  453. {
  454. long maxfds = ulimit(4, 0L);
  455. exit (maxfds == -1L);
  456. }
  457. ],bash_cv_ulimit_maxfds=yes, bash_cv_ulimit_maxfds=no,
  458. AC_MSG_ERROR(cannot check ulimit if cross compiling))])
  459. AC_MSG_RESULT($bash_cv_ulimit_maxfds)
  460. if test $bash_cv_ulimit_maxfds = yes; then
  461. AC_DEFINE(ULIMIT_MAXFDS)
  462. fi
  463. ])
  464.  
  465. AC_DEFUN(BASH_CHECK_LIB_TERMCAP,
  466. [
  467. if test "X$bash_cv_termcap_lib" = "X"; then
  468. _bash_needmsg=yes
  469. else
  470. AC_MSG_CHECKING(which library has the termcap functions)
  471. _bash_needmsg=
  472. fi
  473. AC_CACHE_VAL(bash_cv_termcap_lib,
  474. [AC_CHECK_LIB(termcap, tgetent, bash_cv_termcap_lib=libtermcap,
  475.     [AC_CHECK_LIB(curses, tgetent, bash_cv_termcap_lib=libcurses,
  476.     [AC_CHECK_LIB(ncurses, tgetent, bash_cv_termcap_lib=libncurses,
  477.         bash_cv_termcap_lib=gnutermcap)])])])
  478. if test "X$_bash_needmsg" = "Xyes"; then
  479. AC_MSG_CHECKING(which library has the termcap functions)
  480. fi
  481. AC_MSG_RESULT(using $bash_cv_termcap_lib)
  482. if test $bash_cv_termcap_lib = gnutermcap; then
  483. LDFLAGS="$LDFLAGS -L./lib/termcap"
  484. TERMCAP_LIB="./lib/termcap/libtermcap.a"
  485. TERMCAP_DEP="./lib/termcap/libtermcap.a"
  486. elif test $bash_cv_termcap_lib = libtermcap && test -z "$prefer_curses"; then
  487. TERMCAP_LIB=-ltermcap
  488. TERMCAP_DEP=
  489. elif test $bash_cv_termcap_lib = libncurses; then
  490. TERMCAP_LIB=-lncurses
  491. TERMCAP_DEP=
  492. else
  493. TERMCAP_LIB=-lcurses
  494. TERMCAP_DEP=
  495. fi
  496. ])
  497.  
  498. AC_DEFUN(BASH_FUNC_GETCWD,
  499. [AC_MSG_CHECKING([if getcwd() calls popen()])
  500. AC_CACHE_VAL(bash_cv_getcwd_calls_popen,
  501. [AC_TRY_RUN([
  502. #include <stdio.h>
  503. #ifdef HAVE_UNISTD_H
  504. #include <unistd.h>
  505. #endif
  506.  
  507. #ifndef __STDC__
  508. #ifndef const
  509. #define const
  510. #endif
  511. #endif
  512.  
  513. int popen_called;
  514.  
  515. FILE *
  516. popen(command, type)
  517.      const char *command;
  518.      const char *type;
  519. {
  520.     popen_called = 1;
  521.     return (FILE *)NULL;
  522. }
  523.  
  524. FILE *_popen(command, type)
  525.      const char *command;
  526.      const char *type;
  527. {
  528.   return (popen (command, type));
  529. }
  530.  
  531. int
  532. pclose(stream)
  533. FILE *stream;
  534. {
  535.     return 0;
  536. }
  537.  
  538. int
  539. _pclose(stream)
  540. FILE *stream;
  541. {
  542.     return 0;
  543. }
  544.  
  545. main()
  546. {
  547.     char    lbuf[32];
  548.     popen_called = 0;
  549.     getcwd(lbuf, 32);
  550.     exit (popen_called);
  551. }
  552. ], bash_cv_getcwd_calls_popen=no, bash_cv_getcwd_calls_popen=yes,
  553. AC_MSG_ERROR(cannot check whether getcwd calls popen if cross compiling))])
  554. AC_MSG_RESULT($bash_cv_getcwd_calls_popen)
  555. if test $bash_cv_getcwd_calls_popen = yes; then
  556. AC_DEFINE(GETCWD_BROKEN)
  557. fi
  558. ])
  559.  
  560. AC_DEFUN(BASH_STRUCT_DIRENT_D_INO,
  561. [AC_REQUIRE([AC_HEADER_DIRENT])
  562. AC_MSG_CHECKING(if struct dirent has a d_ino member)
  563. AC_CACHE_VAL(bash_cv_dirent_has_dino,
  564. [AC_TRY_COMPILE([
  565. #include <stdio.h>
  566. #include <sys/types.h>
  567. #ifdef HAVE_UNISTD_H
  568. # include <unistd.h>
  569. #endif /* HAVE_UNISTD_H */
  570. #if defined(HAVE_DIRENT_H)
  571. # include <dirent.h>
  572. #else
  573. # define dirent direct
  574. # ifdef HAVE_SYS_NDIR_H
  575. #  include <sys/ndir.h>
  576. # endif /* SYSNDIR */
  577. # ifdef HAVE_SYS_DIR_H
  578. #  include <sys/dir.h>
  579. # endif /* SYSDIR */
  580. # ifdef HAVE_NDIR_H
  581. #  include <ndir.h>
  582. # endif
  583. #endif /* HAVE_DIRENT_H */
  584. ],[
  585. struct dirent d; int z; z = d.d_ino;
  586. ], bash_cv_dirent_has_dino=yes, bash_cv_dirent_has_dino=no)])
  587. AC_MSG_RESULT($bash_cv_dirent_has_dino)
  588. if test $bash_cv_dirent_has_dino = yes; then
  589. AC_DEFINE(STRUCT_DIRENT_HAS_D_INO)
  590. fi
  591. ])
  592.  
  593. AC_DEFUN(BASH_STRUCT_DIRENT_D_FILENO,
  594. [AC_REQUIRE([AC_HEADER_DIRENT])
  595. AC_MSG_CHECKING(if struct dirent has a d_fileno member)
  596. AC_CACHE_VAL(bash_cv_dirent_has_d_fileno,
  597. [AC_TRY_COMPILE([
  598. #include <stdio.h>
  599. #include <sys/types.h>
  600. #ifdef HAVE_UNISTD_H
  601. # include <unistd.h>
  602. #endif /* HAVE_UNISTD_H */
  603. #if defined(HAVE_DIRENT_H)
  604. # include <dirent.h>
  605. #else
  606. # define dirent direct
  607. # ifdef HAVE_SYS_NDIR_H
  608. #  include <sys/ndir.h>
  609. # endif /* SYSNDIR */
  610. # ifdef HAVE_SYS_DIR_H
  611. #  include <sys/dir.h>
  612. # endif /* SYSDIR */
  613. # ifdef HAVE_NDIR_H
  614. #  include <ndir.h>
  615. # endif
  616. #endif /* HAVE_DIRENT_H */
  617. ],[
  618. struct dirent d; int z; z = d.d_fileno;
  619. ], bash_cv_dirent_has_d_fileno=yes, bash_cv_dirent_has_d_fileno=no)])
  620. AC_MSG_RESULT($bash_cv_dirent_has_d_fileno)
  621. if test $bash_cv_dirent_has_d_fileno = yes; then
  622. AC_DEFINE(STRUCT_DIRENT_HAS_D_FILENO)
  623. fi
  624. ])
  625.  
  626. AC_DEFUN(BASH_REINSTALL_SIGHANDLERS,
  627. [AC_REQUIRE([AC_TYPE_SIGNAL])
  628. AC_REQUIRE([BASH_SIGNAL_CHECK])
  629. AC_MSG_CHECKING([if signal handlers must be reinstalled when invoked])
  630. AC_CACHE_VAL(bash_cv_must_reinstall_sighandlers,
  631. [AC_TRY_RUN([
  632. #include <signal.h>
  633. #ifdef HAVE_UNISTD_H
  634. #include <unistd.h>
  635. #endif
  636.  
  637. typedef RETSIGTYPE sigfunc();
  638.  
  639. int nsigint;
  640.  
  641. #ifdef HAVE_POSIX_SIGNALS
  642. sigfunc *
  643. set_signal_handler(sig, handler)
  644.      int sig;
  645.      sigfunc *handler;
  646. {
  647.   struct sigaction act, oact;
  648.   act.sa_handler = handler;
  649.   act.sa_flags = 0;
  650.   sigemptyset (&act.sa_mask);
  651.   sigemptyset (&oact.sa_mask);
  652.   sigaction (sig, &act, &oact);
  653.   return (oact.sa_handler);
  654. }
  655. #else
  656. #define set_signal_handler(s, h) signal(s, h)
  657. #endif
  658.  
  659. RETSIGTYPE
  660. sigint(s)
  661. int s;
  662. {
  663.   nsigint++;
  664. }
  665.  
  666. main()
  667. {
  668.     nsigint = 0;
  669.     set_signal_handler(SIGINT, sigint);
  670.     kill((int)getpid(), SIGINT);
  671.     kill((int)getpid(), SIGINT);
  672.     exit(nsigint != 2);
  673. }
  674. ], bash_cv_must_reinstall_sighandlers=no, bash_cv_must_reinstall_sighandlers=yes,
  675. AC_MSG_ERROR(cannot check signal handling if cross compiling))])
  676. AC_MSG_RESULT($bash_cv_must_reinstall_sighandlers)
  677. if test $bash_cv_must_reinstall_sighandlers = yes; then
  678. AC_DEFINE(MUST_REINSTALL_SIGHANDLERS)
  679. fi
  680. ])
  681.  
  682. AC_DEFUN(BASH_FUNC_SBRK_DECLARED,
  683. [AC_MSG_CHECKING(for declaration of sbrk in <unistd.h>)
  684. AC_CACHE_VAL(bash_cv_sbrk_declared,
  685. [AC_EGREP_HEADER(sbrk, unistd.h,
  686.  bash_cv_sbrk_declared=yes, bash_cv_sbrk_declared=no)])
  687. AC_MSG_RESULT($bash_cv_sbrk_declared)
  688. if test $bash_cv_sbrk_declared = yes; then
  689. AC_DEFINE(SBRK_DECLARED)
  690. fi
  691. ])
  692.  
  693. dnl check that some necessary job control definitions are present
  694. AC_DEFUN(BASH_JOB_CONTROL_MISSING,
  695. [AC_REQUIRE([BASH_SIGNAL_CHECK])
  696. AC_MSG_CHECKING(for presence of necessary job control definitions)
  697. AC_CACHE_VAL(bash_cv_job_control_missing,
  698. [AC_TRY_RUN([
  699. #include <sys/types.h>
  700. #ifdef HAVE_SYS_WAIT_H
  701. #include <sys/wait.h>
  702. #endif
  703. #ifdef HAVE_UNISTD_H
  704. #include <unistd.h>
  705. #endif
  706. #include <signal.h>
  707.  
  708. /* Add more tests in here as appropriate. */
  709. main()
  710. {
  711. /* signal type */
  712. #if !defined (HAVE_POSIX_SIGNALS) && !defined (HAVE_BSD_SIGNALS)
  713. exit(1);
  714. #endif
  715.  
  716. /* signals and tty control. */
  717. #if !defined (SIGTSTP) || !defined (SIGSTOP) || !defined (SIGCONT)
  718. exit (1);
  719. #endif
  720.  
  721. /* process control */
  722. #if !defined (WNOHANG) || !defined (WUNTRACED) 
  723. exit(1);
  724. #endif
  725.  
  726. /* Posix systems have tcgetpgrp and waitpid. */
  727. #if defined (_POSIX_VERSION) && !defined (HAVE_TCGETPGRP)
  728. exit(1);
  729. #endif
  730.  
  731. #if defined (_POSIX_VERSION) && !defined (HAVE_WAITPID)
  732. exit(1);
  733. #endif
  734.  
  735. /* Other systems have TIOCSPGRP/TIOCGPRGP and wait3. */
  736. #if !defined (_POSIX_VERSION) && !defined (HAVE_WAIT3)
  737. exit(1);
  738. #endif
  739.  
  740. exit(0);
  741. }],bash_cv_job_control_missing=present, bash_cv_job_control_missing=missing,
  742.     AC_MSG_ERROR(cannot check job control if cross-compiling))
  743. ])
  744. AC_MSG_RESULT($bash_cv_job_control_missing)
  745. if test $bash_cv_job_control_missing = missing; then
  746. AC_DEFINE(JOB_CONTROL_MISSING)
  747. fi
  748. ])
  749.  
  750. dnl check whether named pipes are present
  751. dnl this requires a previous check for mkfifo, but that is awkward to specify
  752. AC_DEFUN(BASH_SYS_NAMED_PIPES,
  753. [AC_MSG_CHECKING(for presence of named pipes)
  754. AC_CACHE_VAL(bash_cv_sys_named_pipes,
  755. [AC_TRY_RUN([
  756. #include <sys/types.h>
  757. #include <sys/stat.h>
  758. #ifdef HAVE_UNISTD_H
  759. #include <unistd.h>
  760. #endif
  761.  
  762. /* Add more tests in here as appropriate. */
  763. main()
  764. {
  765. int fd;
  766.  
  767. #if defined (HAVE_MKFIFO)
  768. exit (0);
  769. #endif
  770.  
  771. #if !defined (S_IFIFO) && (defined (_POSIX_VERSION) && !defined (S_ISFIFO))
  772. exit (1);
  773. #endif
  774.  
  775. #if defined (NeXT)
  776. exit (1);
  777. #endif
  778.  
  779. fd = mknod ("/tmp/sh-np-autoconf", 0666 | S_IFIFO, 0);
  780. if (fd == -1)
  781.   exit (1);
  782. close(fd);
  783. unlink ("/tmp/sh-np-autoconf");
  784. exit(0);
  785. }],bash_cv_sys_named_pipes=present, bash_cv_sys_named_pipes=missing,
  786.     AC_MSG_ERROR(cannot check for named pipes if cross-compiling))
  787. ])
  788. AC_MSG_RESULT($bash_cv_sys_named_pipes)
  789. if test $bash_cv_sys_named_pipes = missing; then
  790. AC_DEFINE(NAMED_PIPES_MISSING)
  791. fi
  792. ])
  793.  
  794. AC_DEFUN(BASH_FUNC_POSIX_SETJMP,
  795. [AC_REQUIRE([BASH_SIGNAL_CHECK])
  796. AC_MSG_CHECKING(for presence of POSIX-style sigsetjmp/siglongjmp)
  797. AC_CACHE_VAL(bash_cv_func_sigsetjmp,
  798. [AC_TRY_RUN([
  799. #ifdef HAVE_UNISTD_H
  800. #include <unistd.h>
  801. #endif
  802. #include <sys/types.h>
  803. #include <signal.h>
  804. #include <setjmp.h>
  805.  
  806. main()
  807. {
  808. #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
  809. exit (1);
  810. #else
  811.  
  812. int code;
  813. sigset_t set, oset;
  814. sigjmp_buf xx;
  815.  
  816. /* get the mask */
  817. sigemptyset(&set);
  818. sigemptyset(&oset);
  819. sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &set);
  820. sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset);
  821.  
  822. /* save it */
  823. code = sigsetjmp(xx, 1);
  824. if (code)
  825.   exit(0);    /* could get sigmask and compare to oset here. */
  826.  
  827. /* change it */
  828. sigaddset(&set, SIGINT);
  829. sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL);
  830.  
  831. /* and siglongjmp */
  832. siglongjmp(xx, 10);
  833. exit(1);
  834. #endif
  835. }],bash_cv_func_sigsetjmp=present, bash_cv_func_sigsetjmp=missing,
  836.    AC_MSG_ERROR(cannot check for sigsetjmp/siglongjmp if cross-compiling))
  837. ])
  838. AC_MSG_RESULT($bash_cv_func_sigsetjmp)
  839. if test $bash_cv_func_sigsetjmp = present; then
  840. AC_DEFINE(HAVE_POSIX_SIGSETJMP)
  841. fi
  842. ])
  843.  
  844. AC_DEFUN(BASH_HAVE_TIOCGWINSZ,
  845. [AC_MSG_CHECKING(for TIOCGWINSZ in sys/ioctl.h)
  846. AC_CACHE_VAL(bash_cv_tiocgwinsz_in_ioctl,
  847. [AC_TRY_COMPILE([#include <sys/types.h>
  848. #include <sys/ioctl.h>], [int x = TIOCGWINSZ;],
  849.   bash_cv_tiocgwinsz_in_ioctl=yes,bash_cv_tiocgwinsz_in_ioctl=no)])
  850. AC_MSG_RESULT($bash_cv_tiocgwinsz_in_ioctl)
  851. if test $bash_cv_tiocgwinsz_in_ioctl = yes; then   
  852. AC_DEFINE(GWINSZ_IN_SYS_IOCTL)
  853. fi
  854. ])
  855.  
  856. AC_DEFUN(BASH_STRUCT_WINSIZE,
  857. [AC_MSG_CHECKING(for struct winsize in sys/ioctl.h)
  858. AC_CACHE_VAL(bash_cv_struct_winsize_in_ioctl,
  859. [AC_TRY_COMPILE([#include <sys/types.h>
  860. #include <sys/ioctl.h>], [struct winsize x;],
  861.   bash_cv_struct_winsize_in_ioctl=yes,bash_cv_struct_winsize_in_ioctl=no)])
  862. AC_MSG_RESULT($bash_cv_struct_winsize_in_ioctl)
  863. if test $bash_cv_struct_winsize_in_ioctl = yes; then   
  864. AC_DEFINE(STRUCT_WINSIZE_IN_SYS_IOCTL)
  865. fi
  866. ])
  867.  
  868. AC_DEFUN(BASH_HAVE_TIOCSTAT,
  869. [AC_MSG_CHECKING(for TIOCSTAT in sys/ioctl.h)
  870. AC_CACHE_VAL(bash_cv_tiocstat_in_ioctl,
  871. [AC_TRY_COMPILE([#include <sys/types.h>
  872. #include <sys/ioctl.h>], [int x = TIOCSTAT;],
  873.   bash_cv_tiocstat_in_ioctl=yes,bash_cv_tiocstat_in_ioctl=no)])
  874. AC_MSG_RESULT($bash_cv_tiocstat_in_ioctl)
  875. if test $bash_cv_tiocstat_in_ioctl = yes; then   
  876. AC_DEFINE(TIOCSTAT_IN_SYS_IOCTL)
  877. fi
  878. ])
  879.  
  880. AC_DEFUN(BASH_HAVE_FIONREAD,
  881. [AC_MSG_CHECKING(for FIONREAD in sys/ioctl.h)
  882. AC_CACHE_VAL(bash_cv_fionread_in_ioctl,
  883. [AC_TRY_COMPILE([#include <sys/types.h>
  884. #include <sys/ioctl.h>], [int x = FIONREAD;],
  885.   bash_cv_fionread_in_ioctl=yes,bash_cv_fionread_in_ioctl=no)])
  886. AC_MSG_RESULT($bash_cv_fionread_in_ioctl)
  887. if test $bash_cv_fionread_in_ioctl = yes; then   
  888. AC_DEFINE(FIONREAD_IN_SYS_IOCTL)
  889. fi
  890. ])
  891.  
  892. dnl
  893. dnl See if speed_t is declared in <sys/types.h>.  Some versions of linux
  894. dnl require a definition of speed_t each time <termcap.h> is included,
  895. dnl but you can only get speed_t if you include <termios.h> (on some
  896. dnl versions) or <sys/types.h> (on others).
  897. dnl
  898. AC_DEFUN(BASH_MISC_SPEED_T,
  899. [AC_MSG_CHECKING(for speed_t in sys/types.h)
  900. AC_CACHE_VAL(bash_cv_speed_t_in_sys_types,
  901. [AC_TRY_COMPILE([#include <sys/types.h>], [speed_t x;],
  902.   bash_cv_speed_t_in_sys_types=yes,bash_cv_speed_t_in_sys_types=no)])
  903. AC_MSG_RESULT($bash_cv_speed_t_in_sys_types)
  904. if test $bash_cv_speed_t_in_sys_types = yes; then   
  905. AC_DEFINE(SPEED_T_IN_SYS_TYPES)
  906. fi
  907. ])
  908.  
  909. AC_DEFUN(BASH_CHECK_GETPW_FUNCS,
  910. [AC_MSG_CHECKING(whether programs are able to redeclare getpw functions)
  911. AC_CACHE_VAL(bash_cv_can_redecl_getpw,
  912. [AC_TRY_COMPILE([#include <sys/types.h>
  913. #include <pwd.h>
  914. extern struct passwd *getpwent();], [struct passwd *z; z = getpwent();],
  915.   bash_cv_can_redecl_getpw=yes,bash_cv_can_redecl_getpw=no)])
  916. AC_MSG_RESULT($bash_cv_can_redecl_getpw)
  917. if test $bash_cv_can_redecl_getpw = no; then
  918. AC_DEFINE(HAVE_GETPW_DECLS)
  919. fi
  920. ])
  921.  
  922. AC_DEFUN(BASH_CHECK_DEV_FD,
  923. [AC_MSG_CHECKING(whether /dev/fd is available)
  924. AC_CACHE_VAL(bash_cv_dev_fd,
  925. [if test -d /dev/fd  && test -r /dev/fd/0; then
  926.    bash_cv_dev_fd=standard
  927.  elif test -d /proc/self/fd && test -r /proc/self/fd/0; then
  928.    bash_cv_dev_fd=whacky
  929.  else
  930.    bash_cv_dev_fd=absent
  931.  fi
  932. ])
  933. AC_MSG_RESULT($bash_cv_dev_fd)
  934. if test $bash_cv_dev_fd = "standard"; then
  935.   AC_DEFINE(HAVE_DEV_FD)
  936.   AC_DEFINE(DEV_FD_PREFIX, "/dev/fd/")
  937. elif test $bash_cv_dev_fd = "whacky"; then
  938.   AC_DEFINE(HAVE_DEV_FD)
  939.   AC_DEFINE(DEV_FD_PREFIX, "/proc/self/fd/")
  940. fi
  941. ])
  942.  
  943. dnl
  944. dnl Check for the presence of getpeername (the only networking function
  945. dnl bash currently requires) in libsocket.  If libsocket is present,
  946. dnl check for libnsl and add it to LIBS if it's there, since most
  947. dnl systems with libsocket require linking with libnsl as well.
  948. dnl This should only be called if getpeername was not found in libc.
  949. dnl
  950. AC_DEFUN(BASH_CHECK_SOCKLIB,
  951. [
  952. if test "X$bash_cv_have_socklib" = "X"; then
  953. _bash_needmsg=
  954. else
  955. AC_MSG_CHECKING(for socket library)
  956. _bash_needmsg=yes
  957. fi
  958. AC_CACHE_VAL(bash_cv_have_socklib,
  959. [AC_CHECK_LIB(socket, getpeername,
  960.         bash_cv_have_socklib=yes, bash_cv_have_socklib=no, -lnsl)])
  961. if test "X$_bash_needmsg" = Xyes; then
  962.   AC_MSG_RESULT($bash_cv_have_socklib)
  963.   _bash_needmsg=
  964. fi
  965. if test $bash_cv_have_socklib = yes; then
  966.   # check for libnsl, add it to LIBS if present
  967.   if test "X$bash_cv_have_libnsl" = "X"; then
  968.     _bash_needmsg=
  969.   else
  970.     AC_MSG_CHECKING(for libnsl)
  971.     _bash_needmsg=yes
  972.   fi
  973.   AC_CACHE_VAL(bash_cv_have_libnsl,
  974.        [AC_CHECK_LIB(nsl, t_open,
  975.          bash_cv_have_libnsl=yes, bash_cv_have_libnsl=no)])
  976.   if test "X$_bash_needmsg" = Xyes; then
  977.     AC_MSG_RESULT($bash_cv_have_libnsl)
  978.     _bash_needmsg=
  979.   fi
  980.   if test $bash_cv_have_libnsl = yes; then
  981.     LIBS="-lsocket -lnsl $LIBS"
  982.   else
  983.     LIBS="-lsocket $LIBS"
  984.   fi
  985.   AC_DEFINE(HAVE_LIBSOCKET)
  986.   AC_DEFINE(HAVE_GETPEERNAME)
  987. fi
  988. ])
  989.  
  990. AC_DEFUN(BASH_DEFAULT_MAIL_DIR,
  991. [AC_MSG_CHECKING(for default mail directory)
  992. AC_CACHE_VAL(bash_cv_mail_dir,
  993. [if test -d /var/mail; then
  994.    bash_cv_mail_dir=/var/mail
  995.  elif test -d /usr/mail; then
  996.    bash_cv_mail_dir=/usr/mail
  997.  elif test -d /usr/spool/mail; then
  998.    bash_cv_mail_dir=/usr/spool/mail
  999.  elif test -d /var/spool/mail; then
  1000.    bash_cv_mail_dir=/var/spool/mail
  1001.  else
  1002.    bash_cv_mail_dir=unknown
  1003.  fi
  1004. ])
  1005. AC_MSG_RESULT($bash_cv_mail_dir)
  1006. if test $bash_cv_mail_dir = "/var/mail"; then
  1007.    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/mail")
  1008. elif test $bash_cv_mail_dir = "/usr/mail"; then
  1009.    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/mail")
  1010. elif test $bash_cv_mail_dir = "/var/spool/mail"; then
  1011.    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/spool/mail")
  1012. elif test $bash_cv_mail_dir = "/usr/spool/mail"; then
  1013.    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/spool/mail")
  1014. else
  1015.    AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "unknown")
  1016. fi
  1017. ])
  1018.  
  1019. dnl
  1020. dnl Check if HPUX needs _KERNEL defined for RLIMIT_* definitions
  1021. dnl
  1022. AC_DEFUN(BASH_KERNEL_RLIMIT_CHECK,
  1023. [AC_MSG_CHECKING([whether $host_os needs _KERNEL for RLIMIT defines])
  1024. AC_CACHE_VAL(bash_cv_kernel_rlimit,
  1025. [AC_TRY_COMPILE([
  1026. #include <sys/types.h>
  1027. #include <sys/resource.h>
  1028. ],
  1029. [
  1030.   int f;
  1031.   f = RLIMIT_DATA;
  1032. ], bash_cv_kernel_rlimit=no,
  1033.     [AC_TRY_COMPILE([
  1034.      #include <sys/types.h>
  1035.      #define _KERNEL
  1036.      #include <sys/resource.h>
  1037.      #undef _KERNEL
  1038.      ],
  1039.      [
  1040.     int f;
  1041.         f = RLIMIT_DATA;
  1042.      ], bash_cv_kernel_rlimit=yes, bash_cv_kernel_rlimit=no)]
  1043. )])
  1044. AC_MSG_RESULT($bash_cv_kernel_rlimit)
  1045. if test $bash_cv_kernel_rlimit = yes; then
  1046. AC_DEFINE(RLIMIT_NEEDS_KERNEL)
  1047. fi
  1048. ])
  1049.  
  1050. AC_DEFUN(BASH_FUNC_STRCOLL,
  1051. [
  1052. AC_MSG_CHECKING(whether or not strcoll and strcmp differ)
  1053. AC_CACHE_VAL(bash_cv_func_strcoll_broken,
  1054. [AC_TRY_RUN([
  1055. #include <stdio.h>
  1056. #if defined (HAVE_LOCALE_H)
  1057. #include <locale.h>
  1058. #endif
  1059.  
  1060. main(c, v)
  1061. int     c;
  1062. char    *v[];
  1063. {
  1064.         int     r1, r2;
  1065.         char    *deflocale, *defcoll;
  1066.  
  1067. #ifdef HAVE_SETLOCALE
  1068.         deflocale = setlocale(LC_ALL, "");
  1069.     defcoll = setlocale(LC_COLLATE, "");
  1070. #endif
  1071.  
  1072. #ifdef HAVE_STRCOLL
  1073.     /* These two values are taken from tests/glob-test. */
  1074.         r1 = strcoll("abd", "aXd");
  1075. #else
  1076.     r1 = 0;
  1077. #endif
  1078.         r2 = strcmp("abd", "aXd");
  1079.  
  1080.     /* These two should both be greater than 0.  It is permissible for
  1081.        a system to return different values, as long as the sign is the
  1082.        same. */
  1083.  
  1084.         /* Exit with 1 (failure) if these two values are both > 0, since
  1085.        this tests whether strcoll(3) is broken with respect to strcmp(3)
  1086.        in the default locale. */
  1087.     exit (r1 > 0 && r2 > 0);
  1088. }
  1089. ], bash_cv_func_strcoll_broken=yes, bash_cv_func_strcoll_broken=no,
  1090.    AC_MSG_ERROR(cannot check strcoll if cross compiling))
  1091. ])
  1092. AC_MSG_RESULT($bash_cv_func_strcoll_broken)
  1093. if test $bash_cv_func_strcoll_broken = yes; then
  1094. AC_DEFINE(STRCOLL_BROKEN)
  1095. fi
  1096. ])
  1097.