home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD2.bin / bbs / gnu / rcs-5.6.0.1-src.lha / rcs-5.6.0.1 / src / conf.sh < prev    next >
Encoding:
Linux/UNIX/POSIX Shell Script  |  1994-02-24  |  35.9 KB  |  1,692 lines

  1. #!/bin/sh
  2. # Output RCS compile-time configuration.
  3. Id='$Id: conf.sh,v 5.14.0.1 1993/03/25 04:24:49 eggert Exp $'
  4. #    Copyright 1990, 1991 by Paul Eggert
  5. #    Distributed under license by the Free Software Foundation, Inc.
  6.  
  7. # This file is part of RCS.
  8. #
  9. # RCS is free software; you can redistribute it and/or modify
  10. # it under the terms of the GNU General Public License as published by
  11. # the Free Software Foundation; either version 2, or (at your option)
  12. # any later version.
  13. #
  14. # RCS is distributed in the hope that it will be useful,
  15. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. # GNU General Public License for more details.
  18. #
  19. # You should have received a copy of the GNU General Public License
  20. # along with RCS; see the file COPYING.  If not, write to
  21. # the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  22. #
  23. # Report problems and direct all questions to:
  24. #
  25. #     rcs-bugs@cs.purdue.edu
  26.  
  27. CC='gcc'
  28. CFLAGS=' -O2 '
  29. COMPAT2='0'
  30. DIFF3='/gnu/bin/diff3'
  31. DIFF3_A='1'
  32. DIFF3_BIN='1'
  33. DIFF='/gnu/bin/diff'
  34. DIFF_FLAGS='-an'
  35. DIFF_L='1'
  36. DIFF_SUCCESS='0'
  37. DIFF_FAILURE='1'
  38. DIFF_TROUBLE='2'
  39. ED='/gnu/bin/emacs'
  40. LDFLAGS=''
  41. LDLIBS=''
  42. RCSPREFIX='/gnu/bin/'
  43. SENDMAIL=''
  44.  
  45. # Take care of doing redirection to a.h ourself, since some systems may have
  46. # problems reading a file that is already open for write.
  47. # Standard error can be ignored if a.h is OK,
  48. # and can be inspected for clues otherwise.
  49.  
  50. # The Makefile overrides the following defaults.
  51. : ${CC=cc}
  52. : ${CFLAGS=-O}
  53. : ${COMPAT2=0}
  54. : ${DIFF3=${RCSPREFIX}diff3}
  55. : ${DIFF3_A=1}
  56. : ${DIFF3_BIN=1}
  57. : ${DIFF=${RCSPREFIX}diff}
  58. : ${DIFF_FLAGS=-an}
  59. : ${DIFF_L=1}
  60. : ${DIFF_SUCCESS=0} ${DIFF_FAILURE=1} ${DIFF_TROUBLE=2}
  61. : ${ED=/bin/ed}
  62. : ${RCSPREFIX=/usr/local/bin/}
  63. : ${SENDMAIL='"/usr/lib/sendmail"'}
  64. # : ${LDFLAGS=} ${LDLIBS=} tickles old shell bug
  65.  
  66. C="$CC $CFLAGS"
  67. CL="$CC $CFLAGS $LDFLAGS"
  68. L=$LDLIBS
  69. RM='rm -f a.out'
  70.  
  71. cat >>a.h <<'EOF'
  72. /* RCS compile-time configuration */
  73.  
  74.     /* $Id */
  75.  
  76. /*
  77.  * This file is generated automatically.
  78.  * If you edit it by hand your changes may be lost.
  79.  * Instead, please try to fix conf.sh,
  80.  * and send your fixes to rcs-bugs@cs.purdue.edu.
  81.  */
  82.  
  83. EOF
  84.  
  85. : exitmain
  86. cat >a.c <<'EOF'
  87. #include "a.h"
  88. int main(argc,argv) int argc; char **argv; { return argc-1; }
  89. EOF
  90. $RM && $CL a.c $L >&2 || exit
  91. e='exit(n), 3 /* lint fodder */'
  92. if ./a.out -
  93. then :
  94. elif ./a.out
  95. then e=n
  96. fi
  97. echo >>a.h "#define exitmain(n) return $e /* how to exit from main() */"
  98.  
  99. : _POSIX_SOURCE
  100. cat >a.c <<'EOF'
  101. #include "a.h"
  102. #include <stdio.h>
  103. int main() { exitmain(fileno(stdout) < 0); }
  104. EOF
  105. a='/* ' z='*/ '
  106. $RM || exit
  107. if ($CL a.c $L && ./a.out) >&2
  108. then :
  109. elif $RM || exit; ($CL -D_POSIX_SOURCE a.c $L && ./a.out) >&2
  110. then a= z=
  111. fi
  112. cat >>a.h <<'EOF'
  113. $a#define _POSIX_SOURCE $z/* Define this if Posix + strict Standard C.  */
  114.  
  115. #include <errno.h>
  116. #include <stdio.h>
  117. #include <time.h>
  118. EOF
  119.  
  120. cat >>a.h <<'EOF'
  121.  
  122. /* Comment out #include lines below that do not work.  */
  123. EOF
  124.  
  125. # Run `$CS a.c $LS' instead of `$CL a.c $L' for compile-time checking only.
  126. # This speeds up the configuration process.
  127. if $C -S a.c >&2
  128. then CS="$C -S" LS=    # Generate assembly language output.
  129. elif $C -c a.c >&2
  130. then CS="$C -c" LS=    # Generate object code.
  131. else CS=$CL LS=$L    # Generate an executable.
  132. fi
  133.  
  134. # standard include files
  135. # sys/types.h and sys/stat.h must come first because others depend on them.
  136. has_signal=1
  137. for h in \
  138.     sys/types sys/stat \
  139.     dirent fcntl limits pwd signal stdlib string sys/mman sys/wait unistd utime vfork
  140. do
  141.     i="#include <$h.h>"
  142.     : $i
  143.     cat >a.c <<'EOF'
  144. #include "a.h"
  145. $i
  146. int main(){ exitmain(0); }
  147. EOF
  148.     $RM || exit
  149.     ($CL a.c $L && ./a.out) >&2 || {
  150.         case $h in
  151.         string)
  152.             i='#include <strings.h>';;
  153.         *)
  154.             i="/* $i */"
  155.         esac
  156.         case $h in
  157.         signal) has_signal=0
  158.         esac
  159.     }
  160.     echo >>a.h "$i"
  161. done
  162.  
  163. cat >>a.h <<'EOF'
  164.  
  165. /* Define the following symbols to be 1 or 0.  */
  166. EOF
  167.  
  168. # has_sys_*_h
  169. for H in dir param
  170. do
  171.     : has_sys_${H}_h
  172.     cat >a.c <<'EOF'
  173. #include "a.h"
  174. #include <sys/$H.h>
  175. int main() { exitmain(0); }
  176. EOF
  177.     $RM || exit
  178.     if ($CL a.c $L && ./a.out) >&2
  179.     then h=1
  180.     else h=0
  181.     fi
  182.     echo >>a.h "#define has_sys_${H}_h $h /* Does #include <sys/$H.h> work?  */"
  183. done
  184.  
  185.  
  186. # We must do NAME_MAX and has_readlink next, because they might generate
  187. # #include directives that affect later definitions.
  188.  
  189. : NAME_MAX
  190. cat >a.c <<'EOF'
  191. #include "a.h"
  192. char b[NAME_MAX + 2];
  193. main()
  194. {
  195. #if !defined(NAME_MAX)
  196.     exitmain(1);
  197. #else
  198.     int i;
  199.     b[0] = 'a'; b[1] = '.';
  200.     for (i = 2;  i < NAME_MAX;  i++)
  201.         b[i] = 'a';
  202.     b[i] = 'b';
  203.     exitmain(creat(b, 0) < 0);
  204. #endif
  205. }
  206. EOF
  207. $RM a.*ab || exit
  208. if $CL a.c $L >&2 && ./a.out && test -f a.*ab
  209. then a= z=
  210. else a='/* ' z='*/ '
  211. fi
  212. rm -f a.*ab || exit
  213.  
  214. : has_readlink
  215. cat >a.c <<'EOF'
  216. #include "a.h"
  217. char b[7];
  218. int main()
  219. {
  220.     exitmain(readlink("a.sym2",b,7) != 6  ||  strcmp(b, "a.sym1") != 0);
  221. }
  222. EOF
  223. $RM a.sym* || exit
  224. if (ln -s a.sym1 a.sym2 && $CL a.c $L && ./a.out) >&2
  225. then h=1
  226. else h=0
  227. fi
  228. cat >>a.h <<'EOF'
  229. #define has_readlink $h /* Does readlink() work?  */
  230.  
  231. $a#undef NAME_MAX $z/* Uncomment this if NAME_MAX is broken.  */
  232.  
  233. #if !defined(NAME_MAX) && !defined(_POSIX_NAME_MAX)
  234. #    if has_sys_dir_h
  235. #        include <sys/dir.h>
  236. #    endif
  237. #    ifndef NAME_MAX
  238. #        ifndef MAXNAMLEN
  239. #            define MAXNAMLEN 14
  240. #        endif
  241. #        define NAME_MAX MAXNAMLEN
  242. #    endif
  243. #endif
  244. #if !defined(PATH_MAX) && !defined(_POSIX_PATH_MAX)
  245. #    if has_sys_param_h
  246. #        include <sys/param.h>
  247. #        define included_sys_param_h 1
  248. #    endif
  249. #    ifndef PATH_MAX
  250. #        ifndef MAXPATHLEN
  251. #            define MAXPATHLEN 1024
  252. #        endif
  253. #        define PATH_MAX (MAXPATHLEN-1)
  254. #    endif
  255. #endif
  256. #if has_readlink && !defined(MAXSYMLINKS)
  257. #    if has_sys_param_h && !included_sys_param_h
  258. #        include <sys/param.h>
  259. #    endif
  260. #    ifndef MAXSYMLINKS
  261. #        define MAXSYMLINKS 20 /* BSD; not standard yet */
  262. #    endif
  263. #endif
  264. EOF
  265.  
  266. cat >>a.h <<'EOF'
  267.  
  268. /* Comment out the keyword definitions below if the keywords work.  */
  269. EOF
  270.  
  271. : const, volatile
  272. for i in const volatile
  273. do
  274.     cat >a.c <<'EOF'
  275. #    include "a.h"
  276.     enum Boolean { false, true };
  277.     static enum Boolean $i zero;
  278.     static enum Boolean $i * $i azero = &zero;
  279.     static enum Boolean $i * $i * $i aazero = &azero;
  280.     int main() { exitmain(!!**aazero); }
  281. EOF
  282.     a= z=
  283.     if $CS a.c $LS >&2
  284.     then
  285.         cat >a.c <<'EOF'
  286.             typedef unsigned char $i *Iptr_type;
  287.             struct { Iptr_type lim; } s, *f = &s;
  288.             int main() {
  289.                 Iptr_type lim;
  290.                 lim = f->lim;
  291.                 return !!lim;
  292.             }
  293. EOF
  294.         if $CS a.c $LS >&2
  295.         then a='/* ' z=' */'
  296.         fi
  297.     fi
  298.     echo >>a.h "$a#define $i$z"
  299. done
  300.  
  301. # *_t
  302. cat >>a.h <<'EOF'
  303.  
  304. /* Comment out the typedefs below if the types are already declared.  */
  305. /* Fix any uncommented typedefs that are wrong.  */
  306. EOF
  307. cat >a.c <<'EOF'
  308. #include "a.h"
  309. t x;
  310. int main() { exitmain(0); }
  311. EOF
  312. for t in mode_t pid_t sig_atomic_t size_t ssize_t time_t uid_t
  313. do
  314.     : $t
  315.     case $t in
  316.     size_t) i=unsigned;;
  317.     time_t) i=long;;
  318.     *) i=int;;
  319.     esac
  320.     if $CS -Dt=$t a.c $LS >&2
  321.     then a='/* ' z=' */'
  322.     else a= z=
  323.     fi
  324.     echo >>a.h "${a}typedef $i $t;$z"
  325. done
  326.  
  327. : has_prototypes, has_stdarg, has_varargs, va_start_args
  328. cat >a.ha <<'EOF'
  329. #if has_prototypes
  330. #    define P(params) params
  331. #else
  332. #    define P(params) ()
  333. #endif
  334. #if has_stdarg
  335. #    include <stdarg.h>
  336. #else
  337. #    if has_varargs
  338. #        include <varargs.h>
  339. #    else
  340.         typedef char *va_list;
  341. #        define va_dcl int va_alist;
  342. #        define va_start(ap) ((ap) = (va_list)&va_alist)
  343. #        define va_arg(ap,t) (((t*) ((ap)+=sizeof(t)))  [-1])
  344. #        define va_end(ap)
  345. #    endif
  346. #endif
  347. #if va_start_args == 2
  348. #    define vararg_start va_start
  349. #else
  350. #    define vararg_start(ap,p) va_start(ap)
  351. #endif
  352. EOF
  353. cat >a.c <<'EOF'
  354. #include "a.h"
  355. #include "a.ha"
  356. #if has_prototypes
  357. char *f(char **p, ...)
  358. #else
  359. char *f(p, va_alist) char **p; va_dcl
  360. #endif
  361. {
  362.     char *s;
  363.     va_list v;
  364.     vararg_start(v,p);
  365.     s = p[va_arg(v,int)];
  366.     va_end(v);
  367.     return s;
  368. }
  369. int main P((int, char**));
  370. int main(argc, argv) int argc; char **argv; {
  371.     exitmain(f(argv,0) != argv[0]  ||  f(argv,1) != argv[1]);
  372. }
  373. EOF
  374. for has_prototypes in 1 0
  375. do
  376.     for has_stdarg in 1 v 0
  377.     do
  378.         case $has_stdarg in
  379.         v) has_varargs=1 has_stdarg=0;;
  380.         *) has_varargs=0
  381.         esac
  382.         case $has_stdarg in
  383.         0) as='1 2';;
  384.         1) as='2 1'
  385.         esac
  386.         for va_start_args in $as
  387.         do
  388.             $RM || exit
  389.             $CL \
  390.                 -Dhas_prototypes=$has_prototypes \
  391.                 -Dhas_stdarg=$has_stdarg \
  392.                 -Dhas_varargs=$has_varargs \
  393.                 -Dva_start_args=$va_start_args \
  394.                 a.c $L >&2 && ./a.out && break
  395.         done && break
  396.     done && break
  397. done || {
  398.     echo >&2 "cannot deduce has_prototypes, has_stdarg, va_start_args"
  399.     exit 1
  400. }
  401. cat >>a.h - a.ha <<'EOF'
  402.  
  403. /* Define the following symbols to be 1 or 0.  */
  404. #define has_prototypes $has_prototypes /* Do function prototypes work?  */
  405. #define has_stdarg $has_stdarg /* Does <stdarg.h> work?  */
  406. #define has_varargs $has_varargs /* Does <varargs.h> work?  */
  407. #define va_start_args $va_start_args /* How many args does va_start() take?  */
  408. EOF
  409.  
  410. : text_equals_binary_stdio, FOPEN_...
  411. cat >a.c <<'EOF'
  412. #include "a.h"
  413.     int
  414. copyto(filename, mode)
  415.     char const *filename, *mode;
  416. {
  417.     int c;
  418.     FILE *f, *g;
  419.     if (!(f = fopen("a.out", "rb")) || !(g = fopen(filename, mode)))
  420.         return 1;
  421.     while (c=getc(f), !feof(f))
  422.         if (ferror(f)  ||  putc(c,g)<0 && ferror(g))
  423.             return 1;
  424.     return fclose(f)!=0 || fclose(g)!=0;
  425. }
  426. int main() { exitmain(copyto("a.d", "w+b") || copyto("a.e", "w+")); }
  427. EOF
  428. e=1
  429. $RM a.d a.e || exit
  430. $CL a.c $L >&2 && ./a.out && cmp a.out a.d && {
  431.     cmp a.out a.e || e=0
  432. }
  433. cat >>a.h <<'EOF'
  434.  
  435. #define text_equals_binary_stdio $e /* Does stdio treat text like binary?  */
  436. #define text_work_stdio 0 /* Text i/o for working file, binary for RCS file?  */
  437. #if text_equals_binary_stdio
  438.     /* Text and binary i/o behave the same, or binary i/o does not work.  */
  439. #    define FOPEN_R "r"
  440. #    define FOPEN_W "w"
  441. #    define FOPEN_WPLUS "w+"
  442. #else
  443.     /* Text and binary i/o behave differently.  */
  444.     /* This is incompatible with Posix and Unix.  */
  445. #    define FOPEN_R "rb"
  446. #    define FOPEN_W "wb"
  447. #    define FOPEN_WPLUS "w+b"
  448. #endif
  449. #if text_work_stdio
  450. #    define FOPEN_R_WORK "r"
  451. #    define FOPEN_W_WORK "w"
  452. #    define FOPEN_WPLUS_WORK "w+"
  453. #else
  454. #    define FOPEN_R_WORK FOPEN_R
  455. #    define FOPEN_W_WORK FOPEN_W
  456. #    define FOPEN_WPLUS_WORK FOPEN_WPLUS
  457. #endif
  458.  
  459. /* Define or comment out the following symbols as needed.  */
  460. EOF
  461.  
  462. : bad_fopen_wplus
  463. cat >a.c <<'EOF'
  464. #include "a.h"
  465. int main() { exitmain(!fopen("a.d",FOPEN_WPLUS)); }
  466. EOF
  467. $RM || exit
  468. if echo nonempty >a.d && $CL a.c $L >&2 && ./a.out && test ! -s a.d
  469. then b=0
  470. else b=1
  471. fi
  472. echo >>a.h "#define bad_fopen_wplus $b /* Does fopen(f,FOPEN_WPLUS) fail to truncate f?  */"
  473.  
  474. : getlogin_is_secure
  475. echo >>a.h "#define getlogin_is_secure 0 /* Is getlogin() secure?  Usually it's not.  */"
  476.  
  477. : has_dirent
  478. cat >a.c <<'EOF'
  479. #include "a.h"
  480. int main() {
  481.     DIR *d = opendir(".");
  482.     struct dirent *e;
  483.     while ((e = readdir(d)))
  484.         if (strcmp(e->d_name, "a.c") == 0  &&  closedir(d) == 0)
  485.             exitmain(0);
  486.     exitmain(1);
  487. }
  488. EOF
  489. $RM || exit
  490. if $CL a.c $L >&2 && ./a.out
  491. then h=1
  492. else h=0
  493. fi
  494. echo >>a.h "#define has_dirent $h /* Do opendir(), readdir(), closedir() work?  */"
  495.  
  496. : has_fchmod
  497. cat >a.c <<'EOF'
  498. #include "a.h"
  499. int main() { exitmain(fchmod(fileno(stdin),0) != 0); }
  500. EOF
  501. $RM || exit
  502. if $CL a.c $L >&2 && ./a.out <a.c && test ! -r a.c
  503. then h=1
  504. else h=0
  505. fi
  506. echo >>a.h "#define has_fchmod $h /* Does fchmod() work?  */"
  507. rm -f a.c || exit
  508.  
  509. : has_fputs
  510. cat >a.c <<'EOF'
  511. #include "a.h"
  512. int main() { exitmain(fputs("Hello\"\nworld", stdout) != 12); }
  513. EOF
  514. Hello='Hello"
  515. world'
  516. $RM || exit
  517. if $CL a.c $L >&2 && ./a.out >/dev/null && x=`./a.out` && test " $x" = " $Hello"
  518. then h=1
  519. else h=0
  520. fi
  521. echo >>a.h "#define has_fputs $h /* Does fputs() work?  */"
  522.  
  523. : has_ftruncate
  524. cat >a.c <<'EOF'
  525. #include "a.h"
  526. int main(argc, argv) int argc; char **argv; {
  527.     int f = creat(argv[1], 0);
  528.     if (f<0 || write(f,"abc",3)!=3 || ftruncate(f,(off_t)0)!=0 || close(f)!=0)
  529.             exitmain(1);
  530.     exitmain(0);
  531. }
  532. EOF
  533. $RM || exit
  534. if $CL a.c $L >&2
  535. then
  536.     h=1
  537.     # Check out /tmp too; it's buggy on some hosts.
  538.     for d in . /tmp
  539.     do
  540.         if test -d $d
  541.         then
  542.             f=$d/a.d
  543.             rm -f $f || exit
  544.             ./a.out $f && test ! -s $f && test -f $f  ||  h=0
  545.             rm -f $f || exit
  546.         fi
  547.     done
  548. else h=0
  549. fi
  550. echo >>a.h "#define has_ftruncate $h /* Does ftruncate() work?  */"
  551.  
  552. : has_getuid
  553. cat >a.c <<'EOF'
  554. #include "a.h"
  555. #ifndef getuid
  556.     uid_t getuid();
  557. #endif
  558. int main() { exitmain(getuid()!=getuid()); }
  559. EOF
  560. $RM || exit
  561. if ($CL a.c $L && ./a.out) >&2
  562. then has_getuid=1
  563. else has_getuid=0
  564. fi
  565. echo >>a.h "#define has_getuid $has_getuid /* Does getuid() work?  */"
  566.  
  567. : has_getpwuid
  568. case $has_getuid in
  569. 0)
  570.     a='/* ' z='*/ ' h=?;;
  571. *)
  572.     a= z=
  573.     cat >a.c <<'EOF'
  574. #include "a.h"
  575. int main() { exitmain(!getpwuid(0)); }
  576. EOF
  577.     $RM || exit
  578.     if ($CL a.c $L && ./a.out) >&2
  579.     then h=1
  580.     else h=0
  581.     fi
  582. esac
  583. echo >>a.h "$a#define has_getpwuid $h $z/* Does getpwuid() work?  */"
  584.  
  585. : has_link
  586. cat >a.c <<'EOF'
  587. #include "a.h"
  588. int main() { exitmain(link("a.c","a.d") != 0); }
  589. EOF
  590. $RM a.d || exit
  591. if ($CL a.c $L && ./a.out && cmp a.c a.d) >&2
  592. then h=1
  593. else h=0
  594. fi
  595. rm -f a.d || exit
  596. echo >>a.h "#define has_link $h /* Does link() work?  */"
  597.  
  598. : has_memcmp
  599. cat >a.c <<'EOF'
  600. #include "a.h"
  601. int main() { exitmain(memcmp("beautiful","beautiful",10) != 0); }
  602. EOF
  603. $RM || exit
  604. if ($CL a.c $L && ./a.out) >&2
  605. then h=1
  606. else h=0
  607. fi
  608. echo >>a.h "#define has_memcmp $h /* Does memcmp() work?  */"
  609.  
  610. : has_memcpy
  611. cat >a.c <<'EOF'
  612. #include "a.h"
  613. char a[3];
  614. int main() {
  615.     memcpy(a,"xy",3);
  616.     exitmain(strcmp(a,"xy")!=0);
  617. }
  618. EOF
  619. $RM || exit
  620. if ($CL a.c $L && ./a.out) >&2
  621. then h=1
  622. else h=0
  623. fi
  624. echo >>a.h "#define has_memcpy $h /* Does memcpy() work?  */"
  625.  
  626. : has_memmove
  627. cat >a.c <<'EOF'
  628. #include "a.h"
  629. char a[4];
  630. int main() {
  631.     strcpy(a, "xy");
  632.     memmove(a+1, a, 3);
  633.     exitmain(strcmp(a,"xxy")!=0);
  634. }
  635. EOF
  636. $RM || exit
  637. if ($CL a.c $L && ./a.out) >&2
  638. then h=1
  639. else h=0
  640. fi
  641. echo >>a.h "#define has_memmove $h /* Does memmove() work?  */"
  642.  
  643. : has_mmap, has_madvise
  644. cat >a.c <<'EOF'
  645. #define CHAR1 '#' /* the first character in this file */
  646. #include "a.h"
  647. #ifndef mmap
  648.     caddr_t mmap();
  649. #endif
  650. caddr_t a;
  651. struct stat b;
  652. #ifndef MADVISE_OK
  653. #    define MADVISE_OK (madvise(a,b.st_size,MADV_SEQUENTIAL)==0 && madvise(a,b.st_size,MADV_NORMAL)==0)
  654. #endif
  655. int main()
  656. {
  657.     if (fstat(fileno(stdin), &b) != 0)
  658.         exitmain(1);
  659.     a = mmap(
  660.         (caddr_t)0, b.st_size, PROT_READ, MAP_SHARED,
  661.         fileno(stdin), (off_t)0
  662.     );
  663.     exitmain(
  664.         a == (caddr_t)-1  ||
  665.         !MADVISE_OK ||
  666.         *a != CHAR1  ||
  667.         munmap(a, b.st_size)  !=  0
  668.     );
  669. }
  670. EOF
  671. a=0 has_mmap=0
  672. $RM || exit
  673. if ($CL -DMADVISE_OK=1 a.c $L && ./a.out <a.c) >&2
  674. then
  675.     has_mmap=1
  676.     $RM || exit
  677.     ($CL a.c $L && ./a.out <a.c) >&2 && a=1
  678. fi
  679. echo >>a.h "#define has_madvise $a /* Does madvise() work?  */"
  680. echo >>a.h "#define has_mmap $has_mmap /* Does mmap() work on regular files?  */"
  681.  
  682. : has_rename, bad_a_rename, bad_b_rename
  683. cat >a.c <<'EOF'
  684. #include "a.h"
  685. int main() { exitmain(rename("a.a","a.b") != 0); }
  686. EOF
  687. echo a >a.a && $RM a.b || exit
  688. if ($CL a.c $L && ./a.out && test -f a.b) >&2
  689. then
  690.     h=1
  691.     rm -f a.a a.b &&
  692.     echo a >a.a && chmod -w a.a || exit
  693.     if ./a.out && test ! -f a.a && test -f a.b
  694.     then a=0
  695.     else a=1
  696.     fi
  697.     rm -f a.a a.b &&
  698.     echo a >a.a && echo b >a.b && chmod -w a.b || exit
  699.     if ./a.out && test ! -f a.a && test -f a.b
  700.     then b=0
  701.     else b=1
  702.     fi
  703.     rm -f a.a a.b || exit
  704. else h=0 a=0 b=0
  705. fi
  706. echo >>a.h "#define has_rename $h /* Does rename() work?  */"
  707. echo >>a.h "#define bad_a_rename $a /* Does rename(A,B) fail if A is unwritable?  */"
  708. echo >>a.h "#define bad_b_rename $b /* Does rename(A,B) fail if B is unwritable?  */"
  709.  
  710. : void, VOID
  711. cat >a.c <<'EOF'
  712. #include "a.h"
  713. void f() {}
  714. int main() {f(); exitmain(0);}
  715. EOF
  716. if $CS a.c $LS >&2
  717. then
  718.     v='(void) '
  719. else
  720.     v=
  721.     echo >>a.h 'typedef int void;'
  722. fi
  723. echo >>a.h "#define VOID $v/* 'VOID e;' discards the value of an expression 'e'.  */"
  724.  
  725. : has_seteuid
  726. case $has_getuid in
  727. 0)
  728.     a='/* ' z='*/ ' has_seteuid=?;;
  729. *)
  730.     a= z=
  731.     cat >a.c <<'EOF'
  732. #include "a.h"
  733. #ifndef geteuid
  734.     uid_t geteuid();
  735. #endif
  736. int main() {
  737. /* Guess, don't test.  Ugh.  Testing would require running conf.sh setuid.  */
  738. /* seteuid() isn't standardized yet, so the guess below may well be wrong.  */
  739. #if !_POSIX_VERSION || _POSIX_VERSION<=199009L&&!defined(sgi)&&!defined(__sgi__)&&!defined(sun)&&!defined(__sun__)
  740.     exitmain(1);
  741. #else
  742.     exitmain(seteuid(geteuid()) != 0);
  743. #endif
  744. }
  745. EOF
  746.     $RM || exit
  747.     if ($CL a.c $L && ./a.out) >&2
  748.     then has_seteuid=1
  749.     else has_seteuid=0
  750.     fi
  751. esac
  752. echo >>a.h "$a#define has_seteuid $has_seteuid $z/* Does seteuid() work?  See README.  */"
  753.  
  754. : has_setuid
  755. h=$has_seteuid
  756. case $h in
  757. 0)
  758.     cat >a.c <<'EOF'
  759. #include "a.h"
  760. #ifndef getuid
  761.     uid_t getuid();
  762. #endif
  763. int main() { exitmain(setuid(getuid()) != 0); }
  764. EOF
  765.     $RM || exit
  766.     ($CL a.c $L && ./a.out) >&2 && h=1
  767. esac
  768. echo >>a.h "$a#define has_setuid $h $z/* Does setuid() exist?  */"
  769.  
  770. : has_signal, signal_args, signal_type, sig_zaps_handler
  771. cat >a.c <<'EOF'
  772. #include "a.h"
  773. #ifndef getpid
  774.     pid_t getpid();
  775. #endif
  776. #if !defined(signal) && declare_signal
  777.     signal_type (*signal P((int,signal_type(*)signal_args)))signal_args;
  778. #endif
  779. signal_type nothing(i) int i; {}
  780. int main(argc, argv) int argc; char **argv;
  781. {
  782.     signal(SIGINT, nothing);
  783.     while (--argc)
  784.         kill(getpid(), SIGINT);
  785.     exitmain(0);
  786. }
  787. EOF
  788. for declare_signal in 1 0
  789. do
  790.     for signal_type in void int
  791.     do
  792.         for signal_args in 'P((int))' '()'
  793.         do
  794.             $RM || exit
  795.             ($CL \
  796.                 -Ddeclare_signal=$declare_signal \
  797.                 -Dsignal_args="$signal_args" \
  798.                 -Dsignal_type=$signal_type \
  799.                     a.c $L && ./a.out 1) >&2 && break
  800.         done && break
  801.     done && break
  802. done || {
  803.     echo >&2 "cannot deduce signal_args, signal_type"
  804.     exit 1
  805. }
  806. if ./a.out 1 2 >&2
  807. then z=0
  808. else z=1
  809. fi
  810. cat >>a.h <<'EOF'
  811. #define has_signal $has_signal /* Does signal() work?  */
  812. #define signal_args $signal_args /* arguments of signal handlers */
  813. #define signal_type $signal_type /* type returned by signal handlers */
  814. #define sig_zaps_handler $z /* Must a signal handler reinvoke signal()?  */
  815. EOF
  816.  
  817. : has_sigaction
  818. cat >a.c <<'EOF'
  819. #include "a.h"
  820. #ifndef getpid
  821.     pid_t getpid();
  822. #endif
  823. static sig_atomic_t volatile gotsig;
  824. static void getsig(i) int i; { gotsig = 1; }
  825. int main(argc, argv) int argc; char **argv;
  826. {
  827.     struct sigaction s;
  828.     sigset_t t;
  829.     if (sigemptyset(&t) != 0  ||  sigaddset(&t, SIGINT) != 0)
  830.         exitmain(1);
  831.     if (sigaction(SIGINT, (struct sigaction const*)0, &s) != 0)
  832.         exitmain(1);
  833.     s.sa_handler = getsig;
  834.     s.sa_mask = t;
  835.     if (sigaction(SIGINT, &s, (struct sigaction*)0) != 0)
  836.         exitmain(1);
  837.     kill(getpid(), SIGINT);
  838.     exitmain(gotsig != 1);
  839. }
  840. EOF
  841. $RM || exit
  842. if ($CL a.c $L && ./a.out) >&2
  843. then has_sigaction=1
  844. else has_sigaction=0
  845. fi
  846. echo >>a.h "#define has_sigaction $has_sigaction /* Does struct sigaction work?  */"
  847.  
  848. : has_sigblock, sigmask
  849. a='/* ' z='*/ '
  850. b='/* ' y='*/ '
  851. case $has_sigaction in
  852. 1)
  853.     h=? n=?;;
  854. *)
  855.     a= z=
  856.     cat >a.c <<'EOF'
  857. #include "a.h"
  858. #include <signal.h>
  859. #if define_sigmask
  860. #    define sigmask(s) (1 << ((s)-1))
  861. #endif
  862. int main()
  863. {
  864.     sigblock(sigmask(SIGHUP));
  865.     exitmain(kill(getpid(), SIGHUP) != 0);
  866. }
  867. EOF
  868.     if $RM || exit; ($CL a.c $L && ./a.out) >&2
  869.     then h=1
  870.     elif $RM || exit; ($CL -Ddefine_sigmask=1 a.c $L && ./a.out) >&2
  871.     then h=1 b= y=
  872.     else h=0
  873.     fi
  874. esac
  875. echo >>a.h "$a#define has_sigblock $h $z/* Does sigblock() work?  */"
  876. echo >>a.h "$b#define sigmask(s) (1 << ((s)-1)) $y/* Yield mask for signal number.  */"
  877.  
  878. : has_sys_siglist
  879. cat >a.c <<'EOF'
  880. #include "a.h"
  881. #ifndef sys_siglist
  882.     extern char const *sys_siglist[];
  883. #endif
  884. int main() { exitmain(!sys_siglist[1][0]); }
  885. EOF
  886. $RM || exit
  887. if ($CL a.c $L && ./a.out) >&2
  888. then h=1
  889. else h=0
  890. fi
  891. echo >>a.h "#define has_sys_siglist $h /* Does sys_siglist[] work?  */"
  892.  
  893. : fread_type, Fread, Fwrite
  894. cat >a.c <<'EOF'
  895. #define CHAR1 '#' /* the first character in this file */
  896. #include "a.h"
  897. #if !defined(fread) && declare_fread
  898.     fread_type fread P((void*,freadarg_type,freadarg_type,FILE*));
  899. #endif
  900. int main()
  901. {
  902.     char b;
  903.     exitmain(!(
  904.         fread(&b, (freadarg_type)1, (freadarg_type)1, stdin) == 1  &&
  905.         b==CHAR1
  906.     ));
  907. }
  908. EOF
  909. for declare_fread in 1 0
  910. do
  911.     for fread_type in ssize_t size_t int unsigned
  912.     do
  913.         for freadarg_type in size_t ssize_t unsigned int
  914.         do
  915.             $RM || exit
  916.             (
  917.                 $CL \
  918.                     -Ddeclare_fread=$declare_fread \
  919.                     -Dfreadarg_type=$freadarg_type \
  920.                     -Dfread_type=$fread_type \
  921.                     a.c $L &&
  922.                 ./a.out <a.c
  923.             ) >&2 && break
  924.         done && break
  925.     done && break
  926. done || {
  927.     echo >&2 "cannot deduce fread types"
  928.     exit 1
  929. }
  930. cat >>a.h <<'EOF'
  931. typedef $fread_type fread_type; /* type returned by fread() and fwrite() */
  932. typedef $freadarg_type freadarg_type; /* type of their size arguments */
  933. EOF
  934.  
  935. : malloc_type
  936. cat >a.c <<'EOF'
  937. #include "a.h"
  938. typedef void *malloc_type;
  939. #ifndef malloc
  940.     malloc_type malloc();
  941. #endif
  942. int main() { exitmain(!malloc(1)); }
  943. EOF
  944. if $CS a.c $LS >&2
  945. then t=void
  946. else t=char
  947. fi
  948. echo >>a.h "typedef $t *malloc_type; /* type returned by malloc() */"
  949.  
  950. : has_getcwd
  951. cat >a.c <<'EOF'
  952. #include "a.h"
  953. #ifndef getcwd
  954.     char *getcwd();
  955. #endif
  956. char buf[10000];
  957. int main() { exitmain(!getcwd(buf,10000)); }
  958. EOF
  959. $RM || exit
  960. if ($CL a.c $L && ./a.out) >&2
  961. then has_getcwd=1
  962. else has_getcwd=0
  963. fi
  964. echo >>a.h "#define has_getcwd $has_getcwd /* Does getcwd() work?  */"
  965.  
  966. : has_getwd
  967. case $has_getcwd in
  968. 1)
  969.     a='/* ' z='*/ ' h=?;;
  970. *)
  971.     a= z=
  972.     cat >a.c <<'EOF'
  973. #include "a.h"
  974. #include <sys/param.h>
  975. #ifndef getwd
  976.     char *getwd();
  977. #endif
  978. char buf[MAXPATHLEN];
  979. int main() { exitmain(!getwd(buf)); }
  980. EOF
  981.     $RM || exit
  982.     if ($CL a.c $L && ./a.out) >&2
  983.     then h=1
  984.     else h=0
  985.     fi
  986. esac
  987. echo >>a.h "$a#define has_getwd $h $z/* Does getwd() work?  */"
  988.  
  989. : has_mktemp
  990. cat >a.c <<'EOF'
  991. #include "a.h"
  992. #ifndef mktemp
  993.     char *mktemp();
  994. #endif
  995. int main()
  996. {
  997.     char b[9];
  998.     strcpy(b, "a.XXXXXX");
  999.     exitmain(!mktemp(b));
  1000. }
  1001. EOF
  1002. $RM || exit
  1003. if ($CL a.c $L && ./a.out) >&2
  1004. then h=1
  1005. else h=0
  1006. fi
  1007. echo >>a.h "#define has_mktemp $h /* Does mktemp() work?  */"
  1008.  
  1009. : has_NFS
  1010. echo >>a.h "#define has_NFS 1 /* Might NFS be used?  */"
  1011.  
  1012. : strchr
  1013. cat >a.c <<'EOF'
  1014. #include "a.h"
  1015. #ifndef strchr
  1016.     char *strchr();
  1017. #endif
  1018. int main() {exitmain(!strchr("abc", 'c'));}
  1019. EOF
  1020. $RM || exit
  1021. if ($CL a.c $L && ./a.out) >&2
  1022. then a='/* ' z='*/ '
  1023. else a= z=
  1024. fi
  1025. echo >>a.h "$a#define strchr index $z/* Use old-fashioned name for strchr()?  */"
  1026.  
  1027. : strrchr
  1028. cat >a.c <<'EOF'
  1029. #include "a.h"
  1030. #ifndef strrchr
  1031.     char *strrchr();
  1032. #endif
  1033. int main() {exitmain(!strrchr("abc", 'c'));}
  1034. EOF
  1035. $RM || exit
  1036. if ($CL a.c $L && ./a.out) >&2
  1037. then a='/* ' z='*/ '
  1038. else a= z=
  1039. fi
  1040. echo >>a.h "$a#define strrchr rindex $z/* Use old-fashioned name for strrchr()?  */"
  1041.  
  1042. : bad_unlink
  1043. cat >a.c <<'EOF'
  1044. #include "a.h"
  1045. int main() { exitmain(unlink("a.c") != 0); }
  1046. EOF
  1047. $RM && chmod -w a.c || exit
  1048. if $CL a.c $L >&2 && ./a.out >/dev/null && test ! -f a.c
  1049. then b=0
  1050. else b=1
  1051. fi
  1052. rm -f a.c || exit
  1053. echo >>a.h "#define bad_unlink $b /* Does unlink() fail on unwritable files?  */"
  1054.  
  1055. : has_vfork, has_fork, has_spawn, has_wait, has_waitpid, RCS_SHELL
  1056. cat >a.c <<'EOF'
  1057. #include "a.h"
  1058. #ifndef getpid
  1059.     pid_t getpid();
  1060. #endif
  1061. #if TRY_VFORK
  1062. #    ifndef vfork
  1063.         pid_t vfork();
  1064. #    endif
  1065. #else
  1066. #    ifndef fork
  1067.         pid_t fork();
  1068. #    endif
  1069. #    undef vfork
  1070. #    define vfork fork
  1071. #endif
  1072. #if TRY_WAITPID
  1073. #    ifndef waitpid
  1074.         pid_t waitpid();
  1075. #    endif
  1076. #else
  1077. #    ifndef wait
  1078.         pid_t wait();
  1079. #    endif
  1080. #endif
  1081. pid_t child;
  1082. int status;
  1083. struct stat st;
  1084. int main()
  1085. {
  1086.     pid_t parent = getpid();
  1087.     if (!(child = vfork())) {
  1088.         /* Tickle vfork/compiler bug (e.g. sparc gcc -O (1.37.1).  */
  1089.         pid_t i = getpid(), j = getpid();
  1090.         if (i!=getpid() || j!=getpid())
  1091.             _exit(!i);
  1092.         /* Tickle file descriptor bug (e.g. IRIX 3.3).  */
  1093.         _exit(close(1) != 0);
  1094.     } else {
  1095. #        if TRY_WAITPID
  1096.             if (waitpid(child, &status, 0) != child)
  1097.                 exitmain(1);
  1098. #        else
  1099.             while (wait(&status) != child)
  1100.                 ;
  1101. #        endif
  1102.         /* Test for presence of bugs.  */
  1103.         exitmain(status  ||  parent != getpid()  ||  fstat(1,&st) != 0);
  1104.     }
  1105. }
  1106. EOF
  1107. $RM || exit
  1108. if ($CL -DTRY_VFORK=1 a.c $L && ./a.out) >&2
  1109. then has_vfork=1
  1110. else has_vfork=0
  1111. fi
  1112. echo >>a.h "#define has_vfork $has_vfork /* Does vfork() work?  */"
  1113. h=$has_vfork
  1114. case $h in
  1115. 0)
  1116.     $RM || exit
  1117.     ($CL a.c $L && ./a.out) >&2 && h=1
  1118. esac
  1119. echo >>a.h "#define has_fork $h /* Does fork() work?  */"
  1120. $RM || exit
  1121. if ($CL -DTRY_VFORK=$has_vfork -DTRY_WAITPID=1 a.c $L && ./a.out) >&2
  1122. then h=1
  1123. else h=0
  1124. fi
  1125. echo >>a.h "#define has_spawn 0 /* Does spawn*() work?  */"
  1126. echo >>a.h "#define has_wait 1 /* Does wait() work?  */"
  1127. echo >>a.h "#define has_waitpid $h /* Does waitpid() work?  */"
  1128. echo >>a.h '#define RCS_SHELL "/bin/sh" /* shell to run RCS subprograms */'
  1129.  
  1130. : has_vfprintf
  1131. cat >a.c <<'EOF'
  1132. #include "a.h"
  1133. #if has_prototypes
  1134. int p(char const*format,...)
  1135. #else
  1136. /*VARARGS1*/ int p(format, va_alist) char *format; va_dcl
  1137. #endif
  1138. {
  1139.     int r;
  1140.     va_list args;
  1141.     vararg_start(args, format);
  1142.     r = vfprintf(stderr, format, args);
  1143.     va_end(args);
  1144.     return r;
  1145. }
  1146. int main() { exitmain(p("") != 0); }
  1147. EOF
  1148. $RM || exit
  1149. if ($CL a.c $L && ./a.out) >&2
  1150. then h=1
  1151. else h=0
  1152. fi
  1153. echo >>a.h "#define has_vfprintf $h /* Does vfprintf() work?  */"
  1154.  
  1155. : has__doprintf, has__doprnt
  1156. case $h in
  1157. 1)
  1158.     h=? a='/* ' z='*/ ';;
  1159. *)
  1160.     a= z=
  1161.     cat >a.c <<'EOF'
  1162. #include "a.h"
  1163. #if has_prototypes
  1164. int p(char const*format,...)
  1165. #else
  1166. /*VARARGS1*/ int p(format, va_alist) char *format; va_dcl
  1167. #endif
  1168. {
  1169.     va_list args;
  1170.     vararg_start(args, format);
  1171. #    if TRY__DOPRINTF
  1172.         _doprintf(stderr, format, args);
  1173. #    else
  1174.         _doprnt(format, args, stderr);
  1175. #    endif
  1176.     va_end(args);
  1177. }
  1178. int main() { p(""); exitmain(ferror(stderr) != 0); }
  1179. EOF
  1180.     $RM || exit
  1181.     if ($CL -DTRY__DOPRINTF=1 a.c $L && ./a.out) >&2
  1182.     then h=1
  1183.     else h=0
  1184.     fi
  1185. esac
  1186. echo >>a.h "$a#define has__doprintf $h $z/* Does _doprintf() work?  */"
  1187. case $h in
  1188. 0)
  1189.     $RM || exit
  1190.     if ($CL a.c $L && ./a.out) >&2
  1191.     then h=1
  1192.     else h=0
  1193.     fi
  1194.     a= z=;;
  1195. *)
  1196.     h=? a='/* ' z='*/ '
  1197. esac
  1198. echo >>a.h "$a#define has__doprnt $h $z/* Does _doprnt() work?  */"
  1199.  
  1200. : EXIT_FAILURE
  1201. cat >a.c <<'EOF'
  1202. #include "a.h"
  1203. int main() { exitmain(EXIT_FAILURE); }
  1204. EOF
  1205. $RM || exit
  1206. if $CL a.c $L >&2 && ./a.out
  1207. then a= z=
  1208. else a='/* ' z='*/ '
  1209. fi
  1210. echo >>a.h "$a#undef EXIT_FAILURE $z/* Uncomment this if EXIT_FAILURE is broken.  */"
  1211.  
  1212. : large_memory
  1213. echo >>a.h "#define large_memory $has_mmap /* Can main memory hold entire RCS files?  */"
  1214.  
  1215. : ULONG_MAX
  1216. cat >a.c <<'EOF'
  1217. #include "a.h"
  1218. #ifdef ULONG_MAX
  1219.     /*
  1220.      * "#if ULONG_MAX/10 <= 0" does not always work,
  1221.      * because some buggy implementations put casts in ULONG_MAX.
  1222.      */
  1223.     int main() { exitmain(ULONG_MAX/10 <= 0); }
  1224. #else
  1225.     int main() { exitmain(1); }
  1226. #endif
  1227. EOF
  1228. $RM || exit
  1229. if $CL a.c $L >&2 && ./a.out
  1230. then a='/* ' z='*/ '
  1231. else a= z=
  1232. fi
  1233. echo >>a.h "$a#undef ULONG_MAX $z/* Uncomment this if ULONG_MAX is broken (e.g. < 0).  */"
  1234.  
  1235. : struct utimbuf
  1236. cat >a.c <<'EOF'
  1237. #include "a.h"
  1238. struct utimbuf s;
  1239. int main() { s.actime = s.modtime = 1; exitmain(utime("a.c", &s) != 0); }
  1240. EOF
  1241. $RM || exit
  1242. if ($CL a.c $L && ./a.out) >&2
  1243. then a='/* ' z=' */'
  1244. else a= z=
  1245. fi
  1246. echo >>a.h "${a}struct utimbuf { time_t actime, modtime; };$z /* Uncomment this if needed.  */"
  1247.  
  1248. : CO
  1249. echo >>a.h "#define CO \"${RCSPREFIX}co\" /* name of 'co' program */"
  1250.  
  1251. : COMPAT2
  1252. echo >>a.h "#define COMPAT2 $COMPAT2 /* Are version 2 files supported?  */"
  1253.  
  1254. : DATEFORM
  1255. cat >a.c <<'EOF'
  1256. #include "a.h"
  1257. int main() { printf("%.2d", 1); exitmain(0); }
  1258. EOF
  1259. $RM && $CL a.c $L >&2 && r=`./a.out` || exit
  1260. case $r in
  1261. 01)    f=%.2d;;
  1262. *)    f=%02d
  1263. esac
  1264. echo >>a.h "#define DATEFORM \"$f.$f.$f.$f.$f.${f}\" /* e.g. 01.01.01.01.01.01 */"
  1265.  
  1266. : DIFF
  1267. echo >>a.h "#define DIFF \"${DIFF}\" /* name of 'diff' program */"
  1268.  
  1269. : DIFF3
  1270. echo >>a.h "#define DIFF3 \"${DIFF3}\" /* name of 'diff3' program */"
  1271.  
  1272. echo >>a.h "#define DIFF3_A $DIFF3_A /* Does diff3 have an -A option?  */"
  1273.  
  1274. echo >>a.h "#define DIFF3_BIN $DIFF3_BIN /* Is diff3 user-visible (not the /usr/lib auxiliary)?  */"
  1275.  
  1276. : DIFF_FLAGS
  1277. dfs=
  1278. for df in $DIFF_FLAGS
  1279. do dfs="$dfs, \"${df}\""
  1280. done
  1281. echo >>a.h "#define DIFF_FLAGS $dfs /* Make diff output suitable for RCS.  */"
  1282.  
  1283. : DIFF_L
  1284. echo >>a.h "#define DIFF_L $DIFF_L /* Does diff -L work? */"
  1285.  
  1286. : DIFF_SUCCESS, DIFF_FAILURE, DIFF_TROUBLE
  1287. cat >>a.h <<'EOF'
  1288. #define DIFF_SUCCESS $DIFF_SUCCESS /* DIFF status if no differences are found */
  1289. #define DIFF_FAILURE $DIFF_FAILURE /* DIFF status if differences are found */
  1290. #define DIFF_TROUBLE $DIFF_TROUBLE /* DIFF status if trouble */
  1291. EOF
  1292.  
  1293. : ED
  1294. echo >>a.h "#define ED \"${ED}\" /* name of 'ed' program (used only if !DIFF3_BIN) */"
  1295.  
  1296. : MERGE
  1297. echo >>a.h "#define MERGE \"${RCSPREFIX}merge\" /* name of 'merge' program */"
  1298.  
  1299. : '*SLASH*', ROOTPATH, TMPDIR, X_DEFAULT
  1300. case ${PWD-`pwd`} in
  1301. /*) # Posix
  1302.     SLASH=/
  1303.     qSLASH="'/'"
  1304.     SLASHes=$qSLASH
  1305.     isSLASH='#define isSLASH(c) ((c) == SLASH)'
  1306.     ROOTPATH='isSLASH((p)[0])'
  1307.     X_DEFAULT=",v$SLASH";;
  1308. ?:[/\\]*) # MS-DOS
  1309.     SLASH='\'
  1310.     qSLASH="'\\\\'"
  1311.     SLASHes="$qSLASH: case '/': case ':'"
  1312.     isSLASH='int isSLASH P((int));'
  1313.     ROOTPATH='((p)[0] && (p)[1]==':' && isSLASH((p)[2]))'
  1314.     X_DEFAULT="$SLASH,v";;
  1315. *)
  1316.     echo >&2 "cannot deduce SLASH"; exit 1
  1317. esac
  1318. cat >>a.h <<'EOF'
  1319. #define TMPDIR "${SLASH}tmp" /* default directory for temporary files */
  1320. #define SLASH $qSLASH /* principal pathname separator */
  1321. #define SLASHes $SLASHes /* \`case SLASHes:' labels all pathname separators */
  1322. $isSLASH /* Is arg a pathname separator?  */
  1323. #define ROOTPATH(p) $ROOTPATH /* Is p an absolute pathname?  */
  1324. #define X_DEFAULT "$X_DEFAULT" /* default value for -x option */
  1325. EOF
  1326.  
  1327. : DIFF_ABSOLUTE
  1328. case $DIFF in
  1329. "$SLASH"*) a=1;;
  1330. *) a=0
  1331. esac
  1332. echo >>a.h "#define DIFF_ABSOLUTE $a /* Is ROOTPATH(DIFF) true?  */"
  1333.  
  1334. : ALL_ABSOLUTE
  1335. a=1
  1336. for i in "$DIFF" "$DIFF3" "$ED" "$RCSPREFIX" "$SENDMAIL"/
  1337. do
  1338.     case $i in
  1339.     "$SLASH"* | "\"$SLASH"*) ;;
  1340.     *) a=0 break
  1341.     esac
  1342. done
  1343. echo >>a.h "#define ALL_ABSOLUTE $a /* Are all subprograms absolute pathnames?  */"
  1344.  
  1345. : SENDMAIL
  1346. case $SENDMAIL in
  1347. '') a='/* ' z='*/ ';;
  1348. *) a= z=
  1349. esac
  1350. echo >>a.h "$a#define SENDMAIL $SENDMAIL $z/* how to send mail */"
  1351.  
  1352. : TZ_must_be_set
  1353. echo >>a.h "#define TZ_must_be_set 0 /* Must TZ be set for gmtime() to work?  */"
  1354.  
  1355.  
  1356. : standard function declarations
  1357.  
  1358. cat >>a.h <<'EOF'
  1359.  
  1360.  
  1361.  
  1362. /* Adjust the following declarations as needed.  */
  1363.  
  1364.  
  1365. #if __GNUC__ && !__STRICT_ANSI__
  1366. #    define exiting volatile /* GCC extension: function cannot return */
  1367. #else
  1368. #    define exiting
  1369. #endif
  1370. EOF
  1371.  
  1372. cat >a.ha <<'EOF'
  1373.  
  1374. #if has_ftruncate
  1375.     int ftruncate P((int,off_t));
  1376. #endif
  1377.  
  1378. /* <sys/mman.h> */
  1379. #if has_madvise
  1380.     int madvise P((caddr_t,size_t,int));
  1381. #endif
  1382. #if has_mmap
  1383.     caddr_t mmap P((caddr_t,size_t,int,int,int,off_t));
  1384.     int munmap P((caddr_t,size_t));
  1385. #endif
  1386.  
  1387.  
  1388. /* Posix (ISO/IEC 9945-1: 1990 / IEEE Std 1003.1-1990) */
  1389. /* These definitions are for the benefit of non-Posix hosts, and */
  1390. /* Posix hosts that have Standard C compilers but traditional include files.  */
  1391. /* Unfortunately, mixed-up hosts are all too common.  */
  1392.  
  1393. /* <fcntl.h> */
  1394. #ifdef F_DUPFD
  1395.     int fcntl P((int,int,...));
  1396. #else
  1397.     int dup2 P((int,int));
  1398. #endif
  1399. #ifndef O_BINARY /* some non-Posix hosts need O_BINARY */
  1400. #    define O_BINARY 0 /* no effect on Posix */
  1401. #endif
  1402. #ifdef O_CREAT
  1403. #    define open_can_creat 1
  1404. #else
  1405. #    define open_can_creat 0
  1406. #    define O_RDONLY 0
  1407. #    define O_WRONLY 1
  1408. #    define O_RDWR 2
  1409. #    define O_CREAT 01000
  1410. #    define O_TRUNC 02000
  1411.     int creat P((char const*,mode_t));
  1412. #endif
  1413. #ifndef O_EXCL
  1414. #    define O_EXCL 0
  1415. #endif
  1416.  
  1417. /* <pwd.h> */
  1418. #if has_getpwuid
  1419.     struct passwd *getpwuid P((uid_t));
  1420. #endif
  1421.  
  1422. /* <signal.h> */
  1423. #if has_sigaction
  1424.     int sigaction P((int,struct sigaction const*,struct sigaction*));
  1425.     int sigaddset P((sigset_t*,int));
  1426.     int sigemptyset P((sigset_t*));
  1427. #else
  1428. #if has_sigblock
  1429.     /* BSD */
  1430.     int sigblock P((int));
  1431.     int sigmask P((int));
  1432.     int sigsetmask P((int));
  1433. #endif
  1434. #endif
  1435.  
  1436. /* <stdio.h> */
  1437. FILE *fdopen P((int,char const*));
  1438. int fileno P((FILE*));
  1439.  
  1440. /* <sys/stat.h> */
  1441. int chmod P((char const*,mode_t));
  1442. int fstat P((int,struct stat*));
  1443. int stat P((char const*,struct stat*));
  1444. mode_t umask P((mode_t));
  1445. #if has_fchmod
  1446.     int fchmod P((int,mode_t));
  1447. #endif
  1448. #ifndef S_IRUSR
  1449. #    ifdef S_IREAD
  1450. #        define S_IRUSR S_IREAD
  1451. #    else
  1452. #        define S_IRUSR 0400
  1453. #    endif
  1454. #    ifdef S_IWRITE
  1455. #        define S_IWUSR S_IWRITE
  1456. #    else
  1457. #        define S_IWUSR (S_IRUSR/2)
  1458. #    endif
  1459. #endif
  1460. #ifndef S_IRGRP
  1461. #    if has_getuid
  1462. #        define S_IRGRP (S_IRUSR / 0010)
  1463. #        define S_IWGRP (S_IWUSR / 0010)
  1464. #        define S_IROTH (S_IRUSR / 0100)
  1465. #        define S_IWOTH (S_IWUSR / 0100)
  1466. #    else
  1467.         /* single user OS -- not Posix or Unix */
  1468. #        define S_IRGRP 0
  1469. #        define S_IWGRP 0
  1470. #        define S_IROTH 0
  1471. #        define S_IWOTH 0
  1472. #    endif
  1473. #endif
  1474. #ifndef S_ISREG
  1475. #    define S_ISREG(n) (((n) & S_IFMT) == S_IFREG)
  1476. #endif
  1477.  
  1478. /* <sys/wait.h> */
  1479. #if has_wait
  1480.     pid_t wait P((int*));
  1481. #endif
  1482. #ifndef WEXITSTATUS
  1483. #    define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
  1484. #    undef WIFEXITED /* Avoid 4.3BSD incompatibility with Posix.  */
  1485. #endif
  1486. #ifndef WIFEXITED
  1487. #    define WIFEXITED(stat_val) (!((stat_val) & 255))
  1488. #endif
  1489.  
  1490. /* <unistd.h> */
  1491. char *getlogin P((void));
  1492. int close P((int));
  1493. int isatty P((int));
  1494. int link P((char const*,char const*));
  1495. int open P((char const*,int,...));
  1496. int unlink P((char const*));
  1497. int _filbuf P((FILE*)); /* keeps lint quiet in traditional C */
  1498. int _flsbuf P((int,FILE*)); /* keeps lint quiet in traditional C */
  1499. long pathconf P((char const*,int));
  1500. ssize_t write P((int,void const*,size_t));
  1501. #ifndef STDIN_FILENO
  1502. #    define STDIN_FILENO 0
  1503. #    define STDOUT_FILENO 1
  1504. #    define STDERR_FILENO 2
  1505. #endif
  1506. #if has_fork
  1507. #    if !has_vfork
  1508. #        undef vfork
  1509. #        define vfork fork
  1510. #    endif
  1511.     pid_t vfork P((void)); /* vfork is nonstandard but faster */
  1512. #endif
  1513. #if has_getcwd || !has_getwd
  1514.     char *getcwd P((char*,size_t));
  1515. #else
  1516.     char *getwd P((char*));
  1517. #endif
  1518. #if has_getuid
  1519.     uid_t getuid P((void));
  1520. #endif
  1521. #if has_readlink
  1522.     ssize_t readlink P((char const*,char*,size_t)); /* BSD; not standard yet */
  1523. #endif
  1524. #if has_setuid
  1525. #    if !has_seteuid
  1526. #        undef seteuid
  1527. #        define seteuid setuid
  1528. #    endif
  1529.     int seteuid P((uid_t));
  1530.     uid_t geteuid P((void));
  1531. #endif
  1532. #if has_spawn
  1533.     int spawnv P((int,char const*,char*const*));
  1534. #    if ALL_ABSOLUTE
  1535. #        define spawn_RCS spawnv
  1536. #    else
  1537. #        define spawn_RCS spawnvp
  1538.         int spawnvp P((int,char const*,char*const*));
  1539. #    endif
  1540. #else
  1541.     int execv P((char const*,char*const*));
  1542. #    if ALL_ABSOLUTE
  1543. #        define exec_RCS execv
  1544. #    else
  1545. #        define exec_RCS execvp
  1546.         int execvp P((char const*,char*const*));
  1547. #    endif
  1548. #endif
  1549.  
  1550. /* utime.h */
  1551. int utime P((char const*,struct utimbuf const*));
  1552.  
  1553.  
  1554. /* Standard C library */
  1555. /* These definitions are for the benefit of hosts that have */
  1556. /* traditional C include files, possibly with Standard C compilers.  */
  1557. /* Unfortunately, mixed-up hosts are all too common.  */
  1558.  
  1559. /* <errno.h> */
  1560. extern int errno;
  1561.  
  1562. /* <limits.h> */
  1563. #ifndef ULONG_MAX
  1564.     /* This does not work in #ifs, but it's good enough for us.  */
  1565. #    define ULONG_MAX ((unsigned long)-1)
  1566. #endif
  1567.  
  1568. /* <signal.h> */
  1569. #if has_signal
  1570.     signal_type (*signal P((int,signal_type(*)signal_args)))signal_args;
  1571. #endif
  1572.  
  1573. /* <stdio.h> */
  1574. FILE *fopen P((char const*,char const*));
  1575. fread_type fread P((void*,freadarg_type,freadarg_type,FILE*));
  1576. fread_type fwrite P((void const*,freadarg_type,freadarg_type,FILE*));
  1577. int fclose P((FILE*));
  1578. int feof P((FILE*));
  1579. int ferror P((FILE*));
  1580. int fflush P((FILE*));
  1581. int fprintf P((FILE*,char const*,...));
  1582. int fputs P((char const*,FILE*));
  1583. int fseek P((FILE*,long,int));
  1584. int printf P((char const*,...));
  1585. int rename P((char const*,char const*));
  1586. int sprintf P((char*,char const*,...));
  1587. long ftell P((FILE*));
  1588. void clearerr P((FILE*));
  1589. void perror P((char const*));
  1590. #ifndef L_tmpnam
  1591. #    define L_tmpnam 32 /* power of 2 > sizeof("/usr/tmp/xxxxxxxxxxxxxxx") */
  1592. #endif
  1593. #ifndef SEEK_SET
  1594. #    define SEEK_SET 0
  1595. #endif
  1596. #if has_mktemp
  1597.     char *mktemp P((char*)); /* traditional */
  1598. #else
  1599.     char *tmpnam P((char*));
  1600. #endif
  1601. #if has_vfprintf
  1602.     int vfprintf P((FILE*,char const*,va_list));
  1603. #else
  1604. #if has__doprintf
  1605.     void _doprintf P((FILE*,char const*,va_list)); /* Minix */
  1606. #else
  1607.     void _doprnt P((char const*,va_list,FILE*)); /* BSD */
  1608. #endif
  1609. #endif
  1610.  
  1611. /* <stdlib.h> */
  1612. char *getenv P((char const*));
  1613. exiting void _exit P((int));
  1614. exiting void exit P((int));
  1615. malloc_type malloc P((size_t));
  1616. malloc_type realloc P((malloc_type,size_t));
  1617. void free P((malloc_type));
  1618. #ifndef EXIT_FAILURE
  1619. #    define EXIT_FAILURE 1
  1620. #endif
  1621. #ifndef EXIT_SUCCESS
  1622. #    define EXIT_SUCCESS 0
  1623. #endif
  1624. #if !has_fork && !has_spawn
  1625.     int system P((char const*));
  1626. #endif
  1627.  
  1628. /* <string.h> */
  1629. char *strcpy P((char*,char const*));
  1630. char *strchr P((char const*,int));
  1631. char *strrchr P((char const*,int));
  1632. int memcmp P((void const*,void const*,size_t));
  1633. int strcmp P((char const*,char const*));
  1634. size_t strlen P((char const*));
  1635. void *memcpy P((void*,void const*,size_t));
  1636. #if has_memmove
  1637.     void *memmove P((void*,void const*,size_t));
  1638. #endif
  1639.  
  1640. /* <time.h> */
  1641. time_t time P((time_t*));
  1642. EOF
  1643.  
  1644. cat >a.c <<'EOF'
  1645. #include "a.h"
  1646. #define a 0
  1647. #define b 1
  1648. #if h==a
  1649. #    include "a.ha"
  1650. #else
  1651. #    include "a.hb"
  1652. #endif
  1653. int main() { exitmain(0); }
  1654. EOF
  1655.  
  1656. # Comment out lines in a.ha that the compiler rejects.
  1657. # a.ha may not contain comments that cross line boundaries.
  1658. # Leave the result in a.h$h.
  1659. h=a l=1
  1660. U=`wc -l <a.ha | sed 's| ||g'`
  1661. commentOut='s|^[^#/][^/]*|/* & */|'
  1662.  
  1663. until  test $U -lt $l  ||  $CS -Dh=$h a.c $LS >&2
  1664. do
  1665.     case $h in
  1666.     a) i=b;;
  1667.     *) i=a
  1668.     esac
  1669.  
  1670.     # The compiler rejects some line in l..U.
  1671.     # Use binary search to set l to be the index of the first bad line in l..U.
  1672.     u=$U
  1673.     while test $l -lt $u
  1674.     do
  1675.         M=`expr '(' $l + $u ')' / 2`
  1676.         M1=`expr $M + 1`
  1677.         sed "$M1,\$$commentOut" a.h$h >a.h$i || exit
  1678.         if $CS -Dh=$i a.c $LS >&2
  1679.         then l=$M1
  1680.         else u=$M
  1681.         fi
  1682.     done
  1683.  
  1684.     # Comment out the bad line.
  1685.     sed "$l$commentOut" a.h$h >a.h$i || exit
  1686.  
  1687.     h=$i
  1688.     l=`expr $l + 1`
  1689. done
  1690.  
  1691. cat a.h$h
  1692.