![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to configure CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104|
Return to configure CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 root 1: #!/bin/sh
2: # Guess values for system-dependent variables and create Makefiles.
3: # Generated automatically using autoconf.
4: # Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
5:
6: # This program is free software; you can redistribute it and/or modify
7: # it under the terms of the GNU General Public License as published by
8: # the Free Software Foundation; either version 2, or (at your option)
9: # any later version.
10:
11: # This program is distributed in the hope that it will be useful,
12: # but WITHOUT ANY WARRANTY; without even the implied warranty of
13: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: # GNU General Public License for more details.
15:
16: # You should have received a copy of the GNU General Public License
17: # along with this program; if not, write to the Free Software
18: # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19:
20: # Usage: configure [--srcdir=DIR] [--host=HOST] [--gas] [--nfp] [--no-create]
21: # [--prefix=PREFIX] [--exec-prefix=PREFIX] [--with-PACKAGE] [TARGET]
22: # Ignores all args except --srcdir, --prefix, --exec-prefix, --no-create, and
23: # --with-PACKAGE unless this script has special code to handle it.
24:
25:
26: for arg
27: do
28: # Handle --exec-prefix with a space before the argument.
29: if test x$next_exec_prefix = xyes; then exec_prefix=$arg; next_exec_prefix=
30: # Handle --host with a space before the argument.
31: elif test x$next_host = xyes; then next_host=
32: # Handle --prefix with a space before the argument.
33: elif test x$next_prefix = xyes; then prefix=$arg; next_prefix=
34: # Handle --srcdir with a space before the argument.
35: elif test x$next_srcdir = xyes; then srcdir=$arg; next_srcdir=
36: else
37: case $arg in
38: # For backward compatibility, also recognize exact --exec_prefix.
39: -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* | --exec=* | --exe=* | --ex=* | --e=*)
40: exec_prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;;
41: -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- | --exec | --exe | --ex | --e)
42: next_exec_prefix=yes ;;
43:
44: -gas | --gas | --ga | --g) ;;
45:
46: -host=* | --host=* | --hos=* | --ho=* | --h=*) ;;
47: -host | --host | --hos | --ho | --h)
48: next_host=yes ;;
49:
50: -nfp | --nfp | --nf) ;;
51:
52: -no-create | --no-create | --no-creat | --no-crea | --no-cre | --no-cr | --no-c | --no- | --no)
53: no_create=1 ;;
54:
55: -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
56: prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;;
57: -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
58: next_prefix=yes ;;
59:
60: -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=* | --s=*)
61: srcdir=`echo $arg | sed 's/[-a-z_]*=//'` ;;
62: -srcdir | --srcdir | --srcdi | --srcd | --src | --sr | --s)
63: next_srcdir=yes ;;
64:
65: -with-* | --with-*)
66: package=`echo $arg|sed 's/-*with-//'`
67: # Delete all the valid chars; see if any are left.
68: if test -n "`echo $package|sed 's/[-a-zA-Z0-9_]*//g'`"; then
69: echo "configure: $package: invalid package name" >&2; exit 1
70: fi
71: eval "with_`echo $package|sed s/-/_/g`=1" ;;
72:
73: *) ;;
74: esac
75: fi
76: done
77:
78: trap 'rm -f conftest* core; exit 1' 1 3 15
79:
80: rm -f conftest*
81: compile='${CC-cc} $DEFS conftest.c -o conftest $LIBS >/dev/null 2>&1'
82:
83: # A filename unique to this package, relative to the directory that
84: # configure is in, which we can look for to find out if srcdir is correct.
85: unique_file=policy.h
86:
87: # Find the source files, if location was not specified.
88: if test -z "$srcdir"; then
89: srcdirdefaulted=yes
90: # Try the directory containing this script, then `..'.
91: prog=$0
92: confdir=`echo $prog|sed 's%/[^/][^/]*$%%'`
93: test "X$confdir" = "X$prog" && confdir=.
94: srcdir=$confdir
95: if test ! -r $srcdir/$unique_file; then
96: srcdir=..
97: fi
98: fi
99: if test ! -r $srcdir/$unique_file; then
100: if test x$srcdirdefaulted = xyes; then
101: echo "configure: Can not find sources in \`${confdir}' or \`..'." 1>&2
102: else
103: echo "configure: Can not find sources in \`${srcdir}'." 1>&2
104: fi
105: exit 1
106: fi
107: # Preserve a srcdir of `.' to avoid automounter screwups with pwd.
108: # But we can't avoid them for `..', to make subdirectories work.
109: case $srcdir in
110: .|/*|~*) ;;
111: *) srcdir=`cd $srcdir; pwd` ;; # Make relative path absolute.
112: esac
113:
114:
115: compile='rm -f conftest.t;
116: mv conftest.c conftest.t;
117: echo "$DEFS" > conftest.c;
118: cat conftest.t >> conftest.c;
119: rm -f conftest.t;
120: ${CC-cc} conftest.c -o conftest $LIBS >/dev/null 2>&1'
121:
122: if test -z "$CC"; then
123: echo checking for gcc
124: saveifs="$IFS"; IFS="${IFS}:"
125: for dir in $PATH; do
126: test -z "$dir" && dir=.
127: if test -f $dir/gcc; then
128: CC="gcc"
129: break
130: fi
131: done
132: IFS="$saveifs"
133: fi
134: test -z "$CC" && CC="cc"
135:
136: # Find out if we are using GNU C, under whatever name.
137: cat > conftest.c <<EOF
138: #ifdef __GNUC__
139: yes
140: #endif
141: EOF
142: ${CC-cc} -E conftest.c > conftest.out 2>&1
143: if egrep yes conftest.out >/dev/null 2>&1; then
144: GCC=1 # For later tests.
145: fi
146: rm -f conftest*
147:
148: echo checking how to run the C preprocessor
149: if test -z "$CPP"; then
150: CPP='${CC-cc} -E'
151: cat > conftest.c <<EOF
152: $DEFS
153: #include <stdio.h>
154: EOF
155: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
156: if test -z "$err"; then
157: :
158: else
159: CPP=/lib/cpp
160: fi
161: rm -f conftest*
162: fi
163:
164: if test -n "$GCC"; then
165: echo checking whether -traditional is needed
166: pattern="Autoconf.*'x'"
167: prog='#include <sgtty.h>
168: Autoconf TIOCGETP'
169: cat > conftest.c <<EOF
170: $DEFS
171: $prog
172: EOF
173: eval "$CPP conftest.c > conftest.out 2>&1"
174: if egrep "$pattern" conftest.out >/dev/null 2>&1; then
175: need_trad=1
176: fi
177: rm -f conftest*
178:
179:
180: if test -z "$need_trad"; then
181: prog='#include <termio.h>
182: Autoconf TCGETA'
183: cat > conftest.c <<EOF
184: $DEFS
185: $prog
186: EOF
187: eval "$CPP conftest.c > conftest.out 2>&1"
188: if egrep "$pattern" conftest.out >/dev/null 2>&1; then
189: need_trad=1
190: fi
191: rm -f conftest*
192:
193: fi
194: test -n "$need_trad" && CC="$CC -traditional"
195: fi
196:
197: # Make sure to not get the incompatible SysV /etc/install and
198: # /usr/sbin/install, which might be in PATH before a BSD-like install,
199: # or the SunOS /usr/etc/install directory, or the AIX /bin/install,
200: # or the AFS install, which mishandles nonexistent args. (Sigh.)
201: if test -z "$INSTALL"; then
202: echo checking for install
203: saveifs="$IFS"; IFS="${IFS}:"
204: for dir in $PATH; do
205: test -z "$dir" && dir=.
206: case $dir in
207: /etc|/usr/sbin|/usr/etc|/usr/afsws/bin) ;;
208: *)
209: if test -f $dir/install; then
210: if grep dspmsg $dir/install >/dev/null 2>&1; then
211: : # AIX
212: else
213: INSTALL="$dir/install -c"
214: INSTALL_PROGRAM='$(INSTALL)'
215: INSTALL_DATA='$(INSTALL) -m 644'
216: break
217: fi
218: fi
219: ;;
220: esac
221: done
222: IFS="$saveifs"
223: fi
224: INSTALL=${INSTALL-cp}
225: INSTALL_PROGRAM=${INSTALL_PROGRAM-'$(INSTALL)'}
226: INSTALL_DATA=${INSTALL_DATA-'$(INSTALL)'}
227:
228: if test -z "$RANLIB"; then
229: echo checking for ranlib
230: saveifs="$IFS"; IFS="${IFS}:"
231: for dir in $PATH; do
232: test -z "$dir" && dir=.
233: if test -f $dir/ranlib; then
234: RANLIB="ranlib"
235: break
236: fi
237: done
238: IFS="$saveifs"
239: fi
240: test -z "$RANLIB" && RANLIB="@:"
241:
242: echo checking for POSIXized ISC
243: if test -d /etc/conf/kconfig.d &&
244: grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1
245: then
246: ISC=1 # If later tests want to check for ISC.
247: DEFS="${DEFS}#define _POSIX_SOURCE 1
248: "
249: SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_SOURCE\${SEDdB}_POSIX_SOURCE\${SEDdC}1\${SEDdD}
250: \${SEDuA}_POSIX_SOURCE\${SEDuB}_POSIX_SOURCE\${SEDuC}1\${SEDuD}
251: \${SEDeA}_POSIX_SOURCE\${SEDeB}_POSIX_SOURCE\${SEDeC}1\${SEDeD}
252: "
253: if test -n "$GCC"; then
254: CC="$CC -posix"
255: else
256: CC="$CC -Xp"
257: fi
258: fi
259:
260: echo checking for minix/config.h
261: cat > conftest.c <<EOF
262: $DEFS
263: #include <minix/config.h>
264: EOF
265: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
266: if test -z "$err"; then
267: MINIX=1
268: fi
269: rm -f conftest*
270:
271: # The Minix shell can't assign to the same variable on the same line!
272: if test -n "$MINIX"; then
273: DEFS="${DEFS}#define _POSIX_SOURCE 1
274: "
275: SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_SOURCE\${SEDdB}_POSIX_SOURCE\${SEDdC}1\${SEDdD}
276: \${SEDuA}_POSIX_SOURCE\${SEDuB}_POSIX_SOURCE\${SEDuC}1\${SEDuD}
277: \${SEDeA}_POSIX_SOURCE\${SEDeB}_POSIX_SOURCE\${SEDeC}1\${SEDeD}
278: "
279: DEFS="${DEFS}#define _POSIX_1_SOURCE 2
280: "
281: SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_1_SOURCE\${SEDdB}_POSIX_1_SOURCE\${SEDdC}2\${SEDdD}
282: \${SEDuA}_POSIX_1_SOURCE\${SEDuB}_POSIX_1_SOURCE\${SEDuC}2\${SEDuD}
283: \${SEDeA}_POSIX_1_SOURCE\${SEDeB}_POSIX_1_SOURCE\${SEDeC}2\${SEDeD}
284: "
285: DEFS="${DEFS}#define _MINIX 1
286: "
287: SEDDEFS="${SEDDEFS}\${SEDdA}_MINIX\${SEDdB}_MINIX\${SEDdC}1\${SEDdD}
288: \${SEDuA}_MINIX\${SEDuB}_MINIX\${SEDuC}1\${SEDuD}
289: \${SEDeA}_MINIX\${SEDeB}_MINIX\${SEDeC}1\${SEDeD}
290: "
291: fi
292:
293: echo checking for AIX
294: cat > conftest.c <<EOF
295: $DEFS
296: #ifdef _AIX
297: yes
298: #endif
299:
300: EOF
301: eval "$CPP conftest.c > conftest.out 2>&1"
302: if egrep "yes" conftest.out >/dev/null 2>&1; then
303: DEFS="${DEFS}#define _ALL_SOURCE 1
304: "
305: SEDDEFS="${SEDDEFS}\${SEDdA}_ALL_SOURCE\${SEDdB}_ALL_SOURCE\${SEDdC}1\${SEDdD}
306: \${SEDuA}_ALL_SOURCE\${SEDuB}_ALL_SOURCE\${SEDuC}1\${SEDuD}
307: \${SEDeA}_ALL_SOURCE\${SEDeB}_ALL_SOURCE\${SEDeC}1\${SEDeD}
308: "
309: fi
310: rm -f conftest*
311:
312:
313: echo checking for DYNIX/ptx libseq
314: cat > conftest.c <<EOF
315: $DEFS
316: #if defined(_SEQUENT_)
317: yes
318: #endif
319:
320: EOF
321: eval "$CPP conftest.c > conftest.out 2>&1"
322: if egrep "yes" conftest.out >/dev/null 2>&1; then
323: SEQUENT=1
324: fi
325: rm -f conftest*
326:
327: test -n "$SEQUENT" && test -f /usr/lib/libseq.a &&
328: LIBS="$LIBS -lseq"
329:
330: echo checking for IRIX libsun
331: if test -f /usr/lib/libsun.a; then
332: LIBS="$LIBS -lsun"
333: fi
334:
335: echo checking whether cross-compiling
336: # If we cannot run a trivial program, we must be cross compiling.
337: cat > conftest.c <<EOF
338: main(){exit(0);}
339: EOF
340: eval $compile
341: if test -s conftest && (./conftest; exit) 2>/dev/null; then
342: :
343: else
344: cross_compiling=1
345: fi
346: rm -f conftest*
347:
348: CFLAGS=${CFLAGS--g}
349: echo checking for mail program
350: if test -s /usr/ucb/mail; then
351: DEFS="${DEFS}#define MAIL_PROGRAM `echo '"/usr/ucb/mail"'`
352: "
353: SEDDEFS="${SEDDEFS}\${SEDdA}MAIL_PROGRAM\${SEDdB}MAIL_PROGRAM\${SEDdC}`echo '"/usr/ucb/mail"'`\${SEDdD}
354: \${SEDuA}MAIL_PROGRAM\${SEDuB}MAIL_PROGRAM\${SEDuC}`echo '"/usr/ucb/mail"'`\${SEDuD}
355: \${SEDeA}MAIL_PROGRAM\${SEDeB}MAIL_PROGRAM\${SEDeC}`echo '"/usr/ucb/mail"'`\${SEDeD}
356: "
357: elif test -s /bin/mail; then
358: DEFS="${DEFS}#define MAIL_PROGRAM `echo '"/bin/mail"'`
359: "
360: SEDDEFS="${SEDDEFS}\${SEDdA}MAIL_PROGRAM\${SEDdB}MAIL_PROGRAM\${SEDdC}`echo '"/bin/mail"'`\${SEDdD}
361: \${SEDuA}MAIL_PROGRAM\${SEDuB}MAIL_PROGRAM\${SEDuC}`echo '"/bin/mail"'`\${SEDuD}
362: \${SEDeA}MAIL_PROGRAM\${SEDeB}MAIL_PROGRAM\${SEDeC}`echo '"/bin/mail"'`\${SEDeD}
363: "
364: elif test -s /usr/bin/mail; then
365: DEFS="${DEFS}#define MAIL_PROGRAM `echo '"/usr/bin/mail"'`
366: "
367: SEDDEFS="${SEDDEFS}\${SEDdA}MAIL_PROGRAM\${SEDdB}MAIL_PROGRAM\${SEDdC}`echo '"/usr/bin/mail"'`\${SEDdD}
368: \${SEDuA}MAIL_PROGRAM\${SEDuB}MAIL_PROGRAM\${SEDuC}`echo '"/usr/bin/mail"'`\${SEDuD}
369: \${SEDeA}MAIL_PROGRAM\${SEDeB}MAIL_PROGRAM\${SEDeC}`echo '"/usr/bin/mail"'`\${SEDeD}
370: "
371: elif test -s /usr/bin/mailx; then
372: DEFS="${DEFS}#define MAIL_PROGRAM `echo '"/usr/bin/mailx"'`
373: "
374: SEDDEFS="${SEDDEFS}\${SEDdA}MAIL_PROGRAM\${SEDdB}MAIL_PROGRAM\${SEDdC}`echo '"/usr/bin/mailx"'`\${SEDdD}
375: \${SEDuA}MAIL_PROGRAM\${SEDuB}MAIL_PROGRAM\${SEDuC}`echo '"/usr/bin/mailx"'`\${SEDuD}
376: \${SEDeA}MAIL_PROGRAM\${SEDeB}MAIL_PROGRAM\${SEDeC}`echo '"/usr/bin/mailx"'`\${SEDeD}
377: "
378: fi
379: echo checking for echo program
380: if (PATH= echo test) 2>/dev/null | grep test >/dev/null 2>&1; then
381: DEFS="${DEFS}#define ECHO_PROGRAM `echo '"echo"'`
382: "
383: SEDDEFS="${SEDDEFS}\${SEDdA}ECHO_PROGRAM\${SEDdB}ECHO_PROGRAM\${SEDdC}`echo '"echo"'`\${SEDdD}
384: \${SEDuA}ECHO_PROGRAM\${SEDuB}ECHO_PROGRAM\${SEDuC}`echo '"echo"'`\${SEDuD}
385: \${SEDeA}ECHO_PROGRAM\${SEDeB}ECHO_PROGRAM\${SEDeC}`echo '"echo"'`\${SEDeD}
386: "
387: elif test -s /bin/echo; then
388: DEFS="${DEFS}#define ECHO_PROGRAM `echo '"/bin/echo"'`
389: "
390: SEDDEFS="${SEDDEFS}\${SEDdA}ECHO_PROGRAM\${SEDdB}ECHO_PROGRAM\${SEDdC}`echo '"/bin/echo"'`\${SEDdD}
391: \${SEDuA}ECHO_PROGRAM\${SEDuB}ECHO_PROGRAM\${SEDuC}`echo '"/bin/echo"'`\${SEDuD}
392: \${SEDeA}ECHO_PROGRAM\${SEDeB}ECHO_PROGRAM\${SEDeC}`echo '"/bin/echo"'`\${SEDeD}
393: "
394: fi
395: echo checking for ln -s
396: rm -f conftestdata
397: if ln -s X conftestdata 2>/dev/null
398: then
399: rm -f conftestdata
400: LN_S="ln -s"
401: else
402: LN_S=ln
403: fi
404:
405:
406: for hdr in stddef.h string.h strings.h unistd.h stdlib.h limits.h
407: do
408: trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
409: echo checking for ${hdr}
410: cat > conftest.c <<EOF
411: $DEFS
412: #include <${hdr}>
413: EOF
414: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
415: if test -z "$err"; then
416: DEFS="${DEFS}#define ${trhdr} 1
417: "
418: SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD}
419: \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD}
420: \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD}
421: "
422: fi
423: rm -f conftest*
424: done
425:
426: for hdr in time.h sys/wait.h sys/ioctl.h dirent.h memory.h sys/param.h
427: do
428: trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
429: echo checking for ${hdr}
430: cat > conftest.c <<EOF
431: $DEFS
432: #include <${hdr}>
433: EOF
434: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
435: if test -z "$err"; then
436: DEFS="${DEFS}#define ${trhdr} 1
437: "
438: SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD}
439: \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD}
440: \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD}
441: "
442: fi
443: rm -f conftest*
444: done
445:
446: for hdr in utime.h fcntl.h sys/file.h sys/times.h libc.h sysexits.h
447: do
448: trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
449: echo checking for ${hdr}
450: cat > conftest.c <<EOF
451: $DEFS
452: #include <${hdr}>
453: EOF
454: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
455: if test -z "$err"; then
456: DEFS="${DEFS}#define ${trhdr} 1
457: "
458: SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD}
459: \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD}
460: \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD}
461: "
462: fi
463: rm -f conftest*
464: done
465:
466: for hdr in poll.h tiuser.h xti.h sys/tli.h stropts.h ftw.h glob.h
467: do
468: trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
469: echo checking for ${hdr}
470: cat > conftest.c <<EOF
471: $DEFS
472: #include <${hdr}>
473: EOF
474: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
475: if test -z "$err"; then
476: DEFS="${DEFS}#define ${trhdr} 1
477: "
478: SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD}
479: \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD}
480: \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD}
481: "
482: fi
483: rm -f conftest*
484: done
485:
486: for hdr in sys/types.tcp.h
487: do
488: trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
489: echo checking for ${hdr}
490: cat > conftest.c <<EOF
491: $DEFS
492: #include <${hdr}>
493: EOF
494: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
495: if test -z "$err"; then
496: DEFS="${DEFS}#define ${trhdr} 1
497: "
498: SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD}
499: \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD}
500: \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD}
501: "
502: fi
503: rm -f conftest*
504: done
505:
506: echo checking for sys/select.h
507: cat > conftest.c <<EOF
508: #include <sys/select.h>
509: #include <sys/time.h>
510: main() { exit(0); }
511: t() { int i; }
512: EOF
513: if eval $compile; then
514: DEFS="${DEFS}#define HAVE_SYS_SELECT_H 1
515: "
516: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_SYS_SELECT_H\${SEDdB}HAVE_SYS_SELECT_H\${SEDdC}1\${SEDdD}
517: \${SEDuA}HAVE_SYS_SELECT_H\${SEDuB}HAVE_SYS_SELECT_H\${SEDuC}1\${SEDuD}
518: \${SEDeA}HAVE_SYS_SELECT_H\${SEDeB}HAVE_SYS_SELECT_H\${SEDeC}1\${SEDeD}
519: "
520: fi
521: rm -f conftest*
522:
523: echo checking for major, minor and makedev header
524: cat > conftest.c <<EOF
525: #include <sys/types.h>
526: main() { exit(0); }
527: t() { return makedev(0, 0); }
528: EOF
529: if eval $compile; then
530: makedev=1
531: fi
532: rm -f conftest*
533:
534: if test -z "$makedev"; then
535: echo checking for sys/mkdev.h
536: cat > conftest.c <<EOF
537: $DEFS
538: #include <sys/mkdev.h>
539: EOF
540: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
541: if test -z "$err"; then
542: DEFS="${DEFS}#define MAJOR_IN_MKDEV 1
543: "
544: SEDDEFS="${SEDDEFS}\${SEDdA}MAJOR_IN_MKDEV\${SEDdB}MAJOR_IN_MKDEV\${SEDdC}1\${SEDdD}
545: \${SEDuA}MAJOR_IN_MKDEV\${SEDuB}MAJOR_IN_MKDEV\${SEDuC}1\${SEDuD}
546: \${SEDeA}MAJOR_IN_MKDEV\${SEDeB}MAJOR_IN_MKDEV\${SEDeC}1\${SEDeD}
547: " makedev=1
548: fi
549: rm -f conftest*
550:
551: fi
552: if test -z "$makedev"; then
553: echo checking for sys/sysmacros.h
554: cat > conftest.c <<EOF
555: $DEFS
556: #include <sys/sysmacros.h>
557: EOF
558: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
559: if test -z "$err"; then
560: DEFS="${DEFS}#define MAJOR_IN_SYSMACROS 1
561: "
562: SEDDEFS="${SEDDEFS}\${SEDdA}MAJOR_IN_SYSMACROS\${SEDdB}MAJOR_IN_SYSMACROS\${SEDdC}1\${SEDdD}
563: \${SEDuA}MAJOR_IN_SYSMACROS\${SEDuB}MAJOR_IN_SYSMACROS\${SEDuC}1\${SEDuD}
564: \${SEDeA}MAJOR_IN_SYSMACROS\${SEDeB}MAJOR_IN_SYSMACROS\${SEDeC}1\${SEDeD}
565: "
566: fi
567: rm -f conftest*
568:
569: fi
570:
571: echo checking for return type of signal handlers
572: cat > conftest.c <<EOF
573: #include <sys/types.h>
574: #include <signal.h>
575: #ifdef signal
576: #undef signal
577: #endif
578: extern void (*signal ()) ();
579: main() { exit(0); }
580: t() { int i; }
581: EOF
582: if eval $compile; then
583: DEFS="${DEFS}#define RETSIGTYPE void
584: "
585: SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}void\${SEDdD}
586: \${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}void\${SEDuD}
587: \${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}void\${SEDeD}
588: "
589: else
590: DEFS="${DEFS}#define RETSIGTYPE int
591: "
592: SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}int\${SEDdD}
593: \${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}int\${SEDuD}
594: \${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}int\${SEDeD}
595: "
596: fi
597: rm -f conftest*
598:
599:
600: echo checking for time.h and sys/time.h being included together
601: cat > conftest.c <<EOF
602: #include <sys/time.h>
603: #include <time.h>
604: main() { exit(0); }
605: t() { int i; }
606: EOF
607: if eval $compile; then
608: DEFS="${DEFS}#define HAVE_SYS_TIME_AND_TIME_H 1
609: "
610: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_SYS_TIME_AND_TIME_H\${SEDdB}HAVE_SYS_TIME_AND_TIME_H\${SEDdC}1\${SEDdD}
611: \${SEDuA}HAVE_SYS_TIME_AND_TIME_H\${SEDuB}HAVE_SYS_TIME_AND_TIME_H\${SEDuC}1\${SEDuD}
612: \${SEDeA}HAVE_SYS_TIME_AND_TIME_H\${SEDeB}HAVE_SYS_TIME_AND_TIME_H\${SEDeC}1\${SEDeD}
613: "
614: fi
615: rm -f conftest*
616:
617: echo checking for termios.h and sys/ioctl.h being included together
618: cat > conftest.c <<EOF
619: #include <termios.h>
620: #include <sys/ioctl.h>
621: main() { exit(0); }
622: t() { int i; }
623: EOF
624: if eval $compile; then
625: DEFS="${DEFS}#define HAVE_TERMIOS_AND_SYS_IOCTL_H 1
626: "
627: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_TERMIOS_AND_SYS_IOCTL_H\${SEDdB}HAVE_TERMIOS_AND_SYS_IOCTL_H\${SEDdC}1\${SEDdD}
628: \${SEDuA}HAVE_TERMIOS_AND_SYS_IOCTL_H\${SEDuB}HAVE_TERMIOS_AND_SYS_IOCTL_H\${SEDuC}1\${SEDuD}
629: \${SEDeA}HAVE_TERMIOS_AND_SYS_IOCTL_H\${SEDeB}HAVE_TERMIOS_AND_SYS_IOCTL_H\${SEDeC}1\${SEDeD}
630: "
631: fi
632: rm -f conftest*
633:
634: echo checking for CBREAK
635: cat > conftest.c <<EOF
636: #include <sgtty.h>
637: main() { exit(0); }
638: t() { int i = CBREAK; }
639: EOF
640: if eval $compile; then
641: DEFS="${DEFS}#define HAVE_CBREAK 1
642: "
643: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_CBREAK\${SEDdB}HAVE_CBREAK\${SEDdC}1\${SEDdD}
644: \${SEDuA}HAVE_CBREAK\${SEDuB}HAVE_CBREAK\${SEDuC}1\${SEDuD}
645: \${SEDeA}HAVE_CBREAK\${SEDeB}HAVE_CBREAK\${SEDeC}1\${SEDeD}
646: "
647: fi
648: rm -f conftest*
649:
650: echo checking for pid_t in sys/types.h
651: cat > conftest.c <<EOF
652: #include <sys/types.h>
653: main() { exit(0); }
654: t() { pid_t x; }
655: EOF
656: if eval $compile; then
657: :
658: else
659: DEFS="${DEFS}#define PID_T int
660: "
661: SEDDEFS="${SEDDEFS}\${SEDdA}PID_T\${SEDdB}PID_T\${SEDdC}int\${SEDdD}
662: \${SEDuA}PID_T\${SEDuB}PID_T\${SEDuC}int\${SEDuD}
663: \${SEDeA}PID_T\${SEDeB}PID_T\${SEDeC}int\${SEDeD}
664: "
665: fi
666: rm -f conftest*
667:
668: echo checking for uid_t in sys/types.h
669: cat > conftest.c <<EOF
670: #include <sys/types.h>
671: main() { exit(0); }
672: t() { uid_t x; }
673: EOF
674: if eval $compile; then
675: :
676: else
677: DEFS="${DEFS}#define UID_T int
678: "
679: SEDDEFS="${SEDDEFS}\${SEDdA}UID_T\${SEDdB}UID_T\${SEDdC}int\${SEDdD}
680: \${SEDuA}UID_T\${SEDuB}UID_T\${SEDuC}int\${SEDuD}
681: \${SEDeA}UID_T\${SEDeB}UID_T\${SEDeC}int\${SEDeD}
682: "
683: fi
684: rm -f conftest*
685:
686: echo checking for gid_t in sys/types.h
687: cat > conftest.c <<EOF
688: #include <sys/types.h>
689: main() { exit(0); }
690: t() { gid_t x; }
691: EOF
692: if eval $compile; then
693: :
694: else
695: DEFS="${DEFS}#define GID_T int
696: "
697: SEDDEFS="${SEDDEFS}\${SEDdA}GID_T\${SEDdB}GID_T\${SEDdC}int\${SEDdD}
698: \${SEDuA}GID_T\${SEDuB}GID_T\${SEDuC}int\${SEDuD}
699: \${SEDeA}GID_T\${SEDeB}GID_T\${SEDeC}int\${SEDeD}
700: "
701: fi
702: rm -f conftest*
703:
704: echo checking for off_t in sys/types.h
705: cat > conftest.c <<EOF
706: #include <sys/types.h>
707: main() { exit(0); }
708: t() { off_t x; }
709: EOF
710: if eval $compile; then
711: :
712: else
713: DEFS="${DEFS}#define OFF_T long
714: "
715: SEDDEFS="${SEDDEFS}\${SEDdA}OFF_T\${SEDdB}OFF_T\${SEDdC}long\${SEDdD}
716: \${SEDuA}OFF_T\${SEDuB}OFF_T\${SEDuC}long\${SEDuD}
717: \${SEDeA}OFF_T\${SEDeB}OFF_T\${SEDeC}long\${SEDeD}
718: "
719: fi
720: rm -f conftest*
721:
722: echo checking for sig_atomic_t in signal.h
723: cat > conftest.c <<EOF
724: #include <signal.h>
725: main() { exit(0); }
726: t() { sig_atomic_t x; }
727: EOF
728: if eval $compile; then
729: DEFS="${DEFS}#define HAVE_SIG_ATOMIC_T_IN_SIGNAL_H 1
730: "
731: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_SIG_ATOMIC_T_IN_SIGNAL_H\${SEDdB}HAVE_SIG_ATOMIC_T_IN_SIGNAL_H\${SEDdC}1\${SEDdD}
732: \${SEDuA}HAVE_SIG_ATOMIC_T_IN_SIGNAL_H\${SEDuB}HAVE_SIG_ATOMIC_T_IN_SIGNAL_H\${SEDuC}1\${SEDuD}
733: \${SEDeA}HAVE_SIG_ATOMIC_T_IN_SIGNAL_H\${SEDeB}HAVE_SIG_ATOMIC_T_IN_SIGNAL_H\${SEDeC}1\${SEDeD}
734: "
735: fi
736: rm -f conftest*
737:
738: echo checking for sig_atomic_t in sys/types.h
739: cat > conftest.c <<EOF
740: #include <sys/types.h>
741: main() { exit(0); }
742: t() { sig_atomic_t x; }
743: EOF
744: if eval $compile; then
745: DEFS="${DEFS}#define HAVE_SIG_ATOMIC_T_IN_TYPES_H 1
746: "
747: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_SIG_ATOMIC_T_IN_TYPES_H\${SEDdB}HAVE_SIG_ATOMIC_T_IN_TYPES_H\${SEDdC}1\${SEDdD}
748: \${SEDuA}HAVE_SIG_ATOMIC_T_IN_TYPES_H\${SEDuB}HAVE_SIG_ATOMIC_T_IN_TYPES_H\${SEDuC}1\${SEDuD}
749: \${SEDeA}HAVE_SIG_ATOMIC_T_IN_TYPES_H\${SEDeB}HAVE_SIG_ATOMIC_T_IN_TYPES_H\${SEDeC}1\${SEDeD}
750: "
751: fi
752: rm -f conftest*
753:
754: case $DEFS in
755: *HAVE_STDDEF_H*)
756: echo checking for size_t in stddef.h
757: cat > conftest.c <<EOF
758: #include <stddef.h>
759: main() { exit(0); }
760: t() { size_t x; }
761: EOF
762: if eval $compile; then
763: DEFS="${DEFS}#define HAVE_SIZE_T_IN_STDDEF_H 1
764: "
765: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_SIZE_T_IN_STDDEF_H\${SEDdB}HAVE_SIZE_T_IN_STDDEF_H\${SEDdC}1\${SEDdD}
766: \${SEDuA}HAVE_SIZE_T_IN_STDDEF_H\${SEDuB}HAVE_SIZE_T_IN_STDDEF_H\${SEDuC}1\${SEDuD}
767: \${SEDeA}HAVE_SIZE_T_IN_STDDEF_H\${SEDeB}HAVE_SIZE_T_IN_STDDEF_H\${SEDeC}1\${SEDeD}
768: "
769: fi
770: rm -f conftest*
771: ;;
772: esac
773: echo checking for size_t in sys/types.h
774: cat > conftest.c <<EOF
775: #include <sys/types.h>
776: main() { exit(0); }
777: t() { size_t x; }
778: EOF
779: if eval $compile; then
780: DEFS="${DEFS}#define HAVE_SIZE_T_IN_TYPES_H 1
781: "
782: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_SIZE_T_IN_TYPES_H\${SEDdB}HAVE_SIZE_T_IN_TYPES_H\${SEDdC}1\${SEDdD}
783: \${SEDuA}HAVE_SIZE_T_IN_TYPES_H\${SEDuB}HAVE_SIZE_T_IN_TYPES_H\${SEDuC}1\${SEDuD}
784: \${SEDeA}HAVE_SIZE_T_IN_TYPES_H\${SEDeB}HAVE_SIZE_T_IN_TYPES_H\${SEDeC}1\${SEDeD}
785: "
786: fi
787: rm -f conftest*
788:
789: echo checking for time_t in time.h
790: cat > conftest.c <<EOF
791: #include <time.h>
792: main() { exit(0); }
793: t() { time_t i; }
794: EOF
795: if eval $compile; then
796: DEFS="${DEFS}#define HAVE_TIME_T_IN_TIME_H 1
797: "
798: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_TIME_T_IN_TIME_H\${SEDdB}HAVE_TIME_T_IN_TIME_H\${SEDdC}1\${SEDdD}
799: \${SEDuA}HAVE_TIME_T_IN_TIME_H\${SEDuB}HAVE_TIME_T_IN_TIME_H\${SEDuC}1\${SEDuD}
800: \${SEDeA}HAVE_TIME_T_IN_TIME_H\${SEDeB}HAVE_TIME_T_IN_TIME_H\${SEDeC}1\${SEDeD}
801: "
802: fi
803: rm -f conftest*
804:
805: echo checking for time_t in sys/types.h
806: cat > conftest.c <<EOF
807: #include <sys/types.h>
808: main() { exit(0); }
809: t() { time_t i; }
810: EOF
811: if eval $compile; then
812: DEFS="${DEFS}#define HAVE_TIME_T_IN_TYPES_H 1
813: "
814: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_TIME_T_IN_TYPES_H\${SEDdB}HAVE_TIME_T_IN_TYPES_H\${SEDdC}1\${SEDdD}
815: \${SEDuA}HAVE_TIME_T_IN_TYPES_H\${SEDuB}HAVE_TIME_T_IN_TYPES_H\${SEDuC}1\${SEDuD}
816: \${SEDeA}HAVE_TIME_T_IN_TYPES_H\${SEDeB}HAVE_TIME_T_IN_TYPES_H\${SEDeC}1\${SEDeD}
817: "
818: fi
819: rm -f conftest*
820:
821: echo checking how to get filesystem space usage
822: # SVR4
823: cat > conftest.c <<EOF
824: $DEFS
825: #include <sys/statvfs.h>
826: EOF
827: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
828: if test -z "$err"; then
829: DEFS="${DEFS}#define STAT_STATVFS 1
830: "
831: SEDDEFS="${SEDDEFS}\${SEDdA}STAT_STATVFS\${SEDdB}STAT_STATVFS\${SEDdC}1\${SEDdD}
832: \${SEDuA}STAT_STATVFS\${SEDuB}STAT_STATVFS\${SEDuC}1\${SEDuD}
833: \${SEDeA}STAT_STATVFS\${SEDeB}STAT_STATVFS\${SEDeC}1\${SEDeD}
834: " space=1
835: fi
836: rm -f conftest*
837: if test -z "$space"; then
838: # AIX
839: echo "${DEFS}#include <sys/statfs.h>" > conftest.c
840: eval "$CPP conftest.c > conftest.out 2>&1"
841: if egrep "f_nlsdirtype" conftest.out >/dev/null 2>&1; then
842: DEFS="${DEFS}#define STAT_STATFS2_BSIZE 1
843: "
844: SEDDEFS="${SEDDEFS}\${SEDdA}STAT_STATFS2_BSIZE\${SEDdB}STAT_STATFS2_BSIZE\${SEDdC}1\${SEDdD}
845: \${SEDuA}STAT_STATFS2_BSIZE\${SEDuB}STAT_STATFS2_BSIZE\${SEDuC}1\${SEDuD}
846: \${SEDeA}STAT_STATFS2_BSIZE\${SEDeB}STAT_STATFS2_BSIZE\${SEDeC}1\${SEDeD}
847: " space=1
848: fi
849: rm -f conftest*
850:
851: fi
852: if test -z "$space"; then
853: # SVR3
854: cat > conftest.c <<EOF
855: $DEFS
856: #include <sys/statfs.h>
857: EOF
858: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
859: if test -z "$err"; then
860: DEFS="${DEFS}#define STAT_STATFS4 1
861: "
862: SEDDEFS="${SEDDEFS}\${SEDdA}STAT_STATFS4\${SEDdB}STAT_STATFS4\${SEDdC}1\${SEDdD}
863: \${SEDuA}STAT_STATFS4\${SEDuB}STAT_STATFS4\${SEDuC}1\${SEDuD}
864: \${SEDeA}STAT_STATFS4\${SEDeB}STAT_STATFS4\${SEDeC}1\${SEDeD}
865: " space=1
866: fi
867: rm -f conftest*
868: fi
869: if test -z "$space"; then
870: # 4.3BSD
871: cat > conftest.c <<EOF
872: $DEFS
873: #include <sys/vfs.h>
874: EOF
875: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
876: if test -z "$err"; then
877: DEFS="${DEFS}#define STAT_STATFS2_BSIZE 1
878: "
879: SEDDEFS="${SEDDEFS}\${SEDdA}STAT_STATFS2_BSIZE\${SEDdB}STAT_STATFS2_BSIZE\${SEDdC}1\${SEDdD}
880: \${SEDuA}STAT_STATFS2_BSIZE\${SEDuB}STAT_STATFS2_BSIZE\${SEDuC}1\${SEDuD}
881: \${SEDeA}STAT_STATFS2_BSIZE\${SEDeB}STAT_STATFS2_BSIZE\${SEDeC}1\${SEDeD}
882: " space=1
883: fi
884: rm -f conftest*
885: fi
886: if test -z "$space"; then
887: # 4.4BSD
888: echo "${DEFS}#include <sys/mount.h>" > conftest.c
889: eval "$CPP conftest.c > conftest.out 2>&1"
890: if egrep "MOUNT_UFS" conftest.out >/dev/null 2>&1; then
891: DEFS="${DEFS}#define STAT_STATFS2_FSIZE 1
892: "
893: SEDDEFS="${SEDDEFS}\${SEDdA}STAT_STATFS2_FSIZE\${SEDdB}STAT_STATFS2_FSIZE\${SEDdC}1\${SEDdD}
894: \${SEDuA}STAT_STATFS2_FSIZE\${SEDuB}STAT_STATFS2_FSIZE\${SEDuC}1\${SEDuD}
895: \${SEDeA}STAT_STATFS2_FSIZE\${SEDeB}STAT_STATFS2_FSIZE\${SEDeC}1\${SEDeD}
896: " space=1
897: fi
898: rm -f conftest*
899:
900: fi
901: if test -z "$space"; then
902: # Ultrix
903: cat > conftest.c <<EOF
904: $DEFS
905: #include <sys/mount.h>
906: EOF
907: err=`eval "$CPP conftest.c 2>&1 >/dev/null"`
908: if test -z "$err"; then
909: DEFS="${DEFS}#define STAT_STATFS2_FS_DATA 1
910: "
911: SEDDEFS="${SEDDEFS}\${SEDdA}STAT_STATFS2_FS_DATA\${SEDdB}STAT_STATFS2_FS_DATA\${SEDdC}1\${SEDdD}
912: \${SEDuA}STAT_STATFS2_FS_DATA\${SEDuB}STAT_STATFS2_FS_DATA\${SEDuC}1\${SEDuD}
913: \${SEDeA}STAT_STATFS2_FS_DATA\${SEDeB}STAT_STATFS2_FS_DATA\${SEDeC}1\${SEDeD}
914: " space=1
915: fi
916: rm -f conftest*
917: fi
918: if test -z "$space"; then
919: echo checking for ustat
920: cat > conftest.c <<EOF
921: #include <stdio.h>
922: main() { exit(0); }
923: t() {
924: #ifdef __stub_ustat
925: choke me
926: #else
927: /* Override any gcc2 internal prototype to avoid an error. */
928: extern char ustat(); ustat();
929: #endif
930: }
931: EOF
932: if eval $compile; then
933: DEFS="${DEFS}#define STAT_USTAT 1
934: "
935: SEDDEFS="${SEDDEFS}\${SEDdA}STAT_USTAT\${SEDdB}STAT_USTAT\${SEDdC}1\${SEDdD}
936: \${SEDuA}STAT_USTAT\${SEDuB}STAT_USTAT\${SEDuC}1\${SEDuD}
937: \${SEDeA}STAT_USTAT\${SEDeB}STAT_USTAT\${SEDeC}1\${SEDeD}
938: "
939: fi
940: rm -f conftest*
941: #endif
942:
943: fi
944: echo checking for void
945: cat > conftest.c <<EOF
946:
947: main() { exit(0); }
948: t() { extern void foo (); (void) exit (0); }
949: EOF
950: if eval $compile; then
951: DEFS="${DEFS}#define HAVE_VOID 1
952: "
953: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_VOID\${SEDdB}HAVE_VOID\${SEDdC}1\${SEDdD}
954: \${SEDuA}HAVE_VOID\${SEDuB}HAVE_VOID\${SEDuC}1\${SEDuD}
955: \${SEDeA}HAVE_VOID\${SEDeB}HAVE_VOID\${SEDeC}1\${SEDeD}
956: "
957: fi
958: rm -f conftest*
959:
960: echo checking for unsigned char
961: cat > conftest.c <<EOF
962:
963: main() { exit(0); }
964: t() { unsigned char i = (unsigned char) -1; }
965: EOF
966: if eval $compile; then
967: DEFS="${DEFS}#define HAVE_UNSIGNED_CHAR 1
968: "
969: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_UNSIGNED_CHAR\${SEDdB}HAVE_UNSIGNED_CHAR\${SEDdC}1\${SEDdD}
970: \${SEDuA}HAVE_UNSIGNED_CHAR\${SEDuB}HAVE_UNSIGNED_CHAR\${SEDuC}1\${SEDuD}
971: \${SEDeA}HAVE_UNSIGNED_CHAR\${SEDeB}HAVE_UNSIGNED_CHAR\${SEDeC}1\${SEDeD}
972: "
973: fi
974: rm -f conftest*
975:
976: echo checking for errno
977: cat > conftest.c <<EOF
978: #include <errno.h>
979: main() { exit(0); }
980: t() { int i = errno; errno = 1; }
981: EOF
982: if eval $compile; then
983: DEFS="${DEFS}#define HAVE_ERRNO_DECLARATION 1
984: "
985: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_ERRNO_DECLARATION\${SEDdB}HAVE_ERRNO_DECLARATION\${SEDdC}1\${SEDdD}
986: \${SEDuA}HAVE_ERRNO_DECLARATION\${SEDuB}HAVE_ERRNO_DECLARATION\${SEDuC}1\${SEDuD}
987: \${SEDeA}HAVE_ERRNO_DECLARATION\${SEDeB}HAVE_ERRNO_DECLARATION\${SEDeC}1\${SEDeD}
988: "
989: fi
990: rm -f conftest*
991:
992:
993: for func in memset memcmp memchr memcpy bcopy bcmp bzero
994: do
995: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
996: echo checking for ${func}
997: cat > conftest.c <<EOF
998: #include <stdio.h>
999: main() { exit(0); }
1000: t() {
1001: #ifdef __stub_${func}
1002: choke me
1003: #else
1004: /* Override any gcc2 internal prototype to avoid an error. */
1005: extern char ${func}(); ${func}();
1006: #endif
1007: }
1008: EOF
1009: if eval $compile; then
1010: DEFS="${DEFS}#define ${trfunc} 1
1011: "
1012: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1013: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1014: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1015: "
1016: fi
1017: rm -f conftest*
1018: #endif
1019: done
1020:
1021: for func in strchr strrchr index rindex strerror strtol strstr
1022: do
1023: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1024: echo checking for ${func}
1025: cat > conftest.c <<EOF
1026: #include <stdio.h>
1027: main() { exit(0); }
1028: t() {
1029: #ifdef __stub_${func}
1030: choke me
1031: #else
1032: /* Override any gcc2 internal prototype to avoid an error. */
1033: extern char ${func}(); ${func}();
1034: #endif
1035: }
1036: EOF
1037: if eval $compile; then
1038: DEFS="${DEFS}#define ${trfunc} 1
1039: "
1040: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1041: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1042: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1043: "
1044: fi
1045: rm -f conftest*
1046: #endif
1047: done
1048:
1049: for func in strdup strcasecmp strncasecmp stricmp strnicmp
1050: do
1051: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1052: echo checking for ${func}
1053: cat > conftest.c <<EOF
1054: #include <stdio.h>
1055: main() { exit(0); }
1056: t() {
1057: #ifdef __stub_${func}
1058: choke me
1059: #else
1060: /* Override any gcc2 internal prototype to avoid an error. */
1061: extern char ${func}(); ${func}();
1062: #endif
1063: }
1064: EOF
1065: if eval $compile; then
1066: DEFS="${DEFS}#define ${trfunc} 1
1067: "
1068: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1069: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1070: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1071: "
1072: fi
1073: rm -f conftest*
1074: #endif
1075: done
1076:
1077: for func in bsearch vfprintf
1078: do
1079: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1080: echo checking for ${func}
1081: cat > conftest.c <<EOF
1082: #include <stdio.h>
1083: main() { exit(0); }
1084: t() {
1085: #ifdef __stub_${func}
1086: choke me
1087: #else
1088: /* Override any gcc2 internal prototype to avoid an error. */
1089: extern char ${func}(); ${func}();
1090: #endif
1091: }
1092: EOF
1093: if eval $compile; then
1094: DEFS="${DEFS}#define ${trfunc} 1
1095: "
1096: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1097: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1098: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1099: "
1100: fi
1101: rm -f conftest*
1102: #endif
1103: done
1104:
1105: for func in remove ftruncate ltrunc rename opendir dup2 waitpid wait4
1106: do
1107: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1108: echo checking for ${func}
1109: cat > conftest.c <<EOF
1110: #include <stdio.h>
1111: main() { exit(0); }
1112: t() {
1113: #ifdef __stub_${func}
1114: choke me
1115: #else
1116: /* Override any gcc2 internal prototype to avoid an error. */
1117: extern char ${func}(); ${func}();
1118: #endif
1119: }
1120: EOF
1121: if eval $compile; then
1122: DEFS="${DEFS}#define ${trfunc} 1
1123: "
1124: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1125: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1126: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1127: "
1128: fi
1129: rm -f conftest*
1130: #endif
1131: done
1132:
1133: for func in sigsetjmp setret sigaction sigvec sigset
1134: do
1135: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1136: echo checking for ${func}
1137: cat > conftest.c <<EOF
1138: #include <stdio.h>
1139: main() { exit(0); }
1140: t() {
1141: #ifdef __stub_${func}
1142: choke me
1143: #else
1144: /* Override any gcc2 internal prototype to avoid an error. */
1145: extern char ${func}(); ${func}();
1146: #endif
1147: }
1148: EOF
1149: if eval $compile; then
1150: DEFS="${DEFS}#define ${trfunc} 1
1151: "
1152: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1153: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1154: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1155: "
1156: fi
1157: rm -f conftest*
1158: #endif
1159: done
1160:
1161: for func in sigprocmask sigblock sighold getdtablesize sysconf
1162: do
1163: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1164: echo checking for ${func}
1165: cat > conftest.c <<EOF
1166: #include <stdio.h>
1167: main() { exit(0); }
1168: t() {
1169: #ifdef __stub_${func}
1170: choke me
1171: #else
1172: /* Override any gcc2 internal prototype to avoid an error. */
1173: extern char ${func}(); ${func}();
1174: #endif
1175: }
1176: EOF
1177: if eval $compile; then
1178: DEFS="${DEFS}#define ${trfunc} 1
1179: "
1180: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1181: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1182: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1183: "
1184: fi
1185: rm -f conftest*
1186: #endif
1187: done
1188:
1189: for func in setpgrp setsid setreuid gethostname uname
1190: do
1191: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1192: echo checking for ${func}
1193: cat > conftest.c <<EOF
1194: #include <stdio.h>
1195: main() { exit(0); }
1196: t() {
1197: #ifdef __stub_${func}
1198: choke me
1199: #else
1200: /* Override any gcc2 internal prototype to avoid an error. */
1201: extern char ${func}(); ${func}();
1202: #endif
1203: }
1204: EOF
1205: if eval $compile; then
1206: DEFS="${DEFS}#define ${trfunc} 1
1207: "
1208: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1209: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1210: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1211: "
1212: fi
1213: rm -f conftest*
1214: #endif
1215: done
1216:
1217: for func in gettimeofday ftw glob
1218: do
1219: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1220: echo checking for ${func}
1221: cat > conftest.c <<EOF
1222: #include <stdio.h>
1223: main() { exit(0); }
1224: t() {
1225: #ifdef __stub_${func}
1226: choke me
1227: #else
1228: /* Override any gcc2 internal prototype to avoid an error. */
1229: extern char ${func}(); ${func}();
1230: #endif
1231: }
1232: EOF
1233: if eval $compile; then
1234: DEFS="${DEFS}#define ${trfunc} 1
1235: "
1236: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1237: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1238: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1239: "
1240: fi
1241: rm -f conftest*
1242: #endif
1243: done
1244:
1245: SAVELIBS="$LIBS"
1246: LIBS=`echo $LIBS | sed 's/-linet//'`
1247: for func in getline
1248: do
1249: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1250: echo checking for ${func}
1251: cat > conftest.c <<EOF
1252: #include <stdio.h>
1253: main() { exit(0); }
1254: t() {
1255: #ifdef __stub_${func}
1256: choke me
1257: #else
1258: /* Override any gcc2 internal prototype to avoid an error. */
1259: extern char ${func}(); ${func}();
1260: #endif
1261: }
1262: EOF
1263: if eval $compile; then
1264: DEFS="${DEFS}#define ${trfunc} 1
1265: "
1266: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1267: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1268: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1269: "
1270: fi
1271: rm -f conftest*
1272: #endif
1273: done
1274:
1275: LIBS="$SAVELIBS"
1276: echo checking for ftime
1277: cat > conftest.c <<EOF
1278: #include <stdio.h>
1279: main() { exit(0); }
1280: t() {
1281: #ifdef __stub_ftime
1282: choke me
1283: #else
1284: /* Override any gcc2 internal prototype to avoid an error. */
1285: extern char ftime(); ftime();
1286: #endif
1287: }
1288: EOF
1289: if eval $compile; then
1290: if test -n "$cross_compiling"
1291: then
1292: DEFS="${DEFS}#define HAVE_FTIME 1
1293: "
1294: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_FTIME\${SEDdB}HAVE_FTIME\${SEDdC}1\${SEDdD}
1295: \${SEDuA}HAVE_FTIME\${SEDuB}HAVE_FTIME\${SEDuC}1\${SEDuD}
1296: \${SEDeA}HAVE_FTIME\${SEDeB}HAVE_FTIME\${SEDeC}1\${SEDeD}
1297: "
1298: else
1299: cat > conftest.c <<EOF
1300:
1301: #include <sys/types.h>
1302: #include <sys/timeb.h>
1303: main ()
1304: {
1305: struct timeb s, slast;
1306: int c = 0;
1307: ftime (&slast);
1308: while (c < 10)
1309: {
1310: ftime (&s);
1311: if (s.time < slast.time
1312: || (s.time == slast.time && s.millitm < slast.millitm))
1313: exit (1);
1314: if (s.time != slast.time)
1315: ++c;
1316: slast.time = s.time;
1317: slast.millitm = s.millitm;
1318: }
1319: exit (0);
1320: }
1321:
1322: EOF
1323: eval $compile
1324: if test -s conftest && (./conftest; exit) 2>/dev/null; then
1325: DEFS="${DEFS}#define HAVE_FTIME 1
1326: "
1327: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_FTIME\${SEDdB}HAVE_FTIME\${SEDdC}1\${SEDdD}
1328: \${SEDuA}HAVE_FTIME\${SEDuB}HAVE_FTIME\${SEDuC}1\${SEDuD}
1329: \${SEDeA}HAVE_FTIME\${SEDeB}HAVE_FTIME\${SEDeC}1\${SEDeD}
1330: "
1331: else
1332: echo 1>&2 "Your ftime seems to be buggy"
1333: fi
1334: fi
1335: rm -f conftest*
1336: fi
1337: rm -f conftest*
1338: #endif
1339:
1340: for func in times
1341: do
1342: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1343: echo checking for ${func}
1344: cat > conftest.c <<EOF
1345: #include <stdio.h>
1346: main() { exit(0); }
1347: t() {
1348: #ifdef __stub_${func}
1349: choke me
1350: #else
1351: /* Override any gcc2 internal prototype to avoid an error. */
1352: extern char ${func}(); ${func}();
1353: #endif
1354: }
1355: EOF
1356: if eval $compile; then
1357: DEFS="${DEFS}#define ${trfunc} 1
1358: "
1359: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1360: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1361: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1362: "
1363: fi
1364: rm -f conftest*
1365: #endif
1366: done
1367:
1368: for func in napms nap usleep poll select
1369: do
1370: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1371: echo checking for ${func}
1372: cat > conftest.c <<EOF
1373: #include <stdio.h>
1374: main() { exit(0); }
1375: t() {
1376: #ifdef __stub_${func}
1377: choke me
1378: #else
1379: /* Override any gcc2 internal prototype to avoid an error. */
1380: extern char ${func}(); ${func}();
1381: #endif
1382: }
1383: EOF
1384: if eval $compile; then
1385: DEFS="${DEFS}#define ${trfunc} 1
1386: "
1387: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1388: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1389: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1390: "
1391: fi
1392: rm -f conftest*
1393: #endif
1394: done
1395:
1396: case $DEFS in
1397: *HAVE_NAPMS*) ;;
1398: *HAVE_NAP*) ;;
1399: *HAVE_USLEEP*) ;;
1400: *HAVE_POLL*) ;;
1401: *HAVE_SELECT*) ;;
1402: *) echo 1>&2 'WARNING: No way to sleep for less than one second'
1403: echo 1>&2 ' \p in chat scripts will sleep for a full second'
1404: ;;
1405: esac
1406: for func in getgrent
1407: do
1408: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1409: echo checking for ${func}
1410: cat > conftest.c <<EOF
1411: #include <stdio.h>
1412: main() { exit(0); }
1413: t() {
1414: #ifdef __stub_${func}
1415: choke me
1416: #else
1417: /* Override any gcc2 internal prototype to avoid an error. */
1418: extern char ${func}(); ${func}();
1419: #endif
1420: }
1421: EOF
1422: if eval $compile; then
1423: DEFS="${DEFS}#define ${trfunc} 1
1424: "
1425: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1426: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1427: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1428: "
1429: fi
1430: rm -f conftest*
1431: #endif
1432: done
1433:
1434: trfrom='[a-z]' trto='[A-Z]'
1435: for i in socket t_open; do
1436: def=HAVE_`echo $i|tr "$trfrom" "$trto"`
1437: echo checking for $i
1438: cat > conftest.c <<EOF
1439: #include <stdio.h>
1440: main() { exit(0); }
1441: t() {
1442: #ifdef __stub_$i
1443: choke me
1444: #else
1445: /* Override any gcc2 internal prototype to avoid an error. */
1446: extern char $i(); $i();
1447: #endif
1448: }
1449: EOF
1450: if eval $compile; then
1451: DEFS="${DEFS}#define $def 1
1452: "
1453: SEDDEFS="${SEDDEFS}\${SEDdA}$def\${SEDdB}$def\${SEDdC}1\${SEDdD}
1454: \${SEDuA}$def\${SEDuB}$def\${SEDuC}1\${SEDuD}
1455: \${SEDeA}$def\${SEDeB}$def\${SEDeC}1\${SEDeD}
1456: "
1457: else
1458: missing=1
1459: fi
1460: rm -f conftest*
1461: #endif
1462: for lib in "-lsocket" "-lsocket -lnsl" "-lnsl" "-lxti"; do
1463: if test -n "$missing"; then
1464: case $LIBS in
1465: *${lib}*) ;;
1466: *)
1467: SAVELIBS="$LIBS"
1468: LIBS="$LIBS $lib"
1469: missing=
1470: echo checking for $i with $lib
1471: cat > conftest.c <<EOF
1472:
1473: main() { exit(0); }
1474: t() { extern char $i(); $i(); }
1475: EOF
1476: if eval $compile; then
1477: DEFS="${DEFS}#define $def 1
1478: "
1479: SEDDEFS="${SEDDEFS}\${SEDdA}$def\${SEDdB}$def\${SEDdC}1\${SEDdD}
1480: \${SEDuA}$def\${SEDuB}$def\${SEDuC}1\${SEDuD}
1481: \${SEDeA}$def\${SEDeB}$def\${SEDeC}1\${SEDeD}
1482: "
1483: else
1484: missing=1; LIBS="$SAVELIBS"
1485: fi
1486: rm -f conftest*
1487: ;;
1488: esac
1489: fi
1490: done
1491: done
1492: for func in getcwd getwd
1493: do
1494: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1495: echo checking for ${func}
1496: cat > conftest.c <<EOF
1497: #include <stdio.h>
1498: main() { exit(0); }
1499: t() {
1500: #ifdef __stub_${func}
1501: choke me
1502: #else
1503: /* Override any gcc2 internal prototype to avoid an error. */
1504: extern char ${func}(); ${func}();
1505: #endif
1506: }
1507: EOF
1508: if eval $compile; then
1509: DEFS="${DEFS}#define ${trfunc} 1
1510: "
1511: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1512: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1513: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1514: "
1515: fi
1516: rm -f conftest*
1517: #endif
1518: done
1519:
1520: case $DEFS in
1521: *HAVE_GETCWD*) ;;
1522: *HAVE_GETCD*) ;;
1523: *) UNIXOBJS="$UNIXOBJS getcwd.o"
1524: if test -s /bin/pwd; then
1525: DEFS="${DEFS}#define PWD_PROGRAM `echo '"/bin/pwd"'`
1526: "
1527: SEDDEFS="${SEDDEFS}\${SEDdA}PWD_PROGRAM\${SEDdB}PWD_PROGRAM\${SEDdC}`echo '"/bin/pwd"'`\${SEDdD}
1528: \${SEDuA}PWD_PROGRAM\${SEDuB}PWD_PROGRAM\${SEDuC}`echo '"/bin/pwd"'`\${SEDuD}
1529: \${SEDeA}PWD_PROGRAM\${SEDeB}PWD_PROGRAM\${SEDeC}`echo '"/bin/pwd"'`\${SEDeD}
1530: "
1531: fi ;;
1532: esac
1533: for func in mkdir
1534: do
1535: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1536: echo checking for ${func}
1537: cat > conftest.c <<EOF
1538: #include <stdio.h>
1539: main() { exit(0); }
1540: t() {
1541: #ifdef __stub_${func}
1542: choke me
1543: #else
1544: /* Override any gcc2 internal prototype to avoid an error. */
1545: extern char ${func}(); ${func}();
1546: #endif
1547: }
1548: EOF
1549: if eval $compile; then
1550: DEFS="${DEFS}#define ${trfunc} 1
1551: "
1552: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1553: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1554: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1555: "
1556: fi
1557: rm -f conftest*
1558: #endif
1559: done
1560:
1561: case $DEFS in
1562: *HAVE_MKDIR*) UUDIR='# ' ;;
1563: *) UUDIR=
1564: UNIXOBJS="$UNIXOBJS mkdir.o"
1565: if test -s /bin/mkdir; then
1566: DEFS="${DEFS}#define MKDIR_PROGRAM `echo '"/bin/mkdir"'`
1567: "
1568: SEDDEFS="${SEDDEFS}\${SEDdA}MKDIR_PROGRAM\${SEDdB}MKDIR_PROGRAM\${SEDdC}`echo '"/bin/mkdir"'`\${SEDdD}
1569: \${SEDuA}MKDIR_PROGRAM\${SEDuB}MKDIR_PROGRAM\${SEDuC}`echo '"/bin/mkdir"'`\${SEDuD}
1570: \${SEDeA}MKDIR_PROGRAM\${SEDeB}MKDIR_PROGRAM\${SEDeC}`echo '"/bin/mkdir"'`\${SEDeD}
1571: "
1572: fi ;;
1573: esac
1574: for func in rmdir
1575: do
1576: trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
1577: echo checking for ${func}
1578: cat > conftest.c <<EOF
1579: #include <stdio.h>
1580: main() { exit(0); }
1581: t() {
1582: #ifdef __stub_${func}
1583: choke me
1584: #else
1585: /* Override any gcc2 internal prototype to avoid an error. */
1586: extern char ${func}(); ${func}();
1587: #endif
1588: }
1589: EOF
1590: if eval $compile; then
1591: DEFS="${DEFS}#define ${trfunc} 1
1592: "
1593: SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
1594: \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
1595: \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
1596: "
1597: fi
1598: rm -f conftest*
1599: #endif
1600: done
1601:
1602: case $DEFS in
1603: *HAVE_RMDIR*) ;;
1604: *) UNIXOBJS="$UNIXOBJS rmdir.o"
1605: if test -s /bin/rmdir; then
1606: DEFS="${DEFS}#define RMDIR_PROGRAM `echo '"/bin/rmdir"'`
1607: "
1608: SEDDEFS="${SEDDEFS}\${SEDdA}RMDIR_PROGRAM\${SEDdB}RMDIR_PROGRAM\${SEDdC}`echo '"/bin/rmdir"'`\${SEDdD}
1609: \${SEDuA}RMDIR_PROGRAM\${SEDuB}RMDIR_PROGRAM\${SEDuC}`echo '"/bin/rmdir"'`\${SEDuD}
1610: \${SEDeA}RMDIR_PROGRAM\${SEDeB}RMDIR_PROGRAM\${SEDeC}`echo '"/bin/rmdir"'`\${SEDeD}
1611: "
1612: fi ;;
1613: esac
1614: case $DEFS in
1615: *HAVE_BSEARCH*) ;;
1616: *) LIBOBJS="$LIBOBJS bsrch.o" ;;
1617: esac
1618: case $DEFS in
1619: *HAVE_BZERO*) ;;
1620: *HAVE_MEMSET*) ;;
1621: *) LIBOBJS="$LIBOBJS bzero.o" ;;
1622: esac
1623: case $DEFS in
1624: *HAVE_GETLINE*) ;;
1625: *) LIBOBJS="$LIBOBJS getlin.o" ;;
1626: esac
1627: case $DEFS in
1628: *HAVE_MEMCHR*) ;;
1629: *) LIBOBJS="$LIBOBJS memchr.o" ;;
1630: esac
1631: case $DEFS in
1632: *HAVE_MEMCMP*) ;;
1633: *HAVE_BCMP*) ;;
1634: *) LIBOBJS="$LIBOBJS memcmp.o" ;;
1635: esac
1636: case $DEFS in
1637: *HAVE_MEMCPY*) ;;
1638: *HAVE_BCOPY*) ;;
1639: *) LIBOBJS="$LIBOBJS memcpy.o" ;;
1640: esac
1641: case $DEFS in
1642: *HAVE_STRCASECMP*) ;;
1643: *HAVE_STRICMP*) ;;
1644: *) LIBOBJS="$LIBOBJS strcas.o" ;;
1645: esac
1646: case $DEFS in
1647: *HAVE_STRCHR*) ;;
1648: *HAVE_INDEX*) ;;
1649: *) LIBOBJS="$LIBOBJS strchr.o" ;;
1650: esac
1651: case $DEFS in
1652: *HAVE_STRDUP*) ;;
1653: *) LIBOBJS="$LIBOBJS strdup.o" ;;
1654: esac
1655: case $DEFS in
1656: *HAVE_STRNCASECMP*) ;;
1657: *HAVE_STRNICMP*) ;;
1658: *) LIBOBJS="$LIBOBJS strncs.o" ;;
1659: esac
1660: case $DEFS in
1661: *HAVE_STRRCHR*) ;;
1662: *HAVE_RINDEX*) ;;
1663: *) LIBOBJS="$LIBOBJS strrch.o" ;;
1664: esac
1665: case $DEFS in
1666: *HAVE_STRSTR*) ;;
1667: *) LIBOBJS="$LIBOBJS strstr.o" ;;
1668: esac
1669: case $DEFS in
1670: *HAVE_STRTOL*) ;;
1671: *) LIBOBJS="$LIBOBJS strtol.o" ;;
1672: esac
1673: case $DEFS in
1674: *HAVE_OPENDIR*) ;;
1675: *) UNIXOBJS="$UNIXOBJS dirent.o" ;;
1676: esac
1677: case $DEFS in
1678: *HAVE_DUP2*) ;;
1679: *) UNIXOBJS="$UNIXOBJS dup2.o" ;;
1680: esac
1681: case $DEFS in
1682: *HAVE_FTW*) ;;
1683: *) UNIXOBJS="$UNIXOBJS ftw.o" ;;
1684: esac
1685: case $DEFS in
1686: *HAVE_REMOVE*) ;;
1687: *) UNIXOBJS="$UNIXOBJS remove.o" ;;
1688: esac
1689: case $DEFS in
1690: *HAVE_RENAME*) ;;
1691: *) UNIXOBJS="$UNIXOBJS rename.o" ;;
1692: esac
1693: case $DEFS in
1694: *HAVE_STRERROR*) ;;
1695: *) UNIXOBJS="$UNIXOBJS strerr.o" ;;
1696: esac
1697:
1698: case $DEFS in
1699: *HAVE_SIGVEC*)
1700: echo checking for sv_flags
1701: cat > conftest.c <<EOF
1702: #include <signal.h>
1703: main() { exit(0); }
1704: t() { struct sigvec s; s.sv_flags = 0; }
1705: EOF
1706: if eval $compile; then
1707: DEFS="${DEFS}#define HAVE_SIGVEC_SV_FLAGS 1
1708: "
1709: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_SIGVEC_SV_FLAGS\${SEDdB}HAVE_SIGVEC_SV_FLAGS\${SEDdC}1\${SEDdD}
1710: \${SEDuA}HAVE_SIGVEC_SV_FLAGS\${SEDuB}HAVE_SIGVEC_SV_FLAGS\${SEDuC}1\${SEDuD}
1711: \${SEDeA}HAVE_SIGVEC_SV_FLAGS\${SEDeB}HAVE_SIGVEC_SV_FLAGS\${SEDeC}1\${SEDeD}
1712: "
1713: fi
1714: rm -f conftest*
1715: ;;
1716: esac
1717:
1718: trfrom='[a-z]' trto='[A-Z]'
1719: echo checking for times declared as "long"
1720: cat > conftest.c <<EOF
1721: #include <sys/types.h>
1722: #include <pwd.h>
1723: #include <grp.h>
1724: #ifdef HAVE_LIBC_H
1725: #include <libc.h>
1726: #endif
1727: #ifdef HAVE_SYS_TIMES_H
1728: #include <sys/times.h>
1729: #endif
1730: extern long times ();
1731: main() { exit(0); }
1732: t() { }
1733: EOF
1734: if eval $compile; then
1735: DEFS="${DEFS}#define `echo times | tr "$trfrom" "$trto"`_DECLARATION_OK 1
1736: "
1737: SEDDEFS="${SEDDEFS}\${SEDdA}`echo times | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDdB}`echo times | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDdC}1\${SEDdD}
1738: \${SEDuA}`echo times | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDuB}`echo times | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDuC}1\${SEDuD}
1739: \${SEDeA}`echo times | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDeB}`echo times | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDeC}1\${SEDeD}
1740: "
1741: fi
1742: rm -f conftest*
1743:
1744: trfrom='[a-z]' trto='[A-Z]'
1745: echo checking for getpwnam declared as "struct passwd *"
1746: cat > conftest.c <<EOF
1747: #include <sys/types.h>
1748: #include <pwd.h>
1749: #include <grp.h>
1750: #ifdef HAVE_LIBC_H
1751: #include <libc.h>
1752: #endif
1753: #ifdef HAVE_SYS_TIMES_H
1754: #include <sys/times.h>
1755: #endif
1756: extern struct passwd * getpwnam ();
1757: main() { exit(0); }
1758: t() { }
1759: EOF
1760: if eval $compile; then
1761: DEFS="${DEFS}#define `echo getpwnam | tr "$trfrom" "$trto"`_DECLARATION_OK 1
1762: "
1763: SEDDEFS="${SEDDEFS}\${SEDdA}`echo getpwnam | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDdB}`echo getpwnam | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDdC}1\${SEDdD}
1764: \${SEDuA}`echo getpwnam | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDuB}`echo getpwnam | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDuC}1\${SEDuD}
1765: \${SEDeA}`echo getpwnam | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDeB}`echo getpwnam | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDeC}1\${SEDeD}
1766: "
1767: fi
1768: rm -f conftest*
1769:
1770: trfrom='[a-z]' trto='[A-Z]'
1771: echo checking for getpwuid declared as "struct passwd *"
1772: cat > conftest.c <<EOF
1773: #include <sys/types.h>
1774: #include <pwd.h>
1775: #include <grp.h>
1776: #ifdef HAVE_LIBC_H
1777: #include <libc.h>
1778: #endif
1779: #ifdef HAVE_SYS_TIMES_H
1780: #include <sys/times.h>
1781: #endif
1782: extern struct passwd * getpwuid ();
1783: main() { exit(0); }
1784: t() { }
1785: EOF
1786: if eval $compile; then
1787: DEFS="${DEFS}#define `echo getpwuid | tr "$trfrom" "$trto"`_DECLARATION_OK 1
1788: "
1789: SEDDEFS="${SEDDEFS}\${SEDdA}`echo getpwuid | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDdB}`echo getpwuid | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDdC}1\${SEDdD}
1790: \${SEDuA}`echo getpwuid | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDuB}`echo getpwuid | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDuC}1\${SEDuD}
1791: \${SEDeA}`echo getpwuid | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDeB}`echo getpwuid | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDeC}1\${SEDeD}
1792: "
1793: fi
1794: rm -f conftest*
1795:
1796: trfrom='[a-z]' trto='[A-Z]'
1797: echo checking for getgrent declared as "struct group *"
1798: cat > conftest.c <<EOF
1799: #include <sys/types.h>
1800: #include <pwd.h>
1801: #include <grp.h>
1802: #ifdef HAVE_LIBC_H
1803: #include <libc.h>
1804: #endif
1805: #ifdef HAVE_SYS_TIMES_H
1806: #include <sys/times.h>
1807: #endif
1808: extern struct group * getgrent ();
1809: main() { exit(0); }
1810: t() { }
1811: EOF
1812: if eval $compile; then
1813: DEFS="${DEFS}#define `echo getgrent | tr "$trfrom" "$trto"`_DECLARATION_OK 1
1814: "
1815: SEDDEFS="${SEDDEFS}\${SEDdA}`echo getgrent | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDdB}`echo getgrent | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDdC}1\${SEDdD}
1816: \${SEDuA}`echo getgrent | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDuB}`echo getgrent | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDuC}1\${SEDuD}
1817: \${SEDeA}`echo getgrent | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDeB}`echo getgrent | tr "$trfrom" "$trto"`_DECLARATION_OK\${SEDeC}1\${SEDeD}
1818: "
1819: fi
1820: rm -f conftest*
1821:
1822: echo checking for BSD setpgrp
1823: cat > conftest.c <<EOF
1824: #ifdef HAVE_UNISTD_H
1825: #include <unistd.h>
1826: #endif
1827: main() { exit(0); }
1828: t() { getpgrp (0); setpgrp (0, 0); }
1829: EOF
1830: if eval $compile; then
1831: DEFS="${DEFS}#define HAVE_BSD_PGRP 1
1832: "
1833: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_BSD_PGRP\${SEDdB}HAVE_BSD_PGRP\${SEDdC}1\${SEDdD}
1834: \${SEDuA}HAVE_BSD_PGRP\${SEDuB}HAVE_BSD_PGRP\${SEDuC}1\${SEDuD}
1835: \${SEDeA}HAVE_BSD_PGRP\${SEDeB}HAVE_BSD_PGRP\${SEDeC}1\${SEDeD}
1836: "
1837: fi
1838: rm -f conftest*
1839:
1840: echo checking for union wait
1841: cat > conftest.c <<EOF
1842: #include <sys/wait.h>
1843: #ifndef WIFEXITED
1844: #define WIFEXITED(u) ((u).w_termsig == 0)
1845: #endif
1846: main() { exit(0); }
1847: t() { union wait u; if (WIFEXITED (u)) wait (&u); }
1848: EOF
1849: if eval $compile; then
1850: DEFS="${DEFS}#define HAVE_UNION_WAIT 1
1851: "
1852: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_UNION_WAIT\${SEDdB}HAVE_UNION_WAIT\${SEDdC}1\${SEDdD}
1853: \${SEDuA}HAVE_UNION_WAIT\${SEDuB}HAVE_UNION_WAIT\${SEDuC}1\${SEDuD}
1854: \${SEDeA}HAVE_UNION_WAIT\${SEDeB}HAVE_UNION_WAIT\${SEDeC}1\${SEDeD}
1855: "
1856: fi
1857: rm -f conftest*
1858:
1859: if test -n "$cross_compiling"; then
1860: DEFS="${DEFS}#define HAVE_LONG_FILE_NAMES 0
1861: "
1862: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_LONG_FILE_NAMES\${SEDdB}HAVE_LONG_FILE_NAMES\${SEDdC}0\${SEDdD}
1863: \${SEDuA}HAVE_LONG_FILE_NAMES\${SEDuB}HAVE_LONG_FILE_NAMES\${SEDuC}0\${SEDuD}
1864: \${SEDeA}HAVE_LONG_FILE_NAMES\${SEDeB}HAVE_LONG_FILE_NAMES\${SEDeC}0\${SEDeD}
1865: "
1866: DEFS="${DEFS}#define HAVE_RESTARTABLE_SYSCALLS -1
1867: "
1868: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_RESTARTABLE_SYSCALLS\${SEDdB}HAVE_RESTARTABLE_SYSCALLS\${SEDdC}-1\${SEDdD}
1869: \${SEDuA}HAVE_RESTARTABLE_SYSCALLS\${SEDuB}HAVE_RESTARTABLE_SYSCALLS\${SEDuC}-1\${SEDuD}
1870: \${SEDeA}HAVE_RESTARTABLE_SYSCALLS\${SEDeB}HAVE_RESTARTABLE_SYSCALLS\${SEDeC}-1\${SEDeD}
1871: "
1872: else
1873: echo checking for restartable system calls
1874: cat > conftest.c <<EOF
1875: /* Exit 0 (true) if wait returns something other than -1,
1876: i.e. the pid of the child, which means that wait was restarted
1877: after getting the signal. */
1878: #include <sys/types.h>
1879: #include <signal.h>
1880: ucatch (isig) { }
1881: main () {
1882: int i = fork (), status;
1883: if (i == 0) { sleep (3); kill (getppid (), SIGINT); sleep (3); exit (0); }
1884: signal (SIGINT, ucatch);
1885: status = wait(&i);
1886: if (status == -1) wait(&i);
1887: exit (status == -1);
1888: }
1889:
1890: EOF
1891: eval $compile
1892: if test -s conftest && (./conftest; exit) 2>/dev/null; then
1893: DEFS="${DEFS}#define HAVE_RESTARTABLE_SYSCALLS 1
1894: "
1895: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_RESTARTABLE_SYSCALLS\${SEDdB}HAVE_RESTARTABLE_SYSCALLS\${SEDdC}1\${SEDdD}
1896: \${SEDuA}HAVE_RESTARTABLE_SYSCALLS\${SEDuB}HAVE_RESTARTABLE_SYSCALLS\${SEDuC}1\${SEDuD}
1897: \${SEDeA}HAVE_RESTARTABLE_SYSCALLS\${SEDeB}HAVE_RESTARTABLE_SYSCALLS\${SEDeC}1\${SEDeD}
1898: "
1899: fi
1900: rm -f conftest*
1901:
1902: echo checking for long file names
1903: (echo 1 > conftest9012345) 2>/dev/null
1904: (echo 2 > conftest9012346) 2>/dev/null
1905: val=`cat conftest9012345 2>/dev/null`
1906: test -f conftest9012345 && test "$val" = 1 && DEFS="${DEFS}#define HAVE_LONG_FILE_NAMES 1
1907: "
1908: SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_LONG_FILE_NAMES\${SEDdB}HAVE_LONG_FILE_NAMES\${SEDdC}1\${SEDdD}
1909: \${SEDuA}HAVE_LONG_FILE_NAMES\${SEDuB}HAVE_LONG_FILE_NAMES\${SEDuC}1\${SEDuD}
1910: \${SEDeA}HAVE_LONG_FILE_NAMES\${SEDeB}HAVE_LONG_FILE_NAMES\${SEDeC}1\${SEDeD}
1911: "
1912: rm -f conftest9012345 conftest9012346
1913:
1914: fi
1915: if test -n "$prefix"; then
1916: test -z "$exec_prefix" && exec_prefix='${prefix}'
1917: prsub="s%^prefix\\([ ]*\\)=\\([ ]*\\).*$%prefix\\1=\\2$prefix%"
1918: fi
1919: if test -n "$exec_prefix"; then
1920: prsub="$prsub
1921: s%^exec_prefix\\([ ]*\\)=\\([ ]*\\).*$%\
1922: exec_prefix\\1=\\2$exec_prefix%"
1923: fi
1924:
1925: trap 'rm -f config.status; exit 1' 1 3 15
1926: echo creating config.status
1927: rm -f config.status
1928: cat > config.status <<EOF
1929: #!/bin/sh
1930: # Generated automatically by configure.
1931: # Run this file to recreate the current configuration.
1932: # This directory was configured as follows,
1933: # on host `(hostname || uname -n) 2>/dev/null`:
1934: #
1935: # $0 $*
1936:
1937: for arg
1938: do
1939: case "\$arg" in
1940: -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
1941: exec /bin/sh $0 $* ;;
1942: *) echo "Usage: config.status --recheck" 2>&1; exit 1 ;;
1943: esac
1944: done
1945:
1946: trap 'rm -f Makefile uuconf/Makefile lib/Makefile unix/Makefile conf.h conftest*; exit 1' 1 3 15
1947: CC='$CC'
1948: CPP='$CPP'
1949: INSTALL='$INSTALL'
1950: INSTALL_PROGRAM='$INSTALL_PROGRAM'
1951: INSTALL_DATA='$INSTALL_DATA'
1952: RANLIB='$RANLIB'
1953: CFLAGS='$CFLAGS'
1954: LDFLAGS='$LDFLAGS'
1955: LN_S='$LN_S'
1956: UUDIR='$UUDIR'
1957: LIBOBJS='$LIBOBJS'
1958: UNIXOBJS='$UNIXOBJS'
1959: LIBS='$LIBS'
1960: srcdir='$srcdir'
1961: prefix='$prefix'
1962: exec_prefix='$exec_prefix'
1963: prsub='$prsub'
1964: EOF
1965: cat >> config.status <<\EOF
1966:
1967: top_srcdir=$srcdir
1968: for file in .. Makefile uuconf/Makefile lib/Makefile unix/Makefile; do if [ "x$file" != "x.." ]; then
1969: srcdir=$top_srcdir
1970: # Remove last slash and all that follows it. Not all systems have dirname.
1971: dir=`echo $file|sed 's%/[^/][^/]*$%%'`
1972: if test "$dir" != "$file"; then
1973: test "$top_srcdir" != . && srcdir=$top_srcdir/$dir
1974: test ! -d $dir && mkdir $dir
1975: fi
1976: echo creating $file
1977: rm -f $file
1978: echo "# Generated automatically from `echo $file|sed 's|.*/||'`.in by configure." > $file
1979: sed -e "
1980: $prsub
1981: s%@CC@%$CC%g
1982: s%@CPP@%$CPP%g
1983: s%@INSTALL@%$INSTALL%g
1984: s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
1985: s%@INSTALL_DATA@%$INSTALL_DATA%g
1986: s%@RANLIB@%$RANLIB%g
1987: s%@CFLAGS@%$CFLAGS%g
1988: s%@LDFLAGS@%$LDFLAGS%g
1989: s%@LN_S@%$LN_S%g
1990: s%@UUDIR@%$UUDIR%g
1991: s%@LIBOBJS@%$LIBOBJS%g
1992: s%@UNIXOBJS@%$UNIXOBJS%g
1993: s%@LIBS@%$LIBS%g
1994: s%@srcdir@%$srcdir%g
1995: s%@DEFS@%-DHAVE_CONFIG_H%" $top_srcdir/${file}.in >> $file
1996: fi; done
1997:
1998: echo creating conf.h
1999: # These sed commands are put into SEDDEFS when defining a macro.
2000: # They are broken into pieces to make the sed script easier to manage.
2001: # They are passed to sed as "A NAME B NAME C VALUE D", where NAME
2002: # is the cpp macro being defined and VALUE is the value it is being given.
2003: # Each defining turns into a single global substitution command.
2004: #
2005: # SEDd sets the value in "#define NAME VALUE" lines.
2006: SEDdA='s@^\([ ]*\)#\([ ]*define[ ][ ]*\)'
2007: SEDdB='\([ ][ ]*\)[^ ]*@\1#\2'
2008: SEDdC='\3'
2009: SEDdD='@g'
2010: # SEDu turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
2011: SEDuA='s@^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)'
2012: SEDuB='\([ ]\)@\1#\2define\3'
2013: SEDuC=' '
2014: SEDuD='\4@g'
2015: # SEDe turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
2016: SEDeA='s@^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)'
2017: SEDeB='$@\1#\2define\3'
2018: SEDeC=' '
2019: SEDeD='@g'
2020: rm -f conftest.sed
2021: cat > conftest.sed <<CONFEOF
2022: EOF
2023: # Turn off quoting long enough to insert the sed commands.
2024: cat >> config.status <<EOF
2025: $SEDDEFS
2026: EOF
2027: cat >> config.status <<\EOF
2028: CONFEOF
2029: rm -f conftest.h
2030: # Break up the sed commands because old seds have small limits.
2031: cp $top_srcdir/conf.h.in conftest.h1
2032: while :
2033: do
2034: lines=`grep -c . conftest.sed`
2035: if test -z "$lines" || test "$lines" -eq 0; then break; fi
2036: rm -f conftest.s1 conftest.s2 conftest.h2
2037: sed 40q conftest.sed > conftest.s1 # Like head -40.
2038: sed 1,40d conftest.sed > conftest.s2 # Like tail +41.
2039: sed -f conftest.s1 < conftest.h1 > conftest.h2
2040: rm -f conftest.s1 conftest.h1 conftest.sed
2041: mv conftest.h2 conftest.h1
2042: mv conftest.s2 conftest.sed
2043: done
2044: rm -f conftest.sed conftest.h
2045: echo "/* conf.h. Generated automatically by configure. */" > conftest.h
2046: cat conftest.h1 >> conftest.h
2047: rm -f conftest.h1
2048: if cmp -s conf.h conftest.h 2>/dev/null; then
2049: # The file exists and we would not be changing it.
2050: rm -f conftest.h
2051: else
2052: rm -f conf.h
2053: mv conftest.h conf.h
2054: fi
2055:
2056: EOF
2057: chmod +x config.status
2058: test -n "$no_create" || ./config.status
2059:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.