Context Navigation

source: trunk/third/readline/aclocal.m4 @ 12992

Visit:

Revision 12992, 33.4 KB checked in by kcr, 25 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r12991, which included commits to RCS files with non-trunk default branches.

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: