X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=Configure;h=142538917598fd27f154eb038d08047de02d7786;hb=a6c71b5b9462db13c7bb2cd263cee5995315784c;hp=78bfdf943308b30d18e5642bc397a2c289437b8a;hpb=9c839522bf26b16ade2b29398a5335a1e4cb46d9;p=p5sagit%2Fp5-mst-13.2.git diff --git a/Configure b/Configure index 78bfdf9..1425389 100755 --- a/Configure +++ b/Configure @@ -20,7 +20,7 @@ # $Id: Head.U,v 3.0.1.9 1997/02/28 15:02:09 ram Exp $ # -# Generated on Tue Sep 12 16:47:06 EET DST 2000 [metaconfig 3.0 PL70] +# Generated on Tue Oct 24 21:00:34 EET DST 2000 [metaconfig 3.0 PL70] # (with additional metaconfig patches by perlbug@perl.org) cat >/tmp/c1$$ </dev/null`" in +ABYZ) spackage=`echo $first | tr '[:lower:]' '[:upper:]'`$last;; +*) spackage=`echo $first | tr '[a-z]' '[A-Z]'`$last;; +esac : Some greps do not return status, grrr. echo "grimblepritz" >grimble @@ -1285,25 +1936,36 @@ $eunicefix loc loclist=" awk cat +comm +cp echo expr grep ls make +mkdir rm sed +sort touch tr +uniq " trylist=" Mcc ar +byacc cpp +csh date egrep gzip +less ln +more nm +nroff +pg test uname zip @@ -1439,7 +2101,7 @@ int main(int argc, char *argv[]) { return 0; } EOM - if $cc -o try try.c; then + if $cc -o try $ccflags try.c; then : else echo "Uh-oh, the C compiler '$cc' doesn't seem to be working." >&4 @@ -1473,8 +2135,12 @@ EOM fi fi if $test X"$despair" = Xyes; then - echo "You need to find a working C compiler." >&4 - echo "I cannot continue any further, aborting." >&4 + $cat >&4 <whoa +$startsh +EOS +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 + +: function used to set $1 to $val +setvar='var=$1; eval "was=\$$1"; td=$define; tu=$undef; +case "$val$was" in +$define$undef) . ./whoa; eval "$var=\$td";; +$undef$define) . ./whoa; eval "$var=\$tu";; +*) eval "$var=$val";; +esac' + +case "$usethreads" in +$define|true|[yY]*) dflt='y';; +*) dflt='n';; +esac +cat <whoa -$startsh -EOS -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;; +: Which makefile gets called first. This is used by make depend. +case "$firstmakefile" in +'') firstmakefile='makefile';; esac -EOSC - -: function used to set $1 to $val -setvar='var=$1; eval "was=\$$1"; td=$define; tu=$undef; -case "$val$was" in -$define$undef) . ./whoa; eval "$var=\$td";; -$undef$define) . ./whoa; eval "$var=\$tu";; -*) eval "$var=$val";; -esac' case "$usesocks" in $define|true|[yY]*) dflt='y';; @@ -2985,111 +3784,6 @@ none) libs=' ';; *) libs="$ans";; esac -: 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 1;; - *[\\\\/]\$wanted) echo "\$name"; exit 1;; - *) exit 2;; - esac; -done; -# -# status = 0: grep returned 0 lines, case statement not executed -# status = 1: headerfile found -# status = 2: while loop executed, no headerfile found -# -status=\$? -$rm -f foo\$\$.c; -if test \$status -eq 1; then - exit 0; -fi -exit 1 -EOF -chmod +x findhdr - -: 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 dld is available -set dld.h i_dld -eval $inhdr - : determine optimization, if desired, or use for debug flag also case "$optimize" in ' '|$undef) dflt='none';; @@ -3330,7 +4024,7 @@ $cat > try.c <<'EOF' #include int main() { printf("Ok\n"); exit(0); } EOF -set X $cc $optimize $ccflags -o try $ldflags try.c $libs +set X $cc -o try $optimize $ccflags $ldflags try.c $libs shift $cat >try.msg <<'EOM' I've tried to compile and run the following simple program: @@ -3349,7 +4043,7 @@ and I got the following output: EOM dflt=y -if sh -c "$cc $optimize $ccflags -o try $ldflags try.c $libs" >>try.msg 2>&1; then +if sh -c "$cc -o try $optimize $ccflags $ldflags try.c $libs" >>try.msg 2>&1; then if sh -c './try' >>try.msg 2>&1; then xxx=`./try` case "$xxx" in @@ -3401,45 +4095,504 @@ n) echo "OK, that should do.";; esac $rm -f try try.* core +: 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; + echo "#ifdef $type" >> temp.c; + echo "printf(\"We have $type\");" >> temp.c; + echo "#endif" >> temp.c; + $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' + +: define an is-a-typedef? function that prompts if the type is not available. +typedef_ask='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; + echo "#ifdef $type" >> temp.c; + echo "printf(\"We have $type\");" >> temp.c; + echo "#endif" >> temp.c; + $cppstdin $cppflags $cppminus < temp.c >temp.E 2>/dev/null; + echo " " ; + echo "$rp" | $sed -e "s/What is/Looking for/" -e "s/?/./"; + if $contains $type temp.E >/dev/null 2>&1; then + echo "$type found." >&4; + eval "$var=\$type"; + else + echo "$type NOT found." >&4; + dflt="$def"; + . ./myread ; + eval "$var=\$ans"; + fi; + $rm -f temp.?;; +*) eval "$var=\$varval";; +esac' + : define a shorthand compile call compile=' mc_file=$1; shift; -$cc $optimize $ccflags $ldflags -o ${mc_file} $* ${mc_file}.c $libs > /dev/null 2>&1;' +$cc -o ${mc_file} $optimize $ccflags $ldflags $* ${mc_file}.c $libs > /dev/null 2>&1;' : define a shorthand compile call for compilations that should be ok. compile_ok=' mc_file=$1; shift; -$cc $optimize $ccflags $ldflags -o ${mc_file} $* ${mc_file}.c $libs;' +$cc -o ${mc_file} $optimize $ccflags $ldflags $* ${mc_file}.c $libs;' +: check for lengths of integral types echo " " -echo "Checking for GNU C Library..." >&4 -cat >gnulibc.c <&4 + $cat >intsize.c <<'EOCP' #include int main() { -#ifdef __GLIBC__ - exit(0); -#else - exit(1); -#endif + printf("intsize=%d;\n", (int)sizeof(int)); + printf("longsize=%d;\n", (int)sizeof(long)); + printf("shortsize=%d;\n", (int)sizeof(short)); + exit(0); } +EOCP + set intsize + if eval $compile_ok && ./intsize > /dev/null; then + eval `./intsize` + echo "Your integers are $intsize bytes long." + echo "Your long integers are $longsize bytes long." + echo "Your short integers are $shortsize bytes long." + else + $cat >&4 <&4 +$cat >try.c < +#include +int main() +{ + printf("%d\n", (int)sizeof($lseektype)); + return(0); +} +EOCP +set try +if eval $compile_ok; then + lseeksize=`./try` + echo "Your file offsets are $lseeksize bytes long." +else + dflt=$longsize + echo " " + echo "(I can't seem to compile the test program. Guessing...)" + rp="What is the size of your file offsets (in bytes)?" + . ./myread + lseeksize="$ans" +fi +$rm -f try.c try + +: see what type file positions are declared as in the library +rp="What is the type for file position used by fsetpos()?" +set fpos_t fpostype long stdio.h sys/types.h +eval $typedef_ask + +echo " " +case "$fpostype" in +*_t) zzz="$fpostype" ;; +*) zzz="fpos_t" ;; +esac +echo "Checking the size of $zzz..." >&4 +cat > try.c < +#include +int main() { + printf("%d\n", (int)sizeof($fpostype)); + exit(0); +} +EOCP +set try +if eval $compile_ok; then + yyy=`./try` + case "$yyy" in + '') fpossize=4 + echo "(I can't execute the test program--guessing $fpossize.)" >&4 + ;; + *) fpossize=$yyy + echo "Your $zzz is $fpossize bytes long." + ;; + esac +else + dflt="$longsize" + echo " " >&4 + echo "(I can't compile the test program. Guessing...)" >&4 + rp="What is the size of your file positions (in bytes)?" + . ./myread + fpossize="$ans" +fi + + + +# Backward compatibility (uselfs is deprecated). +case "$uselfs" in +"$define"|true|[yY]*) + cat <&4 + +*** Configure -Duselfs is deprecated, using -Duselargefiles instead. +EOM + uselargefiles="$define" + ;; +esac + +case "$lseeksize:$fpossize" in +8:8) cat <&4 + $cat >try.c < +#include +int main() +{ + printf("%d\n", (int)sizeof($lseektype)); + return(0); +} +EOCP + set try + if eval $compile_ok; then + lseeksize=`./try` + $echo "Your file offsets are now $lseeksize bytes long." + else + dflt="$lseeksize" + echo " " + echo "(I can't seem to compile the test program. Guessing...)" + rp="What is the size of your file offsets (in bytes)?" + . ./myread + lseeksize="$ans" + fi + case "$fpostype" in + *_t) zzz="$fpostype" ;; + *) zzz="fpos_t" ;; + esac + $echo $n "Rechecking the size of $zzz...$c" >&4 + $cat > try.c < +#include +int main() { + printf("%d\n", (int)sizeof($fpostype)); + exit(0); +} +EOCP + set try + if eval $compile_ok; then + yyy=`./try` + dflt="$lseeksize" + case "$yyy" in + '') echo " " + echo "(I can't execute the test program--guessing $fpossize.)" >&4 + ;; + *) fpossize=$yyy + echo " $fpossize bytes." >&4 + ;; + esac + else + dflt="$fpossize" + echo " " + echo "(I can't compile the test program. Guessing...)" >&4 + rp="What is the size of your file positions (in bytes)?" + . ./myread + fpossize="$ans" + fi + $rm -f try.c try + fi + ;; +esac + + +case "$usemorebits" in +"$define"|true|[yY]*) + use64bitint="$define" + uselongdouble="$define" + usemorebits="$define" + ;; +*) usemorebits="$undef" + ;; +esac + + +case "$uselonglong" in +"$define"|true|[yY]*) + cat <&4 + +*** Configure -Duselonglong is deprecated, using -Duse64bitint instead. +EOM + use64bitint="$define" + ;; +esac +case "$use64bits" in +"$define"|true|[yY]*) + cat <&4 + +*** Configure -Duse64bits is deprecated, using -Duse64bitint instead. +EOM + use64bitint="$define" + ;; +esac +case "$use64bitints" in +"$define"|true|[yY]*) + cat <&4 + +*** There is no Configure -Duse64bitints, using -Duse64bitint instead. +EOM + use64bitint="$define" + ;; +esac +case "$use64bitsint" in +"$define"|true|[yY]*) + cat <&4 + +*** There is no Configure -Duse64bitsint, using -Duse64bitint instead. +EOM + use64bitint="$define" + ;; +esac +case "$uselonglongs" in +"$define"|true|[yY]*) + cat <&4 + +*** There is no Configure -Duselonglongs, using -Duse64bitint instead. +EOM + use64bitint="$define" + ;; +esac +case "$use64bitsall" in +"$define"|true|[yY]*) + cat <&4 + +*** There is no Configure -Duse64bitsall, using -Duse64bitall instead. +EOM + use64bitall="$define" + ;; +esac + +case "$ccflags" in +*-DUSE_LONG_LONG*|*-DUSE_64_BIT_INT*|*-DUSE_64_BIT_ALL*) use64bitint="$define";; +esac +case "$use64bitall" in +"$define"|true|[yY]*) use64bitint="$define" ;; +esac + +case "$longsize" in +8) cat <&4 +cat >gnulibc.c < +int main() +{ +#ifdef __GLIBC__ + exit(0); +#else + exit(1); +#endif +} +EOM +set gnulibc +if eval $compile_ok && ./gnulibc; then + val="$define" + echo "You are using the GNU C Library" +else + val="$undef" + echo "You are not using the GNU C Library" +fi +$rm -f gnulibc* +set d_gnulibc +eval $setvar + +: see if nm is to be used to determine whether a symbol is defined or not +case "$usenm" in +'') dflt='' case "$d_gnulibc" in "$define") @@ -3829,7 +4982,7 @@ yes) fi;; *) echo "int main() { extern short $1$tdc; printf(\"%hd\", $1$tc); }" > t.c; - if $cc $optimize $ccflags $ldflags -o t t.c $libs >/dev/null 2>&1; + if $cc -o t $optimize $ccflags $ldflags t.c $libs >/dev/null 2>&1; then tval=true; else tval=false; fi; @@ -3870,240 +5023,10248 @@ yes) esac;; esac' -: see if dlopen exists -xxx_runnm="$runnm" -runnm=false -set dlopen d_dlopen +: see if sqrtl exists +set sqrtl d_sqrtl eval $inlibc -runnm="$xxx_runnm" -: determine which dynamic loading, if any, to compile in -echo " " -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 $rsrc/$dldir/dl_${osname}.xs && dflt='y' - ;; +case "$ccflags" in +*-DUSE_LONG_DOUBLE*|*-DUSE_MORE_BITS*) uselongdouble="$define" ;; esac -rp="Do you wish to use dynamic loading?" + +case "$uselongdouble" in +$define|true|[yY]*) dflt='y';; +*) dflt='n';; +esac +cat <&4 + +*** You requested the use of long doubles but you do not seem to have +*** the mathematic functions for long doubles. I'm disabling the use +*** of long doubles. + +EOM + uselongdouble=$undef + ;; +esac + +: check for length of double +echo " " +case "$doublesize" in +'') + echo "Checking to see how big your double precision numbers are..." >&4 + $cat >try.c <<'EOCP' +#include +int main() +{ + printf("%d\n", (int)sizeof(double)); + exit(0); +} +EOCP + set try + if eval $compile_ok; then + doublesize=`./try` + echo "Your double is $doublesize bytes long." + else + dflt='8' + echo "(I can't seem to compile the test program. Guessing...)" + rp="What is the size of a double precision number (in bytes)?" + . ./myread + doublesize="$ans" + fi + ;; +esac +$rm -f try.c try + +: check for long doubles +echo " " +echo "Checking to see if you have long double..." >&4 +echo 'int main() { long double x = 7.0; }' > try.c +set try +if eval $compile; then + val="$define" + echo "You have long double." +else + val="$undef" + echo "You do not have long double." +fi +$rm try.* +set d_longdbl +eval $setvar + +: check for length of long double +case "${d_longdbl}${longdblsize}" in +$define) + echo " " + echo "Checking to see how big your long doubles are..." >&4 + $cat >try.c <<'EOCP' +#include +int main() +{ + printf("%d\n", sizeof(long double)); +} +EOCP + set try + set try + if eval $compile; then + longdblsize=`./try$exe_ext` + echo "Your long doubles are $longdblsize bytes long." + else + dflt='8' + echo " " + echo "(I can't seem to compile the test program. Guessing...)" >&4 + rp="What is the size of a long double (in bytes)?" + . ./myread + longdblsize="$ans" + fi + if $test "X$doublesize" = "X$longdblsize"; then + echo "(That isn't any different from an ordinary double.)" + fi + ;; +esac +$rm -f try.* try + +: 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/ *$//' -e 's/ /_/g' \ + -e 's/$/'"-$osname/" tmparch` + else + tarch="$osname" + fi + $rm -f tmparch +else + tarch="$osname" +fi +case "$myarchname" in +''|"$tarch") ;; +*) + echo "(Your architecture name used to be $myarchname.)" + archname='' + ;; +esac +myarchname="$tarch" +case "$archname" in +'') dflt="$tarch";; +*) dflt="$archname";; +esac +rp='What is your architecture name' +. ./myread +archname="$ans" +case "$usethreads" in +$define) + echo "Threads selected." >&4 + case "$archname" in + *-thread*) echo "...and architecture name already has -thread." >&4 + ;; + *) archname="$archname-thread" + echo "...setting architecture name to $archname." >&4 + ;; + esac + ;; +esac +case "$usemultiplicity" in +$define) + echo "Multiplicity selected." >&4 + case "$archname" in + *-multi*) echo "...and architecture name already has -multi." >&4 + ;; + *) archname="$archname-multi" + echo "...setting architecture name to $archname." >&4 + ;; + esac + ;; +esac +case "$use64bitint$use64bitall" in +*"$define"*) + case "$archname64" in + '') + echo "This architecture is naturally 64-bit, not changing architecture name." >&4 + ;; + *) + case "$use64bitint" in + "$define") echo "64 bit integers selected." >&4 ;; + esac + case "$use64bitall" in + "$define") echo "Maximal 64 bitness selected." >&4 ;; + esac + case "$archname" in + *-$archname64*) echo "...and architecture name already has $archname64." >&4 + ;; + *) archname="$archname-$archname64" + echo "...setting architecture name to $archname." >&4 + ;; + esac + ;; + esac +esac +case "$uselongdouble" in +$define) + echo "Long doubles selected." >&4 + case "$longdblsize" in + $doublesize) + "...but long doubles are equal to doubles, not changing architecture name." >&4 + ;; + *) + case "$archname" in + *-ld*) echo "...and architecture name already has -ld." >&4 + ;; + *) archname="$archname-ld" + echo "...setting architecture name to $archname." >&4 + ;; + esac + ;; + esac + ;; +esac + +: 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 <&4 +else + echo "AFS does not seem to be running..." >&4 +fi + +: determine installation prefix for where package is to be installed. +if $afs; then +$cat <&4 +if $test -r $rsrc/patchlevel.h;then + revision=`awk '/define[ ]+PERL_REVISION/ {print $3}' $rsrc/patchlevel.h` + patchlevel=`awk '/define[ ]+PERL_VERSION/ {print $3}' $rsrc/patchlevel.h` + subversion=`awk '/define[ ]+PERL_SUBVERSION/ {print $3}' $rsrc/patchlevel.h` + api_revision=`awk '/define[ ]+PERL_API_REVISION/ {print $3}' $rsrc/patchlevel.h` + api_version=`awk '/define[ ]+PERL_API_VERSION/ {print $3}' $rsrc/patchlevel.h` + api_subversion=`awk '/define[ ]+PERL_API_SUBVERSION/ {print $3}' $rsrc/patchlevel.h` +else + revision=0 + patchlevel=0 + subversion=0 + api_revision=0 + api_version=0 + api_subversion=0 +fi +$echo "(You have $package version $patchlevel subversion $subversion.)" +case "$osname" in +dos|vms) + : XXX Should be a Configure test for double-dots in filenames. + version=`echo $revision $patchlevel $subversion | \ + $awk '{ printf "%d_%d_%d\n", $1, $2, $3 }'` + api_versionstring=`echo $api_revision $api_version $api_subversion | \ + $awk '{ printf "%d_%d_%d\n", $1, $2, $3 }'` + ;; +*) + version=`echo $revision $patchlevel $subversion | \ + $awk '{ printf "%d.%d.%d\n", $1, $2, $3 }'` + api_versionstring=`echo $api_revision $api_version $api_subversion | \ + $awk '{ printf "%d.%d.%d\n", $1, $2, $3 }'` + ;; +esac +: Special case the 5.005_xx maintenance series, which used 5.005 +: without any subversion label as a subdirectory in $sitelib +if test "${api_revision}${api_version}${api_subversion}" = "550"; then + api_versionstring='5.005' +fi + +: determine installation style +: For now, try to deduce it from prefix unless it is already set. +: Reproduce behavior of 5.005 and earlier, maybe drop that in 5.7. +case "$installstyle" in +'') case "$prefix" in + *perl*) dflt='lib';; + *) dflt='lib/perl5' ;; + esac + ;; +*) dflt="$installstyle" ;; +esac +: Probably not worth prompting for this since we prompt for all +: the directories individually, and the prompt would be too long and +: confusing anyway. +installstyle=$dflt + +: determine where private library files go +: Usual default is /usr/local/lib/perl5/$version. +: Also allow things like /opt/perl/lib/$version, since +: /opt/perl/lib/perl5... would be redundant. +: The default "style" setting is made in installstyle.U +case "$installstyle" in +*lib/perl5*) set dflt privlib lib/$package/$version ;; +*) set dflt privlib lib/$version ;; +esac +eval $prefixit +$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 ;; - *) case "$osname" in - svr4*|esix*|solaris) dflt='-fPIC' ;; - *) dflt='-fpic' ;; - esac ;; - esac ;; - ' ') dflt='none' ;; - *) 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 + *) + $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 + echo "(That's for file descriptors, not floppy disks.)" + val="$undef" +fi +set d_suidsafe +eval $setvar + +$rm -f reflect flect + +: now see if they want to do setuid emulation +echo " " +val="$undef" +case "$d_suidsafe" in +"$define") + val="$undef" + echo "No need to emulate SUID scripts since they are secure here." >& 4 + ;; +*) + $cat <&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 1;; + *[\\\\/]\$wanted) echo "\$name"; exit 1;; + *) exit 2;; + esac; +done; +# +# status = 0: grep returned 0 lines, case statement not executed +# status = 1: headerfile found +# status = 2: while loop executed, no headerfile found +# +status=\$? +$rm -f foo\$\$.c; +if test \$status -eq 1; then + exit 0; +fi +exit 1 +EOF +chmod +x findhdr + +: 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 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 "$usemymalloc" in +''|[yY]*|true|$define) dflt='y' ;; +*) dflt='n' ;; +esac +rp="Do you wish to attempt to use the malloc that comes with $package?" +. ./myread +usemymalloc="$ans" +case "$ans" in +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 + +: 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 +case "$malloctype" in +'') + if $cc $ccflags -c -DTRY_MALLOC malloc.c >/dev/null 2>&1; then + malloctype='void *' + else + malloctype='char *' + fi + ;; +esac +echo "Your system wants malloc to return '$malloctype', it would seem." >&4 + +case "$freetype" in +'') + if $cc $ccflags -c -DTRY_FREE malloc.c >/dev/null 2>&1; then + freetype='void' + else + freetype='int' + fi + ;; +esac +echo "Your system uses $freetype free(), it would seem." >&4 +$rm -f malloc.[co] +$cat <&4 +$cat >prototype.c <<'EOCP' +int 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* + +case "$prototype" in +"$define") ;; +*) ansi2knr='ansi2knr' + echo " " + cat <&4 + +$me: FATAL ERROR: +This version of $package can only be compiled by a compiler that +understands function prototypes. Unfortunately, your C compiler + $cc $ccflags +doesn't seem to understand them. Sorry about that. + +If GNU cc is available for your system, perhaps you could try that instead. + +Eventually, we hope to support building Perl with pre-ANSI compilers. +If you would like to help in that effort, please contact . + +Aborting Configure now. +EOM + exit 2 + ;; +esac + +: 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" +: Change installation prefix, if necessary. +: XXX Bug? -- ignores Configure -Dinstallprefix setting. +if $test X"$prefix" != X"$installprefix"; then + installbin=`echo $binexp | sed "s#^$prefix#$installprefix#"` +else + installbin="$binexp" +fi + +: Find perl5.005 or later. +echo "Looking for a previously installed perl5.005 or later... " +case "$perl5" in +'') for tdir in `echo "$binexp:$PATH" | $sed "s/$path_sep/ /g"`; do + : Check if this perl is recent and can load a simple module + if $test -x $tdir/perl && $tdir/perl -Mless -e 'use 5.005;' >/dev/null 2>&1; then + perl5=$tdir/perl + break; + elif $test -x $tdir/perl5 && $tdir/perl5 -Mless -e 'use 5.005;' >/dev/null 2>&1; then + perl5=$tdir/perl + break; + fi + done + ;; +*) perl5="$perl5" + ;; +esac +case "$perl5" in +'') echo "None found. That's ok.";; +*) echo "Using $perl5." ;; +esac + +: Determine list of previous versions to include in @INC +$cat > getverlist <> getverlist <<'EOPL' +# Can't have leading @ because metaconfig interprets it as a command! +;@inc_version_list=(); +# XXX Redo to do opendir/readdir? +if (-d $stem) { + chdir($stem); + ;@candidates = glob("5.*"); +} +else { + ;@candidates = (); +} + +# XXX ToDo: These comparisons must be reworked when two-digit +# subversions come along, so that 5.7.10 compares as greater than +# 5.7.3! By that time, hope that 5.6.x is sufficiently +# widespread that we can use the built-in version vectors rather +# than reinventing them here. For 5.6.0, however, we must +# assume this script will likely be run by 5.005_0x. --AD 1/2000. +foreach $d (@candidates) { + if ($d lt $version) { + if ($d ge $api_versionstring) { + unshift(@inc_version_list, grep { -d } "$d/$archname", $d); + } + elsif ($d ge "5.005") { + unshift(@inc_version_list, grep { -d } $d); + } + } + else { + # Skip newer version. I.e. don't look in + # 5.7.0 if we're installing 5.6.1. + } +} + +if (@inc_version_list) { + print join(' ', @inc_version_list); +} +else { + # Blank space to preserve value for next Configure run. + print " "; +} +EOPL +chmod +x getverlist +case "$inc_version_list" in +'') if test -x "$perl5"; then + dflt=`$perl5 getverlist` + else + dflt='none' + fi + ;; +$undef) dflt='none' ;; +*) dflt="$inc_version_list" ;; +esac +case "$dflt" in +''|' ') dflt=none ;; +esac +case "$dflt" in +5.005) case "$bincompat5005" in + $define|true|[yY]*) ;; + *) dflt=none ;; + esac + ;; +esac +$cat <<'EOM' + +In order to ease the process of upgrading, this version of perl +can be configured to use modules built and installed with earlier +versions of perl that were installed under $prefix. Specify here +the list of earlier versions that this version of perl should check. +If Configure detected no earlier versions of perl installed under +$prefix, then the list will be empty. Answer 'none' to tell perl +to not search earlier versions. + +The default should almost always be sensible, so if you're not sure, +just accept the default. +EOM + +rp='List of earlier versions to include in @INC?' +. ./myread +case "$ans" in +[Nn]one|''|' ') inc_version_list=' ' ;; +*) inc_version_list="$ans" ;; +esac +case "$inc_version_list" in +''|' ') + inc_version_list_init='0';; +*) inc_version_list_init=`echo $inc_version_list | + $sed -e 's/^/"/' -e 's/ /","/g' -e 's/$/",0/'` + ;; +esac +$rm -f getverlist + +: determine whether to install perl also as /usr/bin/perl + +echo " " +if $test -d /usr/bin -a "X$installbin" != X/usr/bin; then + $cat <try.c <<'EOM' +/* Test for whether ELF binaries are produced */ +#include +#include +int main() { + char b[4]; + int i = open("a.out",O_RDONLY); + if(i == -1) + exit(1); /* fail */ + if(read(i,b,4)==4 && b[0]==127 && b[1]=='E' && b[2]=='L' && b[3]=='F') + exit(0); /* succeed (yes, it's ELF) */ + else + exit(1); /* fail */ +} +EOM + if $cc $ccflags try.c >/dev/null 2>&1 && ./a.out; then + cat <&4 <&4 <&4 <&4 + +Adding $xxx to the flags +passed to $ld so that the perl executable will find the +installed shared $libperl. + +EOM + ;; + esac + ;; + esac +fi +# Fix ccdlflags in AIX for building external extensions. +# (For building Perl itself bare -bE:perl.exp is needed, +# Makefile.SH takes care of this.) +case "$osname" in +aix) ccdlflags="$ccdlflags -bE:$installarchlib/CORE/perl.exp" ;; +esac +# Respect a hint or command-line value. +case "$shrpenv" in +'') shrpenv="$tmp_shrpenv" ;; +esac +case "$ldlibpthname" in +'') ldlibpthname=LD_LIBRARY_PATH ;; +none) ldlibpthname='' ;; +esac + +: determine where manual pages are on this system +echo " " +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 +if $test -d "$sysman"; then + echo "System manual is in $sysman." >&4 +else + echo "Could not find manual pages in source form." >&4 +fi + +: determine where manual pages go +set man1dir man1dir none +eval $prefixit +$cat <$first) 2>/dev/null; then + if $test -f 123456789abcde; then + echo 'You cannot have filenames longer than 14 characters. Sigh.' >&4 + val="$undef" + else + echo 'You can have filenames longer than 14 characters.'>&4 + val="$define" + fi +else + $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 123456789abcde* + +: determine where library module manual pages go +set man3dir man3dir none +eval $prefixit +$cat <&4 + +WARNING: Previous versions of perl installed man3 pages into +$privlib/man/man3. This version will suggest a +new default of $dflt. +EOM + tdflt=$dflt + dflt='n' + rp='Do you wish to preserve the old behavior?(y/n)' + . ./myread + case "$ans" in + y*) dflt="$privlib/man/man3" ;; + *) dflt=$tdflt ;; + esac + fi + ;; +*) dflt="$man3dir" ;; +esac +case "$dflt" in +' ') dflt=none ;; +esac +echo " " +fn=dn+~ +rp="Where do the $package library man pages (source) go?" +. ./getfile +man3dir="$ans" +man3direxp="$ansexp" +case "$man3dir" in +'') man3dir=' ' + installman3dir='';; +esac + +: Change installation prefix, if necessary. +if $test X"$prefix" != X"$installprefix"; then + installman3dir=`echo $man3direxp | $sed "s#^$prefix#$installprefix#"` +else + installman3dir="$man3direxp" +fi + +: What suffix to use on installed man pages +case "$man3dir" in +' ') + man3ext='0' + ;; +*) + rp="What suffix should be used for the $package library man pages?" + case "$man3ext" in + '') case "$man3dir" in + *3) dflt=3 ;; + *3p) dflt=3p ;; + *3pm) dflt=3pm ;; + *l) dflt=l;; + *n) dflt=n;; + *o) dflt=o;; + *p) dflt=p;; + *C) dflt=C;; + *L) dflt=L;; + *L3) dflt=L3;; + *) dflt=3;; + esac + ;; + *) dflt="$man3ext";; + esac + . ./myread + man3ext="$ans" + ;; +esac + +: 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 .';; + *) case "$hostcat" in + nidump*) hostcat='';; + esac + ;; + 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 +case "$hostcat" in +'') test -f /etc/hosts && hostcat='cat /etc/hosts';; +esac +case "$groupcat" in +'') test -f /etc/group && groupcat='cat /etc/group';; +esac +case "$passcat" in +'') test -f /etc/passwd && passcat='cat /etc/passwd';; +esac + +: 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 + +case "$myhostname" in +*.*) + dflt=`expr "X$myhostname" : "X[^.]*\(\..*\)"` + myhostname=`expr "X$myhostname" : "X\([^.]*\)\."` + echo "(Trimming domain name from host name--host name is now $myhostname)" + ;; +*) case "$mydomain" in + '') + { + test "X$hostcat" = "Xypcat hosts" && + ypmatch "$myhostname" hosts 2>/dev/null |\ + $sed -e 's/[ ]*#.*//; s/$/ /' > hosts && \ + $test -s hosts + } || { + test "X$hostcat" != "X" && + $hostcat | $sed -n -e "s/[ ]*#.*//; s/\$/ / + /[ ]$myhostname[ . ]/p" > hosts + } + tmp_re="[ . ]" + if $test -f hosts; then + $test x`$awk "/[0-9].*[ ]$myhostname$tmp_re/ { sum++ } + END { print sum }" hosts` = x1 || tmp_re="[ ]" + dflt=.`$awk "/[0-9].*[ ]$myhostname$tmp_re/ {for(i=2; i<=NF;i++) print \\\$i}" \ + hosts | $sort | $uniq | \ + $sed -n -e "s/$myhostname\.\([-a-zA-Z0-9_.]\)/\1/p"` + case `$echo X$dflt` in + X*\ *) echo "(Several hosts in the database matched hostname)" + dflt=. + ;; + X.) echo "(You do not have fully-qualified names in the hosts database)" + ;; + esac + else + echo "(I cannot locate a hosts database anywhere)" + dflt=. + fi + case "$dflt" in + .) + tans=`./loc resolv.conf X /etc /usr/etc` + if $test -f "$tans"; then + echo "(Attempting domain name extraction from $tans)" + dflt=.`$sed -n -e 's/ / /g' \ + -e 's/^search *\([^ ]*\).*/\1/p' $tans \ + | ./tr '[A-Z]' '[a-z]' 2>/dev/null` + case "$dflt" in + .) dflt=.`$sed -n -e 's/ / /g' \ + -e 's/^domain *\([^ ]*\).*/\1/p' $tans \ + | ./tr '[A-Z]' '[a-z]' 2>/dev/null` + ;; + esac + fi + ;; + esac + case "$dflt" in + .) echo "(No help from resolv.conf either -- attempting clever guess)" + dflt=.`sh -c domainname 2>/dev/null` + case "$dflt" in + '') dflt='.';; + .nis.*|.yp.*|.main.*) dflt=`echo $dflt | $sed -e 's/^\.[^.]*//'`;; + esac + ;; + esac + case "$dflt" in + .) echo "(Lost all hope -- silly guess then)" + dflt='.uucp' + ;; + esac + $rm -f hosts + ;; + *) dflt="$mydomain";; + esac;; +esac +echo " " +rp="What is your domain name?" +. ./myread +tans="$ans" +case "$ans" in +'') ;; +.*) ;; +*) tans=".$tans";; +esac +mydomain="$tans" + +: translate upper to lower if necessary +case "$mydomain" in +*[A-Z]*) + echo "(Normalizing case in your domain name)" + mydomain=`echo $mydomain | ./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 + +$cat <&4 <. Versions 5.003_02 and later of perl allow alternate IO +mechanisms via a "PerlIO" abstraction, but the stdio mechanism is still +the default. This abstraction layer can use AT&T's sfio (if you already +have sfio installed) or regular stdio. Using PerlIO with sfio may cause +problems with some extension modules. Using PerlIO with stdio is safe, +but it is slower than plain stdio and therefore is not the default. + +If this doesn't make any sense to you, just accept the default '$dflt'. +EOM +rp='Use the experimental PerlIO abstraction layer?' +. ./myread +case "$ans" in +y|Y) + val="$define" + ;; +*) + echo "Ok, doing things the stdio way" + val="$undef" + ;; +esac +set useperlio +eval $setvar + +case "$vendorprefix" in +'') d_vendorbin="$undef" + vendorbin='' + vendorbinexp='' + ;; +*) d_vendorbin="$define" + : determine where vendor-supplied executables go. + case "$vendorbin" in + '') dflt=$vendorprefix/bin ;; + *) dflt="$vendorbin" ;; + esac + fn=d~+ + rp='Pathname for the vendor-supplied executables directory?' + . ./getfile + vendorbin="$ans" + vendorbinexp="$ansexp" + ;; +esac +: Change installation prefix, if necessary. +if $test X"$prefix" != X"$installprefix"; then + installvendorbin=`echo $vendorbinexp | $sed "s#^$prefix#$installprefix#"` +else + installvendorbin="$vendorbinexp" +fi + +: determine whether to only install version-specific parts. +echo " " +$cat <&4 + +if $test X"$sPRIfldbl" = X -a X"$doublesize" = X"$longdblsize"; then + $cat >try.c <<'EOCP' +#include +#include +int main() { + double d = 123.456; + printf("%.3f\n", d); +} +EOCP + set try + if eval $compile; then + yyy=`./try$exe_ext` + case "$yyy" in + 123.456) + sPRIfldbl='"f"'; sPRIgldbl='"g"'; sPRIeldbl='"e"'; + sPRIFUldbl='"F"'; sPRIGUldbl='"G"'; sPRIEUldbl='"E"'; + echo "We will use %f." + ;; + esac + fi +fi + +if $test X"$sPRIfldbl" = X; then + $cat >try.c <<'EOCP' +#include +#include +int main() { + long double d = 123.456; + printf("%.3llf\n", d); +} +EOCP + set try + if eval $compile; then + yyy=`./try$exe_ext` + case "$yyy" in + 123.456) + sPRIfldbl='"llf"'; sPRIgldbl='"llg"'; sPRIeldbl='"lle"'; + sPRIFUldbl='"llF"'; sPRIGUldbl='"llG"'; sPRIEUldbl='"llE"'; + echo "We will use %llf." + ;; + esac + fi +fi + +if $test X"$sPRIfldbl" = X; then + $cat >try.c <<'EOCP' +#include +#include +int main() { + long double d = 123.456; + printf("%.3Lf\n", d); +} +EOCP + set try + if eval $compile; then + yyy=`./try$exe_ext` + case "$yyy" in + 123.456) + sPRIfldbl='"Lf"'; sPRIgldbl='"Lg"'; sPRIeldbl='"Le"'; + sPRIFUldbl='"LF"'; sPRIGUldbl='"LG"'; sPRIEUldbl='"LE"'; + echo "We will use %Lf." + ;; + esac + fi +fi + +if $test X"$sPRIfldbl" = X; then + $cat >try.c <<'EOCP' +#include +#include +int main() { + long double d = 123.456; + printf("%.3lf\n", d); +} +EOCP + set try + if eval $compile; then + yyy=`./try$exe_ext` + case "$yyy" in + 123.456) + sPRIfldbl='"lf"'; sPRIgldbl='"lg"'; sPRIeldbl='"le"'; + sPRIFUldbl='"lF"'; sPRIGUldbl='"lG"'; sPRIEUldbl='"lE"'; + echo "We will use %lf." + ;; + esac + fi +fi + +if $test X"$sPRIfldbl" = X; then + echo "Cannot figure out how to print long doubles." >&4 +else + sSCNfldbl=$sPRIfldbl # expect consistency +fi + +$rm -f try try.* + +fi # d_longdbl + +case "$sPRIfldbl" in +'') d_PRIfldbl="$undef"; d_PRIgldbl="$undef"; d_PRIeldbl="$undef"; + d_PRIFUldbl="$undef"; d_PRIGUldbl="$undef"; d_PRIEUldbl="$undef"; + d_SCNfldbl="$undef"; + ;; +*) d_PRIfldbl="$define"; d_PRIgldbl="$define"; d_PRIeldbl="$define"; + d_PRIFUldbl="$define"; d_PRIGUldbl="$define"; d_PRIEUldbl="$define"; + d_SCNfldbl="$define"; + ;; +esac + +: Check how to convert floats to strings. +echo " " +echo "Checking for an efficient way to convert floats to strings." +echo " " > try.c +case "$uselongdouble" in +"$define") echo "#define USE_LONG_DOUBLE" >>try.c ;; +esac +case "$d_longdbl" in +"$define") echo "#define HAS_LONG_DOUBLE" >>try.c ;; +esac +case "$d_PRIgldbl" in +"$define") echo "#define HAS_PRIgldbl" >>try.c ;; +esac +$cat >>try.c < + +#define I_STDLIB $i_stdlib +#ifdef I_STDLIB +#include +#endif + +int +checkit(expect, got) +char *expect; +char *got; +{ + if (strcmp(expect, got)) { + printf("%s oddity: Expected %s, got %s\n", + myname, expect, got); + exit(1); + } +} + +int main() +{ + char buf[64]; + buf[63] = '\0'; + + /* This must be 1st test on (which?) platform */ + /* Alan Burlison */ + Gconvert((DOUBLETYPE)0.1, 8, 0, buf); + checkit("0.1", buf); + + Gconvert((DOUBLETYPE)1.0, 8, 0, buf); + checkit("1", buf); + + Gconvert((DOUBLETYPE)1.1, 8, 0, buf); + checkit("1.1", buf); + + Gconvert((DOUBLETYPE)1.01, 8, 0, buf); + checkit("1.01", buf); + + Gconvert((DOUBLETYPE)1.001, 8, 0, buf); + checkit("1.001", buf); + + Gconvert((DOUBLETYPE)1.0001, 8, 0, buf); + checkit("1.0001", buf); + + Gconvert((DOUBLETYPE)1.00001, 8, 0, buf); + checkit("1.00001", buf); + + Gconvert((DOUBLETYPE)1.000001, 8, 0, buf); + checkit("1.000001", buf); + + Gconvert((DOUBLETYPE)0.0, 8, 0, buf); + checkit("0", buf); + + Gconvert((DOUBLETYPE)-1.0, 8, 0, buf); + checkit("-1", buf); + + /* Some Linux gcvt's give 1.e+5 here. */ + Gconvert((DOUBLETYPE)100000.0, 8, 0, buf); + checkit("100000", buf); + + /* Some Linux gcvt's give -1.e+5 here. */ + Gconvert((DOUBLETYPE)-100000.0, 8, 0, buf); + checkit("-100000", buf); + + Gconvert((DOUBLETYPE)123.456, 8, 0, buf); + checkit("123.456", buf); + + exit(0); +} +EOP +case "$d_Gconvert" in +gconvert*) xxx_list='gconvert gcvt sprintf' ;; +gcvt*) xxx_list='gcvt gconvert sprintf' ;; +sprintf*) xxx_list='sprintf gconvert gcvt' ;; +*) xxx_list='gconvert gcvt sprintf' ;; +esac + +case "$d_longdbl$uselongdouble$d_PRIgldbl" in +"$define$define$define") + # for long doubles prefer first qgcvt, then sprintf + xxx_list="`echo $xxx_list|sed s/sprintf//`" + xxx_list="sprintf $xxx_list" + case "$d_qgcvt" in + "$define") xxx_list="qgcvt $xxx_list" ;; + esac + ;; +esac + +for xxx_convert in $xxx_list; do + echo "Trying $xxx_convert..." + $rm -f try try$_o + set try -DTRY_$xxx_convert + if eval $compile; then + echo "$xxx_convert() found." >&4 + if ./try; then + echo "I'll use $xxx_convert to convert floats into a string." >&4 + break; + else + echo "...But $xxx_convert didn't work as I expected." + fi + else + echo "$xxx_convert NOT found." >&4 + fi +done + +case "$xxx_convert" in +gconvert) d_Gconvert='gconvert((x),(n),(t),(b))' ;; +gcvt) d_Gconvert='gcvt((x),(n),(b))' ;; +qgcvt) d_Gconvert='qgcvt((x),(n),(b))' ;; +*) case "$uselongdouble$d_longdbl$d_PRIgldbl" in + "$define$define$define") + d_Gconvert="sprintf((b),\"%.*\"$sPRIgldbl,(n),(x))" ;; + *) d_Gconvert='sprintf((b),"%.*g",(n),(x))' ;; + esac + ;; +esac + +: Initialize h_fcntl +h_fcntl=false + +: Initialize h_sysfile +h_sysfile=false + +: 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 +int main() { + exit(R_OK); +} +EOCP + : check sys/file.h first, no particular reason here + if $test `./findhdr sys/file.h` && \ + $cc -o access $cppflags -DI_SYS_FILE access.c >/dev/null 2>&1 ; then + h_sysfile=true; + echo " defines the *_OK access constants." >&4 + elif $test `./findhdr fcntl.h` && \ + $cc -o access $cppflags -DI_FCNTL access.c >/dev/null 2>&1 ; then + h_fcntl=true; + echo " defines the *_OK access constants." >&4 + elif $test `./findhdr unistd.h` && \ + $cc -o access $cppflags -DI_UNISTD access.c >/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 accessx exists +set accessx d_accessx +eval $inlibc + +: see if alarm exists +set alarm d_alarm +eval $inlibc + +: see if atolf exists +set atolf d_atolf +eval $inlibc + +: see if atoll exists +set atoll d_atoll +eval $inlibc + +: Look for GNU-cc style attribute checking +echo " " +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 +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" +fi +set d_attribut +eval $setvar +$rm -f attrib* + +: see if bcmp exists +set bcmp d_bcmp +eval $inlibc + +: see if bcopy exists +set bcopy d_bcopy +eval $inlibc + +: see if this is a unistd.h system +set unistd.h i_unistd +eval $inhdr + +: see if getpgrp exists +set getpgrp d_getpgrp +eval $inlibc + +case "$d_getpgrp" in +"$define") + echo " " + echo "Checking to see which flavor of getpgrp is in use..." + $cat >set.c < +#ifdef I_UNISTD +# include +#endif +int main() +{ + if (getuid() == 0) { + printf("(I see you are running Configure as super-user...)\n"); + setuid(1); + } +#ifdef TRY_BSD_PGRP + if (getpgrp(1) == 0) + exit(0); +#else + if (getpgrp() > 0) + exit(0); +#endif + exit(1); +} +EOP + if $cc -o set -DTRY_BSD_PGRP $ccflags $ldflags set.c $libs >/dev/null 2>&1 && ./set; then + echo "You have to use getpgrp(pid) instead of getpgrp()." >&4 + val="$define" + elif $cc -o set $ccflags $ldflags set.c $libs >/dev/null 2>&1 && ./set; then + echo "You have to use getpgrp() instead of getpgrp(pid)." >&4 + val="$undef" + else + echo "I can't seem to compile and run the test program." + if ./usg; then + xxx="a USG one, i.e. you use getpgrp()." + else + # SVR4 systems can appear rather BSD-ish. + case "$i_unistd" in + $undef) + xxx="a BSD one, i.e. you use getpgrp(pid)." + val="$define" + ;; + $define) + xxx="probably a USG one, i.e. you use getpgrp()." + val="$undef" + ;; + esac + fi + echo "Assuming your getpgrp is $xxx" >&4 + fi + ;; +*) val="$undef";; +esac +set d_bsdgetpgrp +eval $setvar +$rm -f set set.c + +: see if setpgrp exists +set setpgrp d_setpgrp +eval $inlibc + +case "$d_setpgrp" in +"$define") + echo " " + echo "Checking to see which flavor of setpgrp is in use..." + $cat >set.c < +#ifdef I_UNISTD +# include +#endif +int main() +{ + if (getuid() == 0) { + printf("(I see you are running Configure as super-user...)\n"); + setuid(1); + } +#ifdef TRY_BSD_PGRP + if (-1 == setpgrp(1, 1)) + exit(0); +#else + if (setpgrp() != -1) + exit(0); +#endif + exit(1); +} +EOP + if $cc -o set -DTRY_BSD_PGRP $ccflags $ldflags set.c $libs >/dev/null 2>&1 && ./set; then + echo 'You have to use setpgrp(pid,pgrp) instead of setpgrp().' >&4 + val="$define" + elif $cc -o set $ccflags $ldflags set.c $libs >/dev/null 2>&1 && ./set; then + echo 'You have to use setpgrp() instead of setpgrp(pid,pgrp).' >&4 + val="$undef" + else + echo "(I can't seem to compile and run the test program.)" + if ./usg; then + xxx="a USG one, i.e. you use setpgrp()." + else + # SVR4 systems can appear rather BSD-ish. + case "$i_unistd" in + $undef) + xxx="a BSD one, i.e. you use setpgrp(pid,pgrp)." + val="$define" + ;; + $define) + xxx="probably a USG one, i.e. you use setpgrp()." + val="$undef" + ;; + esac + fi + echo "Assuming your setpgrp is $xxx" >&4 + fi + ;; +*) val="$undef";; +esac +set d_bsdsetpgrp +eval $setvar +$rm -f set set.c +: see if bzero exists +set bzero d_bzero +eval $inlibc + +: 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())()." >&4 + val="$define" +elif $contains 'extern[ ]*[(\*]*signal' $$.tmp >/dev/null 2>&1 ; then + echo "You have int (*signal())() instead of void." >&4 + val="$undef" +elif $contains 'void.*\*.*sig' $$.tmp >/dev/null 2>&1 ; then + echo "You have void (*signal())()." >&4 + val="$define" +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 + val="$define" + ;; + *) echo "As you already told me, signal handler returns int." >&4 + val="$undef" + ;; + 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" -ge 4; then + xxx=int +else + xxx=long +fi +$cat >try.c < +#include +#include +$signal_t blech(s) int s; { exit(3); } +int main() +{ + $xxx i32; + double f, g; + int result = 0; + char str[16]; + signal(SIGFPE, blech); + + /* Don't let compiler optimize the test away. Store the number + in a writable string for gcc to pass to sscanf under HP/UX. + */ + sprintf(str, "2147483647"); + sscanf(str, "%lf", &f); /* f = (double) 0x7fffffff; */ + g = 10 * f; + i32 = ($xxx) g; + + /* x86 processors will probably give 0x8000 0000, which is a + sign change. We don't want that. We want to mimic SPARC + behavior here, which is to preserve the sign and give + back 0x7fff ffff. + */ + if (i32 != ($xxx) f) + result |= 1; + exit(result); +} +EOCP +set try +if eval $compile_ok; 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 +#include +$signal_t blech(s) int s; { exit(7); } +$signal_t blech_in_list(s) int s; { exit(4); } +unsigned long dummy_long(p) unsigned long p; { return p; } +unsigned int dummy_int(p) unsigned int p; { return p; } +unsigned short dummy_short(p) unsigned short p; { return p; } +int main() +{ + double f; + unsigned long along; + unsigned int aint; + unsigned short ashort; + int result = 0; + char str[16]; + + /* Frustrate gcc-2.7.2's optimizer which failed this test with + a direct f = -123. assignment. gcc-2.8.0 reportedly + optimized the whole file away + */ + /* Store the number in a writable string for gcc to pass to + sscanf under HP/UX. + */ + sprintf(str, "-123"); + sscanf(str, "%lf", &f); /* f = -123.; */ + + 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; + sprintf(str, "1073741824."); + sscanf(str, "%lf", &f); /* 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; + if (result) + exit(result); + signal(SIGFPE, blech_in_list); + sprintf(str, "123."); + sscanf(str, "%lf", &f); /* f = 123.; */ + along = dummy_long((unsigned long)f); + aint = dummy_int((unsigned int)f); + ashort = dummy_short((unsigned short)f); + if (along != (unsigned long)123) + result |= 4; + if (aint != (unsigned int)123) + result |= 4; + if (ashort != (unsigned short)123) + result |= 4; + exit(result); + +} +EOCP +set try +if eval $compile_ok; then + ./try + castflags=$? +else + echo "(I can't seem to compile the test program--assuming it can't)" + castflags=7 +fi +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 set vprintf val -f d_vprintf; eval $csym; $val; then + echo 'vprintf() found.' >&4 + val="$define" + $cat >vprintf.c <<'EOF' +#include + +int main() { xxx("foo"); } + +xxx(va_alist) +va_dcl +{ + va_list args; + char buf[10]; + + va_start(args); + exit((unsigned long)vsprintf(buf,"%s",args) > 10L); +} +EOF + set vprintf + if eval $compile && ./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.' >&4 + val="$undef" + val2="$undef" +fi +set d_vprintf +eval $setvar +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 + +: check for const keyword +echo " " +echo 'Checking to see if your C compiler knows about "const"...' >&4 +$cat >const.c <<'EOCP' +typedef struct spug { int drokk; } spug; +int 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 + val="$undef" + 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" + 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 + +: get csh whereabouts +case "$csh" in +'csh') val="$undef" ;; +*) val="$define" ;; +esac +set d_csh +eval $setvar +: Respect a hint or command line value for full_csh. +case "$full_csh" in +'') full_csh=$csh ;; +esac + +: see if cuserid exists +set cuserid d_cuserid +eval $inlibc + +: 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 +xxx_runnm="$runnm" +runnm=false +set dlerror d_dlerror +eval $inlibc +runnm="$xxx_runnm" + +: 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 than 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() ; + +int 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") ; + fflush (stdout) ; + exit(0); + } + symbol = dlsym(handle, "fred") ; + if (symbol == NULL) { + /* try putting a leading underscore */ + symbol = dlsym(handle, "_fred") ; + if (symbol == NULL) { + printf ("2\n") ; + fflush (stdout) ; + exit(0); + } + printf ("3\n") ; + } + else + printf ("4\n") ; + fflush (stdout) ; + exit(0); +} +EOM + : Call the object file tmp-dyna.o in case dlext=o. + if $cc $ccflags $cccdlflags -c dyna.c > /dev/null 2>&1 && + mv dyna${_o} tmp-dyna${_o} > /dev/null 2>&1 && + $ld -o dyna.$dlext $lddlflags tmp-dyna${_o} > /dev/null 2>&1 && + $cc -o fred $ccflags $ldflags $cccdlflags $ccdlflags fred.c $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 + echo "I'm guessing that dlsym doesn't need a leading underscore." >&4 + fi + ;; +esac + +$rm -f fred fred.? dyna.$dlext dyna.? tmp-dyna.? + +set d_dlsymun +eval $setvar + +hasproto='varname=$1; func=$2; shift; shift; +while $test $# -ge 2; do + case "$1" in + $define) echo "#include <$2>";; + esac ; + shift 2; +done > try.c; +$cppstdin $cppflags $cppminus < try.c > tryout.c 2>/dev/null; +if $contains "$func.*(" tryout.c >/dev/null 2>&1; then + echo "$func() prototype found."; + val="$define"; +else + echo "$func() prototype NOT found."; + val="$undef"; +fi; +set $varname; +eval $setvar; +$rm -f try.c tryout.c' + +: see if prototype for drand48 is available +echo " " +set d_drand48proto drand48 $i_stdlib stdlib.h $i_unistd unistd.h +eval $hasproto + +: see if dup2 exists +set dup2 d_dup2 +eval $inlibc + +: see if eaccess exists +set eaccess d_eaccess +eval $inlibc + +: see if endgrent exists +set endgrent d_endgrent +eval $inlibc + +: see if endhostent exists +set endhostent d_endhent +eval $inlibc + +: see if endnetent exists +set endnetent d_endnent +eval $inlibc + +: see if endprotoent exists +set endprotoent d_endpent +eval $inlibc + +: see if endpwent exists +set endpwent d_endpwent +eval $inlibc + +: see if endservent exists +set endservent d_endsent +eval $inlibc + +: Locate the flags for 'open()' +echo " " +$cat >open3.c <<'EOCP' +#include +#ifdef I_FCNTL +#include +#endif +#ifdef I_SYS_FILE +#include +#endif +int main() { + if(O_RDONLY); +#ifdef O_TRUNC + exit(0); +#else + exit(1); +#endif +} +EOCP +: check sys/file.h first to get FREAD on Sun +if $test `./findhdr sys/file.h` && \ + set open3 -DI_SYS_FILE && eval $compile; 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` && \ + set open3 -DI_FCNTL && eval $compile; 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." >&4 +fi +set d_open3 +eval $setvar +$rm -f open3* + +: see which of string.h or strings.h is needed +echo " " +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 + +: check for non-blocking I/O stuff +case "$h_sysfile" in +true) echo "#include " > head.c;; +*) + case "$h_fcntl" in + true) echo "#include " > head.c;; + *) echo "#include " > head.c;; + esac + ;; +esac +echo " " +echo "Figuring out the flag used by open() for non-blocking I/O..." >&4 +case "$o_nonblock" in +'') + $cat head.c > try.c + $cat >>try.c <<'EOCP' +#include +int main() { +#ifdef O_NONBLOCK + printf("O_NONBLOCK\n"); + exit(0); +#endif +#ifdef O_NDELAY + printf("O_NDELAY\n"); + exit(0); +#endif +#ifdef FNDELAY + printf("FNDELAY\n"); + exit(0); +#endif + exit(0); +} +EOCP + set try + if eval $compile_ok; then + o_nonblock=`./try` + case "$o_nonblock" in + '') echo "I can't figure it out, assuming O_NONBLOCK will do.";; + *) echo "Seems like we can use $o_nonblock.";; + esac + else + echo "(I can't compile the test program; pray O_NONBLOCK is right!)" + fi + ;; +*) echo "Using $hint value $o_nonblock.";; +esac +$rm -f try try.* .out core + +echo " " +echo "Let's see what value errno gets from read() on a $o_nonblock file..." >&4 +case "$eagain" in +'') + $cat head.c > try.c + $cat >>try.c < +#include +#include +#include +#define MY_O_NONBLOCK $o_nonblock +#ifndef errno /* XXX need better Configure test */ +extern int errno; +#endif +#$i_unistd I_UNISTD +#ifdef I_UNISTD +#include +#endif +#$i_string I_STRING +#ifdef I_STRING +#include +#else +#include +#endif +$signal_t blech(x) int x; { exit(3); } +EOCP + $cat >> try.c <<'EOCP' +int main() +{ + int pd[2]; + int pu[2]; + char buf[1]; + char string[100]; + + pipe(pd); /* Down: child -> parent */ + pipe(pu); /* Up: parent -> child */ + if (0 != fork()) { + int ret; + close(pd[1]); /* Parent reads from pd[0] */ + close(pu[0]); /* Parent writes (blocking) to pu[1] */ + if (-1 == fcntl(pd[0], F_SETFL, MY_O_NONBLOCK)) + exit(1); + signal(SIGALRM, blech); + alarm(5); + if ((ret = read(pd[0], buf, 1)) > 0) /* Nothing to read! */ + exit(2); + sprintf(string, "%d\n", ret); + write(2, string, strlen(string)); + alarm(0); +#ifdef EAGAIN + if (errno == EAGAIN) { + printf("EAGAIN\n"); + goto ok; + } +#endif +#ifdef EWOULDBLOCK + if (errno == EWOULDBLOCK) + printf("EWOULDBLOCK\n"); +#endif + ok: + write(pu[1], buf, 1); /* Unblocks child, tell it to close our pipe */ + sleep(2); /* Give it time to close our pipe */ + alarm(5); + ret = read(pd[0], buf, 1); /* Should read EOF */ + alarm(0); + sprintf(string, "%d\n", ret); + write(3, string, strlen(string)); + exit(0); + } + + close(pd[0]); /* We write to pd[1] */ + close(pu[1]); /* We read from pu[0] */ + read(pu[0], buf, 1); /* Wait for parent to signal us we may continue */ + close(pd[1]); /* Pipe pd is now fully closed! */ + exit(0); /* Bye bye, thank you for playing! */ +} +EOCP + set try + if eval $compile_ok; then + echo "$startsh" >mtry + echo "./try >try.out 2>try.ret 3>try.err || exit 4" >>mtry + chmod +x mtry + ./mtry >/dev/null 2>&1 + case $? in + 0) eagain=`$cat try.out`;; + 1) echo "Could not perform non-blocking setting!";; + 2) echo "I did a successful read() for something that was not there!";; + 3) echo "Hmm... non-blocking I/O does not seem to be working!";; + *) echo "Something terribly wrong happened during testing.";; + esac + rd_nodata=`$cat try.ret` + echo "A read() system call with no data present returns $rd_nodata." + case "$rd_nodata" in + 0|-1) ;; + *) + echo "(That's peculiar, fixing that to be -1.)" + rd_nodata=-1 + ;; + esac + case "$eagain" in + '') + echo "Forcing errno EAGAIN on read() with no data available." + eagain=EAGAIN + ;; + *) + echo "Your read() sets errno to $eagain when no data is available." + ;; + esac + status=`$cat try.err` + case "$status" in + 0) echo "And it correctly returns 0 to signal EOF.";; + -1) echo "But it also returns -1 to signal EOF, so be careful!";; + *) echo "However, your read() returns '$status' on EOF??";; + esac + val="$define" + if test "$status" = "$rd_nodata"; then + echo "WARNING: you can't distinguish between EOF and no data!" + val="$undef" + fi + else + echo "I can't compile the test program--assuming errno EAGAIN will do." + eagain=EAGAIN + fi + set d_eofnblk + eval $setvar + ;; +*) + echo "Using $hint value $eagain." + echo "Your read() returns $rd_nodata when no data is present." + case "$d_eofnblk" in + "$define") echo "And you can see EOF because read() returns 0.";; + "$undef") echo "But you can't see EOF status from read() returned value.";; + *) + echo "(Assuming you can't see EOF status from read anyway.)" + d_eofnblk=$undef + ;; + esac + ;; +esac +$rm -f try try.* .out core head.c mtry + +: see if fchmod exists +set fchmod d_fchmod +eval $inlibc + +: see if fchown exists +set fchown d_fchown +eval $inlibc + +: see if this is an fcntl system +set fcntl d_fcntl +eval $inlibc + +hasfield='varname=$1; struct=$2; field=$3; shift; shift; shift; +while $test $# -ge 2; do + case "$1" in + $define) echo "#include <$2>";; + esac ; + shift 2; +done > try.c; +echo "int main () { struct $struct foo; char* bar; bar = (char*)foo.$field; }" >> try.c; +set try; +if eval $compile; then + val="$define"; +else + val="$undef"; +fi; +set $varname; +eval $setvar; +$rm -f try.c try.o' + +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 BSD 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 "X$d_socket" = "X$define"; then + echo "...but you seem to believe that you have sockets." >&4 + else + for net in net socket + do + if test -f /usr/lib/lib$net$_a; then + ( ($nm $nm_opt /usr/lib/lib$net$_a | eval $nm_extract) || \ + $ar t /usr/lib/lib$net$_a) 2>/dev/null >> libc.list + if $contains socket libc.list >/dev/null 2>&1; then + d_socket="$define" + socketlib="-l$net" + case "$net" in + net) + echo "...but the Wollongong group seems to have hacked it in." >&4 + sockethdr="-I/usr/netinclude" + ;; + esac + echo "Found Berkeley sockets interface in lib$net." >& 4 + if $contains setsockopt libc.list >/dev/null 2>&1; then + d_oldsock="$undef" + else + echo "...using the old BSD 4.1c interface, rather than 4.2." >&4 + d_oldsock="$define" + fi + break + fi + fi + done + if test "X$d_socket" != "X$define"; then + echo "or anywhere else I see." >&4 + d_socket="$undef" + d_oldsock="$undef" + fi + fi + fi +fi + +: see if socketpair exists +set socketpair d_sockpair +eval $inlibc + + +echo " " +echo "Checking the availability of certain socket constants..." >& 4 +for ENUM in MSG_CTRUNC MSG_DONTROUTE MSG_OOB MSG_PEEK MSG_PROXY SCM_RIGHTS; do + enum=`$echo $ENUM|./tr '[A-Z]' '[a-z]'` + $cat >try.c < +#include +int main() { + int i = $ENUM; +} +EOF + val="$undef" + set try; if eval $compile; then + val="$define" + fi + set d_${enum}; eval $setvar + $rm -f try.c try +done + +: see if sys/select.h has to be included +set sys/select.h i_sysselct +eval $inhdr + +: see if we should include time.h, sys/time.h, or both +echo " " +if test "X$timeincl" = X; then + echo "Testing to see if we should include , 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 +int 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='' + for s_timezone in '-DS_TIMEZONE' ''; do + 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" + set try $i_time $i_systime $i_systimek $sysselect $s_timeval $s_timezone + if eval $compile; then + set X $i_time $i_systime $i_systimek $sysselect $s_timeval + shift + flags="$*" + echo " " + $echo $n "Succeeded with $flags$c" + fi + ;; + esac + done + 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 +fi + +: check for fd_set items +$cat <fd_set.c < +#ifdef HAS_SOCKET +#include /* Might include */ +#endif +#ifdef I_SYS_TIME +#include +#endif +#ifdef I_SYS_SELECT +#include +#endif +int 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 +set fd_set -DTRYBITS +if eval $compile; 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 + set fd_set + if eval $compile; 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* + +: see if fgetpos exists +set fgetpos d_fgetpos +eval $inlibc + +: see if flock exists +set flock d_flock +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 + + +: check for fpos64_t +echo " " +echo "Checking to see if you have fpos64_t..." >&4 +$cat >try.c < +int main() { fpos64_t x = 7; } +EOCP +set try +if eval $compile; then + val="$define" + echo "You have fpos64_t." +else + val="$undef" + echo "You do not have fpos64_t." + case "$fpossize" in + 8) echo "(Your fpos_t is 64 bits, so you could use that.)" ;; + esac +fi +$rm -f try.* try +set d_fpos64_t +eval $setvar + +: see if frexpl exists +set frexpl d_frexpl +eval $inlibc + +hasstruct='varname=$1; struct=$2; shift; shift; +while $test $# -ge 2; do + case "$1" in + $define) echo "#include <$2>";; + esac ; + shift 2; +done > try.c; +echo "int main () { struct $struct foo; }" >> try.c; +set try; +if eval $compile; then + val="$define"; +else + val="$undef"; +fi; +set $varname; +eval $setvar; +$rm -f try.c try.o' + +: see if this is a sys/param system +set sys/param.h i_sysparam +eval $inhdr + +: see if this is a sys/mount.h system +set sys/mount.h i_sysmount +eval $inhdr + +: see if sys/types.h has to be included +set sys/types.h i_systypes +eval $inhdr + + +echo " " +echo "Checking to see if your system supports struct fs_data..." >&4 +set d_fs_data_s fs_data $i_systypes sys/types.h $i_sysparam sys/param.h $i_sysmount sys/mount.h +eval $hasstruct +case "$d_fs_data_s" in +"$define") echo "Yes, it does." ;; +*) echo "No, it doesn't." ;; +esac + +: see if fseeko exists +set fseeko d_fseeko +eval $inlibc +case "$longsize" in +8) echo "(Your long is 64 bits, so you could use fseek.)" ;; +esac + +: see if fsetpos exists +set fsetpos d_fsetpos +eval $inlibc + + +: see if fstatfs exists +set fstatfs d_fstatfs +eval $inlibc + + +: see if statvfs exists +set statvfs d_statvfs +eval $inlibc + +: see if fstatvfs exists +set fstatvfs d_fstatvfs +eval $inlibc + + +: see if ftello exists +set ftello d_ftello +eval $inlibc +case "$longsize" in +8) echo "(Your long is 64 bits, so you could use ftell.)" ;; +esac + +: see if getcwd exists +set getcwd d_getcwd +eval $inlibc + +: see if getespwnam exists +set getespwnam d_getespwnam +eval $inlibc + + +: see if getfsstat exists +set getfsstat d_getfsstat +eval $inlibc + +: see if getgrent exists +set getgrent d_getgrent +eval $inlibc + +: see if gethostbyaddr exists +set gethostbyaddr d_gethbyaddr +eval $inlibc + +: see if gethostbyname exists +set gethostbyname d_gethbyname +eval $inlibc + +: see if gethostent exists +set gethostent d_gethent +eval $inlibc + +: see how we will look up host name +echo " " +call='' +if set gethostname val -f d_gethname; eval $csym; $val; then + echo 'gethostname() found.' >&4 + d_gethname="$define" + call=gethostname +fi +if 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" + case "$call" in + '') call=uname ;; + esac + fi +fi +case "$d_gethname" in +'') d_gethname="$undef";; +esac +case "$d_uname" in +'') d_uname="$undef";; +esac +case "$d_uname$d_gethname" in +*define*) + dflt=n + cat <&4;; + *) + echo "I'll use 'popen("'"'$aphostname'", "r")'"' to get your hostname." >&4 + ;; + esac;; +esac +case "$d_phostname" in +'') d_phostname="$undef";; +esac + +: see if this is a netdb.h system +set netdb.h i_netdb +eval $inhdr + +: see if prototypes for various gethostxxx netdb.h functions are available +echo " " +set d_gethostprotos gethostent $i_netdb netdb.h +eval $hasproto + +: see if getlogin exists +set getlogin d_getlogin +eval $inlibc + +: see if getmnt exists +set getmnt d_getmnt +eval $inlibc + +: see if getmntent exists +set getmntent d_getmntent +eval $inlibc + +: see if getnetbyaddr exists +set getnetbyaddr d_getnbyaddr +eval $inlibc + +: see if getnetbyname exists +set getnetbyname d_getnbyname +eval $inlibc + +: see if getnetent exists +set getnetent d_getnent +eval $inlibc + +: see if prototypes for various getnetxxx netdb.h functions are available +echo " " +set d_getnetprotos getnetent $i_netdb netdb.h +eval $hasproto + + +: see if getprotobyname exists +set getprotobyname d_getpbyname +eval $inlibc + +: see if getprotobynumber exists +set getprotobynumber d_getpbynumber +eval $inlibc + +: see if getprotoent exists +set getprotoent d_getpent +eval $inlibc + +: see if getpgid exists +set getpgid d_getpgid +eval $inlibc + +: see if getpgrp2 exists +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 prototypes for various getprotoxxx netdb.h functions are available +echo " " +set d_getprotoprotos getprotoent $i_netdb netdb.h +eval $hasproto + +: see if getprpwnam exists +set getprpwnam d_getprpwnam +eval $inlibc + +: see if getpwent exists +set getpwent d_getpwent +eval $inlibc + + +: see if getservbyname exists +set getservbyname d_getsbyname +eval $inlibc + +: see if getservbyport exists +set getservbyport d_getsbyport +eval $inlibc + +: see if getservent exists +set getservent d_getsent +eval $inlibc + +: see if prototypes for various getservxxx netdb.h functions are available +echo " " +set d_getservprotos getservent $i_netdb netdb.h +eval $hasproto + +: see if getspnam exists +set getspnam d_getspnam +eval $inlibc + +: see if gettimeofday or ftime exists +set gettimeofday d_gettimeod +eval $inlibc +case "$d_gettimeod" in +"$undef") + set ftime d_ftime + eval $inlibc + ;; +*) + val="$undef"; set d_ftime; eval $setvar + ;; +esac +case "$d_gettimeod$d_ftime" in +"$undef$undef") + echo " " + echo 'No ftime() nor gettimeofday() -- timing may be less accurate.' >&4 + ;; +esac + +: see if this is an grp system +set grp.h i_grp +eval $inhdr + +case "$i_grp" in +$define) + xxx=`./findhdr grp.h` + $cppstdin $cppflags $cppminus < $xxx >$$.h + + if $contains 'gr_passwd' $$.h >/dev/null 2>&1; then + val="$define" + else + val="$undef" + fi + set d_grpasswd + eval $setvar + + $rm -f $$.h + ;; +*) + val="$undef"; + set d_grpasswd; eval $setvar + ;; +esac + +: see if hasmntopt exists +set hasmntopt d_hasmntopt +eval $inlibc + +: 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 arpa/inet.h has to be included +set arpa/inet.h i_arpainet +eval $inhdr + +: see if htonl --and friends-- exists +val='' +set htonl val +eval $inlibc + +: Maybe they are macros. +case "$val" in +$undef) + $cat >htonl.c < +#include +#$i_niin I_NETINET_IN +#$i_sysin I_SYS_IN +#$i_arpainet I_ARPA_INET +#ifdef I_NETINET_IN +#include +#endif +#ifdef I_SYS_IN +#include +#endif +#ifdef I_ARPA_INET +#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 if iconv exists +set iconv d_iconv +eval $inlibc + +: 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 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 + +: check whether inet_aton exists +set inet_aton d_inetaton +eval $inlibc + +: see if inttypes.h is available +: we want a real compile instead of Inhdr because some systems +: have an inttypes.h which includes non-existent headers +echo " " +$cat >try.c < +int main() { + static int32_t foo32 = 0x12345678; +} +EOCP +set try +if eval $compile; then + echo " found." >&4 + val="$define" +else + echo " NOT found." >&4 + val="$undef" +fi +$rm -f try.c try +set i_inttypes +eval $setvar + +: check for int64_t +echo " " +echo "Checking to see if you have int64_t..." >&4 +$cat >try.c < +#$i_inttypes I_INTTYPES +#ifdef I_INTTYPES +#include +#endif +int main() { int64_t x = 7; } +EOCP +set try +if eval $compile; then + val="$define" + echo "You have int64_t." +else + val="$undef" + echo "You do not have int64_t." +fi +$rm -f try try.* +set d_int64_t +eval $setvar + +: Look for isascii +echo " " +$cat >isascii.c <<'EOCP' +#include +#include +int main() { + int c = 'A'; + if (isascii(c)) + exit(0); + else + exit(1); +} +EOCP +set isascii +if eval $compile; 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 isnan exists +set isnan d_isnan +eval $inlibc + +: see if isnanl exists +set isnanl d_isnanl +eval $inlibc + +: see if killpg exists +set killpg d_killpg +eval $inlibc + +: see if lchown exists +echo " " +$cat > try.c <<'EOCP' +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char lchown(); below. */ +#include +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char lchown(); +int main() { + /* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_lchown) || defined (__stub___lchown) +choke me +#else +lchown(); +#endif +; return 0; } +EOCP +set try +if eval $compile; then + $echo "lchown() found." >&4 + val="$define" +else + $echo "lchown() NOT found." >&4 + val="$undef" +fi +set d_lchown +eval $setvar + +: See if number of significant digits in a double precision number is known +echo " " +$cat >ldbl_dig.c < +#endif +#ifdef I_FLOAT +#include +#endif +#ifdef LDBL_DIG +printf("Contains LDBL_DIG"); +#endif +EOM +$cppstdin $cppflags $cppminus < ldbl_dig.c >ldbl_dig.E 2>/dev/null +if $contains 'LDBL_DIG' ldbl_dig.E >/dev/null 2>&1; then + echo "LDBL_DIG found." >&4 + val="$define" +else + echo "LDBL_DIG NOT found." >&4 + val="$undef" +fi +$rm -f ldbl_dig.? +set d_ldbl_dig +eval $setvar + +: see if link exists +set link d_link +eval $inlibc + +: see if localeconv exists +set localeconv d_locconv +eval $inlibc + +: see if lockf exists +set lockf d_lockf +eval $inlibc + +: check for long long +echo " " +echo "Checking to see if you have long long..." >&4 +echo 'int main() { long long x = 7; return 0; }' > try.c +set try +if eval $compile; then + val="$define" + echo "You have long long." +else + val="$undef" + echo "You do not have long long." +fi +$rm try.* +set d_longlong +eval $setvar + +: check for length of long long +case "${d_longlong}${longlongsize}" in +$define) + echo " " + echo "Checking to see how big your long longs are..." >&4 + $cat >try.c <<'EOCP' +#include +int main() +{ + printf("%d\n", (int)sizeof(long long)); + return(0); +} +EOCP + set try + if eval $compile_ok; then + longlongsize=`./try$exe_ext` + echo "Your long longs are $longlongsize bytes long." + else + dflt='8' + echo " " + echo "(I can't seem to compile the test program. Guessing...)" + rp="What is the size of a long long (in bytes)?" + . ./myread + longlongsize="$ans" + fi + if $test "X$longsize" = "X$longlongsize"; then + echo "(That isn't any different from an ordinary long.)" + fi + ;; +esac +$rm -f try.* try + +: see if prototype for lseek is available +echo " " +set d_lseekproto lseek $i_systypes sys/types.h $i_unistd unistd.h +eval $hasproto + +: see if lstat exists +set lstat d_lstat +eval $inlibc + +: see if madvise exists +set madvise d_madvise +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 memchr exists +set memchr d_memchr +eval $inlibc + +: see if memcmp exists +set memcmp d_memcmp +eval $inlibc + +: see if memcpy exists +set memcpy d_memcpy +eval $inlibc + +: see if memmove exists +set memmove d_memmove +eval $inlibc + +: see if memset exists +set memset d_memset +eval $inlibc + +: see if mkdir exists +set mkdir d_mkdir +eval $inlibc + +: see if mkdtemp exists +set mkdtemp d_mkdtemp +eval $inlibc + +: see if mkfifo exists +set mkfifo d_mkfifo +eval $inlibc + +: see if mkstemp exists +set mkstemp d_mkstemp +eval $inlibc + +: see if mkstemps exists +set mkstemps d_mkstemps +eval $inlibc + +: see if mktime exists +set mktime d_mktime +eval $inlibc + +: see if this is a sys/mman.h system +set sys/mman.h i_sysmman +eval $inhdr + +: see if mmap exists +set mmap d_mmap +eval $inlibc +: see what shmat returns +: default to something harmless +mmaptype='void *' +case "$i_sysmman$d_mmap" in +"$define$define") + $cat >mmap.c <<'END' +#include +void *mmap(); +END + if $cc $ccflags -c mmap.c >/dev/null 2>&1; then + mmaptype='void *' + else + mmaptype='caddr_t' + fi + echo "and it returns ($mmaptype)." >&4 + ;; +esac + + + +: see if modfl exists +set modfl d_modfl +eval $inlibc + +: see if mprotect exists +set mprotect d_mprotect +eval $inlibc + +: see if msgctl exists +set msgctl d_msgctl +eval $inlibc + +: see if msgget exists +set msgget d_msgget +eval $inlibc + +: see if msgsnd exists +set msgsnd d_msgsnd +eval $inlibc + +: see if msgrcv exists +set msgrcv d_msgrcv +eval $inlibc + +: see how much of the 'msg*(2)' library is present. +h_msg=true +echo " " +case "$d_msgctl$d_msgget$d_msgsnd$d_msgrcv" in +*"$undef"*) h_msg=false;; +esac +case "$osname" in +freebsd) + case "`ipcs 2>&1`" in + "SVID messages"*"not configured"*) + echo "Your $osname does not have the msg*(2) configured." >&4 + h_msg=false + val="$undef" + set msgctl d_msgctl + eval $setvar + set msgget d_msgget + eval $setvar + set msgsnd d_msgsnd + eval $setvar + set msgrcv d_msgrcv + eval $setvar + ;; + esac + ;; +esac +: we could also check for sys/ipc.h ... +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." >&4 + val="$undef" +fi +set d_msg +eval $setvar + +: see if msync exists +set msync d_msync +eval $inlibc + +: see if munmap exists +set munmap d_munmap +eval $inlibc + +: see if nice exists +set nice d_nice +eval $inlibc + + +echo " " +echo "Checking which 64-bit integer type we could use..." >&4 + +case "$intsize" in +8) val=int + set quadtype + eval $setvar + val='"unsigned int"' + set uquadtype + eval $setvar + quadkind=1 + ;; +*) case "$longsize" in + 8) val=long + set quadtype + eval $setvar + val='"unsigned long"' + set uquadtype + eval $setvar + quadkind=2 + ;; + *) case "$d_longlong:$longlongsize" in + define:8) + val='"long long"' + set quadtype + eval $setvar + val='"unsigned long long"' + set uquadtype + eval $setvar + quadkind=3 + ;; + *) case "$d_int64_t" in + define) + val=int64_t + set quadtype + eval $setvar + val=uint64_t + set uquadtype + eval $setvar + quadkind=4 + ;; + esac + ;; + esac + ;; + esac + ;; +esac + +case "$quadtype" in +'') echo "Alas, no 64-bit integer types in sight." >&4 + d_quad="$undef" + ;; +*) if test X"$use64bitint" = Xdefine -o X"$longsize" = X8; then + verb="will" + else + verb="could" + fi + echo "We $verb use '$quadtype' for 64-bit integers." >&4 + d_quad="$define" + ;; +esac + +: check for length of character +echo " " +case "$charsize" in +'') + echo "Checking to see how big your characters are (hey, you never know)..." >&4 + $cat >try.c <<'EOCP' +#include +int main() +{ + printf("%d\n", (int)sizeof(char)); + exit(0); +} +EOCP + set try + if eval $compile_ok; then + dflt=`./try` + else + dflt='1' + echo "(I can't seem to compile the test program. Guessing...)" + fi + ;; +*) + dflt="$charsize" + ;; +esac +rp="What is the size of a character (in bytes)?" +. ./myread +charsize="$ans" +$rm -f try.c try + + +echo " " +$echo "Choosing the C types to be used for Perl's internal types..." >&4 + +case "$use64bitint:$d_quad:$quadtype" in +define:define:?*) + ivtype="$quadtype" + uvtype="$uquadtype" + ivsize=8 + uvsize=8 + ;; +*) ivtype="long" + uvtype="unsigned long" + ivsize=$longsize + uvsize=$longsize + ;; +esac + +case "$uselongdouble:$d_longdbl" in +define:define) + nvtype="long double" + nvsize=$longdblsize + ;; +*) nvtype=double + nvsize=$doublesize + ;; +esac + +$echo "(IV will be "$ivtype", $ivsize bytes)" +$echo "(UV will be "$uvtype", $uvsize bytes)" +$echo "(NV will be "$nvtype", $nvsize bytes)" + +$cat >try.c < +#endif +#include +int main() { +#ifdef INT8 + int8_t i = INT8_MAX; + uint8_t u = UINT8_MAX; + printf("int8_t\n"); +#endif +#ifdef INT16 + int16_t i = INT16_MAX; + uint16_t i = UINT16_MAX; + printf("int16_t\n"); +#endif +#ifdef INT32 + int32_t i = INT32_MAX; + uint32_t u = UINT32_MAX; + printf("int32_t\n"); +#endif +} +EOCP + +case "$i8type" in +'') case "$charsize" in + 1) i8type=char + u8type="unsigned char" + i8size=$charsize + u8size=$charsize + ;; + esac + ;; +esac +case "$i8type" in +'') set try -DINT8 + if eval $compile; then + case "`./try$exe_ext`" in + int8_t) i8type=int8_t + u8type=uint8_t + i8size=1 + u8size=1 + ;; + esac + fi + ;; +esac +case "$i8type" in +'') if $test $charsize -ge 1; then + i8type=char + u8type="unsigned char" + i8size=$charsize + u8size=$charsize + fi + ;; +esac + +case "$i16type" in +'') case "$shortsize" in + 2) i16type=short + u16type="unsigned short" + i16size=$shortsize + u16size=$shortsize + ;; + esac + ;; +esac +case "$i16type" in +'') set try -DINT16 + if eval $compile; then + case "`./try$exe_ext`" in + int16_t) + i16type=int16_t + u16type=uint16_t + i16size=2 + u16size=2 + ;; + esac + fi + ;; +esac +case "$i16type" in +'') if $test $shortsize -ge 2; then + i16type=short + u16type="unsigned short" + i16size=$shortsize + u16size=$shortsize + fi + ;; +esac + +case "$i32type" in +'') case "$longsize" in + 4) i32type=long + u32type="unsigned long" + i32size=$longsize + u32size=$longsize + ;; + *) case "$intsize" in + 4) i32type=int + u32type="unsigned int" + i32size=$intsize + u32size=$intsize + ;; + esac + ;; + esac + ;; +esac +case "$i32type" in +'') set try -DINT32 + if eval $compile; then + case "`./try$exe_ext`" in + int32_t) + i32type=int32_t + u32type=uint32_t + i32size=4 + u32size=4 + ;; + esac + fi + ;; +esac +case "$i32type" in +'') if $test $intsize -ge 4; then + i32type=int + u32type="unsigned int" + i32size=$intsize + u32size=$intsize + fi + ;; +esac + +case "$i64type" in +'') case "$d_quad:$quadtype" in + define:?*) + i64type="$quadtype" + u64type="$uquadtype" + i64size=8 + u64size=8 + ;; + esac + ;; +esac + +$echo "Checking whether your NVs can preserve your UVs..." >&4 +$cat <try.c +#include +int main() { + $uvtype k = ($uvtype)~0, l; + $nvtype d; + l = k; + d = ($nvtype)l; + l = ($uvtype)d; + if (l == k) + printf("preserve\n"); + exit(0); +} +EOP +set try +if eval $compile; then + case "`./try$exe_ext`" in + preserve) d_nv_preserves_uv="$define" ;; + esac +fi +case "$d_nv_preserves_uv" in +$define) $echo "Yes, they can." 2>&1 ;; +*) $echo "No, they can't." 2>&1 + d_nv_preserves_uv="$undef" + ;; +esac + +$rm -f try.* try + +case "$d_nv_preserves_uv" in +"$define") d_nv_preserves_uv_bits=`expr $uvsize \* 8` ;; +*) $echo "Checking how many bits of your UVs your NVs can preserve..." >&4 + $cat <try.c +#include +int main() { + $uvtype u = 0; + int n = 8 * $uvsize; + int i; + for (i = 0; i < n; i++) { + u = u << 1 | ($uvtype)1; + if (($uvtype)($nvtype)u != u) + break; + } + printf("%d\n", i); + exit(0); +} +EOP + set try + if eval $compile; then + d_nv_preserves_uv_bits="`./try$exe_ext`" + fi + case "$d_nv_preserves_uv_bits" in + [1-9]*) $echo "Your NVs can preserve $d_nv_preserves_uv_bits bits of your UVs." 2>&1 ;; + *) $echo "Can't figure out how many bits your NVs preserve." 2>&1 + d_nv_preserves_uv_bits="$undef" + ;; + esac + $rm -f try.* try + ;; +esac + + +: check for off64_t +echo " " +echo "Checking to see if you have off64_t..." >&4 +$cat >try.c < +#include +int main() { off64_t x = 7; } +EOCP +set try +if eval $compile; then + val="$define" + echo "You have off64_t." +else + val="$undef" + echo "You do not have off64_t." + case "$lseeksize" in + 8) echo "(Your off_t is 64 bits, so you could use that.)" ;; + esac +fi +$rm -f try.* try +set d_off64_t +eval $setvar + +: see if POSIX threads are available +set pthread.h i_pthread +eval $inhdr + + + + +: how to create joinable pthreads +if test "X$usethreads" = "X$define" -a "X$i_pthread" = "X$define"; then + echo " " + echo "Checking what constant to use for creating joinable pthreads..." >&4 + $cat >try.c <<'EOCP' +#include +int main() { + int detachstate = JOINABLE; +} +EOCP + set try -DJOINABLE=PTHREAD_CREATE_JOINABLE + if eval $compile; then + echo "You seem to use PTHREAD_CREATE_JOINABLE." >&4 + val="$undef" # Yes, undef. + set d_old_pthread_create_joinable + eval $setvar + val="" + set old_pthread_create_joinable + eval $setvar + else + set try -DJOINABLE=PTHREAD_CREATE_UNDETACHED + if eval $compile; then + echo "You seem to use PTHREAD_CREATE_UNDETACHED." >&4 + val="$define" + set d_old_pthread_create_joinable + eval $setvar + val=PTHREAD_CREATE_UNDETACHED + set old_pthread_create_joinable + eval $setvar + else + set try -DJOINABLE=__UNDETACHED + if eval $compile; then + echo "You seem to use __UNDETACHED." >&4 + val="$define" + set d_old_pthread_create_joinable + eval $setvar + val=__UNDETACHED + set old_pthread_create_joinable + eval $setvar + else + echo "Egads, nothing obvious found. Guessing that you use 0." >&4 + val="$define" + set d_old_pthread_create_joinable + eval $setvar + val=0 + set old_pthread_create_joinable + eval $setvar + fi + fi + fi + $rm -f try try.* +else + d_old_pthread_create_joinable="$undef" + old_pthread_create_joinable="" +fi + +: see if pause exists +set pause d_pause +eval $inlibc + +: see if pipe exists +set pipe d_pipe +eval $inlibc + +: see if poll exists +set poll d_poll +eval $inlibc + + +: see whether the various POSIXish _yields exist +$cat >try.c < +#include +int main() { +#ifdef SCHED_YIELD + sched_yield(); +#else +#ifdef PTHREAD_YIELD + pthread_yield(); +#else +#ifdef PTHREAD_YIELD_NULL + pthread_yield(NULL); +#endif +#endif +#endif +} +EOP +: see if sched_yield exists +set try -DSCHED_YIELD +if eval $compile; then + val="$define" + sched_yield='sched_yield()' +else + val="$undef" +fi +case "$usethreads" in +$define) + case "$val" in + $define) echo 'sched_yield() found.' >&4 ;; + *) echo 'sched_yield() NOT found.' >&4 ;; + esac +esac +set d_sched_yield +eval $setvar + +: see if pthread_yield exists +set try -DPTHREAD_YIELD +if eval $compile; then + val="$define" + case "$sched_yield" in + '') sched_yield='pthread_yield()' ;; + esac +else + set try -DPTHREAD_YIELD_NULL + if eval $compile; then + val="$define" + case "$sched_yield" in + '') sched_yield='pthread_yield(NULL)' ;; + esac + else + val="$undef" + fi +fi +case "$usethreads" in +$define) + case "$val" in + $define) echo 'pthread_yield() found.' >&4 ;; + *) echo 'pthread_yield() NOT found.' >&4 ;; + esac + ;; +esac +set d_pthread_yield +eval $setvar + +case "$sched_yield" in +'') sched_yield=undef ;; +esac + +$rm -f try try.* + +: see if this is a pwd.h system +set pwd.h i_pwd +eval $inhdr + +case "$i_pwd" in +$define) + xxx=`./findhdr pwd.h` + $cppstdin $cppflags $cppminus < $xxx >$$.h + + if $contains 'pw_quota' $$.h >/dev/null 2>&1; then + val="$define" + else + val="$undef" + fi + set d_pwquota + eval $setvar + + if $contains 'pw_age' $$.h >/dev/null 2>&1; then + val="$define" + else + val="$undef" + fi + set d_pwage + eval $setvar + + if $contains 'pw_change' $$.h >/dev/null 2>&1; then + val="$define" + else + val="$undef" + fi + set d_pwchange + eval $setvar + + if $contains 'pw_class' $$.h >/dev/null 2>&1; then + val="$define" + else + val="$undef" + fi + set d_pwclass + eval $setvar + + if $contains 'pw_expire' $$.h >/dev/null 2>&1; then + val="$define" + else + val="$undef" + fi + set d_pwexpire + eval $setvar + + if $contains 'pw_comment' $$.h >/dev/null 2>&1; then + val="$define" + else + val="$undef" + fi + set d_pwcomment + eval $setvar + + if $contains 'pw_gecos' $$.h >/dev/null 2>&1; then + val="$define" + else + val="$undef" + fi + set d_pwgecos + eval $setvar + + if $contains 'pw_passwd' $$.h >/dev/null 2>&1; then + val="$define" + else + val="$undef" + fi + set d_pwpasswd + eval $setvar + + $rm -f $$.h + ;; +*) + val="$undef"; + set d_pwquota; eval $setvar + set d_pwage; eval $setvar + set d_pwchange; eval $setvar + set d_pwclass; eval $setvar + set d_pwexpire; eval $setvar + set d_pwcomment; eval $setvar + set d_pwgecos; eval $setvar + set d_pwpasswd; eval $setvar + ;; +esac + +: 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 rmdir exists +set rmdir d_rmdir +eval $inlibc + +: 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 + +: 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 >try.c <>try.c <<'EOCP' +#include +#ifdef I_MEMORY +# include +#endif +#ifdef I_STDLIB +# include +#endif +#ifdef I_STRING +# include +#else +# include +#endif +#ifdef I_UNISTD +# include /* Needed for NetBSD */ +#endif +int 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 + set try + if eval $compile_ok; then + if ./try 2>/dev/null; then + echo "Yes, it can." + val="$define" + else + echo "It can't, sorry." + case "$d_memmove" in + "$define") echo "But that's Ok since you have memmove()." ;; + esac + fi + else + echo "(I can't compile the test program, so we'll assume not...)" + case "$d_memmove" in + "$define") echo "But that's Ok since you have memmove()." ;; + esac + fi + ;; +esac +$rm -f try.* try 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 >try.c <>try.c <<'EOCP' +#include +#ifdef I_MEMORY +# include +#endif +#ifdef I_STDLIB +# include +#endif +#ifdef I_STRING +# include +#else +# include +#endif +#ifdef I_UNISTD +# include /* Needed for NetBSD */ +#endif +int main() +{ +char buf[128], abc[128]; +char *b; +int len; +int off; +int align; + +/* Copy "abcde..." string to char abc[] so that gcc doesn't + try to store the string in read-only memory. */ +memcpy(abc, "abcdefghijklmnopqrstuvwxyz0123456789", 36); + +for (align = 7; align >= 0; align--) { + for (len = 36; len; len--) { + b = buf+align; + memcpy(b, abc, len); + for (off = 1; off <= len; off++) { + memcpy(b+off, b, len); + memcpy(b, b+off, len); + if (memcmp(b, abc, len)) + exit(1); + } + } +} +exit(0); +} +EOCP + set try + if eval $compile_ok; then + if ./try 2>/dev/null; then + echo "Yes, it can." + val="$define" + else + echo "It can't, sorry." + case "$d_memmove" in + "$define") echo "But that's Ok since you have memmove()." ;; + esac + fi + else + echo "(I can't compile the test program, so we'll assume not...)" + case "$d_memmove" in + "$define") echo "But that's Ok since you have memmove()." ;; + esac + fi + ;; +esac +$rm -f try.* try core +set d_safemcpy +eval $setvar + +: can memcmp be trusted to compare relative magnitude? +val="$undef" +case "$d_memcmp" in +"$define") + echo " " + echo "Checking if your memcmp() can compare relative magnitude..." >&4 + $cat >try.c <>try.c <<'EOCP' +#include +#ifdef I_MEMORY +# include +#endif +#ifdef I_STDLIB +# include +#endif +#ifdef I_STRING +# include +#else +# include +#endif +#ifdef I_UNISTD +# include /* Needed for NetBSD */ +#endif +int main() +{ +char a = -1; +char b = 0; +if ((a < b) && memcmp(&a, &b, 1) < 0) + exit(1); +exit(0); +} +EOCP + set try + if eval $compile_ok; then + if ./try 2>/dev/null; then + echo "Yes, it can." + val="$define" + else + echo "No, it can't (it uses signed chars)." + fi + else + echo "(I can't compile the test program, so we'll assume not...)" + fi + ;; +esac +$rm -f try.* try core +set d_sanemcmp +eval $setvar + +: see if select exists +set select d_select +eval $inlibc + +: see if semctl exists +set semctl d_semctl +eval $inlibc + +: see if semget exists +set semget d_semget +eval $inlibc + +: see if semop exists +set semop d_semop +eval $inlibc + +: see how much of the 'sem*(2)' library is present. +h_sem=true +echo " " +case "$d_semctl$d_semget$d_semop" in +*"$undef"*) h_sem=false;; +esac +case "$osname" in +freebsd) + case "`ipcs 2>&1`" in + "SVID messages"*"not configured"*) + echo "Your $osname does not have the sem*(2) configured." >&4 + h_sem=false + val="$undef" + set semctl d_semctl + eval $setvar + set semget d_semget + eval $setvar + set semop d_semop + eval $setvar + ;; + esac + ;; +esac +: we could also check for sys/ipc.h ... +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." >&4 + val="$undef" +fi +set d_sem +eval $setvar + +: see whether sys/sem.h defines union semun +echo " " +$cat > try.c <<'END' +#include +#include +#include +int main () { union semun semun; semun.buf = 0; } +END +set try +if eval $compile; then + echo "You have union semun in ." >&4 + val="$define" +else + echo "You do not have union semun in ." >&4 + val="$undef" +fi +$rm -f try try.c try.h +set d_union_semun +eval $setvar + +: see how to do semctl IPC_STAT +case "$d_sem" in +$define) + : see whether semctl IPC_STAT can use union semun + echo " " + $cat > try.h <>3) +# define S_IWGRP (S_IWUSR>>3) +# define S_IXGRP (S_IXUSR>>3) +# define S_IROTH (S_IRUSR>>6) +# define S_IWOTH (S_IWUSR>>6) +# define S_IXOTH (S_IXUSR>>6) +#endif +#ifndef S_IRWXU +# define S_IRWXU (S_IRUSR|S_IWUSR|S_IXUSR) +# define S_IRWXG (S_IRGRP|S_IWGRP|S_IXGRP) +# define S_IRWXO (S_IROTH|S_IWOTH|S_IXOTH) +#endif +END + + $cat > try.c < +#include +#include +#include +#include +#include +#include "try.h" +#ifndef errno +extern int errno; +#endif +#$d_union_semun HAS_UNION_SEMUN +int main() { + union semun +#ifndef HAS_UNION_SEMUN + { + int val; + struct semid_ds *buf; + unsigned short *array; + } +#endif + arg; + int sem, st; + +#if defined(IPC_PRIVATE) && defined(S_IRWXU) && defined(S_IRWXG) && defined(S_IRWXO) && defined(IPC_CREAT) + sem = semget(IPC_PRIVATE, 1, S_IRWXU|S_IRWXG|S_IRWXO|IPC_CREAT); + if (sem > -1) { + struct semid_ds argbuf; + arg.buf = &argbuf; +# ifdef IPC_STAT + st = semctl(sem, 0, IPC_STAT, arg); + if (st == 0) + printf("semun\n"); + else +# endif /* IPC_STAT */ + printf("semctl IPC_STAT failed: errno = %d\n", errno); +# ifdef IPC_RMID + if (semctl(sem, 0, IPC_RMID, arg) != 0) +# endif /* IPC_RMID */ + printf("semctl IPC_RMID failed: errno = %d\n", errno); + } else +#endif /* IPC_PRIVATE && ... */ + printf("semget failed: errno = %d\n", errno); + return 0; +} +END + val="$undef" + set try + if eval $compile; then + xxx=`./try` + case "$xxx" in + semun) val="$define" ;; + esac + fi + $rm -f try try.c + set d_semctl_semun + eval $setvar + case "$d_semctl_semun" in + $define) + echo "You can use union semun for semctl IPC_STAT." >&4 + also='also' + ;; + *) echo "You cannot use union semun for semctl IPC_STAT." >&4 + also='' + ;; + esac + + : see whether semctl IPC_STAT can use struct semid_ds pointer + $cat > try.c <<'END' +#include +#include +#include +#include +#include "try.h" +#include +#include +#ifndef errno +extern int errno; +#endif +int main() { + struct semid_ds arg; + int sem, st; + +#if defined(IPC_PRIVATE) && defined(S_IRWXU) && defined(S_IRWXG) && defined(S_IRWXO) && defined(IPC_CREAT) + sem = semget(IPC_PRIVATE, 1, S_IRWXU|S_IRWXG|S_IRWXO|IPC_CREAT); + if (sem > -1) { +# ifdef IPC_STAT + st = semctl(sem, 0, IPC_STAT, &arg); + if (st == 0) + printf("semid_ds\n"); + else +# endif /* IPC_STAT */ + printf("semctl IPC_STAT failed: errno = %d\n", errno); +# ifdef IPC_RMID + if (semctl(sem, 0, IPC_RMID, &arg) != 0) +# endif /* IPC_RMID */ + printf("semctl IPC_RMID failed: errno = %d\n", errno); + } else +#endif /* IPC_PRIVATE && ... */ + printf("semget failed: errno = %d\n", errno); + + return 0; +} +END + val="$undef" + set try + if eval $compile; then + xxx=`./try` + case "$xxx" in + semid_ds) val="$define" ;; + esac + fi + $rm -f try try.c + set d_semctl_semid_ds + eval $setvar + case "$d_semctl_semid_ds" in + $define) + echo "You can $also use struct semid_ds* for semctl IPC_STAT." >&4 + ;; + *) echo "You cannot use struct semid_ds* for semctl IPC_STAT." >&4 + ;; + esac + $rm -f try.h + ;; +*) val="$undef" + + # We do not have the full sem*(2) library, so assume we can not + # use either. + + set d_semctl_semun + eval $setvar + + set d_semctl_semid_ds + eval $setvar + ;; +esac + +: see if setegid exists +set setegid d_setegid +eval $inlibc + +: see if seteuid exists +set seteuid d_seteuid +eval $inlibc + +: see if setgrent exists +set setgrent d_setgrent +eval $inlibc + +: see if sethostent exists +set sethostent d_sethent +eval $inlibc + +: see if setlinebuf exists +set setlinebuf d_setlinebuf +eval $inlibc + +: see if setlocale exists +set setlocale d_setlocale +eval $inlibc + +: see if setnetent exists +set setnetent d_setnent +eval $inlibc + +: see if setprotoent exists +set setprotoent d_setpent +eval $inlibc + +: see if setpgid exists +set setpgid d_setpgid +eval $inlibc + +: see if setpgrp2 exists +set setpgrp2 d_setpgrp2 +eval $inlibc + +: see if setpriority exists +set setpriority d_setprior +eval $inlibc + +: see if setproctitle exists +set setproctitle d_setproctitle +eval $inlibc + +: see if setpwent exists +set setpwent d_setpwent +eval $inlibc + +: see if setregid exists +set setregid d_setregid +eval $inlibc +set setresgid d_setresgid +eval $inlibc + +: see if setreuid exists +set setreuid d_setreuid +eval $inlibc +set setresuid d_setresuid +eval $inlibc + +: see if setrgid exists +set setrgid d_setrgid +eval $inlibc + +: see if setruid exists +set setruid d_setruid +eval $inlibc + +: see if setservent exists +set setservent d_setsent +eval $inlibc + +: see if setsid exists +set setsid d_setsid +eval $inlibc + +: see if setvbuf exists +set setvbuf d_setvbuf +eval $inlibc + +: see if sfio.h is available +set sfio.h i_sfio +eval $inhdr + + +: see if sfio library is available +case "$i_sfio" in +$define) + val='' + set sfreserve val + eval $inlibc + ;; +*) + val="$undef" + ;; +esac +: Ok, but do we want to use it. +case "$val" in +$define) + case "$usesfio" in + true|$define|[yY]*) dflt='y';; + *) dflt='n';; + esac + echo "$package can use the sfio library, but it is experimental." + case "$useperlio" in + "$undef") + echo "For sfio also the PerlIO abstraction layer is needed." + echo "Earlier you said you wouldn't want that." + ;; + esac + rp="You seem to have sfio available, do you want to try using it?" + . ./myread + case "$ans" in + y|Y) echo "Ok, turning on both sfio and PerlIO, then." + useperlio="$define" + val="$define" + ;; + *) echo "Ok, avoiding sfio this time. I'll use stdio instead." + val="$undef" + : Remove sfio from list of libraries to use + set `echo X $libs | $sed -e 's/-lsfio / /' -e 's/-lsfio$//'` + shift + libs="$*" + echo "libs = $libs" >&4 + ;; + esac + ;; +*) case "$usesfio" in + true|$define|[yY]*) + echo "Sorry, cannot find sfio on this machine." >&4 + echo "Ignoring your setting of usesfio=$usesfio." >&4 + val="$undef" + ;; + esac + ;; +esac +set d_sfio +eval $setvar +case "$d_sfio" in +$define) usesfio='true';; +*) usesfio='false';; +esac + +: see if shmctl exists +set shmctl d_shmctl +eval $inlibc + +: see if shmget exists +set shmget d_shmget +eval $inlibc + +: see if shmat exists +set shmat d_shmat +eval $inlibc +: see what shmat returns +case "$d_shmat" in +"$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 + xxx=`./findhdr sys/shm.h` + $cppstdin $cppflags $cppminus < $xxx > 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 +eval $inlibc + +: see how much of the 'shm*(2)' library is present. +h_shm=true +echo " " +case "$d_shmctl$d_shmget$d_shmat$d_shmdt" in +*"$undef"*) h_shm=false;; +esac +case "$osname" in +freebsd) + case "`ipcs 2>&1`" in + "SVID shared memory"*"not configured"*) + echo "Your $osname does not have the shm*(2) configured." >&4 + h_shm=false + val="$undef" + set shmctl d_shmctl + evat $setvar + set shmget d_shmget + evat $setvar + set shmat d_shmat + evat $setvar + set shmdt d_shmdt + evat $setvar + ;; + esac + ;; +esac +: we could also check for sys/ipc.h ... +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." >&4 + val="$undef" +fi +set d_shm +eval $setvar + +echo " " +: see if we have sigaction +if set sigaction val -f d_sigaction; eval $csym; $val; then + echo 'sigaction() found.' >&4 + $cat > try.c <<'EOP' +#include +#include +#include +int main() +{ + struct sigaction act, oact; + act.sa_flags = 0; + oact.sa_handler = 0; + /* so that act and oact are used */ + exit(act.sa_flags == 0 && oact.sa_handler == 0); +} +EOP + set try + if eval $compile_ok; then + val="$define" + else + echo "But you don't seem to have a useable struct sigaction." >&4 + val="$undef" + fi +else + echo 'sigaction NOT found.' >&4 + val="$undef" +fi +set d_sigaction; eval $setvar +$rm -f try try$_o try.c + +: see if sigsetjmp exists +echo " " +case "$d_sigsetjmp" in +'') + $cat >try.c <<'EOP' +#include +sigjmp_buf env; +int set = 1; +int main() +{ + if (sigsetjmp(env,1)) + exit(set); + set = 0; + siglongjmp(env, 1); + exit(1); +} +EOP + set try + if eval $compile; then + if ./try >/dev/null 2>&1; then + echo "POSIX sigsetjmp found." >&4 + val="$define" + else + $cat >&4 <&4 + val="$undef" + fi + ;; +*) val="$d_sigsetjmp" + case "$d_sigsetjmp" in + $define) echo "POSIX sigsetjmp found." >&4;; + $undef) echo "sigsetjmp not found." >&4;; + esac + ;; +esac +set d_sigsetjmp +eval $setvar +$rm -f try.c try + +: see if socks5_init exists +set socks5_init d_socks5_init +eval $inlibc + +: see if sys/stat.h is available +set sys/stat.h i_sysstat +eval $inhdr + + +: see if stat knows about block sizes +echo " " +echo "Checking to see if your struct stat has st_blocks field..." >&4 +set d_statblks stat st_blocks $i_sysstat sys/stat.h +eval $hasfield + + +: see if this is a sys/vfs.h system +set sys/vfs.h i_sysvfs +eval $inhdr + + +: see if this is a sys/statfs.h system +set sys/statfs.h i_sysstatfs +eval $inhdr + + +echo " " +echo "Checking to see if your system supports struct statfs..." >&4 +set d_statfs_s statfs $i_systypes sys/types.h $i_sysparam sys/param.h $i_sysmount sys/mount.h $i_sysvfs sys/vfs.h $i_sysstatfs sys/statfs.h +eval $hasstruct +case "$d_statfs_s" in +"$define") echo "Yes, it does." ;; +*) echo "No, it doesn't." ;; +esac + + + +: see if struct statfs knows about f_flags +case "$d_statfs_s" in +define) + echo " " + echo "Checking to see if your struct statfs has f_flags field..." >&4 + set d_statfs_f_flags statfs f_flags $i_systypes sys/types.h $i_sysparam sys/param.h $i_sysmount sys/mount.h $i_sysvfs sys/vfs.h $i_sysstatfs sys/statfs.h + eval $hasfield + ;; +*) val="$undef" + set d_statfs_f_flags + eval $setvar + ;; +esac +case "$d_statfs_f_flags" in +"$define") echo "Yes, it does." ;; +*) echo "No, it doesn't." ;; +esac + +: see if _ptr and _cnt from stdio act std +echo " " +if $contains '_IO_fpos_t' `./findhdr stdio.h` `./findhdr libio.h` >/dev/null 2>&1 ; then + echo "(Looks like you have stdio.h from Linux.)" + case "$stdio_ptr" in + '') stdio_ptr='((fp)->_IO_read_ptr)' + ptr_lval=$define + ;; + *) ptr_lval=$d_stdio_ptr_lval;; + esac + case "$stdio_cnt" in + '') stdio_cnt='((fp)->_IO_read_end - (fp)->_IO_read_ptr)' + cnt_lval=$undef + ;; + *) cnt_lval=$d_stdio_cnt_lval;; + esac + case "$stdio_base" in + '') stdio_base='((fp)->_IO_read_base)';; + esac + case "$stdio_bufsiz" in + '') stdio_bufsiz='((fp)->_IO_read_end - (fp)->_IO_read_base)';; + esac +else + case "$stdio_ptr" in + '') stdio_ptr='((fp)->_ptr)' + ptr_lval=$define + ;; + *) ptr_lval=$d_stdio_ptr_lval;; + esac + case "$stdio_cnt" in + '') stdio_cnt='((fp)->_cnt)' + cnt_lval=$define + ;; + *) cnt_lval=$d_stdio_cnt_lval;; + esac + case "$stdio_base" in + '') stdio_base='((fp)->_base)';; + esac + case "$stdio_bufsiz" in + '') stdio_bufsiz='((fp)->_cnt + (fp)->_ptr - (fp)->_base)';; + esac +fi +: test whether _ptr and _cnt really work +echo "Checking how std your stdio is..." >&4 +$cat >try.c < +#define FILE_ptr(fp) $stdio_ptr +#define FILE_cnt(fp) $stdio_cnt +int main() { + FILE *fp = fopen("try.c", "r"); + char c = getc(fp); + if ( + 18 <= FILE_cnt(fp) && + strncmp(FILE_ptr(fp), "include \n", 18) == 0 + ) + exit(0); + exit(1); +} +EOP +val="$undef" +set try +if eval $compile; then + if ./try; then + echo "Your stdio acts pretty std." + val="$define" + else + echo "Your stdio isn't very std." + fi +else + echo "Your stdio doesn't appear very std." +fi +$rm -f try.c try +set d_stdstdio +eval $setvar + +: Can _ptr be used as an lvalue? +case "$d_stdstdio$ptr_lval" in +$define$define) val=$define ;; +*) val=$undef ;; +esac +set d_stdio_ptr_lval +eval $setvar + +: Can _cnt be used as an lvalue? +case "$d_stdstdio$cnt_lval" in +$define$define) val=$define ;; +*) val=$undef ;; +esac +set d_stdio_cnt_lval +eval $setvar + + +: test whether setting _ptr sets _cnt as a side effect +d_stdio_ptr_lval_sets_cnt="$undef" +d_stdio_ptr_lval_nochange_cnt="$undef" +case "$d_stdio_ptr_lval$d_stdstdio" in +$define$define) + echo "Checking to see what happens if we set the stdio ptr..." >&4 +$cat >try.c < +/* Can we scream? */ +/* Eat dust sed :-) */ +#define FILE_ptr(fp) $stdio_ptr +#define FILE_cnt(fp) $stdio_cnt +int main() { + FILE *fp = fopen("try.c", "r"); + char c = getc(fp); + char *ptr; + size_t cnt; + if (!( + 18 <= FILE_cnt(fp) && + strncmp(FILE_ptr(fp), "include \n", 18) == 0 + )) { + puts("Fail even to read"); + exit (1); + } + ptr = FILE_ptr(fp); + cnt = FILE_cnt(fp); + + FILE_ptr(fp)+= 42; + + if (FILE_ptr(fp) != (ptr + 42)) { + printf("Fail ptr check %p != %p", FILE_ptr(fp), (ptr + 42)); + exit (1); + } + if (FILE_cnt(fp) <= 20) { + printf ("Fail (<20 chars to test)"); + exit (1); + } + if (strncmp(FILE_ptr(fp), "Eat dust sed :-) */\n", 20) != 0) { + puts("Fail compare"); + exit (1); + } + if (cnt == FILE_cnt(fp)) { + puts("Pass_unchanged"); + exit (0); + } + if (FILE_cnt(fp) == (cnt - 42)) { + puts("Pass_changed"); + exit (0); + } + printf("Fail count was %d now %d\n", cnt, FILE_cnt(fp)); + return 1; + +} +EOP + set try + if eval $compile; then + case `./try$exe_ext` in + Pass_changed) + echo "Increasing ptr in your stdio decreases cnt by the same amount. Good." >&4 + d_stdio_ptr_lval_sets_cnt="$define" ;; + Pass_unchanged) + echo "Increasing ptr in your stdio leaves cnt unchanged. Good." >&4 + d_stdio_ptr_lval_nochange_cnt="$define" ;; + Fail*) + echo "Increasing ptr in your stdio didn't do exactly what I expected. We'll not be doing that then." >&4 ;; + *) + echo "It appears attempting to set ptr in your stdio is a bad plan." >&4 ;; + esac + else + echo "It seems we can't set ptr in your stdio. Nevermind." >&4 + fi + $rm -f try.c try + ;; +esac + +: see if _base is also standard +val="$undef" +case "$d_stdstdio" in +$define) + $cat >try.c < +#define FILE_base(fp) $stdio_base +#define FILE_bufsiz(fp) $stdio_bufsiz +int main() { + FILE *fp = fopen("try.c", "r"); + char c = getc(fp); + if ( + 19 <= FILE_bufsiz(fp) && + strncmp(FILE_base(fp), "#include \n", 19) == 0 + ) + exit(0); + exit(1); +} +EOP + set try + if eval $compile; then + if ./try; then + echo "And its _base field acts std." + val="$define" + else + echo "But its _base field isn't std." + fi + else + echo "However, it seems to be lacking the _base field." + fi + $rm -f try.c try + ;; +esac +set d_stdiobase +eval $setvar + +$cat >&4 <try.c < +int main() { + if (&STDIO_STREAM_ARRAY[fileno(stdin)] == stdin) + printf("yes\n"); +} +EOCP + for s in _iob __iob __sF + do + set try -DSTDIO_STREAM_ARRAY=$s + if eval $compile; then + case "`./try$exe_ext`" in + yes) stdio_stream_array=$s; break ;; + esac + fi + done + $rm -f try.* try$exe_ext +esac +case "$stdio_stream_array" in +'') $cat >&4 <&4 <&4 +$cat >try.c <<'EOCP' +int main() +{ + struct blurfl { + int dyick; + } foo, bar; + + foo = bar; +} +EOCP +if $cc -c try.c >/dev/null 2>&1 ; then + val="$define" + echo "Yup, it can." +else + val="$undef" + echo "Nope, it can't." +fi +set d_strctcpy +eval $setvar +$rm -f try.* + +: see if strerror and/or sys_errlist[] exist +echo " " +if test "X$d_strerror" = X -o "X$d_syserrlst" = X; then + 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 'strerror() and sys_errlist[] NOT found.' >&4 + d_strerror="$undef" + d_syserrlst="$undef" + d_strerrm='"unknown"' + fi +fi + +: see if strtod exists +set strtod d_strtod +eval $inlibc + +: see if strtol exists +set strtol d_strtol +eval $inlibc + +: see if strtold exists +set strtold d_strtold +eval $inlibc + +: see if strtoll exists +set strtoll d_strtoll +eval $inlibc + +case "$d_longlong-$d_strtoll" in +"$define-$define") + $cat <try.c <<'EOCP' +#include +#ifdef __hpux +#define strtoll __strtoll +#endif +#ifdef __EMX__ +#define strtoll _strtoll +#endif +#include +extern long long int strtoll(char *s, char **, int); +static int bad = 0; +int check(char *s, long long ell, int een) { + long long gll; + errno = 0; + gll = strtoll(s, 0, 10); + if (!((gll == ell) && (errno == een))) + bad++; +} +int main() { + check(" 1", 1LL, 0); + check(" 0", 0LL, 0); + check("-1", -1LL, 0); + check("-9223372036854775808", -9223372036854775808LL, 0); + check("-9223372036854775808", -9223372036854775808LL, 0); + check(" 9223372036854775807", 9223372036854775807LL, 0); + check("-9223372036854775808", -9223372036854775808LL, 0); + check(" 9223372036854775808", 9223372036854775807LL, ERANGE); + check("-9223372036854775809", -9223372036854775808LL, ERANGE); + if (!bad) + printf("ok\n"); +} +EOCP + set try + if eval $compile; then + yyy=`./try` + case "$yyy" in + ok) echo "Your strtoll() seems to be working okay." ;; + *) cat <&4 +Your strtoll() doesn't seem to be working okay. +EOM + d_strtoll="$undef" + ;; + esac + else + echo "(I can't seem to compile the test program--assuming it doesn't)" + d_strtoll="$undef" + fi + ;; +esac + +: see if strtoul exists +set strtoul d_strtoul +eval $inlibc + +: see if strtoull exists +set strtoull d_strtoull +eval $inlibc + +case "$d_longlong-$d_strtoull" in +"$define-$define") + $cat <try.c <<'EOCP' +#include +#ifdef __hpux +#define strtoull __strtoull +#endif +#include +extern unsigned long long int strtoull(char *s, char **, int); +static int bad = 0; +int check(char *s, long long eull, int een) { + long long gull; + errno = 0; + gull = strtoull(s, 0, 10); + if (!((gull == eull) && (errno == een))) + bad++; +} +int main() { + check(" 1", 1LL, 0); + check(" 0", 0LL, 0); + check("18446744073709551615", 18446744073709551615ULL, 0); + check("18446744073709551616", 18446744073709551615ULL, ERANGE); + if (!bad) + printf("ok\n"); +} +EOCP + set try + if eval $compile; then + case "`./try`" in + ok) echo "Your strtoull() seems to be working okay." ;; + *) cat <&4 +Your strtoull() doesn't seem to be working okay. +EOM + d_strtoull="$undef" + ;; + esac + fi + ;; +esac + +: see if strtouq exists +set strtouq d_strtouq +eval $inlibc + +: 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 + +: see if prototype for telldir is available +echo " " +set d_telldirproto telldir $i_systypes sys/types.h $i_dirent dirent.h +eval $hasproto + +: 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 + rp="What is the type returned by times() on this system?" + set clock_t clocktype long stdio.h sys/types.h $inc + eval $typedef_ask +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 + +: see if umask exists +set umask d_umask +eval $inlibc + +: see if ustat exists +set ustat d_ustat +eval $inlibc + +: 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 + cat <<'EOM' + +Perl can only use a vfork() that doesn't suffer from strict +restrictions on calling functions or modifying global data in +the child. For example, glibc-2.1 contains such a vfork() +that is unsuitable. If your system provides a proper fork() +call, chances are that you do NOT want perl to use vfork(). + +EOM + rp="Do you still want to use vfork()?" + . ./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 < +#endif +#if defined(I_DIRENT) +#include +#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 + set closedir + if eval $compile_ok; 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 knows about "volatile"...' >&4 +$cat >try.c <<'EOCP' +int main() +{ + 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 $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 + +: see if waitpid exists +set waitpid d_waitpid +eval $inlibc + +: see if wcstombs exists +set wcstombs d_wcstombs +eval $inlibc + +: see if wctomb exists +set wctomb d_wctomb +eval $inlibc + +: preserve RCS keywords in files with variable substitution, grrr +Date='$Date' +Id='$Id' +Log='$Log' +RCSfile='$RCSfile' +Revision='$Revision' + +case "$crosscompile" in +''|[nN]*) crosscompile="$undef" ;; +esac + +case "$osname" in +next|rhapsody|darwin) multiarch="$define" ;; +esac +case "$multiarch" in +''|[nN]*) multiarch="$undef" ;; +esac + +: check for alignment requirements +echo " " +case "$crosscompile$multiarch" in +*$define*) + $cat <&4 + if $test "X$uselongdouble" = Xdefine -a "X$d_longdbl" = Xdefine; then + $cat >try.c <<'EOCP' +typedef long double NV; +EOCP + else + $cat >try.c <<'EOCP' +typedef double NV; +EOCP + fi + $cat >>try.c <<'EOCP' +#include +struct foobar { + char foo; + NV bar; +} try_algn; +int main() +{ + printf("%d\n", (int)((char *)&try_algn.bar - (char *)&try_algn.foo)); + return(0); +} +EOCP + set try + if eval $compile_ok; 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 + ;; +esac + + +: set the base revision +baserev=5.0 + +: check for ordering of bytes in a long +echo " " +case "$crosscompile$multiarch" in +*$define*) + $cat <try.c <<'EOCP' +#include +int 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"); + exit(0); +} +EOCP + xxx_prompt=y + set try + if eval $compile && ./try > /dev/null; then + dflt=`./try` + case "$dflt" in + [1-4][1-4][1-4][1-4]|12345678|87654321) + echo "(The test program ran ok.)" + echo "byteorder=$dflt" + xxx_prompt=n + ;; + ????|????????) 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 + case "$xxx_prompt" in + y) + rp="What is the order of bytes in a long?" + . ./myread + byteorder="$ans" + ;; + *) byteorder=$dflt + ;; + esac + ;; + esac + $rm -f try.c try + ;; +esac + + +: how do we catenate cpp tokens here? +echo " " +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." >&4 + 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!" >&4 + 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 < +#include +#include +int main() +{ +#ifdef DB_VERSION_MAJOR /* DB version >= 2 */ + int Major, Minor, Patch ; + unsigned long Version ; + (void)db_version(&Major, &Minor, &Patch) ; + printf("You have Berkeley DB Version 2 or greater\n"); + + printf("db.h is from Berkeley DB Version %d.%d.%d\n", + DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH); + printf("libdb is from Berkeley DB Version %d.%d.%d\n", + Major, Minor, Patch) ; + + /* check that db.h & libdb are compatible */ + if (DB_VERSION_MAJOR != Major || DB_VERSION_MINOR != Minor || DB_VERSION_PATCH != Patch) { + printf("db.h and libdb are incompatible\n") ; + exit(3); + } + + printf("db.h and libdb are compatible\n") ; + + Version = DB_VERSION_MAJOR * 1000000 + DB_VERSION_MINOR * 1000 + + DB_VERSION_PATCH ; + + /* needs to be >= 2.3.4 */ + if (Version < 2003004) { + /* if (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && DB_VERSION_PATCH < 5) { */ + printf("but Perl needs Berkeley DB 2.3.4 or greater\n") ; + exit(2); + } + + exit(0); +#else +#if defined(_DB_H_) && defined(BTREEMAGIC) && defined(HASHMAGIC) + printf("You have Berkeley DB Version 1\n"); + exit(0); /* DB version < 2: the coast is clear. */ +#else + exit(1); /* not Berkeley DB? */ +#endif +#endif +} +EOCP + set try + if eval $compile_ok && ./try; then + echo 'Looks OK.' >&4 + else + echo "I can't use Berkeley DB with your . I'll disable Berkeley DB." >&4 + i_db=$undef + case " $libs " in + *"-ldb "*) + : Remove db from list of libraries to use + echo "Removing unusable -ldb from library list" >&4 + set `echo X $libs | $sed -e 's/-ldb / /' -e 's/-ldb$//'` + shift + libs="$*" + echo "libs = $libs" >&4 + ;; + esac + fi + $rm -f try.* + ;; +esac + +case "$i_db" in +define) + : Check the return type needed for hash + echo " " + echo "Checking return type needed for hash for Berkeley DB ..." >&4 + $cat >try.c < +#include + +#ifndef DB_VERSION_MAJOR +u_int32_t hash_cb (ptr, size) +const void *ptr; +size_t size; +{ +} +HASHINFO info; +int main() +{ + info.hash = hash_cb; +} +#endif +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 + : XXX Maybe we should just give up here. + db_hashtype=u_int32_t + $cat try.out >&4 + echo "Help: I can't seem to compile the db test program." >&4 + echo "Something's wrong, but I'll assume you use $db_hashtype." >&4 + fi + $rm -f try.* + echo "Your version of Berkeley DB uses $db_hashtype for hash." + ;; +*) db_hashtype=u_int32_t + ;; +esac +case "$i_db" in +define) + : Check the return type needed for prefix + echo " " + echo "Checking return type needed for prefix for Berkeley DB ..." >&4 + cat >try.c < +#include + +#ifndef DB_VERSION_MAJOR +size_t prefix_cb (key1, key2) +const DBT *key1; +const DBT *key2; +{ +} +BTREEINFO info; +int main() +{ + info.prefix = prefix_cb; +} +#endif +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 + db_prefixtype='size_t' + : XXX Maybe we should just give up here. + $cat try.out >&4 + echo "Help: I can't seem to compile the db test program." >&4 + echo "Something's wrong, but I'll assume you use $db_prefixtype." >&4 + fi + $rm -f try.* + echo "Your version of Berkeley DB uses $db_prefixtype for prefix." + ;; +*) db_prefixtype='size_t' + ;; +esac + +: check for void type +echo " " +echo "Checking to see how well your C compiler groks the void type..." >&4 +case "$voidflags" in +'') + $cat >try.c <<'EOCP' +#if TRY & 1 +void sub() { +#else +sub() { +#endif + extern void moo(); /* function returning void */ + void (*goo)(); /* ptr to func returning void */ +#if TRY & 8 + void *hue; /* generic ptr */ +#endif +#if TRY & 2 + void (*foo[10])(); +#endif + +#if TRY & 4 + if(goo == moo) { + exit(0); + } +#endif + exit(0); +} +int main() { sub(); } +EOCP + if $cc $ccflags -c -DTRY=$defvoidused try.c >.out 2>&1 ; then + voidflags=$defvoidused + echo "Good. It appears to support void to the level $package wants.">&4 + 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 $ccflags -c -DTRY=1 try.c >/dev/null 2>&1; then + echo "It supports 1..." + if $cc $ccflags -c -DTRY=3 try.c >/dev/null 2>&1; then + echo "It also supports 2..." + if $cc $ccflags -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 $ccflags -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 $ccflags -c -DTRY=13 try.c >/dev/null 2>&1; then + voidflags=13 + echo "But it supports 4 and 8." + else + if $cc $ccflags -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 +case "$voidflags" in +"$defvoidused") ;; +*) $cat >&4 <<'EOM' + Support flag bits are: + 1: basic void declarations. + 2: arrays of pointers to functions returning void. + 4: operations between pointers to and addresses of void functions. + 8: generic void pointers. +EOM + dflt="$voidflags"; + rp="Your void support flags add up to what?" + . ./myread + voidflags="$ans" + ;; +esac +$rm -f try.* .out + + +: How can we generate normalized random numbers ? +echo " " +echo "Looking for a random number function..." >&4 +case "$randfunc" in +'') + if set drand48 val -f; eval $csym; $val; then + dflt="drand48" + echo "Good, found drand48()." >&4 + elif set random val -f; eval $csym; $val; then + dflt="random" + echo "OK, found random()." >&4 + else + dflt="rand" + echo "Yick, looks like I have to use rand()." >&4 + fi + echo " " + ;; +*) + dflt="$randfunc" + ;; +esac +cont=true + +case "$ccflags" in +*-Dmy_rand=*|*-Dmy_srand=*) + echo "Removing obsolete -Dmy_rand, -Dmy_srand, and -Drandbits from ccflags." >&4 + ccflags="`echo $ccflags | sed -e 's/-Dmy_rand=random/ /'`" + ccflags="`echo $ccflags | sed -e 's/-Dmy_srand=srandom/ /'`" + ccflags="`echo $ccflags | sed -e 's/-Drandbits=[0-9][0-9]*/ /'`" + ;; +esac + +while $test "$cont"; do + rp="Use which function to generate random numbers?" + . ./myread + if $test "$ans" = "$dflt"; then + : null + else + randbits='' + fi + randfunc="$ans" + if set $ans val -f; eval $csym; $val; then + cont='' + else + dflt=y + rp="I cannot find function $ans. Use that name anyway?" + . ./myread + dflt=rand + case "$ans" in + [yY]*) cont='';; + esac + fi + case "$cont" in + '') + case "$randfunc" in + drand48) + drand01="drand48()" + seedfunc="srand48" + randbits=48 + randseedtype=long + ;; + rand|random) + case "$randbits" in + '') +echo "Checking to see how many bits your $randfunc() function produces..." >&4 + $cat >try.c < +#ifdef I_UNISTD +# include +#endif +#ifdef I_STDLIB +# include +#endif +int main() +{ + register int i; + register unsigned long tmp; + register unsigned long max = 0L; + + for (i = 1000; i; i--) { + tmp = (unsigned long) $randfunc(); + if (tmp > max) max = tmp; + } + for (i = 0; max; i++) + max /= 2; + printf("%d\n",i); +} +EOCP + set try + if eval $compile_ok; then + dflt=`try` + else + dflt='?' + echo "(I can't seem to compile the test program...)" + fi + ;; + *) + dflt="$randbits" + ;; + esac + rp="How many bits does your $randfunc() function produce?" + . ./myread + randbits="$ans" + $rm -f try.c try + drand01="($randfunc() / (double) ((unsigned long)1 << $randbits))" + seedfunc="s$randfunc" + randseedtype=unsigned + ;; + *) + dflt="31" + rp="How many bits does your $randfunc() function produce?" + . ./myread + randbits="$ans" + seedfunc="s$randfunc" + drand01="($randfunc() / (double) ((unsigned long)1 << $randbits))" + if set $seedfunc val -f; eval $csym; $val; then + echo "(Using $seedfunc() to seed random generator)" + else + echo "(Warning: no $seedfunc() to seed random generator)" + seedfunc=rand + fi + randseedtype=unsigned + ;; + esac + ;; + esac +done + +echo " " +echo "Determining whether or not we are on an EBCDIC system..." >&4 +$cat >tebcdic.c <<'EOM' +int main() +{ + if ('M'==0xd4) return 0; + return 1; +} +EOM + +val=$undef +set tebcdic +if eval $compile_ok; then + if ./tebcdic; then + echo "You seem to speak EBCDIC." >&4 + val="$define" + else + echo "Nope, no EBCDIC, probably ASCII or some ISO Latin. Or UTF8." >&4 + fi +else + echo "I'm unable to compile the test program." >&4 + echo "I'll assume ASCII or some ISO Latin. Or UTF8." >&4 +fi +$rm -f tebcdic.c tebcdic +set ebcdic +eval $setvar + +echo " " +$cat >&4 < try.c ;; +esac +$cat >>try.c < +#$i_unistd I_UNISTD +#ifdef I_UNISTD +# include +#endif +#$d_sysconf HAS_SYSCONF +#$d_stdio_stream_array HAS_STDIO_STREAM_ARRAY +#ifdef HAS_STDIO_STREAM_ARRAY +# define STDIO_STREAM_ARRAY $stdio_stream_array +#endif +int main() { + FILE* p = fopen("try.out", "w"); +#ifdef TRY_FPUTC + fputc('x', p); +#else +# ifdef TRY_FPRINTF + fprintf(p, "x"); +# endif +#endif +#ifdef TRY_FFLUSH_NULL + fflush(NULL); +#endif +#ifdef TRY_FFLUSH_ALL + { + long open_max = -1; +# ifdef PERL_FFLUSH_ALL_FOPEN_MAX + open_max = PERL_FFLUSH_ALL_FOPEN_MAX; +# else +# if defined(HAS_SYSCONF) && defined(_SC_OPEN_MAX) + open_max = sysconf(_SC_OPEN_MAX); +# else +# ifdef FOPEN_MAX + open_max = FOPEN_MAX; +# else +# ifdef OPEN_MAX + open_max = OPEN_MAX; +# else +# ifdef _NFILE + open_max = _NFILE; +# endif +# endif +# endif +# endif +# endif +# ifdef HAS_STDIO_STREAM_ARRAY + if (open_max > 0) { + long i; + for (i = 0; i < open_max; i++) + if (STDIO_STREAM_ARRAY[i]._file >= 0 && + STDIO_STREAM_ARRAY[i]._file < open_max && + STDIO_STREAM_ARRAY[i]._flag) + fflush(&STDIO_STREAM_ARRAY[i]); + } + } +# endif +#endif + _exit(42); +} +EOCP +: first we have to find out how _not_ to flush +if $test "X$fflushNULL" = X -o "X$fflushall" = X; then + output='' + set try -DTRY_FPUTC + if eval $compile; then + $rm -f try.out + ./try$exe_ext 2>/dev/null + if $test ! -s try.out -a "X$?" = X42; then + output=-DTRY_FPUTC + fi + fi + case "$output" in + '') + set try -DTRY_FPRINTF + $rm -f try.out + if eval $compile; then + $rm -f try.out + ./try$exe_ext 2>/dev/null + if $test ! -s try.out -a "X$?" = X42; then + output=-DTRY_FPRINTF + fi + fi + ;; + esac +fi +: check for fflush NULL behaviour +case "$fflushNULL" in +'') set try -DTRY_FFLUSH_NULL $output + if eval $compile; then + $rm -f try.out + ./try$exe_ext 2>/dev/null + code="$?" + if $test -s try.out -a "X$code" = X42; then + fflushNULL="`$cat try.out`" + else + if $test "X$code" != X42; then + $cat >&4 <&4 <tryp.c < +int +main(int argc, char **argv) +{ + char buf[1024]; + int i; + char *bp = buf; + while (1) { + while ((i = getc(stdin)) != -1 + && (*bp++ = i) != '\n' + && bp < &buf[1024]) + /* DO NOTHING */ ; + *bp = '\0'; + fprintf(stdout, "%s", buf); + fflush(NULL); + if (i == -1) + return 0; + bp = buf; + } +} +EOCP + fflushNULL="$define" + set tryp + if eval $compile; then + $rm -f tryp.out + $cat tryp.c | ./tryp$exe_ext 2>/dev/null > tryp.out + if cmp tryp.c tryp.out >/dev/null 2>&1; then + $cat >&4 <&4 <&4 <&4 <tryp.c < +int +main(int argc, char **argv) +{ + char buf[1024]; + int i; + char *bp = buf; + while (1) { + while ((i = getc(stdin)) != -1 + && (*bp++ = i) != '\n' + && bp < &buf[1024]) + /* DO NOTHING */ ; + *bp = '\0'; + fprintf(stdout, "%s", buf); + fflush(stdin); + if (i == -1) + return 0; + bp = buf; + } +} +EOCP + set tryp + if eval $compile; then + $rm -f tryp.out + $cat tryp.c | ./tryp$exe_ext 2>/dev/null > tryp.out + if cmp tryp.c tryp.out >/dev/null 2>&1; then + $cat >&4 <&4 </dev/null + if $test -s try.out -a "X$?" = X42; then + fflushall="`$cat try.out`" + fi + fi + $rm -f core try.core core.try.* + case "$fflushall" in + x) $cat >&4 <&4 <&4 <&4 </dev/null` unsigned short + case $1 in + unsigned) dflt="$1 $2" ;; + *) dflt="$1" ;; + esac + ;; +*) dflt="$gidtype";; +esac +case "$gidtype" in +gid_t) echo "gid_t found." ;; +*) rp="What is the type for group ids returned by getgid()?" + . ./myread + gidtype="$ans" + ;; +esac + +echo " " +case "$gidtype" in +*_t) zzz="$gidtype" ;; +*) zzz="gid" ;; +esac +echo "Checking the size of $zzz..." >&4 +cat > try.c < +#include +int main() { + printf("%d\n", (int)sizeof($gidtype)); + exit(0); +} +EOCP +set try +if eval $compile_ok; then + yyy=`./try` + case "$yyy" in + '') gidsize=4 + echo "(I can't execute the test program--guessing $gidsize.)" >&4 + ;; + *) gidsize=$yyy + echo "Your $zzz is $gidsize bytes long." + ;; + esac +else + gidsize=4 + echo "(I can't compile the test program--guessing $gidsize.)" >&4 +fi + + +echo " " +case "$gidtype" in +*_t) zzz="$gidtype" ;; +*) zzz="gid" ;; +esac +echo "Checking the sign of $zzz..." >&4 +cat > try.c < +#include +int main() { + $gidtype foo = -1; + if (foo < 0) + printf("-1\n"); + else + printf("1\n"); +} +EOCP +set try +if eval $compile; then + yyy=`./try` + case "$yyy" in + '') gidsign=1 + echo "(I can't execute the test program--guessing unsigned.)" >&4 + ;; + *) gidsign=$yyy + case "$gidsign" in + 1) echo "Your $zzz is unsigned." ;; + -1) echo "Your $zzz is signed." ;; + esac + ;; + esac +else + gidsign=1 + echo "(I can't compile the test program--guessing unsigned.)" >&4 +fi + + +echo " " + +if $test X"$quadtype" != X; then + +echo "Checking how to print 64-bit integers..." >&4 + +if $test X"$sPRId64" = X -a X"$quadtype" = Xint; then + $cat >try.c <<'EOCP' +#include +#include +int main() { + int q = 12345678901; + printf("%ld\n", q); +} +EOCP + set try + if eval $compile; then + yyy=`./try$exe_ext` + case "$yyy" in + 12345678901) + sPRId64='"d"'; sPRIi64='"i"'; sPRIu64='"u"'; + sPRIo64='"o"'; sPRIx64='"x"'; sPRIXU64='"X"'; + echo "We will use %d." + ;; + esac + fi +fi + +if $test X"$sPRId64" = X -a X"$quadtype" = Xlong; then + $cat >try.c <<'EOCP' +#include +#include +int main() { + long q = 12345678901; + printf("%ld\n", q); +} +EOCP + set try + if eval $compile; then + yyy=`./try$exe_ext` + case "$yyy" in + 12345678901) + sPRId64='"ld"'; sPRIi64='"li"'; sPRIu64='"lu"'; + sPRIo64='"lo"'; sPRIx64='"lx"'; sPRIXU64='"lX"'; + echo "We will use %ld." + ;; + esac + fi +fi + +if $test X"$sPRId64" = X -a X"$i_inttypes" = X"$define" -a X"$quadtype" = Xint64_t; then + $cat >try.c <<'EOCP' +#include +#include +#include +int main() { + int64_t q = 12345678901; + printf("%" PRId64 "\n", q); +} +EOCP + set try + if eval $compile; then + yyy=`./try$exe_ext` + case "$yyy" in + 12345678901) + sPRId64=PRId64; sPRIi64=PRIi64; sPRIu64=PRIu64; + sPRIo64=PRIo64; sPRIx64=PRIx64; sPRIXU64=PRIXU64; + echo "We will use the C9X style." + ;; + esac + fi +fi + +if $test X"$sPRId64" = X -a X"$quadtype" = X"long long"; then + $cat >try.c <<'EOCP' +#include +#include +int main() { + long long q = 12345678901LL; /* AIX cc requires the LL suffix. */ + printf("%lld\n", q); +} +EOCP + set try + if eval $compile; then + yyy=`./try$exe_ext` + case "$yyy" in + 12345678901) + sPRId64='"lld"'; sPRIi64='"lli"'; sPRIu64='"llu"'; + sPRIo64='"llo"'; sPRIx64='"llx"'; sPRIXU64='"llX"'; + echo "We will use the %lld style." + ;; + esac + fi +fi + +if $test X"$sPRId64" = X -a X"$quadtype" != X; then + $cat >try.c < +#include +int main() { + $quadtype q = 12345678901; + printf("%Ld\n", q); +} +EOCP + set try + if eval $compile; then + yyy=`./try$exe_ext` + case "$yyy" in + 12345678901) + sPRId64='"Ld"'; sPRIi64='"Li"'; sPRIu64='"Lu"'; + sPRIo64='"Lo"'; sPRIx64='"Lx"'; sPRIXU64='"LX"'; + echo "We will use %Ld." + ;; + esac + fi +fi + +if $test X"$sPRId64" = X -a X"$quadtype" != X; then + $cat >try.c < +#include +int main() { + $quadtype q = 12345678901; + printf("%qd\n", q); +} +EOCP + set try + if eval $compile; then + yyy=`./try$exe_ext` + case "$yyy" in + 12345678901) + sPRId64='"qd"'; sPRIi64='"qi"'; sPRIu64='"qu"'; + sPRIo64='"qo"'; sPRIx64='"qx"'; sPRIXU64='"qX"'; + echo "We will use %qd." + ;; + esac + fi +fi + +if $test X"$sPRId64" = X; then + echo "Cannot figure out how to print 64-bit integers." >&4 +fi + +$rm -f try try.* + +fi + +case "$sPRId64" in +'') d_PRId64="$undef"; d_PRIi64="$undef"; d_PRIu64="$undef"; + d_PRIo64="$undef"; d_PRIx64="$undef"; d_PRIXU64="$undef"; + ;; +*) d_PRId64="$define"; d_PRIi64="$define"; d_PRIu64="$define"; + d_PRIo64="$define"; d_PRIx64="$define"; d_PRIXU64="$define"; + ;; +esac + + +echo " " +$echo "Checking the format strings to be used for Perl's internal types..." >&4 + +if $test X"$ivsize" = X8; then + ivdformat="$sPRId64" + uvuformat="$sPRIu64" + uvoformat="$sPRIo64" + uvxformat="$sPRIx64" + uvXUformat="$sPRIXU64" +else + if $test X"$ivsize" = X"$longsize"; then + ivdformat='"ld"' + uvuformat='"lu"' + uvoformat='"lo"' + uvxformat='"lx"' + uvXUformat='"lX"' + else + if $test X"$ivsize" = X"$intsize"; then + ivdformat='"d"' + uvuformat='"u"' + uvoformat='"o"' + uvxformat='"x"' + uvXUformat='"X"' + else + : far out + if $test X"$ivsize" = X"$shortsize"; then + ivdformat='"hd"' + uvuformat='"hu"' + uvoformat='"ho"' + uvxformat='"hx"' + uvXUformat='"hX"' + fi + fi + fi +fi + +if $test X"$uselongdouble" = X"$define" -a X"$d_longdbl" = X"$define" -a X"$d_PRIgldbl" = X"$define"; then + nveformat="$sPRIeldbl" + nvfformat="$sPRIfldbl" + nvgformat="$sPRIgldbl" + nvEUformat="$sPRIEUldbl" + nvFUformat="$sPRIFUldbl" + nvGUformat="$sPRIGUldbl" +else + nveformat='"e"' + nvfformat='"f"' + nvgformat='"g"' + nvEUformat='"E"' + nvFUformat='"F"' + nvGUformat='"G"' +fi + +case "$ivdformat" in +'') echo "$0: Fatal: failed to find format strings, cannot continue." >& 4 + exit 1 + ;; +esac + + +echo " " +$echo "Checking the format string to be used for gids..." >&4 + +case "$gidsign" in +-1) if $test X"$gidsize" = X"$ivsize"; then + gidformat="$ivdformat" + else + if $test X"$gidsize" = X"$longsize"; then + gidformat='"ld"' + else + if $test X"$gidsize" = X"$intsize"; then + gidformat='"d"' + else + if $test X"$gidsize" = X"$shortsize"; then + gidformat='"hd"' + fi + fi + fi + fi + ;; +*) if $test X"$gidsize" = X"$uvsize"; then + gidformat="$uvuformat" + else + if $test X"$gidsize" = X"$longsize"; then + gidformat='"lu"' + else + if $test X"$gidsize" = X"$intsize"; then + gidformat='"u"' + else + if $test X"$gidsize" = X"$shortsize"; then + gidformat='"hu"' + fi + fi + fi + fi + ;; +esac + +: see if getgroups exists +set getgroups d_getgrps +eval $inlibc + +: see if setgroups exists +set setgroups d_setgrps +eval $inlibc + + +: Find type of 2nd arg to 'getgroups()' and 'setgroups()' +echo " " +case "$d_getgrps$d_setgrps" in +*define*) + case "$groupstype" in + '') dflt="$gidtype" ;; + *) dflt="$groupstype" ;; + esac + $cat <&4 +case "$make_set_make" in +'') + $sed 's/^X //' > testmake.mak << 'EOF' +Xall: +X @echo 'maketemp="$(MAKE)"' +EOF + case "`$make -f testmake.mak 2>/dev/null`" in + *maketemp=*) make_set_make='#' ;; + *) make_set_make="MAKE=$make" ;; + esac + $rm -f testmake.mak + ;; +esac +case "$make_set_make" in +'#') echo "Yup, it does.";; +*) echo "Nope, it doesn't.";; +esac + +: see what type is used for mode_t +rp="What is the type used for file modes for system calls (e.g. fchmod())?" +set mode_t modetype int stdio.h sys/types.h +eval $typedef_ask + +: define a fucntion to check prototypes +$cat > protochk <> protochk <<'EOSH' + +$rm -f try.c +foo="$1" +shift +while test $# -ge 2; do + case "$1" in + $define) echo "#include <$2>" >> try.c ;; + literal) echo "$2" >> try.c ;; + esac + shift 2 +done +test "$prototype" = "$define" && echo '#define CAN_PROTOTYPE' >> try.c +cat >> try.c <<'EOCP' +#ifdef CAN_PROTOTYPE +#define _(args) args +#else +#define _(args) () +#endif +EOCP +echo "$foo" >> try.c +echo 'int no_real_function_has_this_name _((void)) { return 0; }' >> try.c +$cc $optimize $ccflags -c try.c > /dev/null 2>&1 +status=$? +$rm -f try.[co] +exit $status +EOSH +chmod +x protochk +$eunicefix protochk + +: see what type is used for size_t +rp="What is the type used for the length parameter for string functions?" +set size_t sizetype 'unsigned int' stdio.h sys/types.h +eval $typedef_ask + +: check for type of arguments to gethostbyaddr. +if test "X$netdb_host_type" = X -o "X$netdb_hlen_type" = X; then + case "$d_gethbyaddr" in + $define) + $cat <&4 + if test "$voidflags" -gt 7; then + echo '#define VOID_PTR char *' > try.c + else + echo '#define VOID_PTR void *' > try.c + fi + $cat >>try.c <<'EOCP' +#include +int main() +{ + printf("%d\n", (int)sizeof(VOID_PTR)); + exit(0); +} +EOCP + set try + if eval $compile_ok; then + ptrsize=`./try` + echo "Your pointers are $ptrsize bytes long." + else + dflt='4' + echo "(I can't seem to compile the test program. Guessing...)" >&4 + rp="What is the size of a pointer (in bytes)?" + . ./myread + ptrsize="$ans" + fi + ;; +esac +$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' +int 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 -o foobar $ccflags $ldflags 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 -o foobar $ccflags $ldflags 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* + +: check for type of arguments to select. +case "$selecttype" in +'') case "$d_select" in + $define) + echo " " + $cat <try.c < +#$i_time I_TIME +#$i_systime I_SYS_TIME +#$i_systimek I_SYS_TIME_KERNEL +#ifdef I_TIME +# include +#endif +#ifdef I_SYS_TIME +# ifdef I_SYS_TIME_KERNEL +# define KERNEL +# endif +# include +# ifdef I_SYS_TIME_KERNEL +# undef KERNEL +# endif +#endif +#$i_sysselct I_SYS_SELECT +#ifdef I_SYS_SELECT +#include +#endif +#$d_socket HAS_SOCKET +#ifdef HAS_SOCKET +# include /* Might include */ +#endif +#include +$selecttype b; +#define S sizeof(*(b)) +#define MINBITS 64 +#define NBYTES (S * 8 > MINBITS ? S : MINBITS/8) +#define NBITS (NBYTES * 8) +int main() { + char s[NBYTES]; + struct timeval t; + int i; + FILE* fp; + int fd; + + fclose(stdin); + fp = fopen("try.c", "r"); + if (fp == 0) + exit(1); + fd = fileno(fp); + if (fd < 0) + exit(2); + b = ($selecttype)s; + for (i = 0; i < NBITS; i++) + FD_SET(i, b); + t.tv_sec = 0; + t.tv_usec = 0; + select(fd + 1, b, 0, 0, &t); + for (i = NBITS - 1; i > fd && FD_ISSET(i, b); i--); + printf("%d\n", i + 1); + return 0; +} +EOCP + set try + if eval $compile_ok; then + selectminbits=`./try` + case "$selectminbits" in + '') cat >&4 <&4 + else + rp='What is the minimum number of bits your select() operates on?' + case "$byteorder" in + 1234|12345678) dflt=32 ;; + *) dflt=1 ;; + esac + . ./myread + val=$ans + selectminbits="$val" + fi + $rm -f try.* try + ;; + *) : no select, so pick a harmless default + selectminbits='32' + ;; + esac + ;; +esac + +: Trace out the files included by signal.h, then look for SIGxxx names. +: Remove SIGARRAYSIZE used by HPUX. +: Remove SIGSTKSIZE used by Linux. +: Remove SIGSTKSZ used by Posix. +: Remove SIGTYP void lines used by OS2. +: Some cpps, like os390, dont give the file name anywhere +if [ "X$fieldn" = X ]; then + : Just make some guesses. We check them later. + xxx='/usr/include/signal.h /usr/include/sys/signal.h' +else + xxx=`echo '#include ' | + $cppstdin $cppminus $cppflags 2>/dev/null | + $grep '^[ ]*#.*include' | + $awk "{print \\$$fieldn}" | $sed 's!"!!g' | $sort | $uniq` +fi +: Check this list of files to be sure we have parsed the cpp output ok. +: This will also avoid potentially non-existent files, such +: as ../foo/bar.h +xxxfiles='' +for xx in $xxx /dev/null ; do + $test -f "$xx" && xxxfiles="$xxxfiles $xx" +done +: If we have found no files, at least try signal.h +case "$xxxfiles" in +'') xxxfiles=`./findhdr signal.h` ;; +esac +xxx=`awk ' +$1 ~ /^#define$/ && $2 ~ /^SIG[A-Z0-9]*$/ && $2 !~ /SIGARRAYSIZE/ && $2 !~ /SIGSTKSIZE/ && $2 !~ /SIGSTKSZ/ && $3 !~ /void/ { + print substr($2, 4, 20) +} +$1 == "#" && $2 ~ /^define$/ && $3 ~ /^SIG[A-Z0-9]*$/ && $3 !~ /SIGARRAYSIZE/ && $4 !~ /void/ { + print substr($3, 4, 20) +}' $xxxfiles` +: Append some common names just in case the awk scan failed. +xxx="$xxx ABRT ALRM BUS CANCEL CHLD CLD CONT DIL EMT FPE" +xxx="$xxx FREEZE HUP ILL INT IO IOT KILL LOST LWP PHONE" +xxx="$xxx PIPE POLL PROF PWR QUIT RTMAX RTMIN SEGV STKFLT STOP" +xxx="$xxx SYS TERM THAW TRAP TSTP TTIN TTOU URG USR1 USR2" +xxx="$xxx USR3 USR4 VTALRM WAITING WINCH WIND WINDOW XCPU XFSZ" + +: generate a few handy files for later +$cat > signal.c <<'EOCP' +#include +#include +#include +int main() { + +/* Strange style to avoid deeply-nested #if/#else/#endif */ +#ifndef NSIG +# ifdef _NSIG +# define NSIG (_NSIG) +# endif +#endif + +#ifndef NSIG +# ifdef SIGMAX +# define NSIG (SIGMAX+1) +# endif +#endif + +#ifndef NSIG +# ifdef SIG_MAX +# define NSIG (SIG_MAX+1) +# endif +#endif + +#ifndef NSIG +# ifdef MAXSIG +# define NSIG (MAXSIG+1) +# endif +#endif + +#ifndef NSIG +# ifdef MAX_SIG +# define NSIG (MAX_SIG+1) +# endif +#endif + +#ifndef NSIG +# ifdef SIGARRAYSIZE +# define NSIG (SIGARRAYSIZE+1) /* Not sure of the +1 */ +# endif +#endif + +#ifndef NSIG +# ifdef _sys_nsig +# define NSIG (_sys_nsig) /* Solaris 2.5 */ +# endif +#endif + +/* Default to some arbitrary number that's big enough to get most + of the common signals. +*/ +#ifndef NSIG +# define NSIG 50 +#endif + +printf("NSIG %d\n", NSIG); + +#ifndef JUST_NSIG + +EOCP + +echo $xxx | $tr ' ' $trnl | $sort | $uniq | $awk ' +{ + printf "#ifdef SIG"; printf $1; printf "\n" + printf "printf(\""; printf $1; printf " %%d\\n\",SIG"; + printf $1; printf ");\n" + printf "#endif\n" +} +END { + printf "#endif /* JUST_NSIG */\n"; + printf "exit(0);\n}\n"; +} +' >>signal.c +$cat >signal.awk <<'EOP' +BEGIN { ndups = 0 } +$1 ~ /^NSIG$/ { nsig = $2 } +($1 !~ /^NSIG$/) && (NF == 2) { + if ($2 > maxsig) { maxsig = $2 } + if (sig_name[$2]) { + dup_name[ndups] = $1 + dup_num[ndups] = $2 + ndups++ + } + else { + sig_name[$2] = $1 + sig_num[$2] = $2 + } +} +END { + if (nsig == 0) { + nsig = maxsig + 1 + } + printf("NSIG %d\n", nsig); + for (n = 1; n < nsig; n++) { + if (sig_name[n]) { + printf("%s %d\n", sig_name[n], sig_num[n]) + } + else { + printf("NUM%d %d\n", n, n) + } + } + for (n = 0; n < ndups; n++) { + printf("%s %d\n", dup_name[n], dup_num[n]) + } +} +EOP +$cat >signal_cmd <>signal_cmd <<'EOS' + +set signal +if eval $compile_ok; then + ./signal$_exe | $sort -n +1 | $uniq | $awk -f signal.awk >signal.lst +else + echo "(I can't seem be able to compile the whole test program)" >&4 + echo "(I'll try it in little pieces.)" >&4 + set signal -DJUST_NSIG + if eval $compile_ok; then + ./signal$_exe > signal.nsg + $cat signal.nsg + else + echo "I can't seem to figure out how many signals you have." >&4 + echo "Guessing 50." >&4 + echo 'NSIG 50' > signal.nsg + fi + : Now look at all the signal names, one at a time. + for xx in `echo $xxx | $tr ' ' $trnl | $sort | $uniq`; do + $cat > signal.c < +#include +#include +int main() { +printf("$xx %d\n", SIG${xx}); +return 0; +} +EOCP + set signal + if eval $compile; then + echo "SIG${xx} found." + ./signal$_exe >> signal.ls1 + else + echo "SIG${xx} NOT found." + fi + done + if $test -s signal.ls1; then + $cat signal.nsg signal.ls1 | + $sort -n +1 | $uniq | $awk -f signal.awk >signal.lst + fi + +fi +if $test -s signal.lst; then + : +else + echo "(AAK! I can't compile the test programs -- Guessing)" >&4 + echo 'kill -l' >signal + set X `csh -f signal.lst +fi +$rm -f signal.c signal$_exe signal$_o signal.nsg signal.ls1 +EOS +chmod a+x signal_cmd +$eunicefix signal_cmd + +: generate list of signal names +echo " " +case "$sig_name_init" in +'') doinit=yes ;; +*) case "$sig_num_init" in + ''|*,*) doinit=yes ;; + esac ;; +esac +case "$doinit" in +yes) + echo "Generating a list of signal names and numbers..." >&4 + . ./signal_cmd + sig_count=`$awk '/^NSIG/ { printf "%d", $2 }' signal.lst` + sig_name=`$awk 'BEGIN { printf "ZERO " } + !/^NSIG/ { printf "%s ", $1 }' signal.lst` + sig_num=`$awk 'BEGIN { printf "0 " } + !/^NSIG/ { printf "%d ", $2 }' signal.lst` + sig_name_init=`$awk 'BEGIN { printf "\"ZERO\", " } + !/^NSIG/ { printf "\"%s\", ", $1 } + END { printf "0\n" }' signal.lst` + sig_num_init=`$awk 'BEGIN { printf "0, " } + !/^NSIG/ { printf "%d, ", $2} + END { printf "0\n"}' signal.lst` + ;; +esac +echo "The following $sig_count signals are available:" +echo " " +echo $sig_name | $awk \ +'BEGIN { linelen = 0 } +{ + for (i = 1; i <= NF; i++) { + name = "SIG" $i " " + linelen = linelen + length(name) + if (linelen > 70) { + printf "\n" + linelen = length(name) + } + printf "%s", name + } + printf "\n" +}' +$rm -f signal signal.c signal.awk signal.lst signal_cmd + +echo " " +case "$sizetype" in +*_t) zzz="$sizetype" ;; +*) zzz="filesize" ;; +esac +echo "Checking the size of $zzz..." >&4 +cat > try.c < +#include +int main() { + printf("%d\n", (int)sizeof($sizetype)); + exit(0); +} +EOCP +set try +if eval $compile_ok; then + yyy=`./try` + case "$yyy" in + '') sizesize=4 + echo "(I can't execute the test program--guessing $sizesize.)" >&4 + ;; + *) sizesize=$yyy + echo "Your $zzz size is $sizesize bytes." + ;; + esac +else + sizesize=4 + echo "(I can't compile the test program--guessing $sizesize.)" >&4 +fi + + +: check for socklen_t +echo " " +echo "Checking to see if you have socklen_t..." >&4 +$cat >try.c < +#$d_socket HAS_SOCKET +#ifdef HAS_SOCKET +#include +#endif +int main() { socklen_t x = 16; } +EOCP +set try +if eval $compile; then + val="$define" + echo "You have socklen_t." +else + val="$undef" + echo "You do not have socklen_t." + case "$sizetype" in + size_t) echo "(You do have size_t, that might work. Some people are happy with just an int.)" ;; + esac +fi +$rm -f try try.* +set d_socklen_t +eval $setvar + +: check for type of the size argument to socket calls +case "$d_socket" in +"$define") + $cat < ssize.c < +#include +#define Size_t $sizetype +#define SSize_t $dflt +int 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"); + exit(0); +} +EOM +echo " " +set ssize +if eval $compile_ok && ./ssize > /dev/null; then + ssizetype=`./ssize` + echo "I'll be using $ssizetype for functions returning a byte count." >&4 +else + $cat >&4 </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 test "X$d_time" = X -o X"$timetype" = X; then + if set time val -f d_time; eval $csym; $val; then + echo 'time() found.' >&4 + val="$define" + rp="What is the type returned by time() on this system?" + set time_t timetype long stdio.h sys/types.h + eval $typedef_ask + else + echo 'time() not found, hope that will do.' >&4 + val="$undef" + timetype='int'; + fi + set d_time + eval $setvar +fi + +: see what type uids are declared as in the kernel +echo " " +echo "Looking for the type for user ids returned by getuid()." +set uid_t uidtype xxx stdio.h sys/types.h +eval $typedef +case "$uidtype" in +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 + ;; +*) dflt="$uidtype";; +esac +case "$uidtype" in +uid_t) echo "uid_t found." ;; +*) rp="What is the type for user ids returned by getuid()?" + . ./myread + uidtype="$ans" + ;; +esac + +echo " " +case "$uidtype" in +*_t) zzz="$uidtype" ;; +*) zzz="uid" ;; +esac +echo "Checking the size of $zzz..." >&4 +cat > try.c < +#include +int main() { + printf("%d\n", (int)sizeof($uidtype)); + exit(0); +} +EOCP +set try +if eval $compile_ok; then + yyy=`./try` + case "$yyy" in + '') uidsize=4 + echo "(I can't execute the test program--guessing $uidsize.)" >&4 + ;; + *) uidsize=$yyy + echo "Your $zzz is $uidsize bytes long." + ;; + esac +else + uidsize=4 + echo "(I can't compile the test program--guessing $uidsize.)" >&4 +fi + +echo " " +case "$uidtype" in +*_t) zzz="$uidtype" ;; +*) zzz="uid" ;; +esac +echo "Checking the sign of $zzz..." >&4 +cat > try.c < +#include +int main() { + $uidtype foo = -1; + if (foo < 0) + printf("-1\n"); + else + printf("1\n"); +} +EOCP +set try +if eval $compile; then + yyy=`./try` + case "$yyy" in + '') uidsign=1 + echo "(I can't execute the test program--guessing unsigned.)" >&4 + ;; + *) uidsign=$yyy + case "$uidsign" in + 1) echo "Your $zzz is unsigned." ;; + -1) echo "Your $zzz is signed." ;; + esac + ;; + esac +else + uidsign=1 + echo "(I can't compile the test program--guessing unsigned.)" >&4 +fi + + + +echo " " +$echo "Checking the format string to be used for uids..." >&4 + +case "$uidsign" in +-1) if $test X"$uidsize" = X"$ivsize"; then + uidformat="$ivdformat" + else + if $test X"$uidsize" = X"$longsize"; then + uidformat='"ld"' + else + if $test X"$uidsize" = X"$intsize"; then + uidformat='"d"' + else + if $test X"$uidsize" = X"$shortsize"; then + uidformat='"hd"' + fi + fi + fi + fi + ;; +*) if $test X"$uidsize" = X"$uvsize"; then + uidformat="$uvuformat" + else + if $test X"$uidsize" = X"$longsize"; then + uidformat='"lu"' + else + if $test X"$uidsize" = X"$intsize"; then + uidformat='"u"' + else + if $test X"$uidsize" = X"$shortsize"; then + uidformat='"hu"' + fi + fi + fi + fi + ;; +esac + +: see if dbm.h is available +: see if dbmclose exists +set dbmclose d_dbmclose +eval $inlibc + +case "$d_dbmclose" in +$define) + set dbm.h i_dbm + eval $inhdr + case "$i_dbm" in + $define) + val="$undef" + set i_rpcsvcdbm + eval $setvar + ;; + *) set rpcsvc/dbm.h i_rpcsvcdbm + eval $inhdr + ;; + esac + ;; +*) echo "We won't be including " + val="$undef" + set i_dbm + eval $setvar + val="$undef" + set i_rpcsvcdbm + eval $setvar + ;; +esac + +: see if this is a sys/file.h system +val='' +set sys/file.h val +eval $inhdr + +: do we need to include sys/file.h ? +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 + +: see if fcntl.h is there +val='' +set fcntl.h val +eval $inhdr + +: 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 + echo "We won't be including ." >&4 + fi + fi + ;; +*) + h_fcntl=false + val="$undef" + ;; +esac +set i_fcntl +eval $setvar + +: see if this is a iconv.h system +set iconv.h i_iconv +eval $inhdr + +: see if this is a ieeefp.h system +set ieeefp.h i_ieeefp +eval $inhdr + +: see if this is a libutil.h system +set libutil.h i_libutil +eval $inhdr + +: see if locale.h is available +set locale.h i_locale +eval $inhdr + +: see if mach cthreads are available +if test "X$usethreads" = "X$define"; then + set mach/cthreads.h i_machcthr + eval $inhdr +else + i_machcthr="$undef" +fi + + + +: see if this is a math.h system +set math.h i_math +eval $inhdr + +: see if this is a mntent.h system +set mntent.h i_mntent +eval $inhdr + +: 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 +val="$t_ndbm" +set i_ndbm +eval $setvar + +: see if net/errno.h is available +val='' +set net/errno.h val +eval $inhdr + +: 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 +set i_neterrno +eval $setvar + +: see if netinet/tcp.h is available +set netinet/tcp.h i_netinettcp +eval $inhdr + +: see if this is a poll.h system +set poll.h i_poll +eval $inhdr + +: see if this is a prot.h system +set prot.h i_prot +eval $inhdr + +echo " " +$echo "Guessing which symbols your C compiler and preprocessor define..." >&4 +$cat <<'EOSH' > Cppsym.know +a29k ABI64 aegis AES_SOURCE AIX AIX32 AIX370 +AIX41 AIX42 AIX43 AIX_SOURCE aixpc ALL_SOURCE +alliant alpha am29000 AM29000 amiga AMIGAOS AMIX +ansi ANSI_C_SOURCE apollo ardent atarist att386 att3b BeOS +BIG_ENDIAN BIT_MSF bsd BSD bsd43 bsd4_2 bsd4_3 BSD4_3 bsd4_4 +BSD_4_3 BSD_4_4 BSD_NET2 BSD_TIME BSD_TYPES BSDCOMPAT bsdi +bull c cadmus clipper CMU COFF COMPILER_VERSION +concurrent convex cpu cray CRAY CRAYMPP ctix CX_UX +CYGWIN DGUX DGUX_SOURCE DJGPP dmert DOLPHIN DPX2 DSO +Dynix DynixPTX ELF encore EPI EXTENSIONS FILE_OFFSET_BITS +FreeBSD GCC_NEW_VARARGS gcos gcx gimpel +GNU_SOURCE GNUC GNUC_MINOR GO32 gould GOULD_PN +H3050R H3050RX hbullx20 hcx host_mips +hp200 hp300 hp700 HP700 hp800 hp9000 +hp9000s200 hp9000s300 hp9000s400 hp9000s500 +hp9000s700 hp9000s800 hp9k8 hp_osf hppa hpux HPUX_SOURCE +i186 i286 i386 i486 i586 i686 i8086 i80960 i860 I960 +iAPX286 ibm ibm032 ibmesa IBMR2 ibmrt ILP32 ILP64 +INLINE_INTRINSICS INTRINSICS INT64 interdata is68k ksr1 +LANGUAGE_C LARGE_FILE_API LARGEFILE64_SOURCE +LARGEFILE_SOURCE LFS64_LARGEFILE LFS_LARGEFILE +Linux LITTLE_ENDIAN LONG64 LONG_DOUBLE LONG_LONG +LONGDOUBLE LONGLONG LP64 luna luna88k Lynx +M68000 m68k m88100 m88k M88KBCS_TARGET M_COFF +M_I186 M_I286 M_I386 M_I8086 M_I86 M_I86SM M_SYS3 +M_SYS5 M_SYSIII M_SYSV M_UNIX M_XENIX MACH machine MachTen +MATH_HAS_NO_SIDE_EFFECTS +mc300 mc500 mc68000 mc68010 mc68020 mc68030 mc68040 +mc68060 mc68k mc68k32 mc700 mc88000 mc88100 merlin +mert MiNT mips MIPS_FPSET MIPS_ISA MIPS_SIM MIPS_SZINT +MIPS_SZLONG MIPS_SZPTR MIPSEB MIPSEL MODERN_C motorola +mpeix MSDOS MTXINU MULTIMAX mvs MVS n16 ncl_el ncl_mr +NetBSD news1500 news1700 news1800 news1900 news3700 +news700 news800 news900 NeXT NLS nonstopux ns16000 ns32000 +ns32016 ns32332 ns32k nsc32000 +OCS88 OEMVS OpenBSD os OS2 OS390 osf OSF1 OSF_SOURCE +pa_risc PA_RISC1_1 PA_RISC2_0 PARAGON parisc +pc532 pdp11 PGC PIC plexus PORTAR posix +POSIX1B_SOURCE POSIX2_SOURCE POSIX4_SOURCE +POSIX_C_SOURCE POSIX_SOURCE POWER +PROTOTYPES PWB pyr QNX R3000 REENTRANT RES Rhapsody RISC6000 +riscix riscos RT scs SCO sequent sgi SGI_SOURCE sinix +SIZE_INT SIZE_LONG SIZE_PTR SOCKET_SOURCE SOCKETS_SOURCE +sony sony_news sonyrisc sparc sparclite spectrum +stardent stdc STDC_EXT stratos sun sun3 sun386 +Sun386i svr3 svr4 SVR4_2 SVR4_SOURCE svr5 +SX system SYSTYPE_BSD SYSTYPE_BSD43 SYSTYPE_BSD44 +SYSTYPE_SVR4 SYSTYPE_SVR5 SYSTYPE_SYSV SYSV SYSV3 SYSV4 SYSV5 +sysV68 sysV88 Tek4132 Tek4300 titan +tower tower32 tower32_200 tower32_600 tower32_700 +tower32_800 tower32_850 tss +u370 u3b u3b2 u3b20 u3b200 u3b20d u3b5 +ultrix UMAXV UnicomPBB UnicomPBD UNICOS UNICOSMK +unix UNIX95 UNIX99 unixpc unos USGr4 USGr4_2 +Utek UTek UTS UWIN uxpm uxps vax venix VMESA vms xenix Xenix286 +XOPEN_SOURCE XOPEN_SOURCE_EXTENDED XPG2 XPG2_EXTENDED +XPG3 XPG3_EXTENDED XPG4 XPG4_EXTENDED +z8000 +EOSH +# Maybe put other stuff here too. +cat <>Cppsym.know +$osname +EOSH +./tr '[a-z]' '[A-Z]' < Cppsym.know > Cppsym.a +./tr '[A-Z]' '[a-z]' < Cppsym.know > Cppsym.b +$cat Cppsym.know > Cppsym.c +$cat Cppsym.a Cppsym.b Cppsym.c | $tr ' ' $trnl | sort | uniq > Cppsym.know +$rm -f Cppsym.a Cppsym.b Cppsym.c +cat < Cppsym +$startsh +if $test \$# -gt 0; then + echo \$* | $tr " " "$trnl" | ./Cppsym.try > Cppsym.got + if $test -s Cppsym.got; then + $rm -f Cppsym.got + exit 0 + fi + $rm -f Cppsym.got + exit 1 +else + $tr " " "$trnl" | ./Cppsym.try + exit 0 +fi +EOSH +chmod +x Cppsym +$eunicefix Cppsym +cat < Cppsym.try +$startsh +cat <<'EOCP' > try.c +#include +int main() { +EOCP +$awk \\ +EOSH +cat <<'EOSH' >> Cppsym.try +'length($1) > 0 { + printf "#ifdef %s\n#if %s+0\nprintf(\"%s=%%ld\\n\", %s);\n#else\nprintf(\"%s\\n\");\n#endif\n#endif\n", $1, $1, $1, $1, $1 + printf "#ifdef _%s\n#if _%s+0\nprintf(\"_%s=%%ld\\n\", _%s);\n#else\nprintf(\"_%s\\n\");\n#endif\n#endif\n", $1, $1, $1, $1, $1 + printf "#ifdef __%s\n#if __%s+0\nprintf(\"__%s=%%ld\\n\", __%s);\n#else\nprintf(\"__%s\\n\");\n#endif\n#endif\n", $1, $1, $1, $1, $1 + printf "#ifdef __%s__\n#if __%s__+0\nprintf(\"__%s__=%%ld\\n\", __%s__);\n#else\nprintf(\"__%s__\\n\");\n#endif\n#endif\n", $1, $1, $1, $1, $1 +}' >> try.c +echo '}' >> try.c +EOSH +cat <> Cppsym.try +ccflags="$ccflags" +case "$osname-$gccversion" in +irix-) ccflags="\$ccflags -woff 1178" ;; +os2-*) ccflags="\$ccflags -Zlinker /PM:VIO" ;; +esac +$cc -o try $optimize \$ccflags $ldflags try.c $libs && ./try$exe_ext +EOSH +chmod +x Cppsym.try +$eunicefix Cppsym.try +./Cppsym < Cppsym.know > Cppsym.true +: now check the C compiler for additional symbols +postprocess_cc_v='' +case "$osname" in +aix) postprocess_cc_v="|$tr , ' '" ;; +esac +$cat >ccsym <tmp.c <&1 $postprocess_cc_v\` +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 +postprocess_cc_v='' +chmod +x ccsym +$eunicefix ccsym +./ccsym > ccsym1.raw +if $test -s ccsym1.raw; then + $sort ccsym1.raw | $uniq >ccsym.raw +else + mv ccsym1.raw ccsym.raw +fi + +$awk '/\=/ { print $0; next } + { print $0"=1" }' ccsym.raw >ccsym.list +$awk '/\=/ { print $0; next } + { 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='' +if $test -z ccsym.raw; then + echo "Your C compiler doesn't seem to define any symbols!" >&4 + echo " " + echo "However, your C preprocessor defines the following symbols:" + $cat Cppsym.true + ccsymbols='' + cppsymbols=`$cat Cppsym.true` + cppsymbols=`echo $cppsymbols` + cppccsymbols="$cppsymbols" +else + 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' + cppccsymbols=`$cat ccsym.com` + cppccsymbols=`echo $cppccsymbols` + $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 ' + cppsymbols=`$cat ccsym.cpp` + cppsymbols=`echo $cppsymbols` + $test "$silent" || sleep 1 + fi + if $test -s ccsym.own; then + $test "$also" && echo " " + echo "Your C compiler ${also}defines the following cpp symbols:" + $sed -e 's/\(..*\)=1/\1/' ccsym.own + $sed -e 's/\(..*\)=.*/\1/' ccsym.own | $uniq >>Cppsym.true + ccsymbols=`$cat ccsym.own` + ccsymbols=`echo $ccsymbols` + $test "$silent" || sleep 1 + fi +fi +$rm -f ccsym* Cppsym.* + +: 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 this is a shadow.h system +set shadow.h i_shadow +eval $inhdr + +: see if this is a socks.h system +set socks.h i_socks +eval $inhdr + +: see if stdarg is available +echo " " +if $test `./findhdr stdarg.h`; then + echo " found." >&4 + valstd="$define" +else + echo " NOT found." >&4 + valstd="$undef" +fi + +: see if varags is available +echo " " +if $test `./findhdr varargs.h`; then + echo " found." >&4 +else + echo " NOT found, but that's ok (I hope)." >&4 +fi + +: set up the varargs testing programs +$cat > varargs.c < +#endif +#ifdef I_VARARGS +#include +#endif + +#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 + echo "false" +fi +$rm -f varargs$_o +EOP +chmod +x varargs + +: now check which varargs header should be included +echo " " +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* - cat << EOM +: see if stddef is available +set stddef.h i_stddef +eval $inhdr -Some systems use ld to create libraries that can be dynamically loaded, -while other systems (such as those using ELF) use $cc. +: see if this is a sunmath.h system +set sunmath.h i_sunmath +eval $inhdr -EOM - case "$ld" in - '') $cat >try.c <<'EOM' -/* Test for whether ELF binaries are produced */ -#include -#include -int main() { - char b[4]; - int i = open("a.out",O_RDONLY); - if(i == -1) - exit(1); /* fail */ - if(read(i,b,4)==4 && b[0]==127 && b[1]=='E' && b[2]=='L' && b[3]=='F') - exit(0); /* succeed (yes, it's ELF) */ +: see if sys/access.h is available +set sys/access.h i_sysaccess +eval $inhdr + +: see if ioctl defs are in sgtty, termio, sys/filio or sys/ioctl +set sys/filio.h i_sysfilio +eval $inhdr +echo " " +if $test `./findhdr sys/ioctl.h`; then + val="$define" + echo ' found.' >&4 +else + val="$undef" + if $test $i_sysfilio = "$define"; then + echo ' NOT found.' >&4 else - exit(1); /* fail */ -} -EOM - if $cc $ccflags try.c >/dev/null 2>&1 && ./a.out; then - cat < found, assuming ioctl args are defined in <$xxx>." >&4 + fi +fi +set i_sysioctl +eval $setvar + + +: see if this is a syslog.h system +set syslog.h i_syslog +eval $inhdr + + +: see if this is a sys/mode.h system +set sys/mode.h i_sysmode +eval $inhdr + +: see if sys/resource.h has to be included +set sys/resource.h i_sysresrc +eval $inhdr + +: see if sys/security.h is available +set sys/security.h i_syssecrt +eval $inhdr + +: see if this is a sys/statvfs.h system +set sys/statvfs.h i_sysstatvfs +eval $inhdr + +: see if this is a sys/uio.h system +set sys/uio.h i_sysuio +eval $inhdr + +: see if this is a sys/un.h system +set sys/un.h i_sysun +eval $inhdr + + +: see if this is a sys/utsname.h system +set sys/utsname.h i_sysutsname +eval $inhdr + +: see if this is a syswait system +set sys/wait.h i_syswait +eval $inhdr + +: see if this is a ustat.h system +set ustat.h i_ustat +eval $inhdr + +: see if this is an utime system +set utime.h i_utime +eval $inhdr + +: see if this is a values.h system +set values.h i_values +eval $inhdr + +: see if this is a vfork system +case "$d_vfork" in +"$define") + set vfork.h i_vfork + eval $inhdr + ;; +*) + i_vfork="$undef" + ;; +esac + +: 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 " ;; - *) dflt="$ld" + esac + ;; +esac +val="$t_gdbm" +set i_gdbm +eval $setvar + +echo " " +echo "Looking for extensions..." >&4 +: If we are using the old config.sh, known_extensions may contain +: old or inaccurate or duplicate values. +known_extensions='' +nonxs_extensions='' +: We do not use find because it might not be available. +: We do not just use MANIFEST because the user may have dropped +: some additional extensions into the source tree and expect them +: to be built. + +: Function to recursively find available extensions, ignoring DynaLoader +: NOTE: recursion limit of 10 to prevent runaway in case of symlink madness +find_extensions=' + for xxx in *; do + case "$xxx" in + DynaLoader|dynaload) ;; + *) + if $test -f $xxx/$xxx.xs; then + known_extensions="$known_extensions $1$xxx"; + elif $test -f $xxx/Makefile.PL; then + nonxs_extensions="$nonxs_extensions $1$xxx"; + else + if $test -d $xxx -a $# -lt 10; then + set $1$xxx/ $*; + cd $xxx; + eval $find_extensions; + cd ..; + shift; + fi; + fi + ;; + esac; + done' +tdir=`pwd` +cd $rsrc/ext +set X +shift +eval $find_extensions +set X $nonxs_extensions +shift +nonxs_extensions="$*" +set X $known_extensions +shift +known_extensions="$*" +cd $tdir + +: Now see which are supported on this system. +avail_ext='' +for xxx in $known_extensions ; do + case "$xxx" in + DB_File|db_file) + case "$i_db" in + $define) avail_ext="$avail_ext $xxx" ;; + esac + ;; + GDBM_File|gdbm_fil) + case "$i_gdbm" in + $define) avail_ext="$avail_ext $xxx" ;; + esac + ;; + NDBM_File|ndbm_fil) + case "$i_ndbm" in + $define) + case "$osname-$use64bitint" in + hpux-define) + case "$libs" in + *-lndbm*) avail_ext="$avail_ext $xxx" ;; + esac + ;; + *) avail_ext="$avail_ext $xxx" ;; + esac + ;; + esac + ;; + ODBM_File|odbm_fil) + case "${i_dbm}${i_rpcsvcdbm}" in + *"${define}"*) + case "$osname-$use64bitint" in + hpux-define) + case "$libs" in + *-ldbm*) avail_ext="$avail_ext $xxx" ;; + esac + ;; + *) avail_ext="$avail_ext $xxx" ;; + esac + ;; + esac + ;; + POSIX|posix) + case "$useposix" in + true|define|y) avail_ext="$avail_ext $xxx" ;; + esac + ;; + Opcode|opcode) + case "$useopcode" in + true|define|y) avail_ext="$avail_ext $xxx" ;; + esac + ;; + Socket|socket) + case "$d_socket" in + true|$define|y) avail_ext="$avail_ext $xxx" ;; + esac + ;; + Sys/Syslog|sys/syslog) + : XXX syslog requires socket + case "$d_socket" in + true|$define|y) avail_ext="$avail_ext $xxx" ;; + esac + ;; + Thread|thread) + case "$usethreads" in + true|$define|y) avail_ext="$avail_ext $xxx" ;; + esac + ;; + IPC/SysV|ipc/sysv) + : XXX Do we need a useipcsysv variable here + case "${d_msg}${d_sem}${d_shm}" in + *"${define}"*) avail_ext="$avail_ext $xxx" ;; + esac + ;; + *) avail_ext="$avail_ext $xxx" ;; esac +done - rp="What command should be used to create dynamic libraries?" - . ./myread - ld="$ans" +set X $avail_ext +shift +avail_ext="$*" - cat << EOM +: Now see which nonxs extensions are supported on this system. +: For now assume all are. +nonxs_ext='' +for xxx in $nonxs_extensions ; do + case "$xxx" in + *) nonxs_ext="$nonxs_ext $xxx" + ;; + esac +done -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". +set X $nonxs_ext +shift +nonxs_ext="$*" + +case $usedl in +$define) + $cat <