X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=Configure;h=86f28eb61d347e23f03ca9ba41c87d7368073ad5;hb=94b6baf514e11d40f0215cb928074cb7980c3082;hp=c183c1a80332050a6f445071a501458f805b15e1;hpb=b3634b015bfd34ae2ab484f115256d52ae40d683;p=p5sagit%2Fp5-mst-13.2.git diff --git a/Configure b/Configure index c183c1a..86f28eb 100755 --- a/Configure +++ b/Configure @@ -1,183 +1,322 @@ #! /bin/sh # -# If these # comments don't work, trim them. Don't worry about any other +# If these # comments don't work, trim them. Don't worry about any other # shell scripts, Configure will trim # comments from them for you. # -# (If you are trying to port this package to a machine without sh, I would -# suggest you cut out the prototypical config.h from the end of Configure -# and edit it to reflect your system. Some packages may include samples +# (If you are trying to port this package to a machine without sh, +# I would suggest you have a look at the prototypical config_h.SH file +# and edit it to reflect your system. Some packages may include samples # of config.h for certain machines, so you might look for one of those.) # -# $RCSfile: Configure,v $$Revision: 4.0.1.7 $$Date: 92/06/08 11:38:16 $ +# Yes, you may rip this off to use in other distribution packages. This +# script belongs to the public domain and cannot be copyrighted. # -# Yes, you may rip this off to use in other distribution packages. -# (Note: this Configure script was generated automatically. Rather than -# working with this copy of Configure, you may wish to get metaconfig.) +# (Note: this Configure script was generated automatically. Rather than +# working with this copy of Configure, you may wish to get metaconfig. +# The dist-3.0 package (which contains metaconfig) was posted in +# comp.sources.misc so you may fetch it yourself from your nearest +# archive site. Check with Archie if you don't know where that can be.) +# + +# $Id: Head.U,v 3.0.1.6 1994/10/29 15:54:19 ram Exp $ +# +# Generated on Tue Feb 28 10:00:27 EST 1995 [metaconfig 3.0 PL51] cat >/tmp/c1$$ </tmp/c2$$ </dev/null` + test "$me" || me=$0 + ;; +esac + +: Proper PATH setting +paths='/bin /usr/bin /usr/local/bin /usr/ucb /usr/local /usr/lbin' +paths=$paths:'/usr/5bin /etc /usr/gnu/bin /usr/new /usr/new/bin /usr/nbin' +paths=$paths:'/sys5.3/bin /sys5.3/usr/bin /bsd4.3/bin /bsd4.3/usr/ucb' +paths=$paths:'/bsd4.3/usr/bin /usr/bsd /bsd43/bin /usr/ccs/bin' +paths=$paths:'/etc /usr/lib /usr/ucblib /lib /usr/ccs/lib' +paths=$paths:'/sbin /usr/sbin /usr/libexec' + +for p in $paths +do + case ":$PATH:" in + *:$p:*) ;; + *) test -d $p && PATH=$PATH:$p ;; + esac +done + +PATH=.:$PATH +export PATH + +: Sanity checks if test ! -t 0; then - echo "Say 'sh Configure', not 'sh /dev/null 2>&1 && \ - echo "(I see you are using the Korn shell. Some ksh's blow up on Configure," && \ - echo "especially on exotic machines. If yours does, try the Bourne shell instead.)" - -unset CDPATH -if test ! -d ../UU; then - if test ! -d UU; then - mkdir UU - fi - cd UU +: On HP-UX, large Configure scripts may exercise a bug in /bin/sh +if test -f /hp-ux -a -f /bin/ksh; then + if (PATH=.; alias -x) >/dev/null 2>&1; then + : already under /bin/ksh + else + cat <<'EOM' +(Feeding myself to ksh to avoid nasty sh bug in "here document" expansion.) +EOM + unset ENV + exec /bin/ksh $0 "$@" + fi +else + : Warn them if they use ksh on other systems + (PATH=.; alias -x) >/dev/null 2>&1 && \ + cat </dev/null 2>>UU/missing) -done -if test -s missing; then - echo "WARNING: the following files are missing:" - cat missing - echo "INTERRUPT NOW, OR HIT RETURN TO PROCEED AT YOUR OWN RISK" - read junk +: general looking path for locating libraries +glibpth="/lib/pa1.1 /usr/lib/large /lib /usr/lib $xlibpth" +glibpth="$glibpth /lib/large /usr/lib/small /lib/small" +glibpth="$glibpth /usr/ccs/lib /usr/ucblib /usr/local/lib /usr/shlib" + +: Private path used by Configure to find libraries. Its value +: is prepended to libpth. This variable takes care of special +: machines, like the mips. Usually, it should be empty. +plibpth='' + +: default library list +libswanted='' +: full support for void wanted by default +defvoidused=15 + +: set useposix=false in your hint file to disable the POSIX extension. +useposix=true +: no include file wanted by default +inclwanted='' + +: List of libraries we want. +libswanted='net socket inet nsl nm ndbm gdbm dbm db malloc dl' +libswanted="$libswanted dld ld sun m c cposix posix ndir dir crypt" +libswanted="$libswanted ucb bsd BSD PW x" +: We probably want to search /usr/shlib before most other libraries. +: This is only used by the lib/ExtUtils/MakeMaker.pm routine extliblist. +glibpth=`echo " $glibpth " | sed -e 's! /usr/shlib ! !'` +glibpth="/usr/shlib $glibpth" +: Do not use vfork unless overridden by a hint file. +usevfork=false +: We might as well always be portable. It makes no difference for +: perl5, and makes people happy. +d_portable=define + +: script used to extract .SH files with variable substitutions +cat >extract <<'EOS' +CONFIG=true +echo "Doing variable substitutions on .SH files..." +if test -f MANIFEST; then + shlist=`awk '{print $1}' options.awk <<'EOF' +BEGIN { + optstr = "dD:eEf:hOrsSU:V"; # getopt-style specification + + len = length(optstr); + for (i = 1; i <= len; i++) { + c = substr(optstr, i, 1); + if (i < len) a = substr(optstr, i + 1, 1); else a = ""; + if (a == ":") { + arg[c] = 1; + i++; + } + opt[c] = 1; + } +} +{ + expect = 0; + str = $0; + if (substr(str, 1, 1) != "-") { + printf("'%s'\n", str); + next; + } + len = length($0); + for (i = 2; i <= len; i++) { + c = substr(str, i, 1); + if (!opt[c]) { + printf("-%s\n", substr(str, i)); + next; + } + printf("-%s\n", c); + if (arg[c]) { + if (i < len) + printf("'%s'\n", substr(str, i + 1)); + else + expect = 1; + next; + } + } +} +END { + if (expect) + print "?"; +} +EOF + +: process the command line options +set X `for arg in "$@"; do echo $arg; done | awk -f options.awk` +eval "set $*" +shift +rm -f options.awk + +: set up default values +fastread='' +reuseval=false +config_sh='' +alldone='' +error='' +silent='' +extractsh='' +override='' +rm -f optdef.sh + +: option parsing +while test $# -gt 0; do + case "$1" in + -d) shift; fastread=yes;; + -e) shift; alldone=cont;; + -f) + shift + cd .. + if test -r "$1"; then + config_sh="$1" + else + echo "$me: cannot read config file $1." >&2 + error=true + fi + cd UU + shift;; + -h) shift; error=true;; + -r) shift; reuseval=true;; + -s) shift; silent=true;; + -E) shift; alldone=exit;; + -O) shift; override=true;; + -S) shift; extractsh=true;; + -D) + shift + case "$1" in + *=) + echo "$me: use '-U symbol=', not '-D symbol='." >&2 + echo "$me: ignoring -D $1" >&2 + ;; + *=*) echo "$1" | \ + sed -e "s/'/'\"'\"'/g" -e "s/=\(.*\)/='\1'/" >> optdef.sh;; + *) echo "$1='define'" >> optdef.sh;; + esac + shift + ;; + -U) + shift + case "$1" in + *=) echo "$1" >> optdef.sh;; + *=*) + echo "$me: use '-D symbol=val', not '-U symbol=val'." >&2 + echo "$me: ignoring -U $1" >&2 + ;; + *) echo "$1='undef'" >> optdef.sh;; + esac + shift + ;; + -V) echo "$me generated by metaconfig 3.0 PL51." >&2 + exit 0;; + --) break;; + -*) echo "$me: unknown option $1" >&2; shift; error=true;; + *) break;; + esac +done + +case "$error" in +true) + cat >&2 <&1 +case "$silent" in +true) exec 1>/dev/null;; +esac + +: run the defines and the undefines, if any, but leave the file out there... +touch optdef.sh +. ./optdef.sh + +case "$extractsh" in +true) + case "$config_sh" in + '') config_sh='config.sh'; config='./config.sh';; + /*) config="$config_sh";; + *) config="./$config_sh";; + esac + echo " " + echo "Fetching answers from $config_sh..." + cd .. + . $config + test "$override" && . ./optdef.sh + echo " " + . ./UU/extract + rm -rf UU + echo "Done." + exit 0 + ;; +esac -: some greps do not return status, grrr. -echo "grimblepritz" >contains.txt -if grep blurfldyick contains.txt >/dev/null 2>&1 ; then - contains=contains -elif grep grimblepritz contains.txt >/dev/null 2>&1 ; then - contains=grep +: set package name +package=perl5 +first=`echo $package | sed -e 's/^\(.\).*/\1/'` +last=`echo $package | sed -e 's/^.\(.*\)/\1/'` +case "`echo AbyZ | tr '[:lower:]' '[:upper:]' 2>/dev/null`" in +ABYZ) spackage=`echo $first | tr '[:lower:]' '[:upper:]'`$last;; +*) spackage=`echo $first | tr '[a-z]' '[A-Z]'`$last;; +esac + +: Eunice requires " " instead of "", can you believe it +echo " " +: Here we go... +echo "Beginning of configuration questions for $package." + +trap 'echo " "; test -d ../UU && rm -rf X $rmlist; exit 1' 1 2 3 15 + +: Some greps do not return status, grrr. +echo "grimblepritz" >grimble +if grep blurfldyick grimble >/dev/null 2>&1 ; then + contains=contains +elif grep grimblepritz grimble >/dev/null 2>&1 ; then + contains=grep else - contains=contains + contains=contains fi +rm -f grimble : the following should work in any shell case "$contains" in contains*) - echo " " - echo "AGH! Grep doesn't return a status. Attempting remedial action." - cat >contains <<'EOSS' + echo " " + echo "AGH! Grep doesn't return a status. Attempting remedial action." + cat >contains <<'EOSS' grep "$1" "$2" >.greptmp && cat .greptmp && test -s .greptmp EOSS chmod +x contains esac -: see if sh knows # comments +: first determine how to suppress newline on echo command echo " " -echo "Checking your sh to see if it knows about # comments..." -if sh -c '#' >/dev/null 2>&1 ; then - echo "Your sh handles # comments correctly." - shsharp=true - spitshell=cat - echo " " - echo "Okay, let's see if #! works on this system..." - if test -f /bsd43/bin/echo; then - echo "#!/bsd43/bin/echo hi" > spit.sh - else - echo "#!/bin/echo hi" > spit.sh - fi - $eunicefix spit.sh - chmod +x spit.sh - ./spit.sh > today - if $contains hi today >/dev/null 2>&1; then - echo "It does." - sharpbang='#!' - else - echo "#! /bin/echo hi" > spit.sh - $eunicefix spit.sh - chmod +x spit.sh - ./spit.sh > today - if test -s today; then - echo "It does." - sharpbang='#! ' - else - echo "It doesn't." - sharpbang=': use ' - fi - fi +echo "Checking echo to see how to suppress newlines..." +(echo "hi there\c" ; echo " ") >.echotmp +if $contains c .echotmp >/dev/null 2>&1 ; then + echo "...using -n." + n='-n' + c='' else - echo "Your sh doesn't grok # comments--I will strip them later on." - shsharp=false - echo "exec grep -v '^#'" >spitshell - chmod +x spitshell - $eunicefix spitshell - spitshell=`pwd`/spitshell - echo "I presume that if # doesn't work, #! won't work either!" - sharpbang=': use ' + cat <<'EOM' +...using \c +EOM + n='' + c='\c' fi +echo $n "The star should be here-->$c" +echo '*' +rm -f .echotmp -: figure out how to guarantee sh startup +: Now test for existence of everything in MANIFEST echo " " -echo "Checking out how to guarantee sh startup..." -startsh=$sharpbang'/bin/sh' -echo "Let's see if '$startsh' works..." -cat >start.sh <&4 + awk '$1 !~ /PACK[A-Z]+/ {print $1}' ../MANIFEST | split -50 + rm -f missing + for filelist in x??; do + (cd ..; ls `cat UU/$filelist` >/dev/null 2>>UU/missing) + done + if test -s missing; then + cat missing >&4 + cat >&4 <<'EOM' -chmod +x start.sh -$eunicefix start.sh -if ./start.sh; then - echo "Yup, it does." -else - echo "Nope. You may have to fix up the shell scripts to make sure sh runs them." -fi +THIS PACKAGE SEEMS TO BE INCOMPLETE. + +You have the option of continuing the configuration process, despite the +distinct possibility that your kit is damaged, by typing 'y'es. If you +do, don't blame me if something goes wrong. I advise you to type 'n'o +and contact the author (lwall@netlabs.com). -: first determine how to suppress newline on echo command -echo "Checking echo to see how to suppress newlines..." -(echo "hi there\c" ; echo " ") >echotmp -if $contains c echotmp >/dev/null 2>&1 ; then - echo "...using -n." - n='-n' - c='' -else - cat <<'EOM' -...using \c EOM - n='' - c='\c' + echo $n "Continue? [n] $c" >&4 + read ans + case "$ans" in + y*) + echo "Continuing..." >&4 + rm -f missing + ;; + *) + echo "ABORTING..." >&4 + kill $$ + ;; + esac + else + echo "Looks good..." >&4 + fi +else + echo "There is no MANIFEST file. I hope your kit is complete !" fi -echo $n "Type carriage return to continue. Your cursor should be here-->$c" -read ans +rm -f missing x?? + +: compute the number of columns on the terminal for proper question formatting +case "$COLUMNS" in +'') COLUMNS='80';; +esac + +: set up the echo used in my read +myecho="case \"\$xxxm\" in +'') echo $n \"\$rp $c\" >&4;; +*) case \"\$rp\" in + '') echo $n \"[\$xxxm] $c\";; + *) + if test \`echo \"\$rp [\$xxxm] \" | wc -c\` -ge $COLUMNS; then + echo \"\$rp\" >&4 + echo $n \"[\$xxxm] $c\" >&4 + else + echo $n \"\$rp [\$xxxm] $c\" >&4 + fi + ;; + esac;; +esac" : now set up to do reads with possible shell escape and default assignment cat <myread +xxxm=\$dflt +$myecho +ans='!' case "\$fastread" in -yes) ans=''; echo " " ;; -*) ans='!';; +yes) case "\$dflt" in + '') ;; + *) ans=''; + case "\$silent-\$rp" in + true-) ;; + *) echo " " >&4;; + esac;; + esac;; +*) case "\$silent" in + true) case "\$rp" in + '') ans='';; + esac;; + esac;; esac while expr "X\$ans" : "X!" >/dev/null; do - read ans - case "\$ans" in - !) - sh - echo " " - echo $n "\$rp $c" - ;; - !*) - set \`expr "X\$ans" : "X!\(.*\)\$"\` - sh -c "\$*" - echo " " - echo $n "\$rp $c" - ;; - esac + read answ + set x \$xxxm + shift + aok=''; eval "ans=\"\$answ\"" && aok=y + case "\$answ" in + "\$ans") + case "\$ans" in + \\&*) + set x \`expr "X\$ans" : "X&\(.*\)\$"\` + shift + case "\$1" in + -d) + fastread=yes + echo "(OK, I'll run with -d after this question.)" + ;; + -*) + echo "*** Sorry, \$1 not supported yet." + ;; + esac + $myecho + ans=! + ;; + "!") + sh 1>&4 + echo " " + $myecho + ;; + !*) + set x \`expr "X\$ans" : "X!\(.*\)\$"\` + shift + sh 1>&4 -c "\$*" + echo " " + $myecho + ;; + esac;; + *) + case "\$aok" in + y) + echo "*** Substitution done -- please confirm." + xxxm="\$ans" + ans=\`echo $n "\$ans$c" | tr '\012' ' '\` + xxxm="\$ans" + ans=! + ;; + *) + echo "*** Error -- try again." + ans=! + ;; + esac + $myecho + ;; + esac + case "\$ans\$xxxm\$nostick" in + '') + ans=! + $myecho + ;; + esac done -rp='Your answer:' case "\$ans" in -'') ans="\$dflt";; +'') ans="\$xxxm";; esac EOSC +: create .config dir to save info across Configure sessions +test -d ../.config || mkdir ../.config +cat >../.config/README </dev/null || whoami) 2>&1` +if $contains "^$user\$" ../.config/instruct >/dev/null 2>&1; then + firsttime=false + echo " " + rp='Would you like to see the instructions?' + dflt=n + . ./myread + case "$ans" in + [yY]*) ;; + *) needman=false;; + esac +fi +if $needman; then + cat <>../.config/instruct;; + esac +fi + +: see if sh knows # comments +echo " " +echo "Checking your sh to see if it knows about # comments..." >&4 +if `sh -c '#' >/dev/null 2>&1`; then + echo "Your sh handles # comments correctly." + shsharp=true + spitshell=cat + echo " " + echo "Okay, let's see if #! works on this system..." + xcat=/bin/cat + test -f $xcat || xcat=/usr/bin/cat + echo "#!$xcat" >try + $eunicefix try + chmod +x try + ./try > today + if test -s today; then + echo "It does." + sharpbang='#!' + else + echo "#! $xcat" > try + $eunicefix try + chmod +x try + ./try > today + if test -s today; then + echo "It does." + sharpbang='#! ' + else + echo "It's just a comment." + sharpbang=': use ' + fi + fi +else + echo "Your sh doesn't grok # comments--I will strip them later on." + shsharp=false + cd .. + echo "exec grep -v '^[ ]*#'" >spitshell + chmod +x spitshell + $eunicefix spitshell + spitshell=`pwd`/spitshell + cd UU + echo "I presume that if # doesn't work, #! won't work either!" + sharpbang=': use ' +fi +rm -f try today + +: figure out how to guarantee sh startup +echo " " +echo "Checking out how to guarantee sh startup..." >&4 +case "$SYSTYPE" in +*bsd*|sys5*) startsh=$sharpbang"/$SYSTYPE/bin/sh";; +*) startsh=$sharpbang'/bin/sh';; +esac +echo "Let's see if '$startsh' works..." +cat >try <&4 cat <loc $startsh case \$# in @@ -564,24 +1239,27 @@ shift dflt=\$1 shift for dir in \$*; do - case "\$thing" in - .) + case "\$thing" in + .) if test -d \$dir/\$thing; then - echo \$dir - exit 0 + echo \$dir + exit 0 fi ;; - *) - if test -f \$dir/\$thing; then - echo \$dir/\$thing - exit 0 + *) + for thisthing in \$dir/\$thing; do + : just loop through to pick last item + done + if test -f \$thisthing; then + echo \$thisthing + exit 0 elif test -f \$dir/\$thing.exe; then - : on Eunice apparently - echo \$dir/\$thing - exit 0 + : on Eunice apparently + echo \$dir/\$thing + exit 0 fi ;; - esac + esac done echo \$dflt exit 1 @@ -589,526 +1267,593 @@ EOSC chmod +x loc $eunicefix loc loclist=" +awk cat +comm cp echo expr +find grep +ln +ls mkdir -mv rm sed sort +touch tr uniq " trylist=" Mcc -bison +byacc cpp csh +date egrep line nroff perl test uname -yacc " -pth=`echo :$boPATH:$PATH:$eoPATH: | sed -e 's/:/ /g'` +pth=`echo $PATH | sed -e 's/:/ /g'` +pth="$pth /lib /usr/lib" for file in $loclist; do - xxx=`./loc $file $file $pth` - eval $file=$xxx - eval _$file=$xxx - case "$xxx" in - /*) - echo $file is in $xxx. - ;; - *) - echo "I don't know where $file is. I hope it's in everyone's PATH." - ;; - esac + xxx=`./loc $file $file $pth` + eval $file=$xxx + eval _$file=$xxx + case "$xxx" in + /*) + echo $file is in $xxx. + ;; + *) + echo "I don't know where $file is. I hope it's in everyone's PATH." + ;; + esac done echo " " echo "Don't worry if any of the following aren't found..." -ans=offhand +say=offhand for file in $trylist; do - xxx=`./loc $file $file $pth` - eval $file=$xxx - eval _$file=$xxx - case "$xxx" in - /*) - echo $file is in $xxx. - ;; - *) - echo "I don't see $file out there, $ans." - ans=either - ;; - esac + xxx=`./loc $file $file $pth` + eval $file=$xxx + eval _$file=$xxx + case "$xxx" in + /*) + echo $file is in $xxx. + ;; + *) + echo "I don't see $file out there, $say." + say=either + ;; + esac done case "$egrep" in egrep) - echo "Substituting grep for egrep." - egrep=$grep - ;; + echo "Substituting grep for egrep." + egrep=$grep + ;; esac case "$test" in test) - echo "Hopefully test is built into your sh." - ;; -/bin/test) - if sh -c "PATH= test true" >/dev/null 2>&1; then - echo "Using the test built into your sh." - test=test - fi - ;; + echo "Hopefully test is built into your sh." + ;; *) - test=test - ;; + if `sh -c "PATH= test true" >/dev/null 2>&1`; then + echo "Using the test built into your sh." + test=test + _test=test + fi + ;; esac case "$echo" in echo) - echo "Hopefully echo is built into your sh." - ;; -/bin/echo) - echo " " - echo "Checking compatibility between /bin/echo and builtin echo (if any)..." - $echo $n "hi there$c" >Loc1.txt - echo $n "hi there$c" >Loc2.txt - if cmp Loc1.txt Loc2.txt >/dev/null 2>&1; then - echo "They are compatible. In fact, they may be identical." - else - case "$n" in - '-n') n='' c='\c' ans='\c' ;; - *) n='-n' c='' ans='-n' ;; - esac - cat <&4 + $echo $n "hi there$c" >foo1 + echo $n "hi there$c" >foo2 + if cmp foo1 foo2 >/dev/null 2>&1; then + echo "They are compatible. In fact, they may be identical." + else + case "$n" in + '-n') n='' c='\c';; + *) n='-n' c='';; + esac + cat <$c" + $echo "*" + fi + $rm -f foo1 foo2 + ;; esac -: set up shell script to do ~ expansion -cat >filexp <&2 - exit 1 - fi - case "\$1" in - */*) - echo \$dir/\`$expr x\$1 : '..[^/]*/\(.*\)'\` - ;; - *) - echo \$dir - ;; - esac - fi - ;; +: determine whether symbolic links are supported +echo " " +$touch blurfl +if $ln -s blurfl sym > /dev/null 2>&1 ; then + echo "Symbolic links are supported." >&4 + lns="$ln -s" +else + echo "Symbolic links are NOT supported." >&4 + lns="$ln" +fi +$rm -f blurfl sym + +: see whether [:lower:] and [:upper:] are supported character classes +echo " " +up='[A-Z]' +low='[a-z]' +case "`echo AbyZ | $tr '[:lower:]' '[:upper:]' 2>/dev/null`" in +ABYZ) + echo "Good, your tr supports [:lower:] and [:upper:] to convert case." >&4 + up='[:upper:]' + low='[:lower:]' + ;; *) - echo \$1 - ;; + echo "Your tr only supports [a-z] and [A-Z] to convert case." >&4 + ;; esac -EOSS -chmod +x filexp -$eunicefix filexp +: set up the translation script tr, must be called with ./tr of course +cat >tr <&1` - if test "X$tmp" = "X$lastuname"; then +: Try to determine whether config.sh was made on this system +case "$config_sh" in +'') +myuname=`( ($uname -a) 2>/dev/null || hostname) 2>&1` +myuname=`echo $myuname | $sed -e 's/^[^=]*=//' -e 's/\///g' | \ + ./tr '[A-Z]' '[a-z]' | tr '\012' ' '` +newmyuname="$myuname" +dflt=n +if test "$fastread" = yes; then dflt=y - else - dflt=n - fi - lastuname="$tmp" - rp="I see a config.sh file. Did Configure make it on THIS system? [$dflt]" - echo $n "$rp $c" - . myread - case "$ans" in - n*) echo "OK, I'll ignore it."; mv ../config.sh ../config.sh.old;; - *) echo "Fetching default answers from your old config.sh file..." - tmp="$n" - ans="$c" - . ../config.sh - n="$tmp" - c="$ans" - hint=previous - ;; - esac -else - lastuname=`(uname -a) 2>&1` +elif test -f ../config.sh; then + if $contains myuname= ../config.sh >/dev/null 2>&1; then + eval "`grep myuname= ../config.sh`" + fi + if test "X$myuname" = "X$newmyuname"; then + dflt=y + fi fi -if test -d ../hints && test ! -f ../config.sh; then - echo ' ' - echo "First time through, eh? I have some defaults handy for the following systems:" - (cd ../hints; ls -C *.sh | sed 's/\.sh/ /g') - dflt='' - : Half the following guesses are probably wrong... - test -f /irix && dflt="$dflt sgi" - test -f /xenix && dflt="$dflt sco_xenix" - test -f /dynix && dflt="$dflt dynix" - test -f /dnix && dflt="$dflt dnix" - test -f /bin/mips && /bin/mips && dflt="$dflt mips" - test -d /NextApps && test -f /usr/adm/software_version && dflt="$dflt next" - if test -f /bin/uname || test -f /usr/bin/uname; then - set `uname -a | tr '[A-Z]' '[a-z]'` - test -f "../hints/$5.sh" && dflt="$dflt $5" - - case "$5" in - 3b2) dflt="$dflt 3b2";; - fps*) dflt="$dflt fps";; - mips*) dflt="$dflt mips";; - [23]100) dflt="$dflt mips";; - next*) dflt="$dflt next" ;; - 6000) dflt="$dflt mc6000";; +: Get old answers from old config file if Configure was run on the +: same system, otherwise use the hints. +hint=default +cd .. +if test -f config.sh; then + echo " " + rp="I see a config.sh file. Shall I use it to set the defaults?" + . UU/myread + case "$ans" in + n*|N*) echo "OK, I'll ignore it."; mv config.sh config.sh.old;; + *) echo "Fetching default answers from your old config.sh file..." >&4 + tmp_n="$n" + tmp_c="$c" + . ./config.sh + cp config.sh UU + n="$tmp_n" + c="$tmp_c" + hint=previous + ;; esac +fi +if test ! -f config.sh; then + $cat <&4 + dflt='' + : Half the following guesses are probably wrong... If you have better + : tests or hints, please send them to lwall@netlabs.com + : The metaconfig authors would also appreciate a copy... + $test -f /irix && osname=irix + $test -f /xenix && osname=sco_xenix + $test -f /dynix && osname=dynix + $test -f /dnix && osname=dnix + $test -f /unicos && osname=unicos && osvers=`$uname -r` + $test -f /bin/mips && /bin/mips && osname=mips + $test -d /NextApps && set X `hostinfo | grep 'NeXT Mach.*:' | \ + $sed -e 's/://' -e 's/\./_/'` && osname=next && osvers=$4 + $test -d /usr/apollo/bin && osname=apollo + $test -f /etc/saf/_sactab && osname=svr4 + $test -d /usr/include/minix && osname=minix + if $test -f $uname; then + set X $myuname + shift + + case "$5" in + fps*) osname=fps ;; + mips*) + case "$4" in + umips) osname=umips ;; + *) osname=mips ;; + esac;; + [23]100) osname=mips ;; + next*) osname=next ;; + news*) osname=news ;; + i386*) + if $test -f /etc/kconfig; then + osname=isc + if test "$lns" = "ln -s"; then + osvers=4 + elif $contains _SYSV3 /usr/include/stdio.h > /dev/null 2>&1 ; then + osvers=3 + elif $contains _POSIX_SOURCE /usr/include/stdio.h > /dev/null 2>&1 ; then + osvers=2 + fi + fi + ;; + esac + + case "$1" in + aix) osname=aix + tmp=`( (oslevel) 2>/dev/null || echo "not found") 2>&1` + case "$tmp" in + 'not found') osvers="$4"."$3" ;; + '<3240'|'<>3240') osvers=3.2.0 ;; + '=3240'|'>3240'|'<3250'|'<>3250') osvers=3.2.4 ;; + '=3250'|'>3250') osvers=3.2.5 ;; + *) osvers=$tmp;; + esac + ;; + dnix) osname=dnix + osvers="$3" + ;; + domainos) osname=apollo + osvers="$3" + ;; + dgux) osname=dgux + osvers="$3" + ;; + freebsd) osname=freebsd + osvers="$3" ;; + genix) osname=genix ;; + hp*) osname=hpux + case "$3" in + *.08.*) osvers=9 ;; + *.09.*) osvers=9 ;; + *.10.*) osvers=10 ;; + *) osvers="$3" ;; + esac + ;; + irix) osname=irix + case "$3" in + 4*) osvers=4 ;; + 5*) osvers=5 ;; + *) osvers="$3" ;; + esac + ;; + linux) osname=linux + case "$3" in + 1*) osvers=1 ;; + *) osvers="$3" ;; + esac + ;; + netbsd*) osname=netbsd + osvers="$3" + ;; + bsd386) osname=bsd386 + osvers=`$uname -r` + ;; + next*) osname=next ;; + solaris) osname=solaris + case "$3" in + 5*) osvers=`echo $3 | $sed 's/^5/2/g'` ;; + *) osvers="$3" ;; + esac + ;; + sunos) osname=sunos + case "$3" in + 5*) osname=solaris + osvers=`echo $3 | $sed 's/^5/2/g'` ;; + *) osvers="$3" ;; + esac + ;; + titanos) osname=titanos + case "$3" in + 1*) osvers=1 ;; + 2*) osvers=2 ;; + 3*) osvers=3 ;; + 4*) osvers=4 ;; + *) osvers="$3" ;; + esac + ;; + ultrix) osname=ultrix + osvers="$3" + ;; + osf1) case "$5" in + alpha) + osname=dec_osf + osvers=`echo "$3" | sed 's/^[vt]//'` + ;; + hp*) osname=hp_osf1 ;; + mips) osname=mips_osf1 ;; + esac + ;; + uts) osname=uts + osvers="$3" + ;; + $2) case "$osname" in + *isc*) ;; + *freebsd*) ;; + svr*) + : svr4.x or possibly later + case "svr$3" in + ${osname}*) + osname=svr$3 + osvers=$4 + ;; + esac + case "$osname" in + svr4.0) + : Check for ESIX + if test -f /stand/boot ; then + eval `grep '^INITPROG=[a-z/0-9]*$' /stand/boot` + if test -n "$INITPROG" -a -f "$INITPROG"; then + isesix=`strings -a $INITPROG|grep 'ESIX SYSTEM V/386 Release 4.0'` + if test -n "$isesix"; then + osname=esix4 + fi + fi + fi + ;; + esac + ;; + *) if test -f /etc/systemid; then + osname=sco + set `echo $3 | $sed 's/\./ /g'` $4 + if $test -f sco_$1_$2_$3.sh; then + osvers=$1.$2.$3 + elif $test -f sco_$1_$2.sh; then + osvers=$1.$2 + elif $test -f sco_$1.sh; then + osvers=$1 + fi + else + case "$osname" in + '') : Still unknown. Probably a generic Sys V. + osname="sysv" + osvers="$3" + ;; + esac + fi + ;; + esac + ;; + *) case "$osname" in + '') : Still unknown. Probably a generic BSD. + osname="$1" + osvers="$3" + ;; + esac + ;; + esac + else + if test -f /vmunix -a -f news_os.sh; then + (what /vmunix | ../UU/tr '[A-Z]' '[a-z]') > ../UU/kernel.what 2>&1 + if $contains news-os ../UU/kernel.what >/dev/null 2>&1; then + osname=news_os + fi + $rm -f ../UU/kernel.what fi - fi - ;; + fi + + : Now look for a hint file osname_osvers, unless one has been + : specified already. + case "$hintfile" in + ''|' ') + file=`echo "${osname}_${osvers}" | $sed -e 's@\.@_@g' -e 's@_$@@'` + : Also try without trailing minor version numbers. + xfile=`echo $file | $sed -e 's@_[^_]*$@@'` + xxfile=`echo $xfile | $sed -e 's@_[^_]*$@@'` + xxxfile=`echo $xxfile | $sed -e 's@_[^_]*$@@'` + xxxxfile=`echo $xxxfile | $sed -e 's@_[^_]*$@@'` + case "$file" in + '') dflt=none ;; + *) case "$osvers" in + '') dflt=$file + ;; + *) if $test -f $file.sh ; then + dflt=$file + elif $test -f $xfile.sh ; then + dflt=$xfile + elif $test -f $xxfile.sh ; then + dflt=$xxfile + elif $test -f $xxxfile.sh ; then + dflt=$xxxfile + elif $test -f $xxxxfile.sh ; then + dflt=$xxxxfile + elif $test -f "${osname}.sh" ; then + dflt="${osname}" + else + dflt=none + fi + ;; + esac + ;; + esac + ;; + *) + dflt=`echo $hintfile | $sed 's/\.sh$//'` + ;; esac - fi - set X `echo $dflt | tr ' ' '\012' | sort | uniq` - shift - dflt=${1+"$@"} - case "$dflt" in - '') dflt=none;; - esac - echo '(You may give one or more space-separated answers, or "none" if appropriate.' - echo 'If your OS version has no hints, do not give a wrong version--say "none".)' - rp="Which of these apply, if any? [$dflt]" - echo $n "$rp $c" - . myread - for file in $ans; do - if test -f ../hints/$file.sh; then - . ../hints/$file.sh - cat ../hints/$file.sh >>../config.sh - hint=recommended - fi - done -fi - -cat >whoa <<'EOF' -eval "was=\$$2" -dflt=y -echo ' ' -echo "*** WHOA THERE!!! ***" -echo " The $hint value for \$$2 on this machine was \"$was\"!" -rp=" Keep the $hint value? [y]" -echo $n "$rp $c" -. myread -case "$ans" in -y) td=$was; tu=$was;; -esac -EOF -setvar='td=$define; tu=$undef; set X $1; eval "was=\$$2"; -case "$val$was" in -defineundef) . whoa; eval "$2=\$td";; -undefdefine) . whoa; eval "$2=\$tu";; -*) eval "$2=$val";; -esac' + $cat <> ../UU/config.sh + elif $test X$tans = X -o X$tans = Xnone ; then + : nothing + else + : Give one chance to correct a possible typo. + echo "$file.sh does not exist" + dflt=$file + rp="hint to use instead?" + . ../UU/myread + for file in $ans; do + if $test -f "$file.sh"; then + . ./$file.sh + $cat $file.sh >> ../UU/config.sh + elif $test X$ans = X -o X$ans = Xnone ; then + : nothing + else + echo "$file.sh does not exist -- ignored." + fi + done + fi + done + + hint=recommended + : Remember our hint file for later. + if $test -f "$file.sh" ; then + hintfile="$file" + else + hintfile='' + fi + + cd .. +fi +cd UU +;; +*) + echo " " + echo "Fetching default answers from $config_sh..." >&4 + tmp_n="$n" + tmp_c="$c" + cd .. + cp $config_sh config.sh 2>/dev/null + . ./config.sh + cd UU + cp ../config.sh . + n="$tmp_n" + c="$tmp_c" + hint=previous ;; - esac -esac -echo "If you don't want the manual sources installed, answer 'none'." -case "$mansrc" in -'') - dflt=`./loc . none /usr/man/local/man1 /usr/man/man.L /usr/man/manl /usr/man/mann /usr/man/u_man/man1 /usr/man/man1 /usr/local/man/man1` - ;; -*) dflt="$mansrc" - ;; esac -cont=true -while $test "$cont" ; do - echo " " - rp="Where do the manual pages (source) go (~name ok)? [$dflt]" - $echo $n "$rp $c" - . myread - case "$ans" in - 'none') - mansrc='' - cont='' - ;; - *) - mansrc=`./filexp "$ans"` - if $test -d "$mansrc"; then - cont='' - else - if $test "$fastread" = yes; then - dflt=y - else - dflt=n - fi - rp="Directory $mansrc doesn't exist. Use that name anyway? [$dflt]" - $echo $n "$rp $c" - . myread - dflt='' - case "$ans" in - y*) cont='';; - esac - fi - ;; - esac +test "$override" && . ./optdef.sh +myuname="$newmyuname" + +: Restore computed paths +for file in $loclist $trylist; do + eval $file="\$_$file" done -case "$mansrc" in -'') - manext='' - ;; -*l) - manext=l - ;; -*n) - manext=n - ;; -*o) - manext=l - ;; -*p) - manext=n - ;; -*C) - manext=C - ;; -*L) - manext=L - ;; -*) - manext=1 - ;; -esac -: Sigh. Well, at least the box is fast... +cat << EOM + +Configure uses the operating system name and version to set some defaults. +The default value is probably right if the name rings a bell. Otherwise, +since spelling matters for me, either accept the default or answer "none" +to leave it blank. + +EOM +case "$osname" in + ''|' ') + case "$hintfile" in + ''|' '|none) dflt=none ;; + *) dflt=`echo $hintfile | $sed -e 's/\.sh$//' -e 's/_.*$//'` ;; + esac + ;; + *) dflt="$osname" ;; +esac +rp="Operating system name?" +. ./myread +case "$ans" in +none) osname='' ;; +*) osname=`echo "$ans" | $sed -e 's/[ ][ ]*/_/g' | ./tr '[A-Z]' '[a-z]'`;; +esac +: who configured the system +cf_time=`$date 2>&1` +(logname > .temp) >/dev/null 2>&1 +$test -s .temp || (whoami > .temp) >/dev/null 2>&1 +$test -s .temp || echo unknown > .temp +cf_by=`$cat .temp` +$rm -f .temp + +: determine where manual pages are on this system echo " " -$echo $n "Hmm... $c" -case "$usrinclude" in -'') dflt='/usr/include';; -*) dflt=$usrinclude;; +case "$sysman" in +'') + syspath='/usr/man/man1 /usr/man/mann /usr/man/manl /usr/man/local/man1' + syspath="$syspath /usr/man/u_man/man1 /usr/share/man/man1" + syspath="$syspath /usr/catman/u_man/man1 /usr/man/l_man/man1" + syspath="$syspath /usr/local/man/u_man/man1 /usr/local/man/l_man/man1" + syspath="$syspath /usr/man/man.L /local/man/man1 /usr/local/man/man1" + sysman=`./loc . /usr/man/man1 $syspath` + ;; esac -inclPath='' -if $test -f /bin/mips && /bin/mips; then - echo "Looks like a MIPS system..." - $cat >usrinclude.c <<'EOCP' -#ifdef SYSTYPE_BSD43 -/bsd43 -#endif -EOCP - if cc -E usrinclude.c > usrinclude.out && $contains / usrinclude.out >/dev/null 2>&1 ; then - echo "and you're compiling with the BSD43 compiler and libraries." - dflt='/bsd43/usr/include' - inclPath='/bsd43' - else - echo "and you're compiling with the SysV compiler and libraries." - fi -else - echo "Doesn't look like a MIPS system." - echo "exit 1" >mips - chmod +x mips - $eunicefix mips -fi - -cont=true -while $test "$cont" ; do - echo " " - rp="Where are the include files you want to use? [$dflt]" - $echo $n "$rp $c" - . myread - usrinclude="$ans" - if $test -d $ans; then - cont='' - else - if $test "$fastread" = yes; then - dflt=y - else - dflt=n - fi - rp="Directory $ans doesn't exist. Use that name anyway? [$dflt]" - $echo $n "$rp $c" - . myread - dflt='' - case "$ans" in - y*) cont='';; - esac - fi -done - -: make some quick guesses about what we are up against -echo " " -echo exit 1 >bsd -echo exit 1 >usg -echo exit 1 >v7 -echo exit 1 >osf1 -echo exit 1 >eunice -echo exit 1 >xenix -echo exit 1 >venix -cat $usrinclude/signal.h $usrinclude/sys/signal.h >guess.txt 2>/dev/null -if test "$usrinclude" = "/bsd43/usr/include" ; then - echo "Looks kind of like a SysV MIPS running BSD, but we'll see..." - echo exit 0 >bsd -elif test -f /osf_boot || $contains "OSF/1" /usr/include/ctype.h; then - echo "Looks like an OSF/1 system, but we'll see..." - echo exit 0 >osf1 -elif test `echo abc | tr a-z A-Z` = Abc ; then - echo "Looks kind of like a USG system, but we'll see..." - echo exit 0 >usg -elif $contains SIGTSTP guess.txt >/dev/null 2>&1 ; then - echo "Looks kind of like a BSD system, but we'll see..." - echo exit 0 >bsd -else - echo "Looks kind of like a version 7 system, but we'll see..." - echo exit 0 >v7 -fi -case "$eunicefix" in -*unixtovms*) - cat <<'EOI' -There is, however, a strange, musty smell in the air that reminds me of -something...hmm...yes...I've got it...there's a VMS nearby, or I'm a Blit. -EOI - echo "exit 0" >eunice - d_eunice="$define" - ;; -*) - echo " " - echo "Congratulations. You aren't running Eunice." - d_eunice="$undef" - ;; -esac -if test -f /xenix; then - echo "Actually, this looks more like a XENIX system..." - echo "exit 0" >xenix -else - echo " " - echo "It's not Xenix..." -fi -chmod +x xenix -$eunicefix xenix -if test -f /venix; then - echo "Actually, this looks more like a VENIX system..." - echo "exit 0" >venix +if $test -d "$sysman"; then + echo "System manual is in $sysman." >&4 else - echo " " - if xenix; then - : null - else - echo "Nor is it Venix..." - fi + echo "Could not find manual pages in source form." >&4 fi -chmod +x bsd usg v7 osf1 eunice venix -$eunicefix bsd usg v7 eunice venix : see what memory models we can support case "$models" in '') - : We may not use Cppsym or we get a circular dependency through cc. - : But this should work regardless of which cc we eventually use. - cat >pdp11.c <<'EOP' + $cat >pdp11.c <<'EOP' main() { #ifdef pdp11 - exit(0); + exit(0); #else - exit(1); + exit(1); #endif } EOP - cc -o pdp11 pdp11.c >/dev/null 2>&1 - if pdp11 2>/dev/null; then - dflt='unsplit split' - else - ans=`./loc . X /lib/small /lib/large /usr/lib/small /usr/lib/large /lib/medium /usr/lib/medium /lib/huge` - case "$ans" in - X) dflt='none';; - *) if $test -d /lib/small || $test -d /usr/lib/small; then - dflt='small' - else - dflt='' - fi - if $test -d /lib/medium || $test -d /usr/lib/medium; then - dflt="$dflt medium" - fi - if $test -d /lib/large || $test -d /usr/lib/large; then - dflt="$dflt large" - fi - if $test -d /lib/huge || $test -d /usr/lib/huge; then - dflt="$dflt huge" - fi - esac - fi - ;; -*) dflt="$models" ;; + cc -o pdp11 pdp11.c >/dev/null 2>&1 + if ./pdp11 2>/dev/null; then + dflt='unsplit split' + else + tans=`./loc . X /lib/small /lib/large /usr/lib/small /usr/lib/large /lib/medium /usr/lib/medium /lib/huge` + case "$tans" in + X) dflt='none';; + *) if $test -d /lib/small || $test -d /usr/lib/small; then + dflt='small' + else + dflt='' + fi + if $test -d /lib/medium || $test -d /usr/lib/medium; then + dflt="$dflt medium" + fi + if $test -d /lib/large || $test -d /usr/lib/large; then + dflt="$dflt large" + fi + if $test -d /lib/huge || $test -d /usr/lib/huge; then + dflt="$dflt huge" + fi + esac + fi;; +*) dflt="$models";; esac $cat </dev/null 2>&1 || \ - $contains '\-i' $mansrc/man1/cc.1 >/dev/null 2>&1; then - dflt='-i' - else - dflt='none' - fi + small='' + medium='' + large='' + huge='' + unsplit='' + split='' ;; - *) dflt="$split";; - esac - rp="What flag indicates separate I and D space? [$dflt]" - $echo $n "$rp $c" - . myread - case "$ans" in - none) ans='';; - esac - split="$ans" - unsplit='' - ;; +*split) + case "$split" in + '') if $contains '\-i' $sysman/ld.1 >/dev/null 2>&1 || \ + $contains '\-i' $sysman/cc.1 >/dev/null 2>&1; then + dflt='-i' + else + dflt='none' + fi;; + *) dflt="$split";; + esac + rp="What flag indicates separate I and D space?" + . ./myread + tans="$ans" + case "$tans" in + none) tans='';; + esac + split="$tans" + unsplit='';; *large*|*small*|*medium*|*huge*) - case "$models" in - *large*) - case "$large" in - '') dflt='-Ml';; - *) dflt="$large";; - esac - rp="What flag indicates large model? [$dflt]" - $echo $n "$rp $c" - . myread - case "$ans" in - none) ans=''; + case "$models" in + *large*) + case "$large" in + '') dflt='-Ml';; + *) dflt="$large";; + esac + rp="What flag indicates large model?" + . ./myread + tans="$ans" + case "$tans" in + none) tans=''; esac - large="$ans" - ;; - *) large='';; - esac - case "$models" in - *huge*) - case "$huge" in - '') dflt='-Mh';; - *) dflt="$huge";; - esac - rp="What flag indicates huge model? [$dflt]" - $echo $n "$rp $c" - . myread - case "$ans" in - none) ans=''; + large="$tans";; + *) large='';; esac - huge="$ans" - ;; - *) huge="$large";; - esac - case "$models" in - *medium*) - case "$medium" in - '') dflt='-Mm';; - *) dflt="$medium";; - esac - rp="What flag indicates medium model? [$dflt]" - $echo $n "$rp $c" - . myread - case "$ans" in - none) ans=''; + case "$models" in + *huge*) case "$huge" in + '') dflt='-Mh';; + *) dflt="$huge";; + esac + rp="What flag indicates huge model?" + . ./myread + tans="$ans" + case "$tans" in + none) tans=''; + esac + huge="$tans";; + *) huge="$large";; esac - medium="$ans" - ;; - *) medium="$large";; - esac - case "$models" in - *small*) - case "$small" in - '') dflt='none';; - *) dflt="$small";; - esac - rp="What flag indicates small model? [$dflt]" - $echo $n "$rp $c" - . myread - case "$ans" in - none) ans=''; + case "$models" in + *medium*) case "$medium" in + '') dflt='-Mm';; + *) dflt="$medium";; + esac + rp="What flag indicates medium model?" + . ./myread + tans="$ans" + case "$tans" in + none) tans=''; + esac + medium="$tans";; + *) medium="$large";; + esac + case "$models" in + *small*) case "$small" in + '') dflt='none';; + *) dflt="$small";; + esac + rp="What flag indicates small model?" + . ./myread + tans="$ans" + case "$tans" in + none) tans=''; + esac + small="$tans";; + *) small='';; esac - small="$ans" ;; - *) small='';; - esac - ;; *) - echo "Unrecognized memory models--you may have to edit Makefile.SH" - ;; + echo "Unrecognized memory models--you may have to edit Makefile.SH" >&4 + ;; esac -: see if we need a special compiler +: make some quick guesses about what we are up against echo " " -if usg; then - case "$cc" in - '') - case "$Mcc" in - /*) dflt='Mcc' - ;; - *) - case "$large" in - -M*) - dflt='cc' - ;; - *) - if $contains '\-M' $mansrc/cc.1 >/dev/null 2>&1 ; then - dflt='cc -M' +$echo $n "Hmm... $c" +echo exit 1 >bsd +echo exit 1 >usg +echo exit 1 >v7 +echo exit 1 >osf1 +echo exit 1 >eunice +echo exit 1 >xenix +echo exit 1 >venix +d_bsd="$undef" +$cat /usr/include/signal.h /usr/include/sys/signal.h >foo 2>/dev/null +if test -f /osf_boot || $contains 'OSF/1' /usr/include/ctype.h >/dev/null 2>&1 +then + echo "Looks kind of like an OSF/1 system, but we'll see..." + echo exit 0 >osf1 +elif test `echo abc | tr a-z A-Z` = Abc ; then + xxx=`./loc addbib blurfl $pth` + if $test -f $xxx; then + echo "Looks kind of like a USG system with BSD features, but we'll see..." + echo exit 0 >bsd + echo exit 0 >usg + else + if $contains SIGTSTP foo >/dev/null 2>&1 ; then + echo "Looks kind of like an extended USG system, but we'll see..." else - dflt='cc' + echo "Looks kind of like a USG system, but we'll see..." fi - ;; - esac - ;; - esac + echo exit 0 >usg + fi +elif $contains SIGTSTP foo >/dev/null 2>&1 ; then + echo "Looks kind of like a BSD system, but we'll see..." + d_bsd="$define" + echo exit 0 >bsd +else + echo "Looks kind of like a Version 7 system, but we'll see..." + echo exit 0 >v7 +fi +case "$eunicefix" in +*unixtovms*) + $cat <<'EOI' +There is, however, a strange, musty smell in the air that reminds me of +something...hmm...yes...I've got it...there's a VMS nearby, or I'm a Blit. +EOI + echo exit 0 >eunice + d_eunice="$define" +: it so happens the Eunice I know will not run shell scripts in Unix format ;; - *) dflt="$cc";; - esac - $cat <<'EOM' - +*) + echo " " + echo "Congratulations. You aren't running Eunice." + d_eunice="$undef" + ;; +esac +if test -f /xenix; then + echo "Actually, this looks more like a XENIX system..." + echo exit 0 >xenix + d_xenix="$define" +else + echo " " + echo "It's not Xenix..." + d_xenix="$undef" +fi +chmod +x xenix +$eunicefix xenix +if test -f /venix; then + echo "Actually, this looks more like a VENIX system..." + echo exit 0 >venix +else + echo " " + if ./xenix; then + : null + else + echo "Nor is it Venix..." + fi +fi +chmod +x bsd usg v7 osf1 eunice xenix venix +$eunicefix bsd usg v7 osf1 eunice xenix venix +$rm -f foo + +: see if we need a special compiler +echo " " +if ./usg; then + case "$cc" in + '') case "$Mcc" in + /*) dflt='Mcc';; + *) case "$large" in + -M*) dflt='cc';; + *) if $contains '\-M' $sysman/cc.1 >/dev/null 2>&1 ; then + if $contains '\-M' $sysman/cpp.1 >/dev/null 2>&1; then + dflt='cc' + else + dflt='cc -M' + fi + else + dflt='cc' + fi;; + esac;; + esac;; + *) dflt="$cc";; + esac + $cat <<'EOM' On some systems the default C compiler will not resolve multiple global -references that happen to have the same name. On some such systems the -"Mcc" command may be used to force these to be resolved. On other systems -a "cc -M" command is required. (Note that the -M flag on other systems -indicates a memory model to use!) If you have the Gnu C compiler, you -might wish to use that instead. What command will force resolution on -EOM - $echo $n "this system? [$dflt] $c" - rp="Command to resolve multiple refs? [$dflt]" - . myread - cc="$ans" -else - case "$cc" in - '') dflt=cc;; - *) dflt="$cc";; - esac - rp="Use which C compiler? [$dflt]" - $echo $n "$rp $c" - . myread - cc="$ans" +references that happen to have the same name. On some such systems the "Mcc" +command may be used to force these to be resolved. On other systems a "cc -M" +command is required. (Note that the -M flag on other systems indicates a +memory model to use!) If you have the Gnu C compiler, you might wish to use +that instead. + +EOM + rp="What command will force resolution on this system?" + . ./myread + cc="$ans" +else + case "$cc" in + '') dflt=cc;; + *) dflt="$cc";; + esac + rp="Use which C compiler?" + . ./myread + cc="$ans" fi -case "$cc" in -*gcc*) cpp=`./loc gcc-cpp $cpp $pth` - case "$nativegcc" in - '') case "$ccflags" in - *-fpcc-struct-return*) dflt=n;; - *) dflt=y;; +echo " " +echo "Checking for GNU cc in disguise and/or its version number..." >&4 +$cat >gccvers.c < +int main() { +#ifdef __GNUC__ +#ifdef __VERSION__ + printf("%s\n", __VERSION__); +#else + printf("%s\n", "1"); +#endif +#endif + exit(0); +} +EOM +if $cc -o gccvers gccvers.c >/dev/null 2>&1; then + gccversion=`./gccvers` + case "$gccversion" in + '') echo "You are not using GNU cc." ;; + *) echo "You are using GNU cc $gccversion." ;; esac - ;; - undef) dflt=n;; - *) dflt=y;; - esac - echo " " - rp="Are your system (especially dbm) libraries compiled with gcc? [$dflt]" - $echo $n "$rp $c" - . myread - case "$ans" in - n*) nativegcc="$undef"; gccflags='-fpcc-struct-return';; - *) nativegcc="$define"; gccflags='';; - esac - case "$gccflags" in - *-ansi*) ;; - *-traditional*) ;; - *) gccflags="$gccflags -traditional -Dvolatile=__volatile__" ;; - esac - ;; +else + echo "I can't compile the test program -- Assuming it isn't GNU cc." +fi +$rm -f gccvers* +case "$gccversion" in +1*) cpp=`./loc gcc-cpp $cpp $pth` ;; esac -: determine optimize, if desired, or use for debug flag also -case "$optimize" in -' ') dflt="none" - ;; -'') dflt="-O"; - ;; -*) dflt="$optimize" - ;; +: decide how portable to be +case "$d_portable" in +"$define") dflt=y;; +*) dflt=n;; esac -cat <filexp <&2 + exit 1 + fi + case "\$1" in + */*) + echo \$dir/\`$expr x\$1 : '..[^/]*/\(.*\)'\` + ;; + *) + echo \$dir + ;; + esac fi - fi -done -case "$optimize" in --g*) - case "$dflt" in - *DEBUGGING*);; - *) dflt="$dflt -DDEBUGGING";; - esac - ;; + ;; +*) + echo \$1 + ;; esac -if $contains 'LANGUAGE_C' $usrinclude/signal.h >/dev/null 2>&1; then - case "$dflt" in - *LANGUAGE_C*);; - *) dflt="$dflt -DLANGUAGE_C";; - *) if osf1; then - dflt="$dflt -D__LANGUAGE_C__" - else - dflt="$dflt -DLANGUAGE_C" - fi - ;; - esac -fi -if $contains '_NO_PROTO' $usrinclude/signal.h >/dev/null 2>&1; then - case "$dflt" in - *_NO_PROTO*);; - *) osf1 || dflt="$dflt -D_NO_PROTO";; - esac -fi -case "$dflt" in -'') dflt=none;; +EOSS +chmod +x filexp +$eunicefix filexp + +: now set up to get a file name +cat <<'EOSC' >getfile +tilde='' +fullpath='' +already='' +skip='' +none_ok='' +exp_file='' +nopath_ok='' +orig_rp="$rp" +orig_dflt="$dflt" + +case "$fn" in +*\(*) + expr $fn : '.*(\(.*\)).*' | tr ',' '\012' >getfile.ok + fn=`echo $fn | sed 's/(.*)//'` + ;; esac -cat </dev/null 2>&1 + then + value="$ans" + ansexp="$ans" + break + fi + case "$ans" in + none) + value='' + ansexp='' + case "$none_ok" in + true) type='';; + esac + ;; + *) + case "$tilde" in + '') value="$ans" + ansexp="$ans";; + *) + value=`UU/filexp $ans` + case $? in + 0) + if test "$ans" != "$value"; then + echo "(That expands to $value on this system.)" + fi + ;; + *) value="$ans";; + esac + ansexp="$value" + case "$exp_file" in + '') value="$ans";; + esac + ;; + esac + case "$fullpath" in + true) + case "$ansexp" in + /*) value="$ansexp" ;; + *) + redo=true + case "$already" in + true) + echo "I shall only accept a full path name, as in /bin/ls." >&4 + echo "Use a ! shell escape if you wish to check pathnames." >&4 + ;; + *) + echo "Please give a full path name, starting with slash." >&4 + case "$tilde" in + true) + echo "Note that using ~name is ok provided it expands well." >&4 + already=true + ;; + esac + esac + ;; + esac + ;; + esac + case "$redo" in + '') + case "$type" in + File) + if test -f "$ansexp"; then + type='' + elif test -r "$ansexp" || (test -h "$ansexp") >/dev/null 2>&1 + then + echo "($value is not a plain file, but that's ok.)" + type='' + fi + ;; + Directory) + if test -d "$ansexp"; then + type='' + fi + ;; + Locate) + if test -d "$ansexp"; then + echo "(Looking for $loc_file in directory $value.)" + value="$value/$loc_file" + ansexp="$ansexp/$loc_file" + fi + if test -f "$ansexp"; then + type='' + fi + case "$nopath_ok" in + true) case "$value" in + */*) ;; + *) echo "Assuming $value will be in people's path." + type='' + ;; + esac + ;; + esac + ;; + esac + + case "$skip" in + true) type=''; + esac + + case "$type" in + '') ;; + *) + if test "$fastread" = yes; then + dflt=y + else + dflt=n + fi + rp="$what $value doesn't exist. Use that name anyway?" + . UU/myread + dflt='' + case "$ans" in + y*) type='';; + *) echo " ";; + esac + ;; + esac + ;; + esac + ;; + esac +done +cd UU +ans="$value" +rp="$orig_rp" +dflt="$orig_dflt" +rm -f getfile.ok +EOSC + +: What should the include directory be ? +echo " " +$echo $n "Hmm... $c" +dflt='/usr/include' +incpath='' +mips_type='' +if $test -f /bin/mips && /bin/mips; then + echo "Looks like a MIPS system..." + $cat >usr.c <<'EOCP' +#ifdef SYSTYPE_BSD43 +/bsd43 +#endif +EOCP + if $cc -E usr.c > usr.out && $contains / usr.out >/dev/null 2>&1; then + dflt='/bsd43/usr/include' + incpath='/bsd43' + mips_type='BSD 4.3' + else + mips_type='System V' + fi + $rm -f usr.c usr.out + echo "and you're compiling with the $mips_type compiler and libraries." + echo "exit 0" >mips +else + echo "Doesn't look like a MIPS system." + echo "exit 1" >mips +fi +chmod +x mips +$eunicefix mips +echo " " +case "$usrinc" in +'') ;; +*) dflt="$usrinc";; +esac +fn=d/ +rp='Where are the include files you want to use?' +. ./getfile +usrinc="$ans" + +: see how we invoke the C preprocessor +echo " " +echo "Now, how can we feed standard input to your C preprocessor..." >&4 +cat <<'EOT' >testcpp.c +#define ABC abc +#define XYZ xyz +ABC.XYZ +EOT +cd .. +echo 'cat >.$$.c; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' >cppstdin +chmod 755 cppstdin +wrapper=`pwd`/cppstdin +ok='false' +cd UU + +if $test "X$cppstdin" != "X" && \ + $cppstdin $cppminus testcpp.out 2>&1 && \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 +then + echo "You used to use $cppstdin $cppminus so we'll use that again." + case "$cpprun" in + '') echo "But let's see if we can live without a wrapper..." ;; + *) + if $cpprun $cpplast testcpp.out 2>&1 && \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 + then + echo "(And we'll use $cpprun $cpplast to preprocess directly.)" + ok='true' + else + echo "(However, $cpprun $cpplast does not work, let's see...)" + fi + ;; + esac +else + case "$cppstdin" in + '') ;; + *) + echo "Good old $cppstdin $cppminus does not seem to be of any help..." + ;; + esac +fi + +if $ok; then + : nothing +elif echo 'Maybe "'"$cc"' -E" will work...'; \ + $cc -E testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "Yup, it does." + x_cpp="$cc -E" + x_minus=''; +elif echo 'Nope...maybe "'"$cc"' -E -" will work...'; \ + $cc -E - testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "Yup, it does." + x_cpp="$cc -E" + x_minus='-'; +elif echo 'Nope...maybe "'"$cc"' -P" will work...'; \ + $cc -P testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "Yipee, that works!" + x_cpp="$cc -P" + x_minus=''; +elif echo 'Nope...maybe "'"$cc"' -P -" will work...'; \ + $cc -P - testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "At long last!" + x_cpp="$cc -P" + x_minus='-'; +elif echo 'No such luck, maybe "'$cpp'" will work...'; \ + $cpp testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "It works!" + x_cpp="$cpp" + x_minus=''; +elif echo 'Nixed again...maybe "'$cpp' -" will work...'; \ + $cpp - testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "Hooray, it works! I was beginning to wonder." + x_cpp="$cpp" + x_minus='-'; +elif echo 'Uh-uh. Time to get fancy. Trying a wrapper...'; \ + $wrapper testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + x_cpp="$wrapper" + x_minus='' + echo "Eureka!" +else + dflt='' + rp="No dice. I can't find a C preprocessor. Name one:" + . ./myread + x_cpp="$ans" + x_minus='' + $x_cpp testcpp.out 2>&1 + if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "OK, that will do." >&4 + else +echo "Sorry, I can't get that to work. Go find one and rerun Configure." >&4 + exit 1 + fi +fi + +case "$ok" in +false) + cppstdin="$x_cpp" + cppminus="$x_minus" + cpprun="$x_cpp" + cpplast="$x_minus" + set X $x_cpp + shift + case "$1" in + "$cpp") + echo "Perhaps can we force $cc -E using a wrapper..." + if $wrapper testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 + then + echo "Yup, we can." + cppstdin="$wrapper" + cppminus=''; + else + echo "Nope, we'll have to live without it..." + fi + ;; + esac + case "$cpprun" in + "$wrapper") + cpprun='' + cpplast='' + ;; + esac + ;; +esac + +case "$cppstdin" in +"$wrapper") ;; +*) $rm -f $wrapper;; +esac +$rm -f testcpp.c testcpp.out + +: determine optimize, if desired, or use for debug flag also +case "$optimize" in +' ') dflt='none';; +'') dflt='-O';; +*) dflt="$optimize";; +esac +$cat </dev/null 2>&1 + then + dflt="$dflt -posix" + fi + ;; + esac + ;; +esac + +case "$mips_type" in +*BSD*) ;; +'') ;; +*) inclwanted="$inclwanted $usrinc/bsd";; +esac +for thisincl in $inclwanted; do + if $test -d $thisincl; then + if $test x$thisincl != x$usrinc; then + case "$dflt" in + *$thisincl*);; + *) dflt="$dflt -I$thisincl";; + esac + fi fi - fi done + +inctest='if $contains $2 $usrinc/$1 >/dev/null 2>&1; then + xxx=true; +elif $contains $2 $usrinc/sys/$1 >/dev/null 2>&1; then + xxx=true; +else + xxx=false; +fi; +if $xxx; then + case "$dflt" in + *$2*);; + *) dflt="$dflt -D$2";; + esac; +fi' + +if ./osf1; then + set signal.h __LANGUAGE_C__; eval $inctest +else + set signal.h LANGUAGE_C; eval $inctest +fi +set signal.h NO_PROTOTYPE; eval $inctest +set signal.h _NO_PROTO; eval $inctest + +case "$dflt" in +'') dflt=none;; +esac +case "$ccflags" in +'') ;; +*) dflt="$ccflags";; +esac +$cat <&4 + set X $cppflags + shift + cppflags='' + $cat >cpp.c <<'EOM' +#define BLURFL foo + +BLURFL xx LFRULB EOM + previous='' + for flag in $* + do + case "$flag" in + -*) ftry="$flag";; + *) ftry="$previous $flag";; + esac + if $cppstdin -DLFRULB=bar $ftry $cppminus cpp1.out 2>/dev/null && \ + $cpprun -DLFRULB=bar $ftry $cpplast cpp2.out 2>/dev/null && \ + $contains 'foo.*xx.*bar' cpp1.out >/dev/null 2>&1 && \ + $contains 'foo.*xx.*bar' cpp2.out >/dev/null 2>&1 + then + cppflags="$cppflags $ftry" + previous='' + else + previous="$flag" + fi + done + set X $cppflags + shift + cppflags=${1+"$@"} + case "$cppflags" in + *-*) echo "They appear to be: $cppflags";; + esac + $rm -f cpp.c cpp?.out + ;; +esac +: flags used in final linking phase +case "$ldflags" in +'') if ./venix; then + dflt='-i -z' + else + dflt='' + fi + case "$ccflags" in + *-posix*) dflt="$dflt -posix" ;; + esac + case "$dflt" in + '') dflt='none' ;; + esac + ;; +*) dflt="$ldflags";; +esac echo " " -rp="Any additional libraries? [$dflt]" -$echo $n "$rp $c" -. myread +rp="Any additional ld flags (NOT including libraries)?" +. ./myread case "$ans" in -none) ans=''; +none) ldflags='';; +*) ldflags="$ans";; esac -libs="$ans" +rmlist="$rmlist pdp11" -: check for size of random number generator -echo " " -case "$alignbytes" in -'') - echo "Checking alignment constraints..." - $cat >try.c <<'EOCP' -struct foobar { - char foo; - double bar; -} try; -main() -{ - printf("%d\n", (char*)&try.bar - (char*)&try.foo); -} -EOCP - if $cc $ccflags try.c -o try >/dev/null 2>&1 ; then - dflt=`./try` - else - dflt='?' - echo "(I can't seem to compile the test program...)" +: Set private lib path +case "$plibpth" in +'') if ./mips; then + plibpth="$incpath/usr/lib /usr/local/lib /usr/ccs/lib" + fi;; +esac +case "$libpth" in +' ') dlist='';; +'') dlist="$plibpth $glibpth";; +*) dlist="$libpth";; +esac + +: Now check and see which directories actually exist, avoiding duplicates +libpth='' +for xxx in $dlist +do + if $test -d $xxx; then + case " $libpth " in + *" $xxx "*) ;; + *) libpth="$libpth $xxx";; + esac fi - ;; +done +$cat <<'EOM' + +Some systems have incompatible or broken versions of libraries. Among +the directories listed in the question below, please remove any you +know not to be holding relevant libraries, and add any that are needed. +Say "none" for none. + +EOM +case "$libpth" in +'') dflt='none';; *) - dflt="$alignbytes" - ;; + set X $libpth + shift + dflt=${1+"$@"} + ;; +esac +rp="Directories to use for library searches?" +. ./myread +case "$ans" in +none) libpth=' ';; +*) libpth="$ans";; esac -rp="Doubles must be aligned on a how-many-byte boundary? [$dflt]" -$echo $n "$rp $c" -. myread -alignbytes="$ans" -$rm -f try.c try -: determine where public executables go -cat <&4 +case "$libs" in +' '|'') dflt='';; +*) dflt="$libs";; +esac +case "$libswanted" in +'') libswanted='c_s';; +esac +for thislib in $libswanted; do + + if xxx=`./loc lib$thislib.$so.[0-9]'*' X $libpth`; $test -f "$xxx"; then + echo "Found -l$thislib (shared)." + case " $dflt " in + *"-l$thislib "*);; + *) dflt="$dflt -l$thislib";; + esac + elif xxx=`./loc lib$thislib.$so X $libpth` ; $test -f "$xxx"; then + echo "Found -l$thislib (shared)." + case " $dflt " in + *"-l$thislib "*);; + *) dflt="$dflt -l$thislib";; + esac + elif xxx=`./loc lib$thislib.a X $libpth`; $test -f "$xxx"; then + echo "Found -l$thislib." + case " $dflt " in + *"-l$thislib "*);; + *) dflt="$dflt -l$thislib";; + esac + elif xxx=`./loc lib${thislib}_s.a X $libpth`; $test -f "$xxx"; then + echo "Found -l${thislib}_s." + case " $dflt " in + *"-l$thislib "*);; + *) dflt="$dflt -l${thislib}_s";; + esac + elif xxx=`./loc Slib$thislib.a X $xlibpth`; $test -f "$xxx"; then + echo "Found -l$thislib." + case " $dflt " in + *"-l$thislib "*);; + *) dflt="$dflt -l$thislib";; + esac + else + echo "No -l$thislib." + fi +done +set X $dflt +shift +dflt="$*" +case "$libs" in +'') dflt="$dflt";; +*) dflt="$libs";; +esac +case "$dflt" in +' '|'') dflt='none';; esac -case "$installbin" in -'') - dflt=`echo $bin | sed 's#^/afs/#/afs/.#'` - test -d $dflt || dflt="$bin" - ;; -*) dflt="$installbin" - ;; +$cat </dev/null` + if $test $dflt -gt 20; then + dflt=y + else + dflt=n + fi + ;; +*) + case "$usenm" in + true) dflt=y;; *) dflt=n;; esac - rp="Directory $installbin doesn't exist. Use that name anyway? [$dflt]" - $echo $n "$rp $c" - . myread - dflt='' - case "$ans" in - y*) cont='';; - esac - fi -done + ;; +esac +$cat <byteorder.c <<'EOCP' -#include -main() -{ - int i; - union { - unsigned long l; - char c[sizeof(long)]; - } u; - - if (sizeof(long) > 4) - u.l = (0x08070605L << 32) | 0x04030201L; - else - u.l = 0x04030201L; - for (i=0; i < sizeof(long); i++) - printf("%c",u.c[i]+'0'); - printf("\n"); -} -EOCP - if $cc byteorder.c -o byteorder >/dev/null 2>&1 ; then - dflt=`./byteorder` - case "$dflt" in - ????|????????) echo "(The test program ran ok.)";; - *) echo "(The test program didn't run right for some reason.)";; +rp='Shall I use nm to extract C symbols from the libraries?' +. ./myread +case "$ans" in +n|N) usenm=false;; +*) usenm=true;; +esac + +runnm=$usenm +case "$reuseval" in +true) runnm=false;; +esac + +: nm options which may be necessary +case "$nm_opt" in +'') if $test -f /mach_boot; then + nm_opt='' + elif $test -d /usr/ccs/lib; then + nm_opt='-p' + elif $test -f /dgux; then + nm_opt='-p' + else + nm_opt='' + fi;; +esac + +case "$runnm" in +true) +: get list of predefined functions in a handy place +echo " " +case "$libc" in +'') libc=unknown + case "$libs" in + *-lc_s*) libc=`./loc libc_s.a $libc $libpth` esac - else - dflt='4321' - echo "(I can't seem to compile the test program. Guessing big-endian...)" - fi - ;; + ;; +esac +libnames=''; +case "$libs" in +'') ;; +*) for thislib in $libs; do + case "$thislib" in + -lc|-lc_s) + : Handle C library specially below. + ;; + -l*) + thislib=`echo $thislib | $sed -e 's/^-l//'` + if try=`./loc lib$thislib.$so.'*' X $libpth`; $test -f "$try"; then + : + elif try=`./loc lib$thislib.$so X $libpth`; $test -f "$try"; then + : + elif try=`./loc lib$thislib.a X $libpth`; $test -f "$try"; then + : + elif try=`./loc lib$thislib X $libpth`; $test -f "$try"; then + : + elif try=`./loc $thislib X $libpth`; $test -f "$try"; then + : + elif try=`./loc Slib$thislib.a X $xlibpth`; $test -f "$try"; then + : + else + try='' + fi + libnames="$libnames $try" + ;; + *) libnames="$libnames $thislib" ;; + esac + done + ;; +esac +xxx=normal +case "$libc" in +unknown) + set /usr/ccs/lib/libc.$so + $test -r $1 || set /usr/lib/libc.$so + $test -r $1 || set /usr/shlib/libc.$so + $test -r $1 || set /usr/lib/libc.$so.[0-9]* + $test -r $1 || set /lib/libc.$so + $test -r $1 || set /lib/libsys_s.a + eval set \$$# + ;; *) - echo " " - dflt="$byteorder" - ;; + set blurfl + ;; esac -rp="What is the order of bytes in a long? [$dflt]" -$echo $n "$rp $c" -. myread -byteorder="$ans" +if $test -r "$1"; then + echo "Your (shared) C library seems to be in $1." + libc="$1" +elif $test -r /lib/libc && $test -r /lib/clib; then + echo "Your C library seems to be in both /lib/clib and /lib/libc." + xxx=apollo + libc='/lib/clib /lib/libc' + if $test -r /lib/syslib; then + echo "(Your math library is in /lib/syslib.)" + libc="$libc /lib/syslib" + fi +elif $test -r "$libc" || (test -h "$libc") >/dev/null 2>&1; then + echo "Your C library seems to be in $libc, as you said before." +elif $test -r $incpath/usr/lib/libc.a; then + libc=$incpath/usr/lib/libc.a; + echo "Your C library seems to be in $libc. That's fine." +elif $test -r /lib/libc.a; then + libc=/lib/libc.a; + echo "Your C library seems to be in $libc. You're normal." +else + if tans=`./loc libc.a blurfl/dyick $libpth`; $test -r "$tans"; then + : + elif tans=`./loc libc blurfl/dyick $libpth`; $test -r "$tans"; then + libnames="$libnames "`./loc clib blurfl/dyick $libpth` + elif tans=`./loc clib blurfl/dyick $libpth`; $test -r "$tans"; then + : + elif tans=`./loc Slibc.a blurfl/dyick $xlibpth`; $test -r "$tans"; then + : + elif tans=`./loc Mlibc.a blurfl/dyick $xlibpth`; $test -r "$tans"; then + : + else + tans=`./loc Llibc.a blurfl/dyick $xlibpth` + fi + if $test -r "$tans"; then + echo "Your C library seems to be in $tans, of all places." + libc=$tans + else + libc='blurfl' + fi +fi +if $test $xxx = apollo -o -r "$libc" || (test -h "$libc") >/dev/null 2>&1; then + dflt="$libc" + cat < libpath + cat >&4 <try.c <<'EOCP' -#include +echo $libc $libnames | tr ' ' '\012' | sort | uniq > libnames +set X `cat libnames` +shift +xxx=files +case $# in 1) xxx=file; esac +echo "Extracting names from the following $xxx for later perusal:" >&4 +echo " " +$sed 's/^/ /' libnames >&4 +echo " " +$echo $n "This may take a while...$c" >&4 + +nm $nm_opt $* 2>/dev/null >libc.tmp +$echo $n ".$c" +$grep fprintf libc.tmp > libc.ptf +xscan='eval "libc.list"; $echo $n ".$c" >&4' +xrun='eval "libc.list"; echo "done" >&4' +if com="$sed -n -e 's/^.* [ADTSI] *_[_.]*//p' -e 's/^.* [ADTSI] //p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^__*//' -e 's/^\([a-zA-Z_0-9$]*\).*xtern.*/\1/p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e '/|UNDEF/d' -e '/FUNC..GL/s/^.*|__*//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^.* D __*//p' -e 's/^.* D //p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^_//' -e 's/^\([a-zA-Z_0-9]*\).*xtern.*text.*/\1/p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^.*|FUNC |GLOB .*|//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$grep '|' | $sed -n -e '/|COMMON/d' -e '/|DATA/d' \ + -e '/ file/d' -e 's/^\([^ ]*\).*/\1/p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^.*|FUNC |GLOB .*|//p' -e 's/^.*|FUNC |WEAK .*|//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^__//' -e '/|Undef/d' -e '/|Proc/s/ .*//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e '/Def. Text/s/.* \([^ ]*\)\$/\1/p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +else + nm -p $* 2>/dev/null >libc.tmp + com="$sed -n -e 's/^.* [ADTS] *_[_.]*//p' -e 's/^.* [ADTS] //p'";\ + eval "libc.list" + if $contains '^fprintf$' libc.list >/dev/null 2>&1; then + nm_opt='-p' + echo "done" >&4 + else + echo " " + echo "nm didn't seem to work right. Trying ar instead..." >&4 + com='' + if ar t $libc > libc.tmp; then + for thisname in $libnames; do + ar t $thisname >>libc.tmp + done + $sed -e 's/\.o$//' < libc.tmp > libc.list + echo "Ok." >&4 + else + echo "ar didn't seem to work right." >&4 + echo "Maybe this is a Cray...trying bld instead..." >&4 + if bld t $libc | $sed -e 's/.*\///' -e 's/\.o:.*$//' > libc.list; then + for thisname in $libnames; do + bld t $libnames | \ + $sed -e 's/.*\///' -e 's/\.o:.*$//' >>libc.list + ar t $thisname >>libc.tmp + done + echo "Ok." >&4 + else + echo "That didn't work either. Giving up." >&4 + exit 1 + fi + fi + fi +fi +nm_extract="$com" +if $test -f /lib/syscalls.exp; then + echo " " + echo "Also extracting names from /lib/syscalls.exp for good ole AIX..." >&4 + $sed -n 's/^\([^ ]*\)[ ]*syscall$/\1/p' /lib/syscalls.exp >>libc.list +fi +;; +esac +$rm -f libnames libpath + +: is a C symbol defined? +csym='tlook=$1; +case "$3" in +-v) tf=libc.tmp; tc=""; tdc="";; +-a) tf=libc.tmp; tc="[0]"; tdc=[];; +*) tlook="^$1\$"; tf=libc.list; tc="()"; tdc="()";; +esac; +tx=yes; +case "$reuseval-$4" in +true-) ;; +true-*) tx=no; eval "tval=\$$4"; case "$tval" in "") tx=yes;; esac;; +esac; +case "$tx" in +yes) + case "$runnm" in + true) + if $contains $tlook $tf >/dev/null 2>&1; + then tval=true; + else tval=false; + fi;; + *) + echo "main() { extern int $1$tdc; printf(\"%d\", $1$tc); }" > t.c; + if $cc $ccflags -o t t.c $ldflags $libs >/dev/null 2>&1; + then tval=true; + else tval=false; + fi; + $rm -f t t.c;; + esac;; +*) + case "$tval" in + $define) tval=true;; + *) tval=false;; + esac;; +esac; +eval "$2=$tval"' + +: set up the script used to warn in case of inconsistency +cat <<'EOSC' >whoa +dflt=y +echo " " +echo "*** WHOA THERE!!! ***" >&4 +echo " The $hint value for \$$var on this machine was \"$was\"!" >&4 +rp=" Keep the $hint value?" +. ./myread +case "$ans" in +y) td=$was; tu=$was;; +esac +EOSC + +: define an is-in-libc? function +inlibc='echo " "; td=$define; tu=$undef; +sym=$1; var=$2; eval "was=\$$2"; +tx=yes; +case "$reuseval$was" in +true) ;; +true*) tx=no;; +esac; +case "$tx" in +yes) + set $sym tres -f; + eval $csym; + case "$tres" in + true) + echo "$sym() found." >&4; + case "$was" in $undef) . ./whoa; esac; eval "$var=\$td";; + *) + echo "$sym() NOT found." >&4; + case "$was" in $define) . ./whoa; esac; eval "$var=\$tu";; + esac;; +*) + case "$was" in + $define) echo "$sym() found." >&4;; + *) echo "$sym() NOT found." >&4;; + esac;; +esac' -blech() { exit(3); } +: see if gconvert exists +set gconvert d_gconvert +eval $inlibc -main() -{ - double f = -123; - unsigned long along; - unsigned int aint; - unsigned short ashort; - int result = 0; +case "$d_gconvert" in +$define) + echo "We'll use it to convert floats into a string then." >&4 + d_Gconvert="gconvert((x),(n),(t),(b))" + ;; +*) + : Maybe we can emulate it with gcvt. + set gcvt d_gcvt + eval $inlibc + + case "$d_gcvt" in + $define) + : Test whether gcvt drops a trailing decimal point + $cat >try.c <<'EOP' +main() { + char buf[64]; + gcvt(1.0, 8, buf); + if (buf[0] != '1' || buf[1] != '\0') + exit(1); + gcvt(0.0, 8, buf); + if (buf[0] != '0' || buf[1] != '\0') + exit(1); + gcvt(-1.0, 8, buf); + if (buf[0] != '-' || buf[1] != '1' || buf[2] != '\0') + exit(1); + exit(0); +} +EOP + if $cc $ccflags $ldflags -o try try.c $libs > /dev/null 2>&1; then + if ./try; then + echo "Good, your gcvt() drops a trailing decimal point." + echo "We'll use it to convert floats into a string." >&4 + d_Gconvert="gcvt((x),(n),(b))" + else + echo "But your gcvt() keeps a trailing decimal point". + d_Gconvert='' + fi + else + echo "Hmm. I can't compile the gcvt test program." + d_Gconvert='' + fi + $rm -f try.c try + ;; + esac + case "$d_Gconvert" in + '') + echo "I'll use sprintf instead to convert floats into a string." >&4 + d_Gconvert='sprintf((b),"%.*g",(n),(x))' + ;; + esac +esac - signal(SIGFPE, blech); - along = (unsigned long)f; - aint = (unsigned int)f; - ashort = (unsigned short)f; - if (along != (unsigned long)-123) - result |= 1; - if (aint != (unsigned int)-123) - result |= 1; - if (ashort != (unsigned short)-123) - result |= 1; - f = (double)0x40000000; - f = f + f; - along = 0; - along = (unsigned long)f; - if (along != 0x80000000) - result |= 2; - f -= 1; - along = 0; - along = (unsigned long)f; - if (along != 0x7fffffff) - result |= 1; - f += 2; - along = 0; - along = (unsigned long)f; - if (along != 0x80000001) - result |= 2; - exit(result); +: Initialize h_fcntl +h_fcntl=false + +: Initialize h_sysfile +h_sysfile=false + +: determine filename position in cpp output +echo " " +echo "Computing filename position in cpp output for #include directives..." >&4 +echo '#include ' > foo.c +$cat >fieldn </dev/null | \ +$grep '^[ ]*#.*stdio\.h' | \ +while read cline; do + pos=1 + set \$cline + while $test \$# -gt 0; do + if $test -r \`echo \$1 | $tr -d '"'\`; then + echo "\$pos" + exit 0 + fi + shift + pos=\`expr \$pos + 1\` + done +done +EOF +chmod +x fieldn +fieldn=`./fieldn` +$rm -f foo.c fieldn +case $fieldn in +'') pos='???';; +1) pos=first;; +2) pos=second;; +3) pos=third;; +*) pos="${fieldn}th";; +esac +echo "Your cpp writes the filename in the $pos field of the line." + +: locate header file +$cat >findhdr <" > foo\$\$.c +$cppstdin $cppminus $cppflags < foo\$\$.c 2>/dev/null | \ +$grep "^[ ]*#.*\$wanted" | \ +while read cline; do + name=\`echo \$cline | $awk "\$awkprg" | $tr -d '"'\` + case "\$name" in + */\$wanted) echo "\$name"; exit 0;; + *) name='';; + esac; +done; +$rm -f foo\$\$.c; +case "\$name" in +'') exit 1;; +esac +EOF +chmod +x findhdr + +: access call always available on UNIX +set access d_access +eval $inlibc + +: locate the flags for 'access()' +case "$d_access" in +"$define") + echo " " + $cat >access.c <<'EOCP' +#include +#ifdef I_FCNTL +#include +#endif +#ifdef I_SYS_FILE +#include +#endif +#ifdef I_UNISTD +#include +#endif +main() { + exit(R_OK); } EOCP -if $cc -o try $ccflags try.c >/dev/null 2>&1; then - ./try - castflags=$? + : check sys/file.h first, no particular reason here + if $test `./findhdr sys/file.h` && \ + $cc $cppflags -DI_SYS_FILE access.c -o access >/dev/null 2>&1 ; then + h_sysfile=true; + echo " defines the *_OK access constants." >&4 + elif $test `./findhdr fcntl.h` && \ + $cc $cppflags -DI_FCNTL access.c -o access >/dev/null 2>&1 ; then + h_fcntl=true; + echo " defines the *_OK access constants." >&4 + elif $test `./findhdr unistd.h` && \ + $cc $cppflags -DI_UNISTD access.c -o access >/dev/null 2>&1 ; then + echo " defines the *_OK access constants." >&4 + else + echo "I can't find the four *_OK access constants--I'll use mine." >&4 + fi + ;; +esac +$rm -f access* + +: see if alarm exists +set alarm d_alarm +eval $inlibc + +: determine the architecture name +echo " " +if xxx=`./loc arch blurfl $pth`; $test -f "$xxx"; then + tarch=`arch`"-$osname" +elif xxx=`./loc uname blurfl $pth`; $test -f "$xxx" ; then + if uname -m > tmparch 2>&1 ; then + tarch=`$sed -e 's/ /_/g' -e 's/$/'"-$osname/" tmparch` + else + tarch="$osname" + fi + $rm -f tmparch else - castflags=3 + tarch="$osname" fi -case "$castflags" in -0) val="$define" - echo "Yup, it does." - ;; -*) val="$undef" - echo "Nope, it doesn't." - ;; +case "$myarchname" in +''|"$tarch") ;; +*) + echo "(Your architecture name used to be $myarchname.)" + archname='' + ;; esac -set d_castneg -eval $setvar -$rm -f try.* +case "$archname" in +'') dflt="$tarch";; +*) dflt="$archname";; +esac +rp='What is your architecture name' +. ./myread +archname="$ans" +myarchname="$tarch" -: see how we invoke the C preprocessor +: is AFS running? echo " " -echo "Now, how can we feed standard input to your C preprocessor..." -cat <<'EOT' >testcpp.c -#define ABC abc -#define XYZ xyz -ABC.XYZ -EOT +if test -d /afs; then + echo "AFS may be running... I'll be extra cautious then..." >&4 + afs=true +else + echo "AFS does not seem to be running..." >&4 + afs=false +fi -cd .. -echo 'cat >.$$.c; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' >cppstdin -chmod 755 cppstdin -wrapper=cppstdin +: determine root of directory hierarchy where package will be installed. +case "$prefix" in +'') + dflt=`./loc . /usr/local /usr/local /local /opt /usr` + ;; +*) + dflt="$prefix" + ;; +esac +$cat <testcpp.out 2>&1 && \ - $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then - echo "You used to use $cppstdin $cppminus so we'll use that again." -elif test "$cc" = gcc && \ - (echo "Using gcc, eh? We'll try to force gcc -E using a wrapper..."; \ - $wrapper testcpp.out 2>&1; \ - $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1) ; then - echo "Yup, we can." - cppstdin="$wrapper" - cppminus=''; -elif echo 'Maybe "'"$cc"' -E" will work...'; \ - $cc -E testcpp.out 2>&1; \ - $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then - echo "Yup, it does." - cppstdin="$cc -E" - cppminus=''; -elif echo 'Nope...maybe "'"$cc"' -E -" will work...'; \ - $cc -E - testcpp.out 2>&1; \ - $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then - echo "Yup, it does." - cppstdin="$cc -E" - cppminus='-'; -elif echo 'No such luck, maybe "'$cpp'" will work...'; \ - $cpp testcpp.out 2>&1; \ - $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then - echo "It works!" - cppstdin="$cpp" - cppminus=''; -elif echo 'Nixed again...maybe "'$cpp' -" will work...'; \ - $cpp - testcpp.out 2>&1; \ - $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then - echo "Hooray, it works! I was beginning to wonder." - cppstdin="$cpp" - cppminus='-'; -elif echo 'Uh-uh. Time to get fancy. Trying a wrapper...'; \ - $wrapper testcpp.out 2>&1; \ - $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then - cppstdin="$wrapper" - cppminus='' - echo "Eureka!." -elif echo 'Nope...maybe "'"$cc"' -P" will work...'; \ - $cc -P testcpp.out 2>&1; \ - $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then - echo "Yipee, that works!" - cppstdin="$cc -P" - cppminus=''; -elif echo 'Nope...maybe "'"$cc"' -P -" will work...'; \ - $cc -P - testcpp.out 2>&1; \ - $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then - echo "At long last!" - cppstdin="$cc -P" - cppminus='-'; -else - dflt=blurfl - $echo $n "No dice. I can't find a C preprocessor. Name one: $c" - rp='Name a C preprocessor:' - . myread - cppstdin="$ans" - $cppstdin testcpp.out 2>&1 - if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then - echo "OK, that will do." - else - echo "Sorry, I can't get that to work. Go find one and rerun Configure." - exit 1 - fi +: determine where private executables go +set dflt privlib lib/$package +eval $prefixit +$cat <libnames -$echo "Extracting names from the following files for later perusal:" -sed 's/^/ /' libnames -echo $n "This may take a while...$c" -set X `cat libnames` -shift -nm $nm_opts $* 2>/dev/null >libc.tmp -$sed -n -e 's/^.* [ATDS] *[_.]*//p' -e 's/^.* [ATDS] //p' libc.list -if $contains '^printf$' libc.list >/dev/null 2>&1; then - echo done -elif $sed -n -e 's/^__*//' -e 's/^\([a-zA-Z_0-9$]*\).*xtern.*/\1/p' \ - libc.list; \ - $contains '^printf$' libc.list >/dev/null 2>&1; then - echo done -elif $sed -n -e '/|UNDEF/d' -e '/FUNC..GL/s/^.*|__*//p' libc.list; \ - $contains '^printf$' libc.list >/dev/null 2>&1; then - echo done -elif $sed -n -e 's/^.* D __*//p' -e 's/^.* D //p' libc.list; \ - $contains '^printf$' libc.list >/dev/null 2>&1; then - echo done -elif $sed -n -e 's/^_//' -e 's/^\([a-zA-Z_0-9]*\).*xtern.*text.*/\1/p' \ - libc.list; \ - $contains '^printf$' libc.list >/dev/null 2>&1; then - echo done -elif $grep '|' libc.list - $contains '^printf$' libc.list >/dev/null 2>&1; then - echo done -elif $sed -n -e 's/^.*|FUNC |GLOB .*|//p' -e 's/^.*|FUNC |WEAK .*|//p' \ - libc.list; \ - $contains '^printf$' libc.list >/dev/null 2>&1; then - echo done -elif $sed -n -e 's/^[ ]*[0-9][0-9a-f]*[ ]*Def. Text[ ]*//p' \ - < libc.tmp | $sed -e 's/\[.*\]//' > libc.list; \ - $contains '^printf$' libc.list >/dev/null 2>&1; then - echo done -else - nm -p $* 2>/dev/null >libc.tmp - $sed -n -e 's/^.* [AT] *_[_.]*//p' -e 's/^.* [AT] //p' libc.list - if $contains '^printf$' libc.list >/dev/null 2>&1; then - nm_opts='-p' - echo "done" - else - echo " " - echo "nm didn't seem to work right." - echo "Trying ar instead..." - if ar t $libc > libc.tmp; then - for thisname in $libnames; do - ar t $thisname >>libc.tmp - done - $sed -e 's/\.o$//' < libc.tmp > libc.list - echo "Ok." - else - echo "ar didn't seem to work right." - echo "Maybe this is a Cray...trying bld instead..." - if bld t $libc | $sed -e 's/.*\///' -e 's/\.o:.*$//' > libc.list; then - for thisname in $libnames; do - bld t $libnames | \ - $sed -e 's/.*\///' -e 's/\.o:.*$//' >>libc.list - ar t $thisname >>libc.tmp - done - echo "Ok." - else - echo "That didn't work either. Giving up." - exit 1 - fi +echo "Checking whether your compiler can handle __attribute__ ..." >&4 +$cat >attrib.c <<'EOCP' +#include +void croak (char* pat,...) __attribute__((format(printf,1,2),noreturn)); +EOCP +if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then + if $contains 'warning' attrib.out >/dev/null 2>&1; then + echo "Your C compiler doesn't fully support __attribute__." + val="$undef" + else + echo "Your C compiler supports __attribute__." + val="$define" fi - fi -fi -if test -f /lib/syscalls.exp; then - echo "Also extracting names from /lib/syscalls.exp for good ole AIX..." - sed -n 's/^\([^ ]*\)[ ]*syscall$/\1/p' /lib/syscalls.exp >>libc.list +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" fi - -inlibc='echo " "; td=$define; tu=$undef; -if $contains "^$1\$" libc.list >/dev/null 2>&1; -then echo "$1() found"; - eval "case \"\$$2\" in undef) . whoa; esac"; eval "$2=\$td"; -else echo "$1() NOT found"; - eval "case \"\$$2\" in define) . whoa; esac"; eval "$2=\$tu"; fi' +set d_attribut +eval $setvar +$rm -f attrib* : see if bcmp exists set bcmp d_bcmp @@ -2049,83 +3653,246 @@ eval $inlibc set bcopy d_bcopy eval $inlibc -case "$d_safebcpy" in -'') - : assume the worst - d_safebcpy=undef - case "$d_bcopy" in - define) - echo "Checking to see if your bcopy() can do overlapping copies..." - $cat >safebcpy.c <<'EOCP' +: see if setpgrp exists +set setpgrp d_setpgrp +eval $inlibc + +: see which flavor of setpgrp is in use +case "$d_setpgrp" in +"$define") + echo " " + $cat >set.c <= 0; align--) { - for (len = 36; len; len--) { - b = buf+align; - bcopy("abcdefghijklmnopqrstuvwxyz0123456789", b, len); - for (off = 1; off <= len; off++) { - bcopy(b, b+off, len); - bcopy(b+off, b, len); - if (bcmp(b, "abcdefghijklmnopqrstuvwxyz0123456789", len)) - exit(1); - } + if (getuid() == 0) { + printf("(I see you are running Configure as super-user...)\n"); + setuid(1); } - } - exit(0); + if (-1 == setpgrp(1, 1)) + exit(1); + exit(0); } -EOCP - if $cc safebcpy.c -o safebcpy $ccflags >/dev/null 2>&1 ; then - if ./safebcpy; then - echo "It can." - d_safebcpy=define - else - echo "It can't." - fi +EOP + if $cc $ccflags -o set set.c $ldflags $libs >/dev/null 2>&1; then + ./set 2>/dev/null + case $? in + 0) echo "You have to use setpgrp() instead of setpgrp(pid, pgrp)." >&4 + val="$undef";; + *) echo "You have to use setpgrp(pid, pgrp) instead of setpgrp()." >&4 + val="$define";; + esac else - echo "(I can't compile the test program, so we'll assume not...)" + if ./usg; then + xxx="USG one, i.e. you use setpgrp()." + val="$undef" + else + xxx="BSD one, i.e. you use setpgrp(pid, pgrp)." + val="$define" + fi + echo "Assuming your setpgrp is a $xxx" >&4 fi ;; - esac - ;; +*) val="$undef";; +esac +set d_bsdpgrp +eval $setvar +$rm -f set set.c + +: Check if we really have byacc +case "$byacc" in +''|'byacc') val="$undef" ;; +*) val="$define" ;; esac +set d_byacc +eval $setvar : see if bzero exists set bzero d_bzero eval $inlibc -: see if sprintf is declared as int or pointer to char -echo " " -cat >ucbsprf.c <<'EOF' -#include -main() -{ - int sprintf(); - char buf[10]; - exit((unsigned long)sprintf(buf,"%s","foo") > 10L); +: check for length of integer +echo " " +case "$intsize" in +'') + echo "Checking to see how big your integers are..." >&4 + $cat >try.c <<'EOCP' +#include +main() +{ + printf("%d\n", sizeof(int)); +} +EOCP + if $cc $ccflags try.c -o try >/dev/null 2>&1 ; then + dflt=`./try` + else + dflt='4' + echo "(I can't seem to compile the test program. Guessing...)" + fi + ;; +*) + dflt="$intsize" + ;; +esac +rp="What is the size of an integer (in bytes)?" +. ./myread +intsize="$ans" +$rm -f try.c try + +: see if signal is declared as pointer to function returning int or void +echo " " +xxx=`./findhdr signal.h` +$test "$xxx" && $cppstdin $cppminus $cppflags < $xxx >$$.tmp 2>/dev/null +if $contains 'int.*\*[ ]*signal' $$.tmp >/dev/null 2>&1 ; then + echo "You have int (*signal())() instead of void." >&4 + val="$undef" +elif $contains 'void.*\*[ ]*signal' $$.tmp >/dev/null 2>&1 ; then + echo "You have void (*signal())() instead of int." >&4 + val="$define" +elif $contains 'extern[ ]*[(\*]*signal' $$.tmp >/dev/null 2>&1 ; then + echo "You have int (*signal())() instead of void." >&4 + val="$undef" +else + case "$d_voidsig" in + '') + echo "I can't determine whether signal handler returns void or int..." >&4 + dflt=void + rp="What type does your signal handler return?" + . ./myread + case "$ans" in + v*) val="$define";; + *) val="$undef";; + esac;; + "$define") + echo "As you already told me, signal handler returns void." >&4;; + *) + echo "As you already told me, signal handler returns int." >&4;; + esac +fi +set d_voidsig +eval $setvar +case "$d_voidsig" in +"$define") signal_t="void";; +*) signal_t="int";; +esac +$rm -f $$.tmp + +: check for ability to cast large floats to 32-bit ints. +echo " " +echo 'Checking whether your C compiler can cast large floats to int32.' >&4 +if $test "$intsize" -eq 4; then + xxx=int +else + xxx=long +fi +$cat >try.c < +#include +$signal_t blech() { exit(3); } +main() +{ + $xxx i32; + double f; + int result = 0; + signal(SIGFPE, blech); + + f = (double) 0x7fffffff; + f = 10 * f; + i32 = ($xxx) f; + + if (i32 != ($xxx) f) + result |= 1; + exit(result); +} +EOCP +if $cc -o try $ccflags try.c >/dev/null 2>&1; then + ./try + yyy=$? +else + echo "(I can't seem to compile the test program--assuming it can't)" + yyy=1 +fi +case "$yyy" in +0) val="$define" + echo "Yup, it can." + ;; +*) val="$undef" + echo "Nope, it can't." + ;; +esac +set d_casti32 +eval $setvar +$rm -f try try.* + +: check for ability to cast negative floats to unsigned +echo " " +echo 'Checking whether your C compiler can cast negative float to unsigned.' >&4 +$cat >try.c < +#include +$signal_t blech() { exit(3); } +main() +{ + double f = -123; + unsigned long along; + unsigned int aint; + unsigned short ashort; + int result = 0; + + signal(SIGFPE, blech); + along = (unsigned long)f; + aint = (unsigned int)f; + ashort = (unsigned short)f; + if (along != (unsigned long)-123) + result |= 1; + if (aint != (unsigned int)-123) + result |= 1; + if (ashort != (unsigned short)-123) + result |= 1; + f = (double)0x40000000; + f = f + f; + along = 0; + along = (unsigned long)f; + if (along != 0x80000000) + result |= 2; + f -= 1.; + along = 0; + along = (unsigned long)f; + if (along != 0x7fffffff) + result |= 1; + f += 2.; + along = 0; + along = (unsigned long)f; + if (along != 0x80000001) + result |= 2; + exit(result); + } -EOF -if $cc $ccflags ucbsprf.c -o ucbsprf >/dev/null 2>&1 && ./ucbsprf; then - echo "Your sprintf() returns (int)." - val="$undef" +EOCP +if $cc -o try $ccflags try.c >/dev/null 2>&1; then + ./try + castflags=$? else - echo "Your sprintf() returns (char*)." - val="$define" + echo "(I can't seem to compile the test program--assuming it can't)" + castflags=3 fi -set d_charsprf +case "$castflags" in +0) val="$define" + echo "Yup, it can." + ;; +*) val="$undef" + echo "Nope, it can't." + ;; +esac +set d_castneg eval $setvar +$rm -f try.* : see if vprintf exists echo " " -if $contains '^vprintf$' libc.list >/dev/null 2>&1; then - echo 'vprintf() found.' - val="$define" - cat >vprintf.c <<'EOF' +if set vprintf val -f d_vprintf; eval $csym; $val; then + echo 'vprintf() found.' >&4 + val="$define" + $cat >vprintf.c <<'EOF' #include main() { xxx("foo"); } @@ -2133,24 +3900,24 @@ main() { xxx("foo"); } xxx(va_alist) va_dcl { - va_list args; - char buf[10]; + va_list args; + char buf[10]; - va_start(args); - exit((unsigned long)vsprintf(buf,"%s",args) > 10L); + va_start(args); + exit((unsigned long)vsprintf(buf,"%s",args) > 10L); } EOF - if $cc $ccflags vprintf.c -o vprintf >/dev/null 2>&1 && ./vprintf; then - echo "Your vsprintf() returns (int)." - val2="$undef" - else - echo "Your vsprintf() returns (char*)." - val2="$define" - fi + if $cc $ccflags vprintf.c -o vprintf >/dev/null 2>&1 && ./vprintf; then + echo "Your vsprintf() returns (int)." >&4 + val2="$undef" + else + echo "Your vsprintf() returns (char*)." >&4 + val2="$define" + fi else - echo 'vprintf() NOT found.' - val="$undef" - val2="$undef" + echo 'vprintf() NOT found.' >&4 + val="$undef" + val2="$undef" fi set d_vprintf eval $setvar @@ -2158,39 +3925,68 @@ val=$val2 set d_charvspr eval $setvar +: see if chown exists +set chown d_chown +eval $inlibc + +: see if chroot exists +set chroot d_chroot +eval $inlibc + : see if chsize exists set chsize d_chsize eval $inlibc -: see if crypt exists +: check for const keyword echo " " -if $contains '^crypt$' libc.list >/dev/null 2>&1; then - echo 'crypt() found.' - val="$define" - cryptlib='' +echo 'Checking to see if your C compiler knows about "const"...' >&4 +$cat >const.c <<'EOCP' +typedef struct spug { int drokk; } spug; +main() +{ + const char *foo; + const spug y; +} +EOCP +if $cc -c $ccflags const.c >/dev/null 2>&1 ; then + val="$define" + echo "Yup, it does." else - cryptlib=`./loc Slibcrypt.a "" $xlibpth` - if $test -z "$cryptlib"; then - cryptlib=`./loc Mlibcrypt.a "" $xlibpth` - else - cryptlib=-lcrypt - fi - if $test -z "$cryptlib"; then - cryptlib=`./loc Llibcrypt.a "" $xlibpth` - else - cryptlib=-lcrypt - fi - if $test -z "$cryptlib"; then - cryptlib=`./loc libcrypt.a "" $libpth` - else - cryptlib=-lcrypt - fi - if $test -z "$cryptlib"; then - echo 'crypt() NOT found.' val="$undef" - else + echo "Nope, it doesn't." +fi +set d_const +eval $setvar + +: see if crypt exists +echo " " +if set crypt val -f d_crypt; eval $csym; $val; then + echo 'crypt() found.' >&4 val="$define" - fi + cryptlib='' +else + cryptlib=`./loc Slibcrypt.a "" $xlibpth` + if $test -z "$cryptlib"; then + cryptlib=`./loc Mlibcrypt.a "" $xlibpth` + else + cryptlib=-lcrypt + fi + if $test -z "$cryptlib"; then + cryptlib=`./loc Llibcrypt.a "" $xlibpth` + else + cryptlib=-lcrypt + fi + if $test -z "$cryptlib"; then + cryptlib=`./loc libcrypt.a "" $libpth` + else + cryptlib=-lcrypt + fi + if $test -z "$cryptlib"; then + echo 'crypt() NOT found.' >&4 + val="$undef" + else + val="$define" + fi fi set d_crypt eval $setvar @@ -2198,121 +3994,564 @@ eval $setvar : get csh whereabouts case "$csh" in 'csh') val="$undef" ;; -*) val="$define" ;; +*) val="$define" ;; esac set d_csh eval $setvar +full_csh=$csh -: see if readdir exists -set readdir d_readdir +: see if cuserid exists +set cuserid d_cuserid +eval $inlibc + +: define an alternate in-header-list? function +inhdr='echo " "; td=$define; tu=$undef; yyy=$@; +cont=true; xxf="echo \"<\$1> found.\" >&4"; +case $# in 2) xxnf="echo \"<\$1> NOT found.\" >&4";; +*) xxnf="echo \"<\$1> NOT found, ...\" >&4";; +esac; +case $# in 4) instead=instead;; *) instead="at last";; esac; +while $test "$cont"; do + xxx=`./findhdr $1` + var=$2; eval "was=\$$2"; + if $test "$xxx" && $test -r "$xxx"; + then eval $xxf; + eval "case \"\$$var\" in $undef) . ./whoa; esac"; eval "$var=\$td"; + cont=""; + else eval $xxnf; + eval "case \"\$$var\" in $define) . ./whoa; esac"; eval "$var=\$tu"; fi; + set $yyy; shift; shift; yyy=$@; + case $# in 0) cont="";; + 2) xxf="echo \"but I found <\$1> $instead.\" >&4"; + xxnf="echo \"and I did not find <\$1> either.\" >&4";; + *) xxf="echo \"but I found <\$1\> instead.\" >&4"; + xxnf="echo \"there is no <\$1>, ...\" >&4";; + esac; +done; +while $test "$yyy"; +do set $yyy; var=$2; eval "was=\$$2"; + eval "case \"\$$var\" in $define) . ./whoa; esac"; eval "$var=\$tu"; + set $yyy; shift; shift; yyy=$@; +done' + +: see if this is a limits.h system +set limits.h i_limits +eval $inhdr + +: see if this is a float.h system +set float.h i_float +eval $inhdr + +: See if number of significant digits in a double precision number is known +echo " " +$cat >dbl_dig.c < +#endif +#ifdef I_FLOAT +#include +#endif +#ifdef DBL_DIG +printf("Contains DBL_DIG"); +#endif +EOM +$cppstdin $cppflags $cppminus < dbl_dig.c >dbl_dig.E 2>/dev/null +if $contains 'DBL_DIG' dbl_dig.E >/dev/null 2>&1; then + echo "DBL_DIG found." >&4 + val="$define" +else + echo "DBL_DIG NOT found." >&4 + val="$undef" +fi +$rm -f dbl_dig.? +set d_dbl_dig +eval $setvar + +: see if difftime exists +set difftime d_difftime +eval $inlibc + +: see if this is a dirent system +echo " " +if xinc=`./findhdr dirent.h`; $test "$xinc"; then + val="$define" + echo " found." >&4 +else + val="$undef" + if xinc=`./findhdr sys/dir.h`; $test "$xinc"; then + echo " found." >&4 + echo " " + else + xinc=`./findhdr sys/ndir.h` + fi + echo " NOT found." >&4 +fi +set i_dirent +eval $setvar + +: Look for type of directory structure. +echo " " +$cppstdin $cppflags $cppminus < "$xinc" > try.c + +case "$direntrytype" in +''|' ') + case "$i_dirent" in + $define) guess1='struct dirent' ;; + *) guess1='struct direct' ;; + esac + ;; +*) guess1="$direntrytype" + ;; +esac + +case "$guess1" in +'struct dirent') guess2='struct direct' ;; +*) guess2='struct dirent' ;; +esac + +if $contains "$guess1" try.c >/dev/null 2>&1; then + direntrytype="$guess1" + echo "Your directory entries are $direntrytype." >&4 +elif $contains "$guess2" try.c >/dev/null 2>&1; then + direntrytype="$guess2" + echo "Your directory entries seem to be $direntrytype." >&4 +else + echo "I don't recognize your system's directory entries." >&4 + rp="What type is used for directory entries on this system?" + dflt="$guess1" + . ./myread + direntrytype="$ans" +fi +$rm -f try.c + + +: see if the directory entry stores field length +echo " " +$cppstdin $cppflags $cppminus < "$xinc" > try.c +if $contains 'd_namlen' try.c >/dev/null 2>&1; then + echo "Good, your directory entry keeps length information in d_namlen." >&4 + val="$define" +else + echo "Your directory entry does not know about the d_namlen field." >&4 + val="$undef" +fi +set d_dirnamlen +eval $setvar +$rm -f try.c + +: see if dlerror exists +set dlerror d_dlerror +eval $inlibc + +: see if dld is available +set dld.h i_dld +eval $inhdr + +: see if dlopen exists +set dlopen d_dlopen eval $inlibc -: see if there are directory access routines out there +: determine which dynamic loading, if any, to compile in echo " " -xxx=`./loc ndir.h x $usrinclude /usr/local/include $inclwanted` -case "$xxx" in -x) - xxx=`./loc sys/ndir.h x $usrinclude /usr/local/include $inclwanted` +dldir="ext/DynaLoader" +case "$usedl" in +$define|y|true) + dflt='y' + usedl="$define" + ;; +$undef|n|false) + dflt='n' + usedl="$undef" + ;; +*) + dflt='n' + case "$d_dlopen" in + $define) dflt='y' ;; + esac + case "$i_dld" in + $define) dflt='y' ;; + esac + : Does a dl_xxx.xs file exist for this operating system + $test -f ../$dldir/dl_${osname}.xs && dflt='y' + ;; +esac +rp="Do you wish to use dynamic loading?" +. ./myread +usedl="$ans" +case "$ans" in +y*) usedl="$define" + case "$dlsrc" in + '') + if $test -f ../$dldir/dl_${osname}.xs ; then + dflt="$dldir/dl_${osname}.xs" + elif $test "$d_dlopen" = "$define" ; then + dflt="$dldir/dl_dlopen.xs" + elif $test "$i_dld" = "$define" ; then + dflt="$dldir/dl_dld.xs" + else + dflt='' + fi + ;; + *) dflt="$dldir/$dlsrc" + ;; + esac + echo "The following dynamic loading files are available:" + : Can not go over to $dldir because getfile has path hard-coded in. + cd ..; ls -C $dldir/dl*.xs; cd UU + rp="Source file to use for dynamic loading" + fn="fne" + . ./getfile + usedl="$define" + : emulate basename + dlsrc=`echo $ans | $sed -e 's@.*/\([^/]*\)$@\1@'` + $cat << EOM + +Some systems may require passing special flags to $cc -c to +compile modules that will be used to create a shared library. +To use no flags, say "none". + +EOM + case "$cccdlflags" in + ''|' ') case "$cc" in + *gcc*) dflt='-fpic' ;; + *) case "$osname" in + hpux) dflt='+z' ;; + next) dflt='none' ;; + solaris) dflt='-K pic' ;; + sunos) dflt='-pic' ;; + svr4*|esix*) dflt='-Kpic' ;; + *) dflt='none' ;; + esac ;; + esac ;; + *) dflt="$cccdlflags" ;; + esac + rp="Any special flags to pass to $cc -c to compile shared library modules?" + . ./myread + case "$ans" in + none) cccdlflags='' ;; + *) cccdlflags="$ans" ;; + esac + + cat << 'EOM' + +Some systems may require passing special flags to ld to create a +library that can be dynamically loaded. If your ld flags include +-L/other/path options to locate libraries outside your loader's normal +search path, you may need to specify those -L options here as well. To +use no flags, say "none". + +EOM + case "$lddlflags" in + ''|' ') case "$osname" in + hpux) dflt='-b' ;; + next) dflt='none' ;; + solaris) dflt='-G' ;; + sunos) dflt='-assert nodefinitions' ;; + svr4*|esix*) dflt="-G $ldflags" ;; + *) dflt='none' ;; + esac + ;; + *) dflt="$lddlflags" ;; + esac + rp="Any special flags to pass to ld to create a dynamically loaded library?" + . ./myread + case "$ans" in + none) lddlflags='' ;; + *) lddlflags="$ans" ;; + esac + + cat </dev/null 2>&1; then - D_dirnamlen="$define" - fi - I_dirent="$define" -elif $test -r $xxx; then - echo "You seem to use <$xxx>," - if $test "$d_readdir" = "$define"; then - echo "and I can get readdir() from your C library." - elif $test -r /usr/lib/libndir.a || $test -r /usr/local/lib/libndir.a; then - echo "and I'll get the routines using -lndir ." - libndir='-lndir' - else - ans=`./loc libndir.a x $libpth` - case "$ans" in - x) - echo "but I can't find the ndir library!" - ;; - *) - echo "and I found the directory library in $ans." - libndir="$ans" - ;; + +val="$undef" +case "$osname" in +esix*|svr4*) + case "$usedl" in + $define) + $cat <&4 + +Be sure to add the perl source directory to the LD_LIBRARY_PATH +environment variable before running make: + LD_LIBRARY_PATH=`cd ..;pwd`; export LD_LIBRARY_PATH +or + setenv LD_LIBRARY_PATH `cd ..;pwd` + +EOM +;; +esac +case "$d_shrplib" in +$define) + case "$shrpdir" in + "") dflt="$archlib/CORE";; + *) dflt="$shrpdir";; esac - fi - if $contains 'd_namlen' $xxx >/dev/null 2>&1; then - D_dirnamlen="$define" - fi - case "$xxx" in - sys/) - I_sys_ndir="$define" + rp="What directory should we install the shared libperl into?" + fn="d~" + . ./getfile + shrpdir="$ans" ;; - *) - I_ndir="$define" +*) shrpdir='none' ;; - esac -else - : The next line used to require this to be a bsd system. - if $contains '^readdir$' libc.list >/dev/null 2>&1 ; then - echo "No ndir library found, but you have readdir() so we'll use that." - if $contains 'd_namlen' $usrinclude/sys/dir.h >/dev/null 2>&1; then - D_dirnamlen="$define" - fi - I_sys_dir="$define" +esac + +: see if dlfcn is available +set dlfcn.h i_dlfcn +eval $inhdr + +case "$usedl" in +$define|y|true) + $cat << EOM + +On a few systems, the dynamically loaded modules that perl generates and uses +will need a different extension then shared libs. The default will probably +be appropriate. + +EOM + case "$dlext" in + '') dflt="$so" ;; + *) dflt="$dlext" ;; + esac + rp='What is the extension of dynamically loaded modules' + . ./myread + dlext="$ans" + ;; +*) + dlext="none" + ;; +esac + +: Check if dlsym need a leading underscore +echo " " +val="$undef" + +case "$dlsrc" in +dl_dlopen.xs) + echo "Checking whether your dlsym() needs a leading underscore ..." >&4 + $cat >dyna.c <<'EOM' +fred () { } +EOM + +$cat >fred.c< +#$i_dlfcn I_DLFCN +#ifdef I_DLFCN +#include /* the dynamic linker include file for Sunos/Solaris */ +#else +#include +#include +#include +#endif + +extern int fred() ; + +main() +{ + void * handle ; + void * symbol ; +#ifndef RTLD_LAZY + int mode = 1 ; +#else + int mode = RTLD_LAZY ; +#endif + handle = dlopen("./dyna.$dlext", mode) ; + if (handle == NULL) { + printf ("1\n") ; + exit(0); + } + symbol = dlsym(handle, "fred") ; + if (symbol == NULL) { + /* try putting a leading underscore */ + symbol = dlsym(handle, "_fred") ; + if (symbol == NULL) { + printf ("2\n") ; + exit(0); + } + printf ("3\n") ; + } else - echo "No ndir library found--using ./$d_ndir.c." -: This will lose since $d_ndir.h is in another directory. -: I doubt we can rely on it being in ../$d_ndir.h . -: At least it will fail in a conservative manner. - if $contains 'd_namlen' $d_ndir.h >/dev/null 2>&1; then - D_dirnamlen="$define" - fi - I_my_dir="$define" - ndirc="$d_ndir.c" - ndiro="$d_ndir.o" - fi + printf ("4\n") ; + exit(0); +} +EOM + if $cc $ccflags $cccdlflags -c dyna.c > /dev/null 2>&1 && + ld $lddlflags -o dyna.$dlext dyna.o > /dev/null 2>&1 && + $cc $ccflags $ldflags $cccdlflags $ccdlflags fred.c -o fred $libs > /dev/null 2>&1; then + xxx=`./fred` + case $xxx in + 1) echo "Test program failed using dlopen." >&4 + echo "Perhaps you should not use dynamic loading." >&4;; + 2) echo "Test program failed using dlsym." >&4 + echo "Perhaps you should not use dynamic loading." >&4;; + 3) echo "dlsym needs a leading underscore" >&4 + val="$define" ;; + 4) echo "dlsym doesn't need a leading underscore." >&4;; + esac + else + echo "I can't compile and run the test program." >&4 + fi + ;; +esac + +$rm -f fred fred.? dyna.$dlext dyna.? + +set d_dlsymun +eval $setvar + +: see if setuid scripts can be secure +$cat <reflect + chmod +x,u+s reflect + ./reflect >flect 2>&1 + if $contains "/dev/fd" flect >/dev/null; then + echo "Congratulations, your kernel has secure setuid scripts!" >&4 + val="$define" + else + $cat <&4 + dflt=n;; + "$undef") + echo "Well, the $hint value is *not* secure." >&4 + dflt=n;; + *) echo "Well, the $hint value *is* secure." >&4 + dflt=y;; + esac + ;; + *) + $rm -f reflect flect + echo "#!$ls" >reflect + chmod +x,u+s reflect + echo >flect + chmod a+w flect + echo '"su" will (probably) prompt you for '"$ans's password." + su $ans -c './reflect >flect' + if $contains "/dev/fd" flect >/dev/null; then + echo "Okay, it looks like setuid scripts are secure." >&4 + dflt=y + else + echo "I don't think setuid scripts are secure." >&4 + dflt=n + fi + ;; + esac + rp='Does your kernel have *secure* setuid scripts?' + . ./myread + case "$ans" in + [yY]*) val="$define";; + *) val="$undef";; + esac + fi +else + echo "I don't think setuid scripts are secure (no /dev/fd directory)." >&4 + val="$undef" fi -val=$D_dirnamlen; set d_dirnamlen; eval $setvar -val=$I_dirent; set i_dirent; eval $setvar -val=$I_sys_dir; set i_sys_dir; eval $setvar -val=$I_my_dir; set i_my_dir; eval $setvar -val=$I_ndir; set i_ndir; eval $setvar -val=$I_sys_ndir; set i_sys_ndir; eval $setvar +set d_suidsafe +eval $setvar + +$rm -f reflect flect : now see if they want to do setuid emulation -case "$d_dosuid" in -'') dflt=n;; -*undef*) dflt=n;; -*) dflt=y;; -esac -cat <& 4 + ;; +*) + $cat <123456789abcdef) 2>/dev/null; then - : not version 8 - if test -f 123456789abcde; then - echo 'You cannot have filenames longer than 14 characters. Sigh.' - val="$undef" - else - echo 'You can have filenames longer than 14 characters.' - val="$define" - fi +rmlist="$rmlist /tmp/cf$$" +$test -d /tmp/cf$$ || mkdir /tmp/cf$$ +first=123456789abcdef +second=/tmp/cf$$/$first +$rm -f $first $second +if (echo hi >$first) 2>/dev/null; then + if $test -f 123456789abcde; then + echo 'You cannot have filenames longer than 14 characters. Sigh.' >&4 + val="$undef" + else + if (echo hi >$second) 2>/dev/null; then + if $test -f /tmp/cf$$/123456789abcde; then + $cat <<'EOM' +That's peculiar... You can have filenames longer than 14 characters, but only +on some of the filesystems. Maybe you are using NFS. Anyway, to avoid problems +I shall consider your system cannot support long filenames at all. +EOM + val="$undef" + else + echo 'You can have filenames longer than 14 characters.' >&4 + val="$define" + fi + else + $cat <<'EOM' +How confusing! Some of your filesystems are sane enough to allow filenames +longer than 14 characters but some others like /tmp can't even think about them. +So, for now on, I shall assume your kernel does not allow them at all. +EOM + val="$undef" + fi + fi else - : version 8 probably - echo "You can't have filenames longer than 14 chars. You can't even think about them!" - val="$undef" + $cat <<'EOM' +You can't have filenames longer than 14 chars. You can't even think about them! +EOM + val="$undef" fi set d_flexfnam eval $setvar +$rm -rf /tmp/cf$$ 123456789abcde* : see if flock exists set flock d_flock eval $inlibc -: see if getgroups exists -set getgroups d_getgrps +: see if fmod exists +set fmod d_fmod +eval $inlibc + +: see if fork exists +set fork d_fork +eval $inlibc + +: see if pathconf exists +set pathconf d_pathconf +eval $inlibc + +: see if fpathconf exists +set fpathconf d_fpathconf +eval $inlibc + +: see if fsetpos exists +set fsetpos d_fsetpos eval $inlibc : see if gethostent exists set gethostent d_gethent eval $inlibc +: see if getlogin exists +set getlogin d_getlogin +eval $inlibc + : see if getpgrp exists set getpgrp d_getpgrp eval $inlibc @@ -2370,62 +4656,204 @@ eval $inlibc set getpgrp2 d_getpgrp2 eval $inlibc +: see if getppid exists +set getppid d_getppid +eval $inlibc + : see if getpriority exists set getpriority d_getprior eval $inlibc -: see if htonl exists -set htonl d_htonl +: see if this is a netinet/in.h or sys/in.h system +set netinet/in.h i_niin sys/in.h i_sysin +eval $inhdr + +: see if htonl --and friends-- exists +val='' +set htonl val eval $inlibc -: index or strcpy +: Maybe they are macros. +case "$val" in +$undef) + $cat >htonl.c < +#include +#$i_niin I_NETINET_IN +#$i_sysin I_SYS_IN +#ifdef I_NETINET_IN +#include +#endif +#ifdef I_SYS_IN +#include +#endif +#ifdef htonl +printf("Defined as a macro."); +#endif +EOM + $cppstdin $cppflags $cppminus < htonl.c >htonl.E 2>/dev/null + if $contains 'Defined as a macro' htonl.E >/dev/null 2>&1; then + val="$define" + echo "But it seems to be defined as a macro." >&4 + fi + $rm -f htonl.? + ;; +esac +set d_htonl +eval $setvar + +: see which of string.h or strings.h is needed echo " " -case "$d_index" in -undef) dflt=y;; -define) dflt=n;; -*) if $test -f /unix; then - dflt=n - else - dflt=y - fi - ;; +strings=`./findhdr string.h` +if $test "$strings" && $test -r "$strings"; then + echo "Using instead of ." >&4 + val="$define" +else + val="$undef" + strings=`./findhdr strings.h` + if $test "$strings" && $test -r "$strings"; then + echo "Using instead of ." >&4 + else + echo "No string header found -- You'll surely have problems." >&4 + fi +fi +set i_string +eval $setvar +case "$i_string" in +"$undef") strings=`./findhdr strings.h`;; +*) strings=`./findhdr string.h`;; esac -if $contains '^index$' libc.list >/dev/null 2>&1 ; then - if $contains '^strchr$' libc.list >/dev/null 2>&1 ; then - echo "Your system has both index() and strchr(). Shall I use" - rp="index() rather than strchr()? [$dflt]" - $echo $n "$rp $c" - . myread - case "$ans" in - n*) d_index="$define" ;; - *) d_index="$undef" ;; - esac - else - d_index="$undef" - echo "index() found." - fi + +: index or strchr +echo " " +if set index val -f; eval $csym; $val; then + if set strchr val -f d_strchr; eval $csym; $val; then + if $contains strchr "$strings" >/dev/null 2>&1 ; then + val="$define" + vali="$undef" + echo "strchr() found." >&4 + else + val="$undef" + vali="$define" + echo "index() found." >&4 + fi + else + val="$undef" + vali="$define" + echo "index() found." >&4 + fi else - if $contains '^strchr$' libc.list >/dev/null 2>&1 ; then - d_index="$define" - echo "strchr() found." - else - echo "No index() or strchr() found!" - d_index="$undef" - fi + if set strchr val -f d_strchr; eval $csym; $val; then + val="$define" + vali="$undef" + echo "strchr() found." >&4 + else + echo "No index() or strchr() found!" >&4 + val="$undef" + vali="$undef" + fi fi +set d_strchr; eval $setvar +val="$vali" +set d_index; eval $setvar -: see if isascii exists -set isascii d_isascii -eval $inlibc +: Look for isascii +echo " " +$cat >isascii.c <<'EOCP' +#include +#include +main() { + int c = 'A'; + if (isascii(c)) + exit(0); + else + exit(1); +} +EOCP +if $cc $ccflags $ldflags -o isascii isascii.c $libs >/dev/null 2>&1 ; then + echo "isascii() found." >&4 + val="$define" +else + echo "isascii() NOT found." >&4 + val="$undef" +fi +set d_isascii +eval $setvar +$rm -f isascii* : see if killpg exists set killpg d_killpg eval $inlibc +: see if link exists +set link d_link +eval $inlibc + +: see if stdio is really std +echo " " +xxx=`./findhdr stdio.h` +if $contains 'char.*_ptr;' "$xxx" >/dev/null 2>&1 ; then + if $contains '_cnt;' "$xxx" >/dev/null 2>&1 ; then + echo "Your stdio is pretty std." >&4 + val="$define" + else + echo "Your stdio isn't very std." >&4 + val="$undef" + fi +else + echo "Your stdio isn't very std." >&4 + val="$undef" +fi +set d_stdstdio +eval $setvar + +: see if stdio is like that in linux +case "$d_stdstdio" in +"$undef") + echo " " + xxx=`./findhdr stdio.h` + $cppstdin $cppflags $cppminus < "$xxx" > stdio.E + if $contains 'char.*_IO_read_base' stdio.E >/dev/null 2>&1 && \ + $contains '_IO_read_ptr' stdio.E >/dev/null 2>&1 && \ + $contains '_IO_read_end' stdio.E >/dev/null 2>&1 ; then + echo "Your stdio looks like linux." >&4 + val="$define" + else + echo "You don't have linux stdio, either." >&4 + val="$undef" + fi + $rm -f stdio.E + ;; +*) val="$undef" ;; +esac + +set d_linuxstd +eval $setvar + +: see if localeconv exists +set localeconv d_locconv +eval $inlibc + +: see if lockf exists +set lockf d_lockf +eval $inlibc + : see if lstat exists set lstat d_lstat eval $inlibc +: see if mblen exists +set mblen d_mblen +eval $inlibc + +: see if mbstowcs exists +set mbstowcs d_mbstowcs +eval $inlibc + +: see if mbtowc exists +set mbtowc d_mbtowc +eval $inlibc + : see if memcmp exists set memcmp d_memcmp eval $inlibc @@ -2434,52 +4862,6 @@ eval $inlibc set memcpy d_memcpy eval $inlibc -case "$d_safemcpy" in -'') - : assume the worst - d_safemcpy=undef - case "$d_memcpy" in - define) - echo "Checking to see if your memcpy() can do overlapping copies..." - $cat >safemcpy.c <<'EOCP' -main() -{ - char buf[128]; - register char *b; - register int len; - register int off; - register int align; - - for (align = 7; align >= 0; align--) { - for (len = 36; len; len--) { - b = buf+align; - memcpy(b,"abcdefghijklmnopqrstuvwxyz0123456789", len); - for (off = 1; off <= len; off++) { - memcpy(b+off, b, len); - memcpy(b, b+off, len); - if (memcmp(b, "abcdefghijklmnopqrstuvwxyz0123456789", len)) - exit(1); - } - } - } - exit(0); -} -EOCP - if $cc safemcpy.c -o safemcpy $ccflags >/dev/null 2>&1 ; then - if ./safemcpy; then - echo "It can." - d_safemcpy=define - else - echo "It can't." - fi - else - echo "(I can't compile the test program, so we'll assume not...)" - fi - ;; - esac - ;; -esac - : see if memmove exists set memmove d_memmove eval $inlibc @@ -2492,6 +4874,14 @@ eval $inlibc set mkdir d_mkdir eval $inlibc +: see if mkfifo exists +set mkfifo d_mkfifo +eval $inlibc + +: see if mktime exists +set mktime d_mktime +eval $inlibc + : see if msgctl exists set msgctl d_msgctl eval $inlibc @@ -2512,167 +4902,107 @@ eval $inlibc h_msg=true echo " " case "$d_msgctl$d_msgget$d_msgsnd$d_msgrcv" in -*undef*) h_msg=false;; +*"$undef"*) h_msg=false;; esac : we could also check for sys/ipc.h ... -if $h_msg && $test -r $usrinclude/sys/msg.h; then - echo "You have the full msg*(2) library." - val="$define" +if $h_msg && $test `./findhdr sys/msg.h`; then + echo "You have the full msg*(2) library." >&4 + val="$define" else - echo "You don't have the full msg*(2) library." - val="$undef" + echo "You don't have the full msg*(2) library." >&4 + val="$undef" fi set d_msg eval $setvar +: see if this is a malloc.h system +set malloc.h i_malloc +eval $inhdr + +: see if stdlib is available +set stdlib.h i_stdlib +eval $inhdr + : determine which malloc to compile in echo " " -case "$d_mymalloc" in -'') - case "$usemymalloc" in - '') - if bsd || v7; then - dflt='y' - else - dflt='n' - fi - ;; - n*) dflt=n;; - *) dflt=y;; - esac - ;; -define) dflt="y" - ;; -*) dflt="n" - ;; +case "$usemymalloc" in +''|y*|true) dflt='y' ;; +n*|false) dflt='n' ;; +*) dflt="$usemymalloc" ;; esac -rp="Do you wish to attempt to use the malloc that comes with $package? [$dflt]" -$echo $n "$rp $c" -. myread +rp="Do you wish to attempt to use the malloc that comes with $package?" +. ./myread +usemymalloc="$ans" case "$ans" in -'') ans=$dflt;; +y*|true) + usemymalloc='y' + mallocsrc='malloc.c' + mallocobj='malloc.o' + d_mymalloc="$define" + case "$libs" in + *-lmalloc*) + : Remove malloc from list of libraries to use + echo "Removing unneeded -lmalloc from library list" >&4 + set `echo X $libs | $sed -e 's/-lmalloc / /' -e 's/-lmalloc$//'` + shift + libs="$*" + echo "libs = $libs" >&4 + ;; + esac + ;; +*) + usemymalloc='n' + mallocsrc='' + mallocobj='' + d_mymalloc="$undef" + ;; esac -case "$ans" in -y*) mallocsrc='malloc.c'; mallocobj='malloc.o' - libs=`echo $libs | sed 's/-lmalloc//'` - val="$define" - case "$mallocptrtype" in - '') - cat >usemymalloc.c <<'END' -#ifdef __STDC__ -#include -#else + +: compute the return types of malloc and free +echo " " +$cat >malloc.c < +#include +#ifdef I_MALLOC #include #endif +#ifdef I_STDLIB +#include +#endif +#ifdef TRY_MALLOC void *malloc(); +#endif +#ifdef TRY_FREE +void free(); +#endif END - if $cc $ccflags -c usemymalloc.c >/dev/null 2>&1; then - mallocptrtype=void +case "$malloctype" in +'') + if $cc $ccflags -c -DTRY_MALLOC malloc.c >/dev/null 2>&1; then + malloctype='void *' else - mallocptrtype=char + malloctype='char *' fi ;; - esac - echo " " - echo "Your system wants malloc to return $mallocptrtype*, it would seem." - ;; -*) mallocsrc=''; - mallocobj=''; - mallocptrtype=void - val="$undef" - ;; esac -set d_mymalloc -eval $setvar - -: see if ndbm is available -echo " " -xxx=`./loc ndbm.h x $usrinclude /usr/local/include $inclwanted` -if test -f $xxx; then - val="$define" - echo "ndbm.h found." -else - val="$undef" - echo "ndbm.h NOT found." -fi -set d_ndbm -eval $setvar - -: see if we have the old dbm -echo " " -xxx=`./loc dbm.h x $usrinclude /usr/local/include $inclwanted` -if test -f $xxx; then - val="$define" - echo "dbm.h found." -else - val="$undef" - echo "dbm.h NOT found." -fi -set d_odbm -eval $setvar +echo "Your system wants malloc to return '$malloctype', it would seem." >&4 -: see whether socket exists -echo " " -socketlib='' -if $contains socket libc.list >/dev/null 2>&1; then - echo "Looks like you have Berkeley networking support." - val="$define" - : now check for advanced features - if $contains setsockopt libc.list >/dev/null 2>&1; then - val2="$undef" - else - echo "...but it uses the old 4.1c interface, rather than 4.2" - val2="$define" - fi -else - : hpux, for one, puts all the socket stuff in socklib.o - if $contains socklib libc.list >/dev/null 2>&1; then - echo "Looks like you have Berkeley networking support." - val="$define" - : we will have to assume that it supports the 4.2 BSD interface - val2="$undef" - else - echo "Hmmm...you don't have Berkeley networking in libc.a..." - : look for an optional networking library - if test -f /usr/lib/libnet.a; then - (ar t /usr/lib/libnet.a || - nm -g /usr/lib/libnet.a) 2>/dev/null >> libc.list - if $contains socket libc.list >/dev/null 2>&1; then - echo "but the Wollongong group seems to have hacked it in." - socketlib="-lnet -lnsl_s" - val="$define" - : now check for advanced features - if $contains setsockopt libc.list >/dev/null 2>&1; then - val2="$undef" - else - echo "...using the old 4.1c interface, rather than 4.2" - val2="$define" - fi - else - echo "or even in libnet.a, which is peculiar." - val="$undef" - val2="$undef" - fi +case "$freetype" in +'') + if $cc $ccflags -c -DTRY_FREE malloc.c >/dev/null 2>&1; then + freetype='void' else - echo "or anywhere else I see." - val="$undef" - val2="$undef" + freetype='int' fi - fi -fi -set d_socket -eval $setvar - -if $contains socketpair libc.list >/dev/null 2>&1; then - val="$define" -else - val="$undef" -fi -set d_sockpair -eval $setvar -val=$val2 -set d_oldsock -eval $setvar + ;; +esac +echo "Your system uses $freetype free(), it would seem." >&4 +$rm -f malloc.[co] +: see if nice exists +set nice d_nice +eval $inlibc : Locate the flags for 'open()' echo " " @@ -2685,9 +5015,7 @@ $cat >open3.c <<'EOCP' #include #endif main() { - if(O_RDONLY); - #ifdef O_TRUNC exit(0); #else @@ -2696,98 +5024,210 @@ main() { } EOCP : check sys/file.h first to get FREAD on Sun -if $test -r $usrinclude/sys/file.h && \ - $cc $cppflags "-DI_SYS_FILE" open3.c -o open3 >/dev/null 2>&1 ; then - h_sys_file=true; - echo "sys/file.h defines the O_* constants..." - if ./open3; then - echo "and you have the 3 argument form of open()." - val="$define" - else - echo "but not the 3 argument form of open(). Oh, well." - val="$undef" - fi -elif $test -r $usrinclude/fcntl.h && \ - $cc "-DI_FCNTL" open3.c -o open3 >/dev/null 2>&1 ; then - h_fcntl=true; - echo "fcntl.h defines the O_* constants..." - if ./open3; then - echo "and you have the 3 argument form of open()." - val="$define" - else - echo "but not the 3 argument form of open(). Oh, well." - val="$undef" - fi +if $test `./findhdr sys/file.h` && \ + $cc $cppflags "-DI_SYS_FILE" open3.c -o open3 >/dev/null 2>&1 ; then + h_sysfile=true; + echo " defines the O_* constants..." >&4 + if ./open3; then + echo "and you have the 3 argument form of open()." >&4 + val="$define" + else + echo "but not the 3 argument form of open(). Oh, well." >&4 + val="$undef" + fi +elif $test `./findhdr fcntl.h` && \ + $cc "-DI_FCNTL" open3.c -o open3 >/dev/null 2>&1 ; then + h_fcntl=true; + echo " defines the O_* constants..." >&4 + if ./open3; then + echo "and you have the 3 argument form of open()." >&4 + val="$define" + else + echo "but not the 3 argument form of open(). Oh, well." >&4 + val="$undef" + fi else - val="$undef" - echo "I can't find the O_* constant definitions! You got problems." + val="$undef" + echo "I can't find the O_* constant definitions! You got problems." >&4 fi set d_open3 eval $setvar +$rm -f open3* -: see if how pwd stuff is defined +: see if pause exists +set pause d_pause +eval $inlibc + +: see if pipe exists +set pipe d_pipe +eval $inlibc + +: see if this is a pwd system echo " " -if $test -r $usrinclude/pwd.h ; then - i_pwd="$define" - echo "pwd.h found." - $cppstdin $cppflags $cppminus <$usrinclude/pwd.h | \ - sed -n '/struct[ ][ ]*passwd/,/^};/p' >pwd.txt - if $contains 'pw_quota' pwd.txt >/dev/null 2>&1; then - d_pwquota="$define" - else +xxx=`./findhdr pwd.h` +if $test "$xxx"; then + i_pwd="$define" + echo " found." >&4 + $cppstdin $cppflags $cppminus < $xxx >$$.h + if $contains 'pw_quota' $$.h >/dev/null 2>&1; then + d_pwquota="$define" + else + d_pwquota="$undef" + fi + if $contains 'pw_age' $$.h >/dev/null 2>&1; then + d_pwage="$define" + else + d_pwage="$undef" + fi + if $contains 'pw_change' $$.h >/dev/null 2>&1; then + d_pwchange="$define" + else + d_pwchange="$undef" + fi + if $contains 'pw_class' $$.h >/dev/null 2>&1; then + d_pwclass="$define" + else + d_pwclass="$undef" + fi + if $contains 'pw_expire' $$.h >/dev/null 2>&1; then + d_pwexpire="$define" + else + d_pwexpire="$undef" + fi + if $contains 'pw_comment' $$.h >/dev/null 2>&1; then + d_pwcomment="$define" + else + d_pwcomment="$undef" + fi + $rm -f $$.h +else + i_pwd="$undef" d_pwquota="$undef" - fi - if $contains 'pw_age' pwd.txt >/dev/null 2>&1; then - d_pwage="$define" - else d_pwage="$undef" - fi - if $contains 'pw_change' pwd.txt >/dev/null 2>&1; then - d_pwchange="$define" - else d_pwchange="$undef" - fi - if $contains 'pw_class' pwd.txt >/dev/null 2>&1; then - d_pwclass="$define" - else d_pwclass="$undef" - fi - if $contains 'pw_expire' pwd.txt >/dev/null 2>&1; then - d_pwexpire="$define" - else d_pwexpire="$undef" - fi - if $contains 'pw_comment' pwd.txt >/dev/null 2>&1; then - d_pwcomment="$define" - else d_pwcomment="$undef" - fi -else - i_pwd="$undef" - d_pwquota="$undef" - d_pwage="$undef" - d_pwchange="$undef" - d_pwclass="$undef" - d_pwexpire="$undef" - d_pwcomment="$undef" - echo "No pwd.h found." + echo " NOT found." >&4 fi +: see if readdir and friends exist +set readdir d_readdir +eval $inlibc +set seekdir d_seekdir +eval $inlibc +set telldir d_telldir +eval $inlibc +set rewinddir d_rewinddir +eval $inlibc + +: see if readlink exists +set readlink d_readlink +eval $inlibc + : see if rename exists set rename d_rename eval $inlibc -: see if rewindir exists -set rewinddir d_rewindir -eval $inlibc - : see if rmdir exists set rmdir d_rmdir eval $inlibc -: see if seekdir exists -set seekdir d_seekdir -eval $inlibc +: can bcopy handle overlapping blocks? +val="$undef" +case "$d_bcopy" in +"$define") + echo " " + echo "Checking to see if your bcopy() can do overlapping copies..." >&4 + $cat >foo.c <<'EOCP' +main() +{ +char buf[128], abc[128]; +char *b; +int len; +int off; +int align; + +bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36); + +for (align = 7; align >= 0; align--) { + for (len = 36; len; len--) { + b = buf+align; + bcopy(abc, b, len); + for (off = 1; off <= len; off++) { + bcopy(b, b+off, len); + bcopy(b+off, b, len); + if (bcmp(b, abc, len)) + exit(1); + } + } +} +exit(0); +} +EOCP + if $cc foo.c -o safebcpy $ccflags $ldflags $libs >/dev/null 2>&1 ; then + if ./safebcpy 2>/dev/null; then + echo "Yes, it can." + val="$define" + else + echo "It can't, sorry." + fi + else + echo "(I can't compile the test program, so we'll assume not...)" + fi + ;; +esac +$rm -f foo.* safebcpy core +set d_safebcpy +eval $setvar + +: can memcpy handle overlapping blocks? +val="$undef" +case "$d_memcpy" in +"$define") + echo " " + echo "Checking to see if your memcpy() can do overlapping copies..." >&4 + $cat >foo.c <<'EOCP' +main() +{ +char buf[128], abc[128]; +char *b; +int len; +int off; +int align; + +memcpy(abc, "abcdefghijklmnopqrstuvwxyz0123456789", 36); + +for (align = 7; align >= 0; align--) { + for (len = 36; len; len--) { + b = buf+align; + memcpy(abc, b, len); + for (off = 1; off <= len; off++) { + memcpy(b, b+off, len); + memcpy(b+off, b, len); + if (memcmp(b, abc, len)) + exit(1); + } + } +} +exit(0); +} +EOCP + if $cc foo.c -o safemcpy $ccflags $ldflags $libs >/dev/null 2>&1 ; then + if ./safemcpy 2>/dev/null; then + echo "Yes, it can." + val="$define" + else + echo "It can't, sorry." + fi + else + echo "(I can't compile the test program, so we'll assume not...)" + fi + ;; +esac +$rm -f foo.* safemcpy core +set d_safemcpy +eval $setvar : see if select exists set select d_select @@ -2809,15 +5249,15 @@ eval $inlibc h_sem=true echo " " case "$d_semctl$d_semget$d_semop" in -*undef*) h_sem=false;; +*"$undef"*) h_sem=false;; esac : we could also check for sys/ipc.h ... -if $h_sem && $test -r $usrinclude/sys/sem.h; then - echo "You have the full sem*(2) library." - val="$define" +if $h_sem && $test `./findhdr sys/sem.h`; then + echo "You have the full sem*(2) library." >&4 + val="$define" else - echo "You don't have the full sem*(2) library." - val="$undef" + echo "You don't have the full sem*(2) library." >&4 + val="$undef" fi set d_sem eval $setvar @@ -2830,8 +5270,16 @@ eval $inlibc set seteuid d_seteuid eval $inlibc -: see if setpgrp exists -set setpgrp d_setpgrp +: see if setlinebuf exists +set setlinebuf d_setlinebuf +eval $inlibc + +: see if setlocale exists +set setlocale d_setlocale +eval $inlibc + +: see if setpgid exists +set setpgid d_setpgid eval $inlibc : see if setpgrp2 exists @@ -2862,6 +5310,10 @@ eval $inlibc set setruid d_setruid eval $inlibc +: see if setsid exists +set setsid d_setsid +eval $inlibc + : see if shmctl exists set shmctl d_shmctl eval $inlibc @@ -2873,19 +5325,34 @@ eval $inlibc : see if shmat exists set shmat d_shmat eval $inlibc - -d_voidshmat="$undef" +: see what shmat returns case "$d_shmat" in -define) - $cppstdin $cppflags $cppminus < $usrinclude/sys/shm.h >voidshmat.txt 2>/dev/null - if $contains "void.*shmat" voidshmat.txt >/dev/null 2>&1; then - echo "and shmat returns (void*)" - d_voidshmat="$define" - else - echo "and shmat returns (char*)" - fi - ;; +"$define") + $cat >shmat.c <<'END' +#include +void *shmat(); +END + if $cc $ccflags -c shmat.c >/dev/null 2>&1; then + shmattype='void *' + else + shmattype='char *' + fi + echo "and it returns ($shmattype)." >&4 + : see if a prototype for shmat is available + $cppstdin $cppflags $cppminus < $usrinc/sys/shm.h > shmat.c 2>/dev/null + if $contains 'shmat.*(' shmat.c >/dev/null 2>&1; then + val="$define" + else + val="$undef" + fi + $rm -f shmat.[co] + ;; +*) + val="$undef" + ;; esac +set d_shmatprototype +eval $setvar : see if shmdt exists set shmdt d_shmdt @@ -2895,471 +5362,1367 @@ eval $inlibc h_shm=true echo " " case "$d_shmctl$d_shmget$d_shmat$d_shmdt" in -*undef*) h_shm=false;; +*"$undef"*) h_shm=false;; esac : we could also check for sys/ipc.h ... -if $h_shm && $test -r $usrinclude/sys/shm.h; then - echo "You have the full shm*(2) library." - val="$define" +if $h_shm && $test `./findhdr sys/shm.h`; then + echo "You have the full shm*(2) library." >&4 + val="$define" else - echo "You don't have the full shm*(2) library." - val="$undef" + echo "You don't have the full shm*(2) library." >&4 + val="$undef" fi set d_shm eval $setvar +socketlib='' +sockethdr='' +: see whether socket exists +echo " " +$echo $n "Hmm... $c" >&4 +if set socket val -f d_socket; eval $csym; $val; then + echo "Looks like you have Berkeley networking support." >&4 + d_socket="$define" + if set setsockopt val -f; eval $csym; $val; then + d_oldsock="$undef" + else + echo "...but it uses the old 4.1c interface, rather than 4.2" >&4 + d_oldsock="$define" + fi +else + if $contains socklib libc.list >/dev/null 2>&1; then + echo "Looks like you have Berkeley networking support." >&4 + d_socket="$define" + : we will have to assume that it supports the 4.2 BSD interface + d_oldsock="$undef" + else + echo "You don't have Berkeley networking in libc.a..." >&4 + if test -f /usr/lib/libnet.a; then + ( (nm $nm_opt /usr/lib/libnet.a | eval $nm_extract) || \ + ar t /usr/lib/libnet.a) 2>/dev/null >> libc.list + if $contains socket libc.list >/dev/null 2>&1; then + echo "...but the Wollongong group seems to have hacked it in." >&4 + socketlib="-lnet" + sockethdr="-I/usr/netinclude" + d_socket="$define" + if $contains setsockopt libc.list >/dev/null 2>&1; then + d_oldsock="$undef" + else + echo "...using the old 4.1c interface, rather than 4.2" >&4 + d_oldsock="$define" + fi + else + echo "or even in libnet.a, which is peculiar." >&4 + d_socket="$undef" + d_oldsock="$undef" + fi + else + echo "or anywhere else I see." >&4 + d_socket="$undef" + d_oldsock="$undef" + fi + fi +fi + +: see if socketpair exists +set socketpair d_sockpair +eval $inlibc + : see if stat knows about block sizes echo " " -if $contains 'st_blocks;' $usrinclude/sys/stat.h >/dev/null 2>&1 ; then - if $contains 'st_blksize;' $usrinclude/sys/stat.h >/dev/null 2>&1 ; then - echo "Your stat knows about block sizes." - val="$define" - else - echo "Your stat doesn't know about block sizes." - val="$undef" - fi +xxx=`./findhdr sys/stat.h` +if $contains 'st_blocks;' "$xxx" >/dev/null 2>&1 ; then + if $contains 'st_blksize;' "$xxx" >/dev/null 2>&1 ; then + echo "Your stat() knows about block sizes." >&4 + val="$define" + else + echo "Your stat() doesn't know about block sizes." >&4 + val="$undef" + fi else - echo "Your stat doesn't know about block sizes." - val="$undef" + echo "Your stat() doesn't know about block sizes." >&4 + val="$undef" fi set d_statblks eval $setvar -: see if stdio is really std +: see if strcoll exists +set strcoll d_strcoll +eval $inlibc + +: check for structure copying echo " " -if $contains 'char.*_ptr.*;' $usrinclude/stdio.h >/dev/null 2>&1 ; then - if $contains '_cnt;' $usrinclude/stdio.h >/dev/null 2>&1 ; then - echo "Your stdio is pretty std." +echo "Checking to see if your C compiler can copy structs..." >&4 +$cat >try.c <<'EOCP' +main() +{ + struct blurfl { + int dyick; + } foo, bar; + + foo = bar; +} +EOCP +if $cc -c try.c >/dev/null 2>&1 ; then val="$define" - else - echo "Your stdio isn't very std." + echo "Yup, it can." +else val="$undef" - fi + echo "Nope, it can't." +fi +set d_strctcpy +eval $setvar +$rm -f try.* + +: see if strerror and/or sys_errlist[] exist +echo " " +if set strerror val -f d_strerror; eval $csym; $val; then + echo 'strerror() found.' >&4 + d_strerror="$define" + d_strerrm='strerror(e)' + if set sys_errlist val -a d_syserrlst; eval $csym; $val; then + echo "(You also have sys_errlist[], so we could roll our own strerror.)" + d_syserrlst="$define" + else + echo "(Since you don't have sys_errlist[], sterror() is welcome.)" + d_syserrlst="$undef" + fi +elif xxx=`./findhdr string.h`; test "$xxx" || xxx=`./findhdr strings.h`; \ + $contains '#[ ]*define.*strerror' "$xxx" >/dev/null 2>&1; then + echo 'strerror() found in string header.' >&4 + d_strerror="$define" + d_strerrm='strerror(e)' + if set sys_errlist val -a d_syserrlst; eval $csym; $val; then + echo "(Most probably, strerror() uses sys_errlist[] for descriptions.)" + d_syserrlst="$define" + else + echo "(You don't appear to have any sys_errlist[], how can this be?)" + d_syserrlst="$undef" + fi +elif set sys_errlist val -a d_syserrlst; eval $csym; $val; then +echo "strerror() not found, but you have sys_errlist[] so we'll use that." >&4 + d_strerror="$undef" + d_syserrlst="$define" + d_strerrm='((e)<0||(e)>=sys_nerr?"unknown":sys_errlist[e])' else - echo "Your stdio isn't very std." - val="$undef" + echo 'strerror() and sys_errlist[] NOT found.' >&4 + d_strerror="$undef" + d_syserrlst="$undef" + d_strerrm='"unknown"' fi -set d_stdstdio + +: see if strxfrm exists +set strxfrm d_strxfrm +eval $inlibc + +: see if symlink exists +set symlink d_symlink +eval $inlibc + +: see if syscall exists +set syscall d_syscall +eval $inlibc + +: see if sysconf exists +set sysconf d_sysconf +eval $inlibc + +: see if system exists +set system d_system +eval $inlibc + +: see if tcgetpgrp exists +set tcgetpgrp d_tcgetpgrp +eval $inlibc + +: see if tcsetpgrp exists +set tcsetpgrp d_tcsetpgrp +eval $inlibc + +: define an is-a-typedef? function +typedef='type=$1; var=$2; def=$3; shift; shift; shift; inclist=$@; +case "$inclist" in +"") inclist="sys/types.h";; +esac; +eval "varval=\$$var"; +case "$varval" in +"") + $rm -f temp.c; + for inc in $inclist; do + echo "#include <$inc>" >>temp.c; + done; + $cppstdin $cppflags $cppminus < temp.c >temp.E 2>/dev/null; + if $contains $type temp.E >/dev/null 2>&1; then + eval "$var=$type"; + else + eval "$var=$def"; + fi; + $rm -f temp.?;; +*) eval "$var=$varval";; +esac' + +: see if this is a sys/times.h system +set sys/times.h i_systimes +eval $inhdr + +: see if times exists +echo " " +if set times val -f d_times; eval $csym; $val; then + echo 'times() found.' >&4 + d_times="$define" + inc='' + case "$i_systimes" in + "$define") inc='sys/times.h';; + esac + set clock_t clocktype long stdio.h sys/types.h $inc + eval $typedef + dflt="$clocktype" + echo " " + rp="What type is returned by times() on this sytem?" + . ./myread + clocktype="$ans" +else + echo 'times() NOT found, hope that will do.' >&4 + d_times="$undef" + clocktype='int' +fi + +: see if truncate exists +set truncate d_truncate +eval $inlibc + +: see if tzname[] exists +echo " " +if set tzname val -a d_tzname; eval $csym; $val; then + val="$define" + echo 'tzname[] found.' >&4 +else + val="$undef" + echo 'tzname[] NOT found.' >&4 +fi +set d_tzname eval $setvar -: check for structure copying +: see if umask exists +set umask d_umask +eval $inlibc + +: see if we have to deal with yellow pages, now NIS. +if $test -d /usr/etc/yp || $test -d /etc/yp; then + if $test -f /usr/etc/nibindd; then + echo " " + echo "I'm fairly confident you're on a NeXT." + echo " " + rp='Do you get the hosts file via NetInfo?' + dflt=y + case "$hostcat" in + nidump*) ;; + '') ;; + *) dflt=n;; + esac + . ./myread + case "$ans" in + y*) hostcat='nidump hosts .';; + *) ;; + esac + fi + case "$hostcat" in + nidump*) ;; + *) + case "$hostcat" in + *ypcat*) dflt=y;; + '') if $contains '^\+' /etc/passwd >/dev/null 2>&1; then + dflt=y + else + dflt=n + fi;; + *) dflt=n;; + esac + echo " " + rp='Are you getting the hosts file via yellow pages?' + . ./myread + case "$ans" in + y*) hostcat='ypcat hosts';; + *) hostcat='cat /etc/hosts';; + esac + ;; + esac +fi + +: now get the host name +echo " " +echo "Figuring out host name..." >&4 +case "$myhostname" in +'') cont=true + echo 'Maybe "hostname" will work...' + if tans=`sh -c hostname 2>&1` ; then + myhostname=$tans + phostname=hostname + cont='' + fi + ;; +*) cont='';; +esac +if $test "$cont"; then + if ./xenix; then + echo 'Oh, dear. Maybe "/etc/systemid" is the key...' + if tans=`cat /etc/systemid 2>&1` ; then + myhostname=$tans + phostname='cat /etc/systemid' + echo "Whadyaknow. Xenix always was a bit strange..." + cont='' + fi + elif $test -r /etc/systemid; then + echo "(What is a non-Xenix system doing with /etc/systemid?)" + fi +fi +if $test "$cont"; then + echo 'No, maybe "uuname -l" will work...' + if tans=`sh -c 'uuname -l' 2>&1` ; then + myhostname=$tans + phostname='uuname -l' + else + echo 'Strange. Maybe "uname -n" will work...' + if tans=`sh -c 'uname -n' 2>&1` ; then + myhostname=$tans + phostname='uname -n' + else + echo 'Oh well, maybe I can mine it out of whoami.h...' + if tans=`sh -c $contains' sysname $usrinc/whoami.h' 2>&1` ; then + myhostname=`echo "$tans" | $sed 's/^.*"\(.*\)"/\1/'` + phostname="sed -n -e '"'/sysname/s/^.*\"\\(.*\\)\"/\1/{'"' -e p -e q -e '}' <$usrinc/whoami.h" + else + case "$myhostname" in + '') echo "Does this machine have an identity crisis or something?" + phostname='';; + *) + echo "Well, you said $myhostname before..." + phostname='echo $myhostname';; + esac + fi + fi + fi +fi +: you do not want to know about this +set $myhostname +myhostname=$1 + +: verify guess +if $test "$myhostname" ; then + dflt=y + rp='Your host name appears to be "'$myhostname'".'" Right?" + . ./myread + case "$ans" in + y*) ;; + *) myhostname='';; + esac +fi + +: bad guess or no guess +while $test "X$myhostname" = X ; do + dflt='' + rp="Please type the (one word) name of your host:" + . ./myread + myhostname="$ans" +done + +: translate upper to lower if necessary +case "$myhostname" in +*[A-Z]*) + echo "(Normalizing case in your host name)" + myhostname=`echo $myhostname | ./tr '[A-Z]' '[a-z]'` + ;; +esac + +: a little sanity check here +case "$phostname" in +'') ;; +*) + case `$phostname | ./tr '[A-Z]' '[a-z]'` in + $myhostname$mydomain|$myhostname) ;; + *) + case "$phostname" in + sed*) + echo "(That doesn't agree with your whoami.h file, by the way.)" + ;; + *) + echo "(That doesn't agree with your $phostname command, by the way.)" + ;; + esac + ;; + esac + ;; +esac + +: see how we will look up host name +echo " " +if false; then + : dummy stub to allow use of elif +elif set uname val -f d_uname; eval $csym; $val; then + if ./xenix; then + $cat <<'EOM' +uname() was found, but you're running xenix, and older versions of xenix +have a broken uname(). If you don't really know whether your xenix is old +enough to have a broken system call, use the default answer. + +EOM + dflt=y + case "$d_uname" in + "$define") dflt=n;; + esac + rp='Is your uname() broken?' + . ./myread + case "$ans" in + n*) d_uname="$define"; call=uname;; + esac + else + echo 'uname() found.' >&4 + d_uname="$define" + call=uname + fi +fi +case "$d_gethname" in +'') d_gethname="$undef";; +esac +case "$d_uname" in +'') d_uname="$undef";; +esac +case "$d_phostname" in +'') d_phostname="$undef";; +esac + +: backward compatibility for d_hvfork +if test X$d_hvfork != X; then + d_vfork="$d_hvfork" + d_hvfork='' +fi +: see if there is a vfork +val='' +set vfork val +eval $inlibc + +: Ok, but do we want to use it. vfork is reportedly unreliable in +: perl on Solaris 2.x, and probably elsewhere. +case "$val" in +$define) + echo " " + case "$usevfork" in + false) dflt='n';; + *) dflt='y';; + esac + rp="Some systems have problems with vfork(). Do you want to use it?" + . ./myread + case "$ans" in + y|Y) ;; + *) + echo "Ok, we won't use vfork()." + val="$undef" + ;; + esac + ;; +esac +set d_vfork +eval $setvar +case "$d_vfork" in +$define) usevfork='true';; +*) usevfork='false';; +esac + +: see if this is an sysdir system +set sys/dir.h i_sysdir +eval $inhdr + +: see if this is an sysndir system +set sys/ndir.h i_sysndir +eval $inhdr + +: see if closedir exists +set closedir d_closedir +eval $inlibc + +case "$d_closedir" in +"$define") + echo " " + echo "Checking whether closedir() returns a status..." >&4 + cat > closedir.c < +#if defined(NeXT) && defined(I_SYS_DIR) /* NeXT needs dirent + sys/dir.h */ +#include +#endif +#else +#ifdef I_SYS_NDIR +#include +#else +#ifdef I_SYS_DIR +#ifdef hp9000s500 +#include /* may be wrong in the future */ +#else +#include +#endif +#endif +#endif +#endif +int main() { return closedir(opendir(".")); } +EOM + if $cc $ccflags $ldflags -o closedir closedir.c $libs > /dev/null 2>&1; then + if ./closedir > /dev/null 2>&1 ; then + echo "Yes, it does." + val="$undef" + else + echo "No, it doesn't." + val="$define" + fi + else + echo "(I can't seem to compile the test program--assuming it doesn't)" + val="$define" + fi + ;; +*) + val="$undef"; + ;; +esac +set d_void_closedir +eval $setvar +$rm -f closedir* +: check for volatile keyword echo " " -echo "Checking to see if your C compiler can copy structs..." -$cat >strctcpy.c <<'EOCP' +echo 'Checking to see if your C compiler knows about "volatile"...' >&4 +$cat >try.c <<'EOCP' main() { - struct blurfl { - int dyick; - } foo, bar; - - foo = bar; + typedef struct _goo_struct goo_struct; + goo_struct * volatile goo = ((goo_struct *)0); + struct _goo_struct { + long long_int; + int reg_int; + char char_var; + }; + typedef unsigned short foo_t; + char *volatile foo; + volatile int bar; + volatile foo_t blech; + foo = foo; } EOCP -if $cc -c strctcpy.c >/dev/null 2>&1 ; then - val="$define" - echo "Yup, it can." +if $cc -c $ccflags try.c >/dev/null 2>&1 ; then + val="$define" + echo "Yup, it does." else - val="$undef" - echo "Nope, it can't." + val="$undef" + echo "Nope, it doesn't." fi -set d_strctcpy +set d_volatile eval $setvar +$rm -f try.* -: see if strerror exists -set strerror d_strerror +: see if there is a wait4 +set wait4 d_wait4 eval $inlibc -: see if symlink exists -set symlink d_symlink +: see if waitpid exists +set waitpid d_waitpid eval $inlibc -: see if syscall exists -set syscall d_syscall +: see if wcstombs exists +set wcstombs d_wcstombs +eval $inlibc + +: see if wctomb exists +set wctomb d_wctomb eval $inlibc -: set if package uses struct tm -w_s_tm=1 +: preserve RCS keywords in files with variable substitution, grrr +Date='$Date' +Id='$Id' +Log='$Log' +RCSfile='$RCSfile' +Revision='$Revision' -: set if package uses struct timeval -case "$d_select" in -define) w_s_timevl=1 ;; +: check for alignment requirements +echo " " +case "$alignbytes" in +'') echo "Checking alignment constraints..." >&4 + $cat >try.c <<'EOCP' +struct foobar { + char foo; + double bar; +} try; +main() +{ + printf("%d\n", (char *)&try.bar - (char *)&try.foo); +} +EOCP + if $cc $ccflags try.c -o try >/dev/null 2>&1; then + dflt=`./try` + else + dflt='8' + echo"(I can't seem to compile the test program...)" + fi + ;; +*) dflt="$alignbytes" + ;; esac +rp="Doubles must be aligned on a how-many-byte boundary?" +. ./myread +alignbytes="$ans" +$rm -f try.c try -: set if package uses localtime function -w_localtim=1 +: determine where public executables go +echo " " +set dflt bin bin +eval $prefixit +fn=d~ +rp='Pathname where the public executables will reside?' +. ./getfile +if $test "X$ansexp" != "X$binexp"; then + installbin='' +fi +bin="$ans" +binexp="$ansexp" +if $afs; then + $cat <, , and -should be included, because this application wants: +Since you are running AFS, I need to distinguish the directory in which +executables reside from the directory in which they are installed (and from +which they are presumably copied to the former directory by occult means). EOM -case "$w_s_itimer" in -1) - echo " struct itimerval" - idefs="-DS_ITIMERVAL $idefs" - ;; -esac -case "$w_s_timevl" in -1) - echo " struct timeval" - idefs="-DS_TIMEVAL $idefs" - ;; -esac -case "$w_s_tm" in -1) - echo " struct tm" - idefs="-DS_TM $idefs" - ;; -esac -case "$w_localtim" in -1) - echo " ctime(3) declarations" - idefs="-DD_CTIME $idefs" - ;; -esac -case "$idefs" in + case "$installbin" in + '') dflt=`echo $binexp | sed 's#^/afs/#/afs/.#'`;; + *) dflt="$installbin";; + esac + fn=de~ + rp='Where will public executables be installed?' + . ./getfile + installbin="$ans" +else + installbin="$binexp" +fi + +: check for ordering of bytes in a long +case "$byteorder" in '') - echo " (something I don't know about)" - ;; + $cat <<'EOM' + +In the following, larger digits indicate more significance. A big-endian +machine like a Pyramid or a Motorola 680?0 chip will come out to 4321. A +little-endian machine like a Vax or an Intel 80?86 chip would be 1234. Other +machines may have weird orders like 3412. A Cray will report 87654321. If +the test program works the default is probably right. +I'm now running the test program... +EOM + $cat >try.c <<'EOCP' +#include +main() +{ + int i; + union { + unsigned long l; + char c[sizeof(long)]; + } u; + + if (sizeof(long) > 4) + u.l = (0x08070605L << 32) | 0x04030201L; + else + u.l = 0x04030201L; + for (i = 0; i < sizeof(long); i++) + printf("%c", u.c[i]+'0'); + printf("\n"); +} +EOCP + if $cc $ccflags try.c -o try >/dev/null 2>&1 ; then + dflt=`./try` + case "$dflt" in + ????|????????) echo "(The test program ran ok.)";; + *) echo "(The test program didn't run right for some reason.)";; + esac + else + dflt='4321' + cat <<'EOM' +(I can't seem to compile the test program. Guessing big-endian...) +EOM + fi + ;; +*) + echo " " + dflt="$byteorder" + ;; esac +rp="What is the order of bytes in a long?" +. ./myread +byteorder="$ans" +$rm -f try.c try + +: how do we catenate cpp tokens here? echo " " -echo "I'm now running the test program..." -$cat >i_time.c <<'EOCP' +echo "Checking to see how your cpp does stuff like catenate tokens..." >&4 +$cat >cpp_stuff.c <<'EOCP' +#define RCAT(a,b)a/**/b +#define ACAT(a,b)a ## b +RCAT(Rei,ser) +ACAT(Cir,cus) +EOCP +$cppstdin $cppflags $cppminus cpp_stuff.out 2>&1 +if $contains 'Circus' cpp_stuff.out >/dev/null 2>&1; then + echo "Oh! Smells like ANSI's been here." + echo "We can catify or stringify, separately or together!" + cpp_stuff=42 +elif $contains 'Reiser' cpp_stuff.out >/dev/null 2>&1; then + echo "Ah, yes! The good old days!" + echo "However, in the good old days we don't know how to stringify and" + echo "catify at the same time." + cpp_stuff=1 +else + $cat >&4 <&4 + cat >try.c <<'EOCP' #include -#ifdef I_TIME -#include -#endif -#ifdef I_SYS_TIME -#ifdef SYSTIMEKERNEL -#define KERNEL -#endif -#include -#endif -#ifdef I_SYS_SELECT -#include -#endif +#include +u_int32_t +hash_cb (ptr, size) +const void * ptr ; +size_t size ; +{ +} +HASHINFO info ; main() { - struct tm foo; - struct tm *tmp; -#ifdef S_TIMEVAL - struct timeval bar; -#endif -#ifdef S_ITIMERVAL - struct itimerval baz; -#endif + info.hash = hash_cb ; +} +EOCP + if $cc $ccflags -c try.c >try.out 2>&1 ; then + if $contains warning try.out >>/dev/null 2>&1 ; then + db_hashtype='int' + else + db_hashtype='u_int32_t' + fi + else + echo "I can't seem to compile the test program." >&4 + db_hashtype=int + fi + $rm -f try.[co] + echo "Your version of Berkeley DB uses $db_hashtype for hash." + ;; +*) db_hashtype=int + ;; +esac - if (foo.tm_sec == foo.tm_sec) - exit(0); -#ifdef S_TIMEVAL - if (bar.tv_sec == bar.tv_sec) - exit(0); +case "$i_db" in +define) + : Check the return type needed for prefix + echo "Checking return type needed for prefix for Berkeley DB ..." >&4 + cat >try.c <<'EOCP' +#include +#include +size_t +prefix_cb (key1, key2) +const DBT * key1 ; +const DBT * key2 ; +{ +} +BTREEINFO info ; +main() +{ + info.prefix = prefix_cb ; +} +EOCP + if $cc $ccflags -c try.c >try.out 2>&1 ; then + if $contains warning try.out >>/dev/null 2>&1 ; then + db_prefixtype='int' + else + db_prefixtype='size_t' + fi + else + echo "I can't seem to compile the test program." >&4 + db_prefixtype='int' + fi + $rm -f try.[co] + echo "Your version of Berkeley DB uses $db_prefixtype for prefix." + ;; +*) db_prefixtype='int' + ;; +esac + +: check for void type +echo " " +echo "Checking to see how well your C compiler groks the void type..." >&4 +echo " " +$cat >&4 <try.c <<'EOCP' +#if TRY & 1 +void main() { +#else +main() { #endif -#ifdef S_ITIMERVAL - if (baz.it_interval == baz.it_interval) - exit(0); + extern void moo(); /* function returning void */ + void (*goo)(); /* ptr to func returning void */ +#if TRY & 8 + void *hue; /* generic ptr */ #endif -#ifdef S_TIMEVAL - if (bar.tv_sec == bar.tv_sec) - exit(0); +#if TRY & 2 + void (*foo[10])(); #endif -#ifdef D_CTIME - /* this might not do anything for us... */ - tmp = localtime((time_t *)0); + +#if TRY & 4 + if(goo == moo) { + exit(0); + } #endif - exit(1); + exit(0); } EOCP -flags='' -for i_sys_select in '' '-DI_SYS_SELECT'; do - for d_systimekernel in '' '-DSYSTIMEKERNEL'; do - for i_time in '' '-DI_TIME'; do - for i_systime in '-DI_SYS_TIME' ''; do - case "$flags" in - '') echo Trying $i_time $i_systime $d_systimekernel $i_sys_select - if $cc $ccflags $idefs \ - $i_time $i_systime $d_systimekernel $i_sys_select \ - i_time.c -o i_time >/dev/null 2>&1 ; then - set X $i_time $i_systime $d_systimekernel $i_sys_select - shift - flags="$*" - echo Succeeded with $flags - fi - ;; - esac - done - done - done -done -case "$flags" in -*SYSTIMEKERNEL*) val="$define";; -*) val="$undef";; + if $cc -c -DTRY=$defvoidused try.c >.out 2>&1 ; then + voidflags=$defvoidused + echo "It appears to support void to the level $package wants ($defvoidused)." + if $contains warning .out >/dev/null 2>&1; then + echo "However, you might get some warnings that look like this:" + $cat .out + fi + else +echo "Hmm, your compiler has some difficulty with void. Checking further..." >&4 + if $cc -c -DTRY=1 try.c >/dev/null 2>&1 ; then + echo "It supports 1..." + if $cc -c -DTRY=3 try.c >/dev/null 2>&1 ; then + echo "It also supports 2..." + if $cc -c -DTRY=7 try.c >/dev/null 2>&1 ; then + voidflags=7 + echo "And it supports 4 but not 8 definitely." + else + echo "It doesn't support 4..." + if $cc -c -DTRY=11 try.c >/dev/null 2>&1 ; then + voidflags=11 + echo "But it supports 8." + else + voidflags=3 + echo "Neither does it support 8." + fi + fi + else + echo "It does not support 2..." + if $cc -c -DTRY=13 try.c >/dev/null 2>&1 ; then + voidflags=13 + echo "But it supports 4 and 8." + else + if $cc -c -DTRY=5 try.c >/dev/null 2>&1 ; then + voidflags=5 + echo "And it supports 4 but has not heard about 8." + else + echo "However it supports 8 but not 4." + fi + fi + fi + else + echo "There is no support at all for void." + voidflags=0 + fi + fi esac -set d_systimekernel -eval $setvar -case "$flags" in -*I_TIME*) val="$define";; -*) val="$undef";; +dflt="$voidflags"; +rp="Your void support flags add up to what?" +. ./myread +voidflags="$ans" +$rm -f try.* .out + +: see if dbm.h is available +set dbm.h t_dbm +eval $inhdr +case "$t_dbm" in +$define) + : see if dbmclose exists + set dbmclose d_dbmclose + eval $inlibc + case "$d_dbmclose" in + $undef) + t_dbm="$undef" + echo "We won't be including " + ;; + esac + ;; esac -set i_time +val="$t_dbm" +set i_dbm eval $setvar -case "$flags" in -*I_SYS_SELECT*) val="$define";; -*) val="$undef";; + +: see if ndbm.h is available +set ndbm.h t_ndbm +eval $inhdr +case "$t_ndbm" in +$define) + : see if dbm_open exists + set dbm_open d_dbm_open + eval $inlibc + case "$d_dbm_open" in + $undef) + t_ndbm="$undef" + echo "We won't be including " + ;; + esac + ;; esac -set i_sys_select +val="$t_ndbm" +set i_ndbm eval $setvar -case "$flags" in -*I_SYS_TIME*) val="$define";; -*) val="$undef";; + +: see if gdbm.h is available +set gdbm.h t_gdbm +eval $inhdr +case "$t_gdbm" in +$define) + : see if gdbm_open exists + set gdbm_open d_gdbm_open + eval $inlibc + case "$d_gdbm_open" in + $undef) + t_gdbm="$undef" + echo "We won't be including " + ;; + esac + ;; esac -set i_sys_time +val="$t_gdbm" +set i_gdbm eval $setvar -case "$flags$i_sys_time$i_time" in -undefundef) i_sys_time="$define"; i_time="$define"; - echo "ICK, NOTHING WORKED!!! You may have to diddle the includes.";; -esac - -: see if telldir exists -set telldir d_telldir -eval $inlibc -: see if signal is declared as pointer to function returning int or void echo " " -$cppstdin $cppflags $cppminus < $usrinclude/signal.h >d_voidsig.txt -if $contains 'int[^A-Za-z]*signal' d_voidsig.txt >/dev/null 2>&1 ; then - echo "You have int (*signal())() instead of void." - val="$undef" -else - echo "You have void (*signal())() instead of int." - val="$define" -fi -set d_voidsig -eval $setvar -case $voidsig in -define) d_tosignal=void;; -*) d_tosignal=int;; -esac +echo "Looking for extensions..." >&4 +cd ../ext +known_extensions='' +for xxx in * ; do + if $test -f $xxx/$xxx.xs; then + known_extensions="$known_extensions $xxx" + fi +done +set X $known_extensions +shift +known_extensions="$*" +cd ../UU + +: Now see which are supported on this system. +avail_ext='' +for xxx in $known_extensions ; do + case "$xxx" in + DB_File) case "$i_db" in + $define) avail_ext="$avail_ext $xxx" ;; + esac + ;; + GDBM_File) case "$i_gdbm" in + $define) avail_ext="$avail_ext $xxx" ;; + esac + ;; + NDBM_File) case "$i_ndbm" in + $define) avail_ext="$avail_ext $xxx" ;; + esac + ;; + ODBM_File) case "$i_dbm" in + $define) avail_ext="$avail_ext $xxx" ;; + esac + ;; + POSIX) case "$useposix" in + true|define|y) avail_ext="$avail_ext $xxx" ;; + esac + ;; + Socket) case "$d_socket" in + $define) avail_ext="$avail_ext $xxx" ;; + esac + ;; + *) avail_ext="$avail_ext $xxx" + ;; + esac +done + +set X $avail_ext +shift +avail_ext="$*" + +case $usedl in +$define) + $cat <try.c <<'EOCP' -main() -{ - typedef unsigned short foo_t; - char *volatile foo; - volatile int bar; - volatile foo_t blech; - foo = foo; -} -EOCP -if $cc -c $ccflags try.c >/dev/null 2>&1 ; then - val="$define" - echo "Yup, it does." -else - val="$undef" - echo "Nope, it doesn't." -fi -set d_volatile -eval $setvar -$rm -f try.* - -: see if there is a wait4 -set wait4 d_wait4 -eval $inlibc +dflt="$fpostype" +rp="What is the type for file position used by fsetpos()?" +. ./myread +fpostype="$ans" -: see if there is a waitpid -set waitpid d_waitpid -eval $inlibc +: Store the full pathname to the sed program for use in the C program +full_sed=$sed : see what type gids are declared as in the kernel +set gid_t gidtype xxx stdio.h sys/types.h +eval $typedef case "$gidtype" in -'') - if $contains 'gid_t;' $usrinclude/sys/types.h >/dev/null 2>&1 ; then - dflt='gid_t'; - else - set `grep '_rgid;' $usrinclude/sys/user.h 2>/dev/null` unsigned short +xxx) + xxx=`./findhdr sys/user.h` + set `grep 'groups\[NGROUPS\];' "$xxx" 2>/dev/null` unsigned short case $1 in unsigned) dflt="$1 $2" ;; *) dflt="$1" ;; esac - fi - ;; -*) dflt="$gidtype" - ;; + ;; +*) dflt="$gidtype";; esac -cont=true echo " " -rp="What type are groups ids returned by getgid(), etc.? [$dflt]" -$echo $n "$rp $c" -. myread +rp="What is the type for group ids returned by getgid()?" +. ./myread gidtype="$ans" -: see what type gids are returned by getgroups +: see if getgroups exists +set getgroups d_getgrps +eval $inlibc + +: Find type of 2nd arg to getgroups echo " " -case "$groupstype" in -'') - if $contains 'getgroups.*short' /usr/lib/lint/llib-lc >/dev/null 2>&1; then - dflt='short' - elif $contains 'getgroups.*int' /usr/lib/lint/llib-lc >/dev/null 2>&1; then - dflt='int' - elif $contains 'getgroups.*short' /usr/include/libc.h >/dev/null 2>&1; then - dflt='short' - elif $contains 'getgroups.*int' /usr/include/libc.h >/dev/null 2>&1; then - dflt='int' - elif $contains 'getgroups.*short' /usr/lib/lint/llib-lbsd >/dev/null 2>&1; then - dflt='short' - elif $contains 'getgroups.*int' /usr/lib/lint/llib-lbsd >/dev/null 2>&1; then - dflt='int' - elif $contains 'int.*gidset' /usr/man/man2/getgroups.2 >/dev/null 2>&1; then - dflt='int' - elif $contains 'gid_t;' $usrinclude/sys/types.h >/dev/null 2>&1 ; then - dflt='gid_t' - else - set `grep 'groups\[NGROUPS\];' $usrinclude/sys/user.h 2>/dev/null` unsigned short - case $1 in - unsigned) dflt="$1 $2" ;; - *) dflt="$1" ;; +case "$d_getgrps" in +'define') + case "$groupstype" in + '') dflt="$gidtype" ;; + *) dflt="$groupstype" ;; esac - fi - ;; -*) dflt="$groupstype" - ;; + $cat <intsize.c <<'EOCP' -#include -main() -{ - printf("%d\n", sizeof(int)); -} -EOCP - if $cc intsize.c -o intsize >/dev/null 2>&1 ; then - dflt=`./intsize` - else - dflt='4' - echo "(I can't seem to compile the test program. Guessing...)" - fi - ;; -*) - dflt="$intsize" - ;; -esac -rp="What is the size of an integer (in bytes)? [$dflt]" -$echo $n "$rp $c" -. myread -intsize="$ans" +dflt="$lseektype" +rp="What type is lseek's offset on this system declared as?" +. ./myread +lseektype="$ans" -: determine where private executables go -case "$privlib" in -'') - dflt=/usr/lib/$package - test -d /usr/local/lib && dflt=/usr/local/lib/$package - ;; -*) dflt="$privlib" - ;; -esac +: determine where manual pages go +set mansrc mansrc none +eval $prefixit $cat <&4 +if $test -r ../patchlevel.h;then + patchlevel=`awk '/PATCHLEVEL/ {print $3}' < ../patchlevel.h` +else + patchlevel=0 +fi +echo "(You have $package $baserev PL$patchlevel.)" + +: Cruising for prototypes +echo " " +echo "Checking out function prototypes..." >&4 +$cat >prototype.c <<'EOCP' +main(int argc, char *argv[]) { + exit(0);} +EOCP +if $cc $ccflags -c prototype.c >prototype.out 2>&1 ; then + echo "Your C compiler appears to support function prototypes." + val="$define" +else + echo "Your C compiler doesn't seem to understand function prototypes." + val="$undef" +fi +set prototype +eval $setvar +$rm -f prototype* : check for size of random number generator echo " " case "$randbits" in '') - echo "Checking to see how many bits your rand function produces..." - $cat >randbits.c <<'EOCP' + echo "Checking to see how many bits your rand function produces..." >&4 + $cat >try.c <<'EOCP' #include main() { - register int i; - register unsigned long tmp; - register unsigned long max = 0L; + register int i; + register unsigned long tmp; + register unsigned long max = 0L; - for (i=1000; i; i--) { - tmp = (unsigned long)rand(); - if (tmp > max) max = tmp; - } - for (i=0; max; i++) - max /= 2; - printf("%d\n",i); + for (i = 1000; i; i--) { + tmp = (unsigned long)rand(); + if (tmp > max) max = tmp; + } + for (i = 0; max; i++) + max /= 2; + printf("%d\n",i); } EOCP - if $cc randbits.c -o randbits >/dev/null 2>&1 ; then - dflt=`./randbits` - else - dflt='?' - echo "(I can't seem to compile the test program...)" - fi - ;; + if $cc try.c -o try >/dev/null 2>&1 ; then + dflt=`try` + else + dflt='?' + echo "(I can't seem to compile the test program...)" + fi + ;; *) - dflt="$randbits" - ;; + dflt="$randbits" + ;; esac -rp="How many bits does your rand() function produce? [$dflt]" -$echo $n "$rp $c" -. myread +rp='How many bits does your rand() function produce?' +. ./myread randbits="$ans" +$rm -f try.c try + +: see if ar generates random libraries by itself +echo " " +echo "Checking how to generate random libraries on your machine..." >&4 +echo 'int bar1() { return bar2(); }' > bar1.c +echo 'int bar2() { return 2; }' > bar2.c +$cat > foo.c <<'EOP' +main() { printf("%d\n", bar1()); exit(0); } +EOP +$cc $ccflags -c bar1.c >/dev/null 2>&1 +$cc $ccflags -c bar2.c >/dev/null 2>&1 +$cc $ccflags -c foo.c >/dev/null 2>&1 +ar rc bar.a bar2.o bar1.o >/dev/null 2>&1 +if $cc $ccflags $ldflags -o foobar foo.o bar.a $libs > /dev/null 2>&1 && + ./foobar >/dev/null 2>&1; then + echo "ar appears to generate random libraries itself." + orderlib=false + ranlib=":" +elif ar ts bar.a >/dev/null 2>&1 && + $cc $ccflags $ldflags -o foobar foo.o bar.a $libs > /dev/null 2>&1 && + ./foobar >/dev/null 2>&1; then + echo "a table of contents needs to be added with 'ar ts'." + orderlib=false + ranlib="ar ts" +else + case "$ranlib" in + :) ranlib='';; + '') + ranlib=`./loc ranlib X /usr/bin /bin /usr/local/bin` + $test -f $ranlib || ranlib='' + ;; + esac + if $test -n "$ranlib"; then + echo "your system has '$ranlib'; we'll use that." + orderlib=false + else + echo "your system doesn't seem to support random libraries" + echo "so we'll use lorder and tsort to order the libraries." + orderlib=true + ranlib=":" + fi +fi +$rm -f foo* bar* -: determine where publicly executable scripts go +: determine where public executable scripts go +set scriptdir scriptdir +eval $prefixit case "$scriptdir" in '') - dflt="$bin" - : guess some guesses - test -d /usr/share/scripts && dflt=/usr/share/scripts - test -d /usr/share/bin && dflt=/usr/share/bin - ;; + dflt="$bin" + : guess some guesses + $test -d /usr/share/scripts && dflt=/usr/share/scripts + $test -d /usr/share/bin && dflt=/usr/share/bin + $test -d /usr/local/script && dflt=/usr/local/script + $test -d $prefixexp/script && dflt=$prefixexp/script + set dflt + eval $prefixup + ;; *) dflt="$scriptdir" - ;; + ;; esac -cont=true $cat <, or both." >&4 +$echo $n "I'm now running the test program...$c" +$cat >try.c <<'EOCP' +#include +#ifdef I_TIME +#include +#endif +#ifdef I_SYSTIME +#ifdef SYSTIMEKERNEL +#define KERNEL +#endif +#include +#endif +#ifdef I_SYSSELECT +#include +#endif +main() +{ + struct tm foo; +#ifdef S_TIMEVAL + struct timeval bar; +#endif +#ifdef S_TIMEZONE + struct timezone tzp; +#endif + if (foo.tm_sec == foo.tm_sec) + exit(0); +#ifdef S_TIMEVAL + if (bar.tv_sec == bar.tv_sec) + exit(0); +#endif + exit(1); +} +EOCP +flags='' +s_timezone='' +sysselect='' +for s_timeval in '-DS_TIMEVAL' ''; do +for i_systimek in '' '-DSYSTIMEKERNEL'; do +for i_time in '' '-DI_TIME'; do +for i_systime in '-DI_SYSTIME' ''; do + case "$flags" in + '') $echo $n ".$c" + if $cc $ccflags \ + $i_time $i_systime $i_systimek $sysselect $s_timeval $s_timezone \ + try.c -o try >/dev/null 2>&1 ; then + set X $i_time $i_systime $i_systimek $sysselect $s_timeval + shift + flags="$*" + echo " " + $echo $n "Succeeded with $flags$c" + fi + ;; esac - fi done +done +done +done +timeincl='' +echo " " +case "$flags" in +*SYSTIMEKERNEL*) i_systimek="$define" + timeincl=`./findhdr sys/time.h` + echo "We'll include with KERNEL defined." >&4;; +*) i_systimek="$undef";; +esac +case "$flags" in +*I_TIME*) i_time="$define" + timeincl=`./findhdr time.h`" $timeincl" + echo "We'll include ." >&4;; +*) i_time="$undef";; +esac +case "$flags" in +*I_SYSTIME*) i_systime="$define" + timeincl=`./findhdr sys/time.h`" $timeincl" + echo "We'll include ." >&4;; +*) i_systime="$undef";; +esac +$rm -f try.c try -case "$installscr" in -'') - dflt=`echo $scriptdir | sed 's#^/afs/#/afs/.#'` - test -d $dflt || dflt="$scriptdir" - ;; -*) dflt="$scriptdir" - ;; +: check for fd_set items +$cat <fd_set.c < +#ifdef HAS_SOCKET +#include /* Might include */ +#endif +#ifdef I_SYS_TIME +#include +#else +#ifdef I_SYS_SELECT +#include +#endif +#endif +main() { + fd_set fds; + +#ifdef TRYBITS + if(fds.fds_bits); +#endif + +#if defined(FD_SET) && defined(FD_CLR) && defined(FD_ISSET) && defined(FD_ZERO) + exit(0); +#else + exit(1); +#endif +} +EOCP +if $cc $ccflags -DTRYBITS fd_set.c -o fd_set >fd_set.out 2>&1 ; then + d_fds_bits="$define" + d_fd_set="$define" + echo "Well, your system knows about the normal fd_set typedef..." >&4 + if ./fd_set; then + echo "and you have the normal fd_set macros (just as I'd expect)." >&4 + d_fd_macros="$define" + else + $cat >&4 <<'EOM' +but not the normal fd_set macros! Gaaack! I'll have to cover for you. +EOM + d_fd_macros="$undef" + fi +else + $cat <<'EOM' +Hmm, your compiler has some difficulty with fd_set. Checking further... +EOM + if $cc $ccflags fd_set.c -o fd_set >fd_set.out 2>&1 ; then + d_fds_bits="$undef" + d_fd_set="$define" + echo "Well, your system has some sort of fd_set available..." >&4 + if ./fd_set; then + echo "and you have the normal fd_set macros." >&4 + d_fd_macros="$define" + else + $cat <<'EOM' +but not the normal fd_set macros! Gross! More work for me... +EOM + d_fd_macros="$undef" + fi + else + echo "Well, you got zip. That's OK, I can roll my own fd_set stuff." >&4 + d_fd_set="$undef" + d_fds_bits="$undef" + d_fd_macros="$undef" + fi +fi +$rm -f fd_set* + + +: check for type of arguments to select. This will only really +: work if the system supports prototypes and provides one for +: select. +case "$d_select" in +$define) + : Make initial guess + case "$selecttype" in + ''|' ') + case "$d_fd_set" in + $define) xxx='fd_set *' ;; + *) xxx='int *' ;; + esac + ;; + *) xxx="$selecttype" + ;; + esac + : backup guess + case "$xxx" in + 'fd_set *') yyy='int *' ;; + 'int *') yyy='fd_set *' ;; + esac + + $cat <try.c < +#ifdef HAS_SOCKET +#include /* Might include */ +#endif +#ifdef I_SYS_TIME +#include +#else +#ifdef I_SYS_SELECT +#include +#endif +#endif +main() +{ + int width; + Select_fd_set_t readfds; + Select_fd_set_t writefds; + Select_fd_set_t exceptfds; + struct timeval timeout; + select(width, readfds, writefds, exceptfds, &timeout); + exit(0); +} +EOCP + if $cc $ccflags -c -DSelect_fd_set_t="$xxx" try.c >/dev/null 2>&1 ; then + selecttype="$xxx" + echo "Your system uses $xxx for the arguments to select." >&4 + elif $cc $ccflags -c -DSelect_fd_set_t="$yyy" try.c >/dev/null 2>&1 ; then + selecttype="$yyy" + echo "Your system uses $yyy for the arguments to select." >&4 + else + rp='What is the type for the 2nd, 3rd, and 4th arguments to select?' + dflt="$xxx" + . ./myread + selecttype="$ans" + fi + $rm -f try.[co] + ;; +*) selecttype = 'int *' + ;; esac -cont=true -$cat <&1 | awk ' + echo "Generating a list of signal names..." >&4 + xxx=`./findhdr signal.h`" "`./findhdr sys/signal.h`" "`./findhdr linux/signal.h` + set X `cat $xxx 2>&1 | $awk ' $1 ~ /^#define$/ && $2 ~ /^SIG[A-Z0-9]*$/ && $3 ~ /^[1-9][0-9]*$/ { - sig[$3] = substr($2,4,20) - if (max < $3 && $3 < 60) { - max = $3 - } + sig[$3] = substr($2,4,20) + if (max < $3 && $3 < 60) { + max = $3 + } } END { - for (i=1; i<=max; i++) { - if (sig[i] == "") - printf "%d", i - else - printf "%s", sig[i] - if (i < max) - printf " " - } - printf "\n" + for (i = 1; i <= max; i++) { + if (sig[i] == "") + printf "%d", i + else + printf "%s", sig[i] + if (i < max) + printf " " + } + printf "\n" } '` - shift - case $# in - 0) echo 'kill -l' >/tmp/foo$$ - set X `$csh -f /tmp/foo$$ + set X `csh -f 70) { + printf "\n" + linelen = length(name) + } + printf "%s", name + } +}' +echo " " + +: see what type is used for size_t +set size_t sizetype 'unsigned int' stdio.h sys/types.h +eval $typedef +dflt="$sizetype" +echo " " +rp="What type is used for the length parameter for string functions?" +. ./myread +sizetype="$ans" + +: see what type is used for signed size_t +set ssize_t ssizetype int stdio.h sys/types.h +eval $typedef +dflt="$ssizetype" +$cat > ssize.c < +#include +#define Size_t $sizetype +#define SSize_t $dflt +main() +{ + if (sizeof(Size_t) == sizeof(SSize_t)) + printf("$dflt\n"); + else if (sizeof(Size_t) == sizeof(int)) + printf("int\n"); + else + printf("long\n"); +} +EOM +echo " " +if $cc $ccflags $ldflags -o ssize ssize.c $libs > /dev/null 2>&1 ; then + ssizetype=`./ssize` + echo "I'll be using $ssizetype for functions returning a byte count." >&4 +else + echo "(I can't compile the test program--please enlighten me!)" + $cat </dev/null 2>&1 ; then - echo "Your stdio uses unsigned chars." - stdchar="unsigned char" +if $contains 'unsigned.*char.*_ptr;' `./findhdr stdio.h` >/dev/null 2>&1 ; then + echo "Your stdio uses unsigned chars." >&4 + stdchar="unsigned char" +else + echo "Your stdio uses signed chars." >&4 + stdchar="char" +fi + +: see if time exists +echo " " +if set time val -f d_time; eval $csym; $val; then + echo 'time() found.' >&4 + val="$define" + set time_t timetype long stdio.h sys/types.h + eval $typedef + dflt="$timetype" + echo " " + rp="What type is returned by time() on this sytem?" + . ./myread + timetype="$ans" else - echo "Your stdio uses signed chars." - stdchar="char" + echo 'time() not found, hope that will do.' >&4 + val="$undef" + timetype='int'; fi +set d_time +eval $setvar : see what type uids are declared as in the kernel +set uid_t uidtype xxx stdio.h sys/types.h +eval $typedef case "$uidtype" in -'') - if $contains 'uid_t;' $usrinclude/sys/types.h >/dev/null 2>&1 ; then - dflt='uid_t'; - else - set `grep '_ruid;' $usrinclude/sys/user.h 2>/dev/null` unsigned short +xxx) + xxx=`./findhdr sys/user.h` + set `grep '_ruid;' "$xxx" 2>/dev/null` unsigned short case $1 in unsigned) dflt="$1 $2" ;; *) dflt="$1" ;; esac - fi - ;; -*) dflt="$uidtype" - ;; + ;; +*) dflt="$uidtype";; esac -cont=true echo " " -rp="What type are user ids returned by getuid(), etc.? [$dflt]" -$echo $n "$rp $c" -. myread +rp="What is the type for user ids returned by getuid()?" +. ./myread uidtype="$ans" -: check for void type -echo " " -$cat < ? +case "$val" in +"$define") + echo " " + if $h_sysfile; then + val="$define" + echo "We'll be including ." >&4 + else + val="$undef" + echo "We won't be including ." >&4 + fi + ;; +*) + h_sysfile=false + ;; +esac +set i_sysfile +eval $setvar -EOM -case "$voidhave" in -'') - $cat >void.c <<'EOCP' -#if TRY & 1 -void main() { -#else -main() { -#endif - extern void moo(); /* function returning void */ - void (*goo)(); /* ptr to func returning void */ -#if TRY & 2 - void (*foo[10])(); -#endif +: see if fcntl.h is there +val='' +set fcntl.h val +eval $inhdr -#if TRY & 4 - if(goo == moo) { - exit(0); - } -#endif - exit(0); -} -EOCP - if $cc -c -DTRY=$voidwant void.c >void.out 2>&1 ; then - voidhave=$voidwant - echo "It appears to support void to the level $package wants ($voidwant)." - if $contains warning void.out >/dev/null 2>&1; then - echo "However, you might get some warnings that look like this:" - $cat void.out - fi - else - echo "Hmm, your compiler has some difficulty with void. Checking further..." - if $cc -c -DTRY=1 void.c >/dev/null 2>&1 ; then - echo "It supports 1..." - if $cc -c -DTRY=3 void.c >/dev/null 2>&1 ; then - voidhave=3 - echo "And it supports 2 but not 4." - else - echo "It doesn't support 2..." - if $cc -c -DTRY=5 void.c >/dev/null 2>&1 ; then - voidhave=5 - echo "But it supports 4." +: see if we can include fcntl.h +case "$val" in +"$define") + echo " " + if $h_fcntl; then + val="$define" + echo "We'll be including ." >&4 + else + val="$undef" + if $h_sysfile; then + echo "We don't need to include if we include ." >&4 else - voidhave=1 - echo "And it doesn't support 4." + echo "We won't be including ." >&4 fi - fi - else - echo "There is no support at all for void." - voidhave=0 fi - fi + ;; +*) + h_fcntl=false + val="$undef" + ;; esac -dflt="$voidhave"; -rp="Your void support flags add up to what? [$dflt]" -$echo $n "$rp $c" -. myread -voidhave="$ans" +set i_fcntl +eval $setvar -: preserve RCS keywords in files with variable substitution, grrr -Log='$Log' -Header='$Header' -Id='$Id' -Author='$Author' -Date='$Date' -Locker='$Locker' -RCSfile='$RCSfile' -Revision='$Revision' -Source='$Source' -State='$State' +: see if this is an grp system +set grp.h i_grp +eval $inhdr + +: see if this is a math.h system +set math.h i_math +eval $inhdr + +: see if memory.h is available. +val='' +set memory.h val +eval $inhdr + +: See if it conflicts with string.h +case "$val" in +$define) + case "$strings" in + '') ;; + *) + $cppstdin $cppflags $cppminus < $strings > mem.h + if $contains 'memcpy' mem.h >/dev/null 2>&1; then + echo " " + echo "We won't be including ." + val="$undef" + fi + $rm -f mem.h + ;; + esac +esac +set i_memory +eval $setvar +: see if net/errno.h is available +val='' +set net/errno.h val +eval $inhdr -: determine compiler compiler -case "$yacc" in -'') if xenix; then - dflt=yacc - else - dflt='yacc -Sm25000' - fi - ;; -*) dflt="$yacc";; -esac -cont=true - echo " " -rp="Which compiler compiler (yacc or bison -y) will you use? [$dflt]" -$echo $n "$rp $c" -. myread -case "$ans" in -'') ans="$dflt";; +: Unfortunately, it causes problems on some systems. Arrgh. +case "$val" in +$define) + cat > try.c <<'EOM' +#include +#include +#include +int func() +{ + return ENOTSOCK; +} +EOM + if $cc $ccflags -c try.c >/dev/null 2>&1; then + echo "We'll be including ." >&4 + else + echo "We won't be including ." >&4 + val="$undef" + fi + $rm -f try.* try + ;; esac -yacc="$ans" +set i_neterrno +eval $setvar -: see if we can include fcntl.h +: get C preprocessor symbols handy echo " " -if $h_fcntl; then - val="$define" - echo "We'll be including ." +$echo $n "Hmm... $c" +echo $al | $tr ' ' '\012' >Cppsym.know +$cat <Cppsym +$startsh +case "\$1" in +-l) list=true + shift + ;; +esac +unknown='' +case "\$list\$#" in +1|2) + for sym do + if $contains "^\$1$" Cppsym.true >/dev/null 2>&1; then + exit 0 + elif $contains "^\$1$" Cppsym.know >/dev/null 2>&1; then + : + else + unknown="\$unknown \$sym" + fi + done + set X \$unknown + shift + ;; +esac +case \$# in +0) exit 1;; +esac +echo \$* | $tr ' ' '\012' | $sed -e 's/\(.*\)/\\ +#ifdef \1\\ +exit 0; _ _ _ _\1\\ \1\\ +#endif\\ +/' >Cppsym\$\$ +echo "exit 1; _ _ _" >>Cppsym\$\$ +$cppstdin $cppminus Cppsym2\$\$ +case "\$list" in +true) $awk 'NF > 5 {print substr(\$6,2,100)}' Cppsym.true + +: now check the C compiler for additional symbols +$cat >ccsym <tmp.c <&1\` +do + case "\$i" in + -D*) echo "\$i" | $sed 's/^-D//';; + -A*) $test "$gccversion" && echo "\$i" | $sed 's/^-A\(.*\)(\(.*\))/\1=\2/';; + esac +done +$rm -f try.c +EOS +chmod +x ccsym +$eunicefix ccsym +./ccsym | $sort | $uniq >ccsym.raw +$awk '/\=/ { print $0; next } { print $0"=1" }' ccsym.raw >ccsym.list +$awk '{ print $0"=1" }' Cppsym.true >ccsym.true +$comm -13 ccsym.true ccsym.list >ccsym.own +$comm -12 ccsym.true ccsym.list >ccsym.com +$comm -23 ccsym.true ccsym.list >ccsym.cpp +also='' +symbols='symbols' +if $test -z ccsym.raw; then + echo "Your C compiler doesn't seem to define any symbol!" >&4 + echo " " + echo "However, your C preprocessor defines the following ones:" + $cat Cppsym.true else - val="$undef" - if $h_sys_file; then - echo "We don't need to if we include ." - else - echo "We won't be including ." - fi + if $test -s ccsym.com; then + echo "Your C compiler and pre-processor define these symbols:" + $sed -e 's/\(.*\)=.*/\1/' ccsym.com + also='also ' + symbols='ones' + $test "$silent" || sleep 1 + fi + if $test -s ccsym.cpp; then + $test "$also" && echo " " + echo "Your C pre-processor ${also}defines the following $symbols:" + $sed -e 's/\(.*\)=.*/\1/' ccsym.cpp + also='further ' + $test "$silent" || sleep 1 + fi + if $test -s ccsym.own; then + $test "$also" && echo " " + echo "Your C compiler ${also}defines the following cpp variables:" + $sed -e 's/\(.*\)=1/\1/' ccsym.own + $sed -e 's/\(.*\)=.*/\1/' ccsym.own | $uniq >>Cppsym.true + $test "$silent" || sleep 1 + fi fi -set i_fcntl -eval $setvar +$rm -f ccsym* + +: see if this is a termio system +val="$undef" +val2="$undef" +val3="$undef" +if $test `./findhdr termios.h`; then + set tcsetattr i_termios + eval $inlibc + val3="$i_termios" +fi +echo " " +case "$val3" in +"$define") echo "You have POSIX termios.h... good!" >&4;; +*) if ./Cppsym pyr; then + case "`/bin/universe`" in + ucb) if $test `./findhdr sgtty.h`; then + val2="$define" + echo " found." >&4 + else + echo "System is pyramid with BSD universe." + echo " not found--you could have problems." >&4 + fi;; + *) if $test `./findhdr termio.h`; then + val="$define" + echo " found." >&4 + else + echo "System is pyramid with USG universe." + echo " not found--you could have problems." >&4 + fi;; + esac + elif ./usg; then + if $test `./findhdr termio.h`; then + echo " found." >&4 + val="$define" + elif $test `./findhdr sgtty.h`; then + echo " found." >&4 + val2="$define" + else +echo "Neither nor found--you could have problems." >&4 + fi + else + if $test `./findhdr sgtty.h`; then + echo " found." >&4 + val2="$define" + elif $test `./findhdr termio.h`; then + echo " found." >&4 + val="$define" + else +echo "Neither nor found--you could have problems." >&4 + fi + fi;; +esac +set i_termio; eval $setvar +val=$val2; set i_sgtty; eval $setvar +val=$val3; set i_termios; eval $setvar -: see if gdbm is available +: see if stdarg is available echo " " -xxx=`./loc gdbm.h x $usrinclude /usr/local/include $inclwanted` -if test -f $xxx; then - val="$define" - echo "gdbm.h found." +if $test `./findhdr stdarg.h`; then + echo " found." >&4 + valstd="$define" else - val="$undef" - echo "gdbm.h NOT found." + echo " NOT found." >&4 + valstd="$undef" fi -set i_gdbm -eval $setvar -: see if this is an grp system +: see if varags is available echo " " -if $test -r $usrinclude/grp.h ; then - val="$define" - echo "grp.h found." +if $test `./findhdr varargs.h`; then + echo " found." >&4 else - val="$undef" - echo "No grp.h found." + echo " NOT found, but that's ok (I hope)." >&4 fi -set i_grp -eval $setvar -: see if this is a netinet/in.h or sys/in.h system -echo " " -xxx=`./loc netinet/in.h x $usrinclude /usr/local/include $inclwanted` -if test -f $xxx; then - val="$define" - val2="$undef" - echo "netinet/in.h found." -else - val="$undef" - echo "No netinet/in.h found, ..." - xxx=`./loc sys/in.h x $usrinclude /usr/local/include $inclwanted` - if test -f $xxx; then - val2="$define" - echo "but I found sys/in.h instead." - else - val2="$undef" - echo "and I didn't find sys/in.h either." - fi -fi -set i_niin -eval $setvar -val=$val2 -set i_sysin -eval $setvar +: set up the varargs testing programs +$cat > varargs.c < +#endif +#ifdef I_VARARGS +#include +#endif -: Do we need to #include ? -echo " " -if $h_sys_file; then - val="$define" - echo "We'll be including ." +#ifdef I_STDARG +int f(char *p, ...) +#else +int f(va_alist) +va_dcl +#endif +{ + va_list ap; +#ifndef I_STDARG + char *p; +#endif +#ifdef I_STDARG + va_start(ap,p); +#else + va_start(ap); + p = va_arg(ap, char *); +#endif + va_end(ap); +} +EOP +$cat > varargs </dev/null 2>&1; then + echo "true" else - val="$undef" - echo "We won't be including ." + echo "false" fi -set i_sys_file -eval $setvar +$rm -f varargs.o +EOP +chmod +x varargs -: see if ioctl defs are in sgtty/termio or sys/ioctl +: now check which varargs header should be included echo " " -if $test -r $usrinclude/sys/ioctl.h ; then - val="$define" - echo "sys/ioctl.h found." -else - val="$undef" - echo "sys/ioctl.h NOT found, assuming ioctl args are defined in sgtty.h." -fi -set i_sysioctl -eval $setvar +i_varhdr='' +case "$valstd" in +"$define") + if `./varargs I_STDARG`; then + val='stdarg.h' + elif `./varargs I_VARARGS`; then + val='varargs.h' + fi + ;; +*) + if `./varargs I_VARARGS`; then + val='varargs.h' + fi + ;; +esac +case "$val" in +'') +echo "I could not find the definition for va_dcl... You have problems..." >&4 + val="$undef"; set i_stdarg; eval $setvar + val="$undef"; set i_varargs; eval $setvar + ;; +*) + set i_varhdr + eval $setvar + case "$i_varhdr" in + stdarg.h) + val="$define"; set i_stdarg; eval $setvar + val="$undef"; set i_varargs; eval $setvar + ;; + varargs.h) + val="$undef"; set i_stdarg; eval $setvar + val="$define"; set i_varargs; eval $setvar + ;; + esac + echo "We'll include <$i_varhdr> to get va_dcl definition." >&4;; +esac +$rm -f varargs* -: see if we should include utime.h -echo " " -if $test -r $usrinclude/utime.h ; then - val="$define" - echo "utime.h found." -else - val="$undef" - echo "No utime.h found, but that's ok." -fi -set i_utime -eval $setvar +: see if stddef is available +set stddef.h i_stddef +eval $inhdr -: see if this is a varargs system +: see if ioctl defs are in sgtty, termio, sys/filio or sys/ioctl +set sys/filio.h i_sysfilio +eval $inhdr echo " " -if $test -r $usrinclude/varargs.h ; then - val="$define" - echo "varargs.h found." +if $test `./findhdr sys/ioctl.h`; then + val="$define" + echo ' found.' >&4 else - val="$undef" - echo "No varargs.h found, but that's ok (I hope)." + val="$undef" + if $test $i_sysfilio = "$define"; then + echo ' NOT found.' >&4 + else + $test $i_sgtty = "$define" && xxx="sgtty.h" + $test $i_termio = "$define" && xxx="termio.h" + $test $i_termios = "$define" && xxx="termios.h" +echo "No found, assuming ioctl args are defined in <$xxx>." >&4 + fi fi -set i_varargs +set i_sysioctl eval $setvar +: see if this is a sys/param system +set sys/param.h i_sysparam +eval $inhdr + +: see if sys/stat.h is available +set sys/stat.h i_sysstat +eval $inhdr + +: see if sys/types.h has to be included +set sys/types.h i_systypes +eval $inhdr + +: see if this is a unistd.h system +set unistd.h i_unistd +eval $inhdr + +: see if this is an utime system +set utime.h i_utime +eval $inhdr + : see if this is a vfork system -echo " " -if $test -r $usrinclude/vfork.h ; then - val="$define" - echo "vfork.h found." -else - val="$undef" - echo "No vfork.h found." -fi -set i_vfork -eval $setvar +case "$d_vfork" in +"$define") + set vfork.h i_vfork + eval $inhdr + ;; +*) + i_vfork="$undef" + ;; +esac : end of configuration questions echo " " echo "End of configuration questions." echo " " +: back to where it started +if test -d ../UU; then + cd .. +fi + +: configuration may be patched via a 'config.over' file +if $test -f config.over; then + echo " " + dflt=y + rp='I see a config.over file. Do you wish to load it?' + . UU/myread + case "$ans" in + n*) echo "OK, I'll ignore it.";; + *) . ./config.over + echo "Configuration override changes have been loaded." + ;; + esac +fi + +: in case they want portability, strip down executable paths +case "$d_portable" in +"$define") + echo " " + echo "Stripping down executable paths..." >&4 + for file in $loclist $trylist; do + eval $file="\$file" + done + ;; +esac + : create config.sh file echo " " -if test -d ../UU; then - cd .. -fi -echo "Creating config.sh..." -test -f config.sh && cp config.sh UU/oldconfig.sh +echo "Creating config.sh..." >&4 $spitshell <config.sh $startsh -# config.sh -# This file was produced by running the Configure script. -d_eunice='$d_eunice' -define='$define' -eunicefix='$eunicefix' -loclist='$loclist' -expr='$expr' -sed='$sed' -echo='$echo' -cat='$cat' -rm='$rm' -mv='$mv' -cp='$cp' -tail='$tail' -tr='$tr' -mkdir='$mkdir' -sort='$sort' -uniq='$uniq' -grep='$grep' -trylist='$trylist' -test='$test' -inews='$inews' -egrep='$egrep' -more='$more' -pg='$pg' -Mcc='$Mcc' -vi='$vi' -mailx='$mailx' -mail='$mail' -cpp='$cpp' -perl='$perl' -emacs='$emacs' -ls='$ls' -rmail='$rmail' -sendmail='$sendmail' -shar='$shar' -smail='$smail' -tbl='$tbl' -troff='$troff' -nroff='$nroff' -uname='$uname' -uuname='$uuname' -line='$line' -chgrp='$chgrp' -chmod='$chmod' -lint='$lint' -sleep='$sleep' -pr='$pr' -tar='$tar' -ln='$ln' -lpr='$lpr' -lp='$lp' -touch='$touch' -make='$make' -date='$date' -csh='$csh' -bash='$bash' -ksh='$ksh' -lex='$lex' -flex='$flex' -bison='$bison' -Log='$Log' +# +# This file was produced by running the Configure script. It holds all the +# definitions figured out by Configure. Should you modify one of these values, +# do not forget to propagate your changes by running "Configure -der". You may +# instead choose to run each of the .SH files by yourself, or "Configure -S". +# + +# Configuration time: $cf_time +# Configured by: $cf_by +# Target system: $myuname + +Author='$Author' +Date='$Date' Header='$Header' Id='$Id' -lastuname='$lastuname' +Locker='$Locker' +Log='$Log' +Mcc='$Mcc' +RCSfile='$RCSfile' +Revision='$Revision' +Source='$Source' +State='$State' +afs='$afs' alignbytes='$alignbytes' +aphostname='$aphostname' +archlib='$archlib' +archlibexp='$archlibexp' +archname='$archname' +awk='$awk' +baserev='$baserev' +bash='$bash' bin='$bin' -installbin='$installbin' +binexp='$binexp' +bison='$bison' +byacc='$byacc' byteorder='$byteorder' +c='$c' +castflags='$castflags' +cat='$cat' +cc='$cc' +cccdlflags='$cccdlflags' +ccdlflags='$ccdlflags' +ccflags='$ccflags' +cf_by='$cf_by' +cf_time='$cf_time' +chgrp='$chgrp' +chmod='$chmod' +chown='$chown' +clocktype='$clocktype' +comm='$comm' +compress='$compress' contains='$contains' -cppstdin='$cppstdin' +cp='$cp' +cpio='$cpio' +cpp='$cpp' +cpp_stuff='$cpp_stuff' +cppflags='$cppflags' +cpplast='$cpplast' cppminus='$cppminus' +cpprun='$cpprun' +cppstdin='$cppstdin' +cryptlib='$cryptlib' +csh='$csh' +d_Gconvert='$d_Gconvert' +d_access='$d_access' +d_alarm='$d_alarm' +d_archlib='$d_archlib' +d_attribut='$d_attribut' d_bcmp='$d_bcmp' d_bcopy='$d_bcopy' -d_safebcpy='$d_safebcpy' +d_bsd='$d_bsd' +d_bsdpgrp='$d_bsdpgrp' +d_byacc='$d_byacc' d_bzero='$d_bzero' +d_casti32='$d_casti32' d_castneg='$d_castneg' -castflags='$castflags' -d_charsprf='$d_charsprf' +d_charvspr='$d_charvspr' +d_chown='$d_chown' +d_chroot='$d_chroot' d_chsize='$d_chsize' +d_closedir='$d_closedir' +d_const='$d_const' d_crypt='$d_crypt' -cryptlib='$cryptlib' d_csh='$d_csh' +d_cuserid='$d_cuserid' +d_dbl_dig='$d_dbl_dig' +d_difftime='$d_difftime' +d_dirnamlen='$d_dirnamlen' +d_dlerror='$d_dlerror' +d_dlopen='$d_dlopen' +d_dlsymun='$d_dlsymun' d_dosuid='$d_dosuid' +d_drem='$d_drem' d_dup2='$d_dup2' +d_eunice='$d_eunice' d_fchmod='$d_fchmod' d_fchown='$d_fchown' d_fcntl='$d_fcntl' +d_fd_macros='$d_fd_macros' +d_fd_set='$d_fd_set' +d_fds_bits='$d_fds_bits' +d_fgetpos='$d_fgetpos' d_flexfnam='$d_flexfnam' d_flock='$d_flock' +d_fmod='$d_fmod' +d_fork='$d_fork' +d_fpathconf='$d_fpathconf' +d_fsetpos='$d_fsetpos' d_getgrps='$d_getgrps' d_gethent='$d_gethent' -d_getpgrp='$d_getpgrp' +d_gethname='$d_gethname' +d_getlogin='$d_getlogin' d_getpgrp2='$d_getpgrp2' +d_getpgrp='$d_getpgrp' +d_getppid='$d_getppid' d_getprior='$d_getprior' d_htonl='$d_htonl' d_index='$d_index' d_isascii='$d_isascii' d_killpg='$d_killpg' +d_link='$d_link' +d_linuxstd='$d_linuxstd' +d_locconv='$d_locconv' +d_lockf='$d_lockf' d_lstat='$d_lstat' +d_mblen='$d_mblen' +d_mbstowcs='$d_mbstowcs' +d_mbtowc='$d_mbtowc' d_memcmp='$d_memcmp' d_memcpy='$d_memcpy' -d_safemcpy='$d_safemcpy' d_memmove='$d_memmove' d_memset='$d_memset' d_mkdir='$d_mkdir' +d_mkfifo='$d_mkfifo' +d_mktime='$d_mktime' d_msg='$d_msg' d_msgctl='$d_msgctl' d_msgget='$d_msgget' d_msgrcv='$d_msgrcv' d_msgsnd='$d_msgsnd' -d_ndbm='$d_ndbm' -d_odbm='$d_odbm' +d_mymalloc='$d_mymalloc' +d_nice='$d_nice' +d_oldsock='$d_oldsock' d_open3='$d_open3' +d_pathconf='$d_pathconf' +d_pause='$d_pause' +d_phostname='$d_phostname' +d_pipe='$d_pipe' +d_portable='$d_portable' +d_pwage='$d_pwage' +d_pwchange='$d_pwchange' +d_pwclass='$d_pwclass' +d_pwcomment='$d_pwcomment' +d_pwexpire='$d_pwexpire' +d_pwquota='$d_pwquota' d_readdir='$d_readdir' +d_readlink='$d_readlink' d_rename='$d_rename' -d_rewindir='$d_rewindir' +d_rewinddir='$d_rewinddir' d_rmdir='$d_rmdir' +d_safebcpy='$d_safebcpy' +d_safemcpy='$d_safemcpy' d_seekdir='$d_seekdir' d_select='$d_select' d_sem='$d_sem' @@ -3870,186 +7781,368 @@ d_semget='$d_semget' d_semop='$d_semop' d_setegid='$d_setegid' d_seteuid='$d_seteuid' -d_setpgrp='$d_setpgrp' +d_setlinebuf='$d_setlinebuf' +d_setlocale='$d_setlocale' +d_setpgid='$d_setpgid' d_setpgrp2='$d_setpgrp2' +d_setpgrp='$d_setpgrp' d_setprior='$d_setprior' d_setregid='$d_setregid' d_setresgid='$d_setresgid' -d_setreuid='$d_setreuid' d_setresuid='$d_setresuid' +d_setreuid='$d_setreuid' d_setrgid='$d_setrgid' d_setruid='$d_setruid' +d_setsid='$d_setsid' d_shm='$d_shm' d_shmat='$d_shmat' -d_voidshmat='$d_voidshmat' +d_shmatprototype='$d_shmatprototype' d_shmctl='$d_shmctl' d_shmdt='$d_shmdt' d_shmget='$d_shmget' +d_shrplib='$d_shrplib' d_socket='$d_socket' d_sockpair='$d_sockpair' -d_oldsock='$d_oldsock' -socketlib='$socketlib' d_statblks='$d_statblks' d_stdstdio='$d_stdstdio' +d_strchr='$d_strchr' +d_strcoll='$d_strcoll' d_strctcpy='$d_strctcpy' +d_strerrm='$d_strerrm' d_strerror='$d_strerror' +d_strxfrm='$d_strxfrm' +d_suidsafe='$d_suidsafe' d_symlink='$d_symlink' d_syscall='$d_syscall' +d_sysconf='$d_sysconf' +d_sysernlst='$d_sysernlst' +d_syserrlst='$d_syserrlst' +d_system='$d_system' +d_tcgetpgrp='$d_tcgetpgrp' +d_tcsetpgrp='$d_tcsetpgrp' d_telldir='$d_telldir' +d_time='$d_time' +d_times='$d_times' d_truncate='$d_truncate' +d_tzname='$d_tzname' +d_umask='$d_umask' +d_uname='$d_uname' d_vfork='$d_vfork' +d_void_closedir='$d_void_closedir' d_voidsig='$d_voidsig' -d_tosignal='$d_tosignal' +d_voidtty='$d_voidtty' d_volatile='$d_volatile' d_vprintf='$d_vprintf' -d_charvspr='$d_charvspr' d_wait4='$d_wait4' d_waitpid='$d_waitpid' +d_wcstombs='$d_wcstombs' +d_wctomb='$d_wctomb' +d_xenix='$d_xenix' +date='$date' +db_hashtype='$db_hashtype' +db_prefixtype='$db_prefixtype' +defvoidused='$defvoidused' +direntrytype='$direntrytype' +dlext='$dlext' +dlsrc='$dlsrc' +dynamic_ext='$dynamic_ext' +echo='$echo' +egrep='$egrep' +emacs='$emacs' +eunicefix='$eunicefix' +expr='$expr' +extensions='$extensions' +find='$find' +flex='$flex' +fpostype='$fpostype' +freetype='$freetype' +full_csh='$full_csh' +full_sed='$full_sed' +gcc='$gcc' +gccversion='$gccversion' gidtype='$gidtype' +glibpth='$glibpth' +grep='$grep' +groupcat='$groupcat' groupstype='$groupstype' +h_fcntl='$h_fcntl' +h_sysfile='$h_sysfile' +hint='$hint' +hostcat='$hostcat' +huge='$huge' +i_bsdioctl='$i_bsdioctl' +i_db='$i_db' +i_dbm='$i_dbm' +i_dirent='$i_dirent' +i_dld='$i_dld' +i_dlfcn='$i_dlfcn' i_fcntl='$i_fcntl' +i_float='$i_float' i_gdbm='$i_gdbm' i_grp='$i_grp' +i_limits='$i_limits' +i_malloc='$i_malloc' +i_math='$i_math' +i_memory='$i_memory' +i_ndbm='$i_ndbm' +i_neterrno='$i_neterrno' i_niin='$i_niin' -i_sysin='$i_sysin' i_pwd='$i_pwd' -d_pwquota='$d_pwquota' -d_pwage='$d_pwage' -d_pwchange='$d_pwchange' -d_pwclass='$d_pwclass' -d_pwexpire='$d_pwexpire' -d_pwcomment='$d_pwcomment' -i_sys_file='$i_sys_file' +i_sgtty='$i_sgtty' +i_stdarg='$i_stdarg' +i_stddef='$i_stddef' +i_stdlib='$i_stdlib' +i_string='$i_string' +i_sysdir='$i_sysdir' +i_sysfile='$i_sysfile' +i_sysfilio='$i_sysfilio' +i_sysin='$i_sysin' i_sysioctl='$i_sysioctl' +i_sysndir='$i_sysndir' +i_sysparam='$i_sysparam' +i_sysselct='$i_sysselct' +i_syssockio='$i_syssockio' +i_sysstat='$i_sysstat' +i_systime='$i_systime' +i_systimek='$i_systimek' +i_systimes='$i_systimes' +i_systypes='$i_systypes' +i_termio='$i_termio' +i_termios='$i_termios' i_time='$i_time' -i_sys_time='$i_sys_time' -i_sys_select='$i_sys_select' -d_systimekernel='$d_systimekernel' +i_unistd='$i_unistd' i_utime='$i_utime' i_varargs='$i_varargs' +i_varhdr='$i_varhdr' i_vfork='$i_vfork' +incpath='$incpath' +inews='$inews' +installarchlib='$installarchlib' +installbin='$installbin' +installmansrc='$installmansrc' +installprivlib='$installprivlib' +installscript='$installscript' intsize='$intsize' +known_extensions='$known_extensions' +ksh='$ksh' +large='$large' +lddlflags='$lddlflags' +ldflags='$ldflags' +less='$less' libc='$libc' -nm_opts='$nm_opts' -libndir='$libndir' -i_my_dir='$i_my_dir' -i_ndir='$i_ndir' -i_sys_ndir='$i_sys_ndir' -i_dirent='$i_dirent' -i_sys_dir='$i_sys_dir' -d_dirnamlen='$d_dirnamlen' -ndirc='$ndirc' -ndiro='$ndiro' -mallocsrc='$mallocsrc' +libpth='$libpth' +libs='$libs' +libswanted='$libswanted' +line='$line' +lint='$lint' +lkflags='$lkflags' +ln='$ln' +lns='$lns' +lp='$lp' +lpr='$lpr' +ls='$ls' +lseektype='$lseektype' +mail='$mail' +mailx='$mailx' +make='$make' mallocobj='$mallocobj' -d_mymalloc='$d_mymalloc' -mallocptrtype='$mallocptrtype' -mansrc='$mansrc' +mallocsrc='$mallocsrc' +malloctype='$malloctype' manext='$manext' -models='$models' -split='$split' -small='$small' +mansrc='$mansrc' +mansrcexp='$mansrcexp' medium='$medium' -large='$large' -huge='$huge' -optimize='$optimize' -ccflags='$ccflags' -cppflags='$cppflags' -ldflags='$ldflags' -cc='$cc' -nativegcc='$nativegcc' -libs='$libs' +mips='$mips' +mips_type='$mips_type' +mkdir='$mkdir' +models='$models' +modetype='$modetype' +more='$more' +mv='$mv' +myarchname='$myarchname' +mydomain='$mydomain' +myhostname='$myhostname' +myuname='$myuname' n='$n' -c='$c' +nm_opt='$nm_opt' +nroff='$nroff' +optimize='$optimize' +orderlib='$orderlib' +osname='$osname' +osvers='$osvers' package='$package' +passcat='$passcat' +patchlevel='$patchlevel' +perl='$perl' +pg='$pg' +phostname='$phostname' +plibpth='$plibpth' +pmake='$pmake' +pr='$pr' +prefix='$prefix' +prefixexp='$prefixexp' +privlib='$privlib' +privlibexp='$privlibexp' +prototype='$prototype' randbits='$randbits' +ranlib='$ranlib' +rm='$rm' +rmail='$rmail' +runnm='$runnm' scriptdir='$scriptdir' -installscr='$installscr' +scriptdirexp='$scriptdirexp' +sed='$sed' +selecttype='$selecttype' +sendmail='$sendmail' +sh='$sh' +shar='$shar' +sharpbang='$sharpbang' +shmattype='$shmattype' +shrpdir='$shrpdir' +shsharp='$shsharp' sig_name='$sig_name' +signal_t='$signal_t' +sizetype='$sizetype' +sleep='$sleep' +smail='$smail' +small='$small' +so='$so' +sockethdr='$sockethdr' +socketlib='$socketlib' +sort='$sort' +spackage='$spackage' spitshell='$spitshell' -shsharp='$shsharp' -sharpbang='$sharpbang' +split='$split' +ssizetype='$ssizetype' startsh='$startsh' +static_ext='$static_ext' stdchar='$stdchar' +strings='$strings' +submit='$submit' +sysman='$sysman' +tail='$tail' +tar='$tar' +tbl='$tbl' +test='$test' +timeincl='$timeincl' +timetype='$timetype' +touch='$touch' +tr='$tr' +troff='$troff' uidtype='$uidtype' -usrinclude='$usrinclude' -inclPath='$inclPath' -void='$void' -voidhave='$voidhave' -voidwant='$voidwant' -w_localtim='$w_localtim' -w_s_timevl='$w_s_timevl' -w_s_tm='$w_s_tm' -yacc='$yacc' -lib='$lib' -privlib='$privlib' -installprivlib='$installprivlib' +uname='$uname' +uniq='$uniq' +usedl='$usedl' +usemymalloc='$usemymalloc' +usenm='$usenm' +useposix='$useposix' +usevfork='$usevfork' +usrinc='$usrinc' +uuname='$uuname' +vi='$vi' +voidflags='$voidflags' +xlibpth='$xlibpth' +zcat='$zcat' EOT -test -f patchlevel.h && awk '{printf "%s=%s\n",$2,$3}' patchlevel.h >>config.sh +: add special variables +$test -f patchlevel.h && \ +awk '/^#define/ {printf "%s=%s\n",$2,$3}' patchlevel.h >>config.sh echo "CONFIG=true" >>config.sh -if test -f UU/oldconfig.sh; then - sed -n 's/^\([a-zA-Z_0-9]*\)=.*/\1/p' config.sh config.sh UU/oldconfig.sh |\ - sort | uniq -u >UU/oldsyms - set X `cat UU/oldsyms` - shift - case $# in - 0) ;; - *) echo "Hmm...You had some extra variables I don't know about...I'll try to keep 'em..." - for sym in `cat UU/oldsyms`; do - echo " Propagating $hint variable "'$'"$sym..." - eval 'tmp="$'"${sym}"'"' - echo "$tmp" | \ - sed -e "s/'/'\"'\"'/g" -e "s/^/$sym='/" -e "s/$/'/" >>config.sh - done - ;; - esac +: propagate old symbols +if $test -f UU/config.sh; then + UU/oldconfig.sh + sed -n 's/^\([a-zA-Z_0-9]*\)=.*/\1/p' config.sh config.sh UU/oldconfig.sh |\ + sort | uniq -u >UU/oldsyms + set X `cat UU/oldsyms` + shift + case $# in + 0) ;; + *) + cat <>config.sh + for sym in `cat UU/oldsyms`; do + echo " Propagating $hint variable "'$'"$sym..." + eval 'tmp="$'"${sym}"'"' + echo "$tmp" | \ + sed -e "s/'/'\"'\"'/g" -e "s/^/$sym='/" -e "s/$/'/" >>config.sh + done + ;; + esac fi -: Finish up -CONFIG=true +: Finish up by extracting the .SH files +case "$alldone" in +exit) + $rm -rf UU + echo "Done." + exit 0 + ;; +cont) + ;; +'') + dflt='' + nostick=true + $cat <&4 -c "$ans";; + esac + ;; esac -chmod +x doSH -./doSH + +: if this fails, just run all the .SH files by hand +. ./config.sh + +echo " " +exec 1>&4 +. ./UU/extract if $contains '^depend:' [Mm]akefile >/dev/null 2>&1; then - dflt=n - $cat < makedepend.out &" It can take a while, so you might not want to run it right now. EOM - rp="Run make depend now? [$dflt]" - $echo $n "$rp $c" - . UU/myread - case "$ans" in - y*) make depend && echo "Now you must run a make." - ;; - *) echo "You must run 'make depend' then 'make'." - ;; - esac + ;; + esac + rp="Run make depend now?" + . UU/myread + case "$ans" in + y*) + make depend && echo "Now you must run a make." + ;; + *) + echo "You must run 'make depend' then 'make'." + ;; + esac elif test -f [Mm]akefile; then - echo " " - echo "Now you must run a make." + echo " " + echo "Now you must run a make." else - echo "Done." + echo "Done." fi -$rm -f kit*isdone +$rm -f kit*isdone ark*isdone $rm -rf UU -: end of Configure + +: End of Configure +