« back to all changes in this revision
Viewing changes to readline-4.0/aclocal.m4
- browse files at revision 4
- compare with another revision
- download diff
- download tarball
- view history from revision 4
- Committer: Bazaar Package Importer
- Author(s): Junichi Uekawa
- Date: 2007-04-22 01:25:44 UTC
- mfrom: (1.1.4 upstream)
- Revision ID: james.westby@ubuntu.com-20070422012544-lugfjb034udblalb
Tags: 2.4.5-1
* new upstream release
* build-depend on texlive
* pbuilder-test: error code changed from '-1' to '1', so update test.
* build-depend on texlive
* pbuilder-test: error code changed from '-1' to '1', so update test.
- files added:
- debian/patches/13_gcc4.3.dpatch
- files removed:
- readline-4.0
- files modified:
- AUTHORS
added
removed
readline-4.0/aclocal.m4
1
dnl
2
dnl Bash specific tests
3
dnl
4
dnl Some derived from PDKSH 5.1.3 autoconf tests
5
dnl
6
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])
Loggerhead is a web-based interface for Breezy
Version: 2.0.1