Submitted By: Ryan Oliver Date: 2010-08-01 Initial Package Version: 5.8.8 Origin: Ryan Oliver Upstream Status: Unknown Description: This patch allows perl to be installed in /usr/lib32 or /usr/lib64 instead of /usr/lib. Rediffed: Against 5.10.0 by Joe Ciccone on 2008-08-30 Against 5.10.1 By Jim Gifford on 2009-08-25 Against 5.12.1 By Joe Ciccone on 2010-08-01 Against 5.16.1 By William Harrington on 2012-08-26 Rename for 5.16.2 by William Harrington on 2012-11-01 diff -Naur perl-5.16.1.orig/Configure perl-5.16.1/Configure --- perl-5.16.1.orig/Configure 2012-08-03 17:35:26.000000000 +0000 +++ perl-5.16.1/Configure 2012-08-26 18:50:40.678852714 +0000 @@ -6184,6 +6184,8 @@ : The default "style" setting is made in installstyle.U case "$installstyle" in *lib/perl5*) set dflt privlib lib/$package/$version ;; +*lib32/perl5*) set dflt privlib lib32/$package/$version ;; +*lib64/perl5*) set dflt privlib lib64/$package/$version ;; *) set dflt privlib lib/$version ;; esac eval $prefixit @@ -6432,6 +6434,8 @@ case "$sitelib" in '') case "$installstyle" in *lib/perl5*) dflt=$siteprefix/lib/$package/site_$prog/$version ;; + *lib32/perl5*) dflt=$siteprefix/lib32/$package/site_$prog/$version ;; + *lib64/perl5*) dflt=$siteprefix/lib64/$package/site_$prog/$version ;; *) dflt=$siteprefix/lib/site_$prog/$version ;; esac ;; @@ -6951,6 +6955,8 @@ prog=`echo $package | $sed 's/-*[0-9.]*$//'` case "$installstyle" in *lib/perl5*) dflt=$vendorprefix/lib/$package/vendor_$prog/$version ;; + *lib32/perl5*) dflt=$vendorprefix/lib32/$package/vendor_$prog/$version ;; + *lib64/perl5*) dflt=$vendorprefix/lib64/$package/vendor_$prog/$version ;; *) dflt=$vendorprefix/lib/vendor_$prog/$version ;; esac ;; diff -Naur perl-5.16.1.orig/Configure.orig perl-5.16.1/Configure.orig --- perl-5.16.1.orig/Configure.orig 1970-01-01 00:00:00.000000000 +0000 +++ perl-5.16.1/Configure.orig 2012-08-03 17:35:26.000000000 +0000 @@ -0,0 +1,23957 @@ +#! /bin/sh +# +# If these # comments don't work, trim them. Don't worry about any other +# shell scripts, Configure will trim # comments from them for you. +# +# (If you are trying to port this package to a machine without sh, +# I would suggest you have a look at the prototypical config_h.SH file +# and edit it to reflect your system. Some packages may include samples +# of config.h for certain machines, so you might look for one of those.) +# +# Yes, you may rip this off to use in other distribution packages. This +# script belongs to the public domain and cannot be copyrighted. +# +# Note: this Configure script was generated automatically. Rather than +# working with this copy of Configure, you may wish to get metaconfig. +# The dist package (which contains metaconfig) is available via SVN: +# svn co https://svn.sourceforge.net/svnroot/dist/trunk/dist +# +# Though this script was generated by metaconfig from metaunits, it is +# OK to send patches against Configure itself. It's up to the Configure +# pumpkin to backport the patch to the metaunits if it is accepted. +# For more information on patching Configure, see pod/perlhack.pod +# +# The metaunits are also available from the public git repository: +# http://perl5.git.perl.org/metaconfig.git/ or +# $ git clone git://perl5.git.perl.org/metaconfig.git metaconfig +# +# See Porting/pumpkin.pod for more information on metaconfig. +# + +# Generated on Sun Apr 1 12:00:35 CEST 2012 [metaconfig 3.5 PL0] +# (with additional metaconfig patches by perlbug@perl.org) + +cat >c1$$ <c2$$ </dev/null` + test "$me" || me=$0 + ;; +esac + +: Proper separator for the PATH environment variable +p_=: +: On OS/2 this directory should exist if this is not floppy only system ":-]" +if test -d c:/. || ( uname -a | grep -i 'os\(/\|\)2' ) 2>&1 >/dev/null ; then + if test -n "$OS2_SHELL"; then + p_=\; + PATH=`cmd /c "echo %PATH%" | tr '\\\\' / ` + OS2_SHELL=`cmd /c "echo %OS2_SHELL%" | tr '\\\\' / | tr '[A-Z]' '[a-z]'` + is_os2=yes + elif test -n "$DJGPP"; then + case "X${MACHTYPE:-nonesuchmach}" in + *cygwin) ;; + *) p_=\; ;; + esac + fi +fi + +: Proper PATH setting +paths='/bin /usr/bin /usr/local/bin /usr/ucb /usr/local /usr/lbin' +paths="$paths /opt/bin /opt/local/bin /opt/local /opt/lbin" +paths="$paths /usr/5bin /etc /usr/gnu/bin /usr/new /usr/new/bin /usr/nbin" +paths="$paths /opt/gnu/bin /opt/new /opt/new/bin /opt/nbin" +paths="$paths /sys5.3/bin /sys5.3/usr/bin /bsd4.3/bin /bsd4.3/usr/ucb" +paths="$paths /bsd4.3/usr/bin /usr/bsd /bsd43/bin /opt/ansic/bin /usr/ccs/bin" +paths="$paths /etc /usr/lib /usr/ucblib /lib /usr/ccs/lib" +paths="$paths /sbin /usr/sbin /usr/libexec" +paths="$paths /system/gnu_library/bin" + +for p in $paths +do + case "$p_$PATH$p_" in + *$p_$p$p_*) ;; + *) test -d $p && PATH=$PATH$p_$p ;; + esac +done + +PATH=.$p_$PATH +export PATH + +: shall we be using ksh? +inksh='' +needksh='' +avoidksh='' +newsh=/bin/ksh +changesh='' +if (PATH=.; alias -x) >/dev/null 2>&1; then + inksh=true +fi +if test -f /hp-ux -a -f /bin/ksh; then + needksh='to avoid sh bug in "here document" expansion' +fi +if test -d /usr/lpp -a -f /usr/bin/bsh -a -f /usr/bin/uname; then + if test X`/usr/bin/uname -v` = X4; then + avoidksh="to avoid AIX 4's /bin/sh" + newsh=/usr/bin/bsh + fi +fi +if test -f /osf_boot -a -f /usr/sbin/setld; then + if test X`/usr/bin/uname -s` = XOSF1; then + avoidksh="to avoid Digital UNIX' ksh" + newsh=/bin/sh + unset BIN_SH + fi +fi +case "$inksh/$needksh" in +/[a-z]*) + ENV='' + changesh=true + reason="$needksh" + ;; +esac +case "$inksh/$avoidksh" in +true/[a-z]*) + changesh=true + reason="$avoidksh" + ;; +esac +case "$inksh/$needksh-$avoidksh-" in +true/--) + cat <&2 </dev/null 2>&1`; then + shsharp=true + spitshell=cat + xcat=/bin/cat + test -f $xcat$_exe || xcat=/usr/bin/cat + if test ! -f $xcat$_exe; then + for p in `echo $PATH | sed -e "s/$p_/ /g"` $paths; do + if test -f $p/cat$_exe; then + xcat=$p/cat + break + fi + done + if test ! -f $xcat$_exe; then + echo "Can't find cat anywhere!" + exit 1 + fi + fi + echo "#!$xcat" >sharp + $eunicefix sharp + chmod +x sharp + ./sharp > today 2>/dev/null + if test -s today; then + sharpbang='#!' + else + echo "#! $xcat" > sharp + $eunicefix sharp + chmod +x sharp + ./sharp > today 2>/dev/null + if test -s today; then + sharpbang='#! ' + else + sharpbang=': use ' + fi + fi +else + echo " " + echo "Your $sh doesn't grok # comments--I will strip them later on." + shsharp=false + cd .. + echo "exec grep -v '^[ ]*#'" >spitshell + chmod +x spitshell + $eunicefix spitshell + spitshell=`pwd`/spitshell + cd UU + echo "I presume that if # doesn't work, #! won't work either!" + sharpbang=': use ' +fi +rm -f sharp today + +: figure out how to guarantee sh startup +case "$startsh" in +'') startsh=${sharpbang}${sh} ;; +*) +esac +cat >sharp < cmdline.opt <>cmdline.opt < cmdl.opt +$arg +EOC + arg_exp=`cat cmdl.opt` + args_exp="$args_exp$args_sep'$arg_exp'" + argn=`expr $argn + 1` + args_sep=' ' +done +rm -f cmdl.opt + +: produce awk script to parse command line options +cat >options.awk <<'EOF' +BEGIN { + optstr = "A:dD:eEf:hKOrsSU:V"; # getopt-style specification + + len = length(optstr); + for (i = 1; i <= len; i++) { + c = substr(optstr, i, 1); + if (i < len) a = substr(optstr, i + 1, 1); else a = ""; + if (a == ":") { + arg[c] = 1; + i++; + } + opt[c] = 1; + } +} +{ + expect = 0; + str = $0; + if (substr(str, 1, 1) != "-") { + printf("'%s'\n", str); + next; + } + len = length($0); + for (i = 2; i <= len; i++) { + c = substr(str, i, 1); + if (!opt[c]) { + printf("-%s\n", substr(str, i)); + next; + } + printf("-%s\n", c); + if (arg[c]) { + if (i < len) + printf("'%s'\n", substr(str, i + 1)); + else + expect = 1; + next; + } + } +} +END { + if (expect) + print "?"; +} +EOF + +: process the command line options +set X `for arg in "$@"; do echo "X$arg"; done | + sed -e s/X// | awk -f options.awk` +eval "set $*" +shift +rm -f options.awk + +: set up default values +fastread='' +reuseval=false +config_sh='' +alldone='' +error='' +silent='' +extractsh='' +override='' +knowitall='' +rm -f optdef.sh posthint.sh +cat >optdef.sh <&2 + error=true + fi + cd UU + shift;; + --help|\ + -h) shift; error=true;; + -r) shift; reuseval=true;; + -s) shift; silent=true; realsilent=true;; + -E) shift; alldone=exit;; + -K) shift; knowitall=true;; + -O) shift; override=true;; + -S) shift; silent=true; extractsh=true;; + -D) + shift + case "$1" in + *=) + echo "$me: use '-U symbol=', not '-D symbol='." >&2 + echo "$me: ignoring -D $1" >&2 + ;; + *=*) echo "$1" | \ + sed -e "s/'/'\"'\"'/g" -e "s/=\(.*\)/='\1'/" >> optdef.sh;; + *) echo "$1='define'" >> optdef.sh;; + esac + shift + ;; + -U) + shift + case "$1" in + *=) echo "$1" >> optdef.sh;; + *=*) + echo "$me: use '-D symbol=val', not '-U symbol=val'." >&2 + echo "$me: ignoring -U $1" >&2 + ;; + *) echo "$1='undef'" >> optdef.sh;; + esac + shift + ;; + -A) + shift + xxx='' + yyy="$1" + zzz='' + uuu=undef + case "$yyy" in + *=*) zzz=`echo "$yyy"|sed 's!=.*!!'` + case "$zzz" in + *:*) zzz='' ;; + *) xxx=append + zzz=" "`echo "$yyy"|sed 's!^[^=]*=!!'` + yyy=`echo "$yyy"|sed 's!=.*!!'` ;; + esac + ;; + esac + case "$xxx" in + '') case "$yyy" in + *:*) xxx=`echo "$yyy"|sed 's!:.*!!'` + yyy=`echo "$yyy"|sed 's!^[^:]*:!!'` + zzz=`echo "$yyy"|sed 's!^[^=]*=!!'` + yyy=`echo "$yyy"|sed 's!=.*!!'` ;; + *) xxx=`echo "$yyy"|sed 's!:.*!!'` + yyy=`echo "$yyy"|sed 's!^[^:]*:!!'` ;; + esac + ;; + esac + case "$xxx" in + append) + echo "$yyy=\"\${$yyy}$zzz\"" >> posthint.sh ;; + clear) + echo "$yyy=''" >> posthint.sh ;; + define) + case "$zzz" in + '') zzz=define ;; + esac + echo "$yyy='$zzz'" >> posthint.sh ;; + eval) + echo "eval \"$yyy=$zzz\"" >> posthint.sh ;; + prepend) + echo "$yyy=\"$zzz\${$yyy}\"" >> posthint.sh ;; + undef) + case "$zzz" in + '') zzz="$uuu" ;; + esac + echo "$yyy=$zzz" >> posthint.sh ;; + *) echo "$me: unknown -A command '$xxx', ignoring -A $1" >&2 ;; + esac + shift + ;; + -V) echo "$me generated by metaconfig 3.5 PL0." >&2 + exit 0;; + --) break;; + -*) echo "$me: unknown option $1" >&2; shift; error=true;; + *) break;; + esac +done + +case "$error" in +true) + cat >&2 <&1 +case "$silent" in +true) exec 1>/dev/null;; +esac + +: run the defines and the undefines, if any, but leave the file out there... +touch optdef.sh +. ./optdef.sh +: create the posthint manipulation script and leave the file out there... +touch posthint.sh + +: set package name +package='perl5' +first=`echo $package | sed -e 's/^\(.\).*/\1/'` +last=`echo $package | sed -e 's/^.\(.*\)/\1/'` +case "`echo AbyZ | tr '[:lower:]' '[:upper:]' 2>/dev/null`" in +ABYZ) spackage=`echo $first | tr '[:lower:]' '[:upper:]'`$last;; +*) spackage=`echo $first | tr '[a-z]' '[A-Z]'`$last;; +esac + +: Some greps do not return status, grrr. +echo "grimblepritz" >grimble +if grep blurfldyick grimble >/dev/null 2>&1 ; then + contains=contains +elif grep grimblepritz grimble >/dev/null 2>&1 ; then + contains=grep +else + contains=contains +fi +rm -f grimble +: the following should work in any shell +case "$contains" in +contains*) + echo " " + echo "AGH! Grep doesn't return a status. Attempting remedial action." + cat >contains <<'EOSS' +grep "$1" "$2" >.greptmp && cat .greptmp && test -s .greptmp +EOSS +chmod +x contains +esac + +: Find the path to the source tree +case "$src" in +'') case "$0" in + */*) src=`echo $0 | sed -e 's%/[^/][^/]*$%%'` + case "$src" in + /*) ;; + .) ;; + *) src=`cd ../$src && pwd` ;; + esac + ;; + *) src='.';; + esac;; +esac +case "$src" in +'') src=/ + rsrc=/ + ;; +/*) rsrc="$src";; +*) rsrc="../$src";; +esac +if test -f $rsrc/Configure && \ + $contains "^package='$package'\$" $rsrc/Configure >/dev/null 2>&1 +then + : found it, so we are ok. +else + rsrc='' + for src in . .. ../.. ../../.. ../../../..; do + if test -f ../$src/Configure && \ + $contains "^package=$package$" ../$src/Configure >/dev/null 2>&1 + then + rsrc=../$src + break + fi + done +fi +case "$rsrc" in +'') + cat <&4 + +Sorry, I can't seem to locate the source dir for $package. Please start +Configure with an explicit path -- i.e. /some/path/Configure. + +EOM + exit 1 + ;; +../.) rsrc='..';; +*) + echo " " + echo "Sources for $package found in \"$src\"." >&4 + ;; +esac + +: script used to extract .SH files with variable substitutions +cat >extract <<'EOS' +PERL_CONFIG_SH=true +echo "Doing variable substitutions on .SH files..." +if test -f MANIFEST; then + set x `awk '{print $1}' < MANIFEST | grep '\.SH$'` +else + echo "(Looking for .SH files under the source directory.)" + set x `(cd "$src"; find . -name "*.SH" -print)` +fi +shift +case $# in +0) set x `(cd "$src"; echo *.SH)`; shift;; +esac +if test ! -f "$src/$1"; then + shift +fi +mkdir_p=' +name=$1; +create=""; +while test $name; do + if test ! -d "$name"; then + create="$name $create"; + name=`echo $name | sed -e "s|^[^/]*$||"`; + name=`echo $name | sed -e "s|\(.*\)/.*|\1|"`; + else + name=""; + fi; +done; +for file in $create; do + mkdir $file; +done +' +for file in $*; do + case "$src" in + ".") + case "$file" in + */*) + dir=`expr X$file : 'X\(.*\)/'` + file=`expr X$file : 'X.*/\(.*\)'` + (cd "$dir" && . ./$file) + ;; + *) + . ./$file + ;; + esac + ;; + *) + case "$file" in + */*) + dir=`expr X$file : 'X\(.*\)/'` + file=`expr X$file : 'X.*/\(.*\)'` + (set x $dir; shift; eval $mkdir_p) + sh <"$src/$dir/$file" + ;; + *) + sh <"$src/$file" + ;; + esac + ;; + esac +done +if test -f "$src/config_h.SH"; then + if test ! -f config.h; then + : oops, they left it out of MANIFEST, probably, so do it anyway. + . "$src/config_h.SH" + fi +fi +EOS + +: extract files and exit if asked to do so +case "$extractsh" in +true) + case "$realsilent" in + true) ;; + *) exec 1>&4;; + esac + case "$config_sh" in + '') config_sh='config.sh';; + esac + echo " " + echo "Fetching answers from $config_sh..." + cd .. + . $config_sh + test "$override" && . ./optdef.sh + echo " " + . UU/extract + rm -rf UU + echo "Extraction done." + exit 0 + ;; +esac + +: Eunice requires " " instead of "", can you believe it +echo " " +: Here we go... +echo "Beginning of configuration questions for $package." + +trap 'echo " "; test -d ../UU && rm -rf X $rmlist; exit 1' 1 2 3 15 + +: first determine how to suppress newline on echo command +echo " " +echo "Checking echo to see how to suppress newlines..." +(echo "hi there\c" ; echo " ") >.echotmp +if $contains c .echotmp >/dev/null 2>&1 ; then + echo "...using -n." + n='-n' + c='' +else + cat <<'EOM' +...using \c +EOM + n='' + c='\c' +fi +echo $n "The star should be here-->$c" +echo '*' +rm -f .echotmp + +: Now test for existence of everything in MANIFEST +echo " " +if test -f "$rsrc/MANIFEST"; then + echo "First let's make sure your kit is complete. Checking..." >&4 + awk '$1 !~ /PACK[A-Z]+/ {print $1}' "$rsrc/MANIFEST" | \ + (split -l 50 2>/dev/null || split -50) + rm -f missing + tmppwd=`pwd` + for filelist in x??; do + (cd "$rsrc"; ls `cat "$tmppwd/$filelist"` \ + >/dev/null 2>>"$tmppwd/missing") + done + if test -s missing; then + cat missing >&4 + cat >&4 <<'EOM' + +THIS PACKAGE SEEMS TO BE INCOMPLETE. + +You have the option of continuing the configuration process, despite the +distinct possibility that your kit is damaged, by typing 'y'es. If you +do, don't blame me if something goes wrong. I advise you to type 'n'o +and contact the author (perlbug@perl.org). + +EOM + echo $n "Continue? [n] $c" >&4 + read ans + case "$ans" in + y*) + echo "Continuing..." >&4 + rm -f missing + ;; + *) + echo "ABORTING..." >&4 + kill $$ + ;; + esac + else + echo "Looks good..." + fi +else + echo "There is no MANIFEST file. I hope your kit is complete !" +fi +rm -f missing x?? + +: Find the appropriate value for a newline for tr +echo " " +if test -n "$DJGPP"; then + trnl='\012' +fi +if test X"$trnl" = X; then + case "`echo foo|tr '\n' x 2>/dev/null`" in + foox) trnl='\n' ;; + esac +fi +if test X"$trnl" = X; then + case "`echo foo|tr '\012' x 2>/dev/null`" in + foox) trnl='\012' ;; + esac +fi +if test X"$trnl" = X; then + case "`echo foo|tr '\r\n' xy 2>/dev/null`" in + fooxy) trnl='\n\r' ;; + esac +fi +if test X"$trnl" = X; then + cat <&2 + +$me: Fatal Error: cannot figure out how to translate newlines with 'tr'. + +EOM + exit 1 +fi + +: compute the number of columns on the terminal for proper question formatting +case "$COLUMNS" in +'') COLUMNS='80';; +esac + +: set up the echo used in my read +myecho="case \"\$xxxm\" in +'') echo $n \"\$rp $c\" >&4;; +*) case \"\$rp\" in + '') echo $n \"[\$xxxm] $c\";; + *) + if test \`echo \"\$rp [\$xxxm] \" | wc -c\` -ge $COLUMNS; then + echo \"\$rp\" >&4 + echo $n \"[\$xxxm] $c\" >&4 + else + echo $n \"\$rp [\$xxxm] $c\" >&4 + fi + ;; + esac;; +esac" + +: now set up to do reads with possible shell escape and default assignment +cat <myread +$startsh +xxxm=\$dflt +$myecho +ans='!' +case "\$fastread" in +yes) case "\$dflt" in + '') ;; + *) ans=''; + case "\$silent-\$rp" in + true-) ;; + *) echo " " >&4;; + esac;; + esac;; +*) case "\$silent" in + true) case "\$rp" in + '') ans='';; + esac;; + esac;; +esac +while expr "X\$ans" : "X!" >/dev/null; do + read answ + set x \$xxxm + shift + aok=''; eval "ans=\\"\$answ\\"" && aok=y + case "\$answ" in + "!") + sh 1>&4 + echo " " + $myecho + ;; + !*) + set x \`expr "X\$ans" : "X!\(.*\)\$"\` + shift + sh 1>&4 -c "\$*" + echo " " + $myecho + ;; + "\$ans") + case "\$ans" in + \\&*) + set x \`expr "X\$ans" : "X&\(.*\)\$"\` + shift + case "\$1" in + -d) + fastread=yes + echo "(OK, I'll run with -d after this question.)" >&4 + ;; + -*) + echo "*** Sorry, \$1 not supported yet." >&4 + ;; + esac + $myecho + ans=! + ;; + esac;; + *) + case "\$aok" in + y) + echo "*** Substitution done -- please confirm." + xxxm="\$ans" + ans=\`echo $n "\$ans$c" | tr '$trnl' ' '\` + xxxm="\$ans" + ans=! + ;; + *) + echo "*** Error -- try again." + ans=! + ;; + esac + $myecho + ;; + esac + case "\$ans\$xxxm\$nostick" in + '') + ans=! + $myecho + ;; + esac +done +case "\$ans" in +'') ans="\$xxxm";; +esac +EOSC + +: create .config dir to save info across Configure sessions +test -d ../.config || mkdir ../.config +cat >../.config/README <&4 <&4 "Okay, continuing." + usedevel="$define" ;; + *) echo >&4 "Okay, bye." + exit 1 + ;; + esac + ;; + esac + usedevel="$undef" + ;; +esac +case "$usedevel" in +$define|true|[yY]*) + case "$versiononly" in + '') versiononly="$define" ;; + esac + case "$installusrbinperl" in + '') installusrbinperl="$undef" ;; + esac + ;; +esac + +: general instructions +needman=true +firsttime=true +user=`(logname) 2>/dev/null` +case "$user" in +'') user=`whoami 2>&1`;; +esac +if $contains "^$user\$" ../.config/instruct >/dev/null 2>&1; then + firsttime=false + echo " " + rp='Would you like to see the instructions?' + dflt=n + . ./myread + case "$ans" in + [yY]*) ;; + *) needman=false;; + esac +fi +if $needman; then + cat <>../.config/instruct;; + esac +fi + +: find out where common programs are +echo " " +echo "Locating common programs..." >&4 +cat <loc +$startsh +case \$# in +0) exit 1;; +esac +thing=\$1 +shift +dflt=\$1 +shift +for dir in \$*; do + case "\$thing" in + .) + if test -d \$dir/\$thing; then + echo \$dir + exit 0 + fi + ;; + *) + for thisthing in \$dir/\$thing; do + : just loop through to pick last item + done + if test -f \$thisthing; then + echo \$thisthing + exit 0 + elif test "X$_exe" != X -a -f \$thisthing$_exe; then + echo \$thisthing + exit 0 + elif test -f \$dir/\$thing.exe; then + if test -n "$DJGPP"; then + echo \$dir/\$thing.exe + elif test "$eunicefix" != ":"; then + : on Eunice apparently + echo \$dir/\$thing + fi + exit 0 + fi + ;; + esac +done +echo \$dflt +exit 1 +EOSC +chmod +x loc +$eunicefix loc +loclist=" +awk +cat +chmod +comm +cp +echo +expr +grep +ls +mkdir +rm +sed +sort +touch +tr +uniq +" +trylist=" +ar +bison +byacc +cpp +csh +date +egrep +gmake +gzip +less +ln +make +more +nm +nroff +perl +pg +test +uname +zip +" +pth=`echo $PATH | sed -e "s/$p_/ /g"` +pth="$pth /lib /usr/lib" +for file in $loclist; do + eval xxx=\$$file + case "$xxx" in + /*|?:[\\/]*) + if test -f "$xxx"; then + : ok + else + echo "WARNING: no $xxx -- ignoring your setting for $file." >&4 + xxx=`./loc $file $file $pth` + fi + ;; + '') xxx=`./loc $file $file $pth`;; + *) xxx=`./loc $xxx $xxx $pth`;; + esac + eval $file=$xxx$_exe + eval _$file=$xxx + case "$xxx" in + /*) + echo $file is in $xxx. + ;; + ?:[\\/]*) + echo $file is in $xxx. + ;; + *) + echo "I don't know where '$file' is, and my life depends on it." >&4 + echo "Go find a public domain implementation or fix your PATH setting!" >&4 + exit 1 + ;; + esac +done +echo " " +echo "Don't worry if any of the following aren't found..." +say=offhand +for file in $trylist; do + eval xxx=\$$file + case "$xxx" in + /*|?:[\\/]*) + if test -f "$xxx"; then + : ok + else + echo "WARNING: no $xxx -- ignoring your setting for $file." >&4 + xxx=`./loc $file $file $pth` + fi + ;; + '') xxx=`./loc $file $file $pth`;; + *) xxx=`./loc $xxx $xxx $pth`;; + esac + eval $file=$xxx$_exe + eval _$file=$xxx + case "$xxx" in + /*) + echo $file is in $xxx. + ;; + ?:[\\/]*) + echo $file is in $xxx. + ;; + *) + echo "I don't see $file out there, $say." + say=either + ;; + esac +done +case "$egrep" in +egrep) + echo "Substituting grep for egrep." + egrep=$grep + _egrep=$grep + ;; +esac +case "$less" in +'') ;; +*) if $less -R /dev/null; then + echo "Substituting less -R for less." + less="$less -R" + _less=$less + fi + ;; +esac +case "$ln" in +ln) + echo "Substituting cp for ln." + ln=$cp + _ln=$cp + ;; +esac +case "$make" in +make) + case "$gmake" in + gmake) + echo "I can't find make or gmake, and my life depends on it." >&4 + echo "Go find a public domain implementation or fix your PATH setting!" >&4 + exit 1 + ;; + esac + ;; +esac +case "$gmake" in +gmake) ;; +*) # We can't have osname yet. + if test -f "/system/gnu_library/bin/ar.pm"; then # Stratus VOS + # Assume that gmake, if found, is definitely GNU make + # and prefer it over the system make. + echo "Substituting gmake for make." + make=$gmake + _make=$gmake + fi + ;; +esac +case "$test" in +test) + echo "Hopefully test is built into your sh." + ;; +*) + if `sh -c "PATH= test true" >/dev/null 2>&1`; then + echo "Using the test built into your sh." + test=test + _test=test + fi + ;; +esac +case "$echo" in +echo) + echo "Hopefully echo is built into your sh." + ;; +'') ;; +*) + echo " " +echo "Checking compatibility between $echo and builtin echo (if any)..." >&4 + $echo $n "hi there$c" >foo1 + echo $n "hi there$c" >foo2 + if cmp foo1 foo2 >/dev/null 2>&1; then + echo "They are compatible. In fact, they may be identical." + else + case "$n" in + '-n') n='' c='\c';; + *) n='-n' c='';; + esac + cat <$c" + $echo "*" + fi + $rm -f foo1 foo2 + ;; +esac + +# This question was auctioned at YAPC::Europe-2007 in Vienna +# I never promised you could answer it. I only auctioned the question. +cat <trygcc +$startsh +EOS +cat <<'EOSC' >>trygcc +case "$cc" in +'') ;; +*) $rm -f try try.* + $cat >try.c <&4 + despair=yes + trygcc=yes + case "$cc" in + *gcc*) trygcc=no ;; + esac + # Skip this test because it gives a false match on output like: + # ./trygcc: line 23: cc: command not found + # case "`$cc -v -c try.c 2>&1`" in + # *gcc*) trygcc=no ;; + # esac + if $test X"$trygcc" = Xyes; then + if gcc -o try -c try.c; then + echo " " + echo "You seem to have a working gcc, though." >&4 + # Switching compilers may undo the work of hints files. + # The most common problem is -D_REENTRANT for threads. + # This heuristic catches that case, but gets false positives + # if -Dusethreads was not actually specified. Better to + # bail out here with a useful message than fail + # mysteriously later. Should we perhaps just try to + # re-invoke Configure -Dcc=gcc config_args ? + if $test -f usethreads.cbu; then + $cat >&4 <&2 + exit 1 + fi + fi + case "$ans" in + [yY]*) cc=gcc; ccname=gcc; ccflags=''; despair=no; + esac + fi + fi + fi + $rm -f try try.* + ;; +esac +EOSC + +cat <checkcc +$startsh +EOS +cat <<'EOSC' >>checkcc +case "$cc" in +'') ;; +*) $rm -f try try.* + $cat >try.c <&4 + fi + $cat >&4 < /dev/null 2>&1 ; then + echo "Symbolic links are supported." >&4 + lns="$ln -s" +else + echo "Symbolic links are NOT supported." >&4 + lns="$ln" +fi +$rm -f blurfl sym + +: determine whether symbolic links are supported +echo " " +case "$lns" in +*"ln"*" -s") + echo "Checking how to test for symbolic links..." >&4 + $lns blurfl sym + if $test "X$issymlink" = X; then + case "$newsh" in + '') sh -c "PATH= test -h sym" >/dev/null 2>&1 ;; + *) $newsh -c "PATH= test -h sym" >/dev/null 2>&1 ;; + esac + if test $? = 0; then + issymlink="test -h" + else + echo "Your builtin 'test -h' may be broken." >&4 + case "$test" in + /*) ;; + *) pth=`echo $PATH | sed -e "s/$p_/ /g"` + for p in $pth + do + if test -f "$p/$test"; then + test="$p/$test" + break + fi + done + ;; + esac + case "$test" in + /*) + echo "Trying external '$test -h'." >&4 + issymlink="$test -h" + if $test ! -h sym >/dev/null 2>&1; then + echo "External '$test -h' is broken, too." >&4 + issymlink='' + fi + ;; + *) issymlink='' ;; + esac + fi + fi + if $test "X$issymlink" = X; then + if $test -L sym 2>/dev/null; then + issymlink="$test -L" + echo "The builtin '$test -L' worked." >&4 + fi + fi + if $test "X$issymlink" != X; then + echo "You can test for symbolic links with '$issymlink'." >&4 + else + echo "I do not know how you can test for symbolic links." >&4 + fi + $rm -f blurfl sym + ;; +*) echo "No symbolic links, so not testing for their testing..." >&4 + ;; +esac +echo " " + +: Make symlinks util +case "$mksymlinks" in +$define|true|[yY]*) + case "$src" in + ''|'.') echo "Cannot create symlinks in the original directory." >&4 + exit 1 + ;; + *) case "$lns:$issymlink" in + *"ln"*" -s:"*"test -"?) + echo "Creating the symbolic links..." >&4 + echo "(First creating the subdirectories...)" >&4 + cd .. + awk '{print $1}' $src/MANIFEST | grep / | sed 's:/[^/]*$::' | sort -u | while true; do + read directory + test -z "$directory" && break + mkdir -p $directory + done + # Sanity check 1. + if test ! -d t/base; then + echo "Failed to create the subdirectories. Aborting." >&4 + exit 1 + fi + echo "(Then creating the symlinks...)" >&4 + awk '{print $1}' $src/MANIFEST | while true; do + read filename + test -z "$filename" && break + if test -f $filename; then + if $issymlink $filename; then + rm -f $filename + fi + fi + if test -f $filename; then + echo "$filename already exists, not symlinking." + else + ln -s $src/$filename $filename + fi + done + # Sanity check 2. + if test ! -f t/base/lex.t; then + echo "Failed to create the symlinks (t/base/lex.t missing). Aborting." >&4 + exit 1 + fi + cd UU + ;; + *) echo "(I cannot figure out how to do symbolic links, ignoring mksymlinks)." >&4 + ;; + esac + ;; + esac + ;; +esac + +: Check for Cross-Compilation +case "$usecrosscompile" in +$define|true|[yY]*) + $echo "Cross-compiling..." + croak='' + case "$cc" in + *-*-gcc) # A cross-compiling gcc, probably. + targetarch=`$echo $cc|$sed 's/-gcc$//'` + ar=$targetarch-ar + # leave out ld, choosing it is more complex + nm=$targetarch-nm + ranlib=$targetarch-ranlib + $echo 'extern int foo;' > try.c + set X `$cc -v -E try.c 2>&1 | $awk '/^#include &4 + for i in $*; do + j="`$echo $i|$sed 's,/include$,/lib,'`" + if $test -d $j; then + libpth="$libpth $j" + fi + done + libpth="`$echo $libpth|$sed 's/^ //'`" + echo "Guessing libpth '$libpth'." >&4 + fi + $rm -f try.c + ;; + esac + case "$targetarch" in + '') echo "Targetarch not defined." >&4; croak=y ;; + *) echo "Using targetarch $targetarch." >&4 ;; + esac + case "$incpth" in + '') echo "Incpth not defined." >&4; croak=y ;; + *) echo "Using incpth '$incpth'." >&4 ;; + esac + case "$libpth" in + '') echo "Libpth not defined." >&4; croak=y ;; + *) echo "Using libpth '$libpth'." >&4 ;; + esac + case "$usrinc" in + '') for i in $incpth; do + if $test -f $i/errno.h -a -f $i/stdio.h -a -f $i/time.h; then + usrinc=$i + echo "Guessing usrinc $usrinc." >&4 + break + fi + done + case "$usrinc" in + '') echo "Usrinc not defined." >&4; croak=y ;; + esac + ;; + *) echo "Using usrinc $usrinc." >&4 ;; + esac + case "$targethost" in + '') echo "Targethost not defined." >&4; croak=y ;; + *) echo "Using targethost $targethost." >&4 + esac + locincpth=' ' + loclibpth=' ' + case "$croak" in + y) echo "Cannot continue, aborting." >&4; exit 1 ;; + esac + case "$src" in + /*) run=$src/Cross/run + targetmkdir=$src/Cross/mkdir + to=$src/Cross/to + from=$src/Cross/from + ;; + *) pwd=`$test -f ../Configure & cd ..; pwd` + run=$pwd/Cross/run + targetmkdir=$pwd/Cross/mkdir + to=$pwd/Cross/to + from=$pwd/Cross/from + ;; + esac + case "$targetrun" in + '') targetrun=ssh ;; + esac + case "$targetto" in + '') targetto=scp ;; + esac + case "$targetfrom" in + '') targetfrom=scp ;; + esac + run=$run-$targetrun + to=$to-$targetto + from=$from-$targetfrom + case "$targetdir" in + '') targetdir=/tmp + echo "Guessing targetdir $targetdir." >&4 + ;; + esac + case "$targetuser" in + '') targetuser=root + echo "Guessing targetuser $targetuser." >&4 + ;; + esac + case "$targetfrom" in + scp) q=-q ;; + *) q='' ;; + esac + case "$targetrun" in + ssh|rsh) + cat >$run <&4 + exit 1 + ;; + esac + case "$targetmkdir" in + */Cross/mkdir) + cat >$targetmkdir <&4 + exit 1 + ;; + esac + case "$targetto" in + scp|rcp) + cat >$to <$to <&4 + exit 1 + ;; + esac + case "$targetfrom" in + scp|rcp) + cat >$from <$from <&4 + exit 1 + ;; + esac + if $test ! -f $run; then + echo "Target 'run' script '$run' not found." >&4 + else + $chmod a+rx $run + fi + if $test ! -f $to; then + echo "Target 'to' script '$to' not found." >&4 + else + $chmod a+rx $to + fi + if $test ! -f $from; then + echo "Target 'from' script '$from' not found." >&4 + else + $chmod a+rx $from + fi + if $test ! -f $run -o ! -f $to -o ! -f $from; then + exit 1 + fi + cat >&4 </dev/null`" in +ABYZ) + echo "Good, your tr supports [:lower:] and [:upper:] to convert case." >&4 + up='[:upper:]' + low='[:lower:]' + ;; +*) # There is a discontinuity in EBCDIC between 'R' and 'S' + # (0xd9 and 0xe2), therefore that is a nice testing point. + if test "X$up" = X -o "X$low" = X; then + case "`echo RS | $tr '[R-S]' '[r-s]' 2>/dev/null`" in + rs) up='[A-Z]' + low='[a-z]' + ;; + esac + fi + if test "X$up" = X -o "X$low" = X; then + case "`echo RS | $tr R-S r-s 2>/dev/null`" in + rs) up='A-Z' + low='a-z' + ;; + esac + fi + if test "X$up" = X -o "X$low" = X; then + case "`echo RS | od -x 2>/dev/null`" in + *D9E2*|*d9e2*) + echo "Hey, this might be EBCDIC." >&4 + if test "X$up" = X -o "X$low" = X; then + case "`echo RS | $tr '[A-IJ-RS-Z]' '[a-ij-rs-z]' 2>/dev/null`" in + rs) up='[A-IJ-RS-Z]' + low='[a-ij-rs-z]' + ;; + esac + fi + if test "X$up" = X -o "X$low" = X; then + case "`echo RS | $tr A-IJ-RS-Z a-ij-rs-z 2>/dev/null`" in + rs) up='A-IJ-RS-Z' + low='a-ij-rs-z' + ;; + esac + fi + ;; + esac + fi +esac +case "`echo RS | $tr \"$up\" \"$low\" 2>/dev/null`" in +rs) + echo "Using $up and $low to convert case." >&4 + ;; +*) + echo "I don't know how to translate letters from upper to lower case." >&4 + echo "Your tr is not acting any way I know of." >&4 + exit 1 + ;; +esac +: set up the translation script tr, must be called with ./tr of course +cat >tr </dev/null` +$test -z "$myuname" && myuname=`hostname 2>/dev/null` +# tr '[A-Z]' '[a-z]' would not work in EBCDIC +# because the A-Z/a-z are not consecutive. +myuname=`echo $myuname | $sed -e 's/^[^=]*=//' -e "s,['/],,g" | \ + ./tr '[A-Z]' '[a-z]' | $tr $trnl ' '` +newmyuname="$myuname" +dflt=n +case "$knowitall" in +'') + if test -f ../config.sh; then + if $contains myuname= ../config.sh >/dev/null 2>&1; then + eval "`grep myuname= ../config.sh`" + fi + if test "X$myuname" = "X$newmyuname"; then + dflt=y + fi + fi + ;; +*) dflt=y;; +esac + +: Get old answers from old config file if Configure was run on the +: same system, otherwise use the hints. +hint=default +cd .. +if test -f config.sh; then + echo " " + rp="I see a config.sh file. Shall I use it to set the defaults?" + . UU/myread + case "$ans" in + n*|N*) echo "OK, I'll ignore it." + mv config.sh config.sh.old + myuname="$newmyuname" + ;; + *) echo "Fetching default answers from your old config.sh file..." >&4 + tmp_n="$n" + tmp_c="$c" + tmp_sh="$sh" + . ./config.sh + cp config.sh UU + n="$tmp_n" + c="$tmp_c" + : Older versions did not always set $sh. Catch re-use of such + : an old config.sh. + case "$sh" in + '') sh="$tmp_sh" ;; + esac + hint=previous + ;; + esac +fi +. ./UU/checkcc +if test ! -f config.sh; then + $cat <&4 + dflt='' + : Half the following guesses are probably wrong... If you have better + : tests or hints, please send them to perlbug@perl.org + : The metaconfig authors would also appreciate a copy... + $test -f /irix && osname=irix + $test -f /xenix && osname=sco_xenix + $test -f /dynix && osname=dynix + $test -f /dnix && osname=dnix + $test -f /lynx.os && osname=lynxos + $test -f /unicos && osname=unicos && osvers=`$uname -r` + $test -f /unicosmk && osname=unicosmk && osvers=`$uname -r` + $test -f /unicosmk.ar && osname=unicosmk && osvers=`$uname -r` + $test -f /bin/mips && /bin/mips && osname=mips + $test -d /NextApps && set X `hostinfo | grep 'NeXT Mach.*:' | \ + $sed -e 's/://' -e 's/\./_/'` && osname=next && osvers=$4 + $test -d /usr/apollo/bin && osname=apollo + $test -f /etc/saf/_sactab && osname=svr4 + $test -d /usr/include/minix && osname=minix + $test -f /system/gnu_library/bin/ar.pm && osname=vos + if $test -d /MachTen -o -d /MachTen_Folder; then + osname=machten + if $test -x /sbin/version; then + osvers=`/sbin/version | $awk '{print $2}' | + $sed -e 's/[A-Za-z]$//'` + elif $test -x /usr/etc/version; then + osvers=`/usr/etc/version | $awk '{print $2}' | + $sed -e 's/[A-Za-z]$//'` + else + osvers="$2.$3" + fi + fi + + $test -f /sys/posix.dll && + $test -f /usr/bin/what && + set X `/usr/bin/what /sys/posix.dll` && + $test "$3" = UWIN && + osname=uwin && + osvers="$5" + + if $test -f $uname; then + set X $myuname + shift + + case "$5" in + fps*) osname=fps ;; + mips*) + case "$4" in + umips) osname=umips ;; + *) osname=mips ;; + esac;; + [23]100) osname=mips ;; + next*) osname=next ;; + i386*) + tmp=`/bin/uname -X 2>/dev/null|awk '/3\.2v[45]/{ print $(NF) }'` + if $test "$tmp" != "" -a "$3" = "3.2" -a -f '/etc/systemid'; then + osname='sco' + osvers=$tmp + elif $test -f /etc/kconfig; then + osname=isc + if test "$lns" = "$ln -s"; then + osvers=4 + elif $contains _SYSV3 /usr/include/stdio.h > /dev/null 2>&1 ; then + osvers=3 + elif $contains _POSIX_SOURCE /usr/include/stdio.h > /dev/null 2>&1 ; then + osvers=2 + fi + fi + tmp='' + ;; + pc*) + if test -n "$DJGPP"; then + osname=dos + osvers=djgpp + fi + ;; + esac + + case "$1" in + aix) osname=aix + tmp=`( (oslevel) 2>/dev/null || echo "not found") 2>&1` + case "$tmp" in + # oslevel can fail with: + # oslevel: Unable to acquire lock. + *not\ found) osvers="$4"."$3" ;; + '<3240'|'<>3240') osvers=3.2.0 ;; + '=3240'|'>3240'|'<3250'|'<>3250') osvers=3.2.4 ;; + '=3250'|'>3250') osvers=3.2.5 ;; + *) osvers=$tmp;; + esac + ;; + bsd386) osname=bsd386 + osvers=`$uname -r` + ;; + cygwin*) osname=cygwin + osvers="$3" + ;; + *dc.osx) osname=dcosx + osvers="$3" + ;; + dnix) osname=dnix + osvers="$3" + ;; + domainos) osname=apollo + osvers="$3" + ;; + dgux) osname=dgux + osvers="$3" + ;; + dragonfly) osname=dragonfly + osvers="$3" + ;; + dynixptx*) osname=dynixptx + osvers=`echo "$4"|sed 's/^v//'` + ;; + freebsd) osname=freebsd + osvers="$3" ;; + genix) osname=genix ;; + gnu) osname=gnu + osvers="$3" ;; + hp*) osname=hpux + osvers=`echo "$3" | $sed 's,.*\.\([0-9]*\.[0-9]*\),\1,'` + ;; + irix*) osname=irix + case "$3" in + 4*) osvers=4 ;; + 5*) osvers=5 ;; + *) osvers="$3" ;; + esac + ;; + linux) osname=linux + case "$3" in + *) osvers="$3" ;; + esac + ;; + MiNT) osname=mint + ;; + netbsd*) osname=netbsd + osvers="$3" + ;; + news-os) osvers="$3" + case "$3" in + 4*) osname=newsos4 ;; + *) osname=newsos ;; + esac + ;; + next*) osname=next ;; + nonstop-ux) osname=nonstopux ;; + openbsd) osname=openbsd + osvers="$3" + ;; + os2) osname=os2 + osvers="$4" + ;; + POSIX-BC | posix-bc ) osname=posix-bc + osvers="$3" + ;; + powerux | power_ux | powermax_os | powermaxos | \ + powerunix | power_unix) osname=powerux + osvers="$3" + ;; + qnx) osname=qnx + osvers="$4" + ;; + solaris) osname=solaris + case "$3" in + 5*) osvers=`echo $3 | $sed 's/^5/2/g'` ;; + *) osvers="$3" ;; + esac + ;; + sunos) osname=sunos + case "$3" in + 5*) osname=solaris + osvers=`echo $3 | $sed 's/^5/2/g'` ;; + *) osvers="$3" ;; + esac + ;; + titanos) osname=titanos + case "$3" in + 1*) osvers=1 ;; + 2*) osvers=2 ;; + 3*) osvers=3 ;; + 4*) osvers=4 ;; + *) osvers="$3" ;; + esac + ;; + ultrix) osname=ultrix + osvers="$3" + ;; + osf1|mls+) case "$5" in + alpha) + osname=dec_osf + osvers=`sizer -v | awk -FUNIX '{print $2}' | awk '{print $1}' | tr '[A-Z]' '[a-z]' | sed 's/^[xvt]//'` + case "$osvers" in + [1-9].[0-9]*) ;; + *) osvers=`echo "$3" | sed 's/^[xvt]//'` ;; + esac + ;; + hp*) osname=hp_osf1 ;; + mips) osname=mips_osf1 ;; + esac + ;; + # UnixWare 7.1.2 is known as Open UNIX 8 + openunix|unixware) osname=svr5 + osvers="$4" + ;; + uts) osname=uts + osvers="$3" + ;; + vos) osvers="$3" + ;; + $2) case "$osname" in + *isc*) ;; + *freebsd*) ;; + svr*) + : svr4.x or possibly later + case "svr$3" in + ${osname}*) + osname=svr$3 + osvers=$4 + ;; + esac + case "$osname" in + svr4.0) + : Check for ESIX + if test -f /stand/boot ; then + eval `grep '^INITPROG=[a-z/0-9]*$' /stand/boot` + if test -n "$INITPROG" -a -f "$INITPROG"; then + isesix=`strings -a $INITPROG|grep 'ESIX SYSTEM V/386 Release 4.0'` + if test -n "$isesix"; then + osname=esix4 + fi + fi + fi + ;; + esac + ;; + *) if test -f /etc/systemid; then + osname=sco + set `echo $3 | $sed 's/\./ /g'` $4 + if $test -f $src/hints/sco_$1_$2_$3.sh; then + osvers=$1.$2.$3 + elif $test -f $src/hints/sco_$1_$2.sh; then + osvers=$1.$2 + elif $test -f $src/hints/sco_$1.sh; then + osvers=$1 + fi + else + case "$osname" in + '') : Still unknown. Probably a generic Sys V. + osname="sysv" + osvers="$3" + ;; + esac + fi + ;; + esac + ;; + *) case "$osname" in + '') : Still unknown. Probably a generic BSD. + osname="$1" + osvers="$3" + ;; + esac + ;; + esac + else + if test -f /vmunix -a -f $src/hints/news_os.sh; then + (what /vmunix | UU/tr '[A-Z]' '[a-z]') > UU/kernel.what 2>&1 + if $contains news-os UU/kernel.what >/dev/null 2>&1; then + osname=news_os + fi + $rm -f UU/kernel.what + elif test -d c:/. -o -n "$is_os2" ; then + set X $myuname + osname=os2 + osvers="$5" + fi + fi + + case "$targetarch" in + '') ;; + *) hostarch=$osname + osname=`echo $targetarch|sed 's,^[^-]*-,,'` + osvers='' + ;; + esac + + : Now look for a hint file osname_osvers, unless one has been + : specified already. + case "$hintfile" in + ''|' ') + file=`echo "${osname}_${osvers}" | $sed -e 's%\.%_%g' -e 's%_$%%'` + : Also try without trailing minor version numbers. + xfile=`echo $file | $sed -e 's%_[^_]*$%%'` + xxfile=`echo $xfile | $sed -e 's%_[^_]*$%%'` + xxxfile=`echo $xxfile | $sed -e 's%_[^_]*$%%'` + xxxxfile=`echo $xxxfile | $sed -e 's%_[^_]*$%%'` + case "$file" in + '') dflt=none ;; + *) case "$osvers" in + '') dflt=$file + ;; + *) if $test -f $src/hints/$file.sh ; then + dflt=$file + elif $test -f $src/hints/$xfile.sh ; then + dflt=$xfile + elif $test -f $src/hints/$xxfile.sh ; then + dflt=$xxfile + elif $test -f $src/hints/$xxxfile.sh ; then + dflt=$xxxfile + elif $test -f $src/hints/$xxxxfile.sh ; then + dflt=$xxxxfile + elif $test -f "$src/hints/${osname}.sh" ; then + dflt="${osname}" + else + dflt=none + fi + ;; + esac + ;; + esac + if $test -f Policy.sh ; then + case "$dflt" in + *Policy*) ;; + none) dflt="Policy" ;; + *) dflt="Policy $dflt" ;; + esac + fi + ;; + *) + dflt=`echo $hintfile | $sed 's/\.sh$//'` + ;; + esac + + if $test -f Policy.sh ; then + $cat <> UU/config.sh + elif $test -f $src/hints/$file.sh; then + . $src/hints/$file.sh + $cat $src/hints/$file.sh >> UU/config.sh + elif $test X"$tans" = X -o X"$tans" = Xnone ; then + : nothing + else + : Give one chance to correct a possible typo. + echo "$file.sh does not exist" + dflt=$file + rp="hint to use instead?" + . UU/myread + for file in $ans; do + if $test -f "$src/hints/$file.sh"; then + . $src/hints/$file.sh + $cat $src/hints/$file.sh >> UU/config.sh + elif $test X$ans = X -o X$ans = Xnone ; then + : nothing + else + echo "$file.sh does not exist -- ignored." + fi + done + fi + done + + hint=recommended + : Remember our hint file for later. + if $test -f "$src/hints/$file.sh" ; then + hintfile="$file" + else + hintfile='' + fi +fi +cd UU +;; +*) + echo " " + echo "Fetching default answers from $config_sh..." >&4 + tmp_n="$n" + tmp_c="$c" + cd .. + cp $config_sh config.sh 2>/dev/null + chmod +w config.sh + . ./config.sh + cd UU + cp ../config.sh . + n="$tmp_n" + c="$tmp_c" + hint=previous + ;; +esac +test "$override" && . ./optdef.sh + +: Restore computed paths +for file in $loclist $trylist; do + eval $file="\$_$file" +done + +cat << EOM + +Configure uses the operating system name and version to set some defaults. +The default value is probably right if the name rings a bell. Otherwise, +since spelling matters for me, either accept the default or answer "none" +to leave it blank. + +EOM +case "$osname" in + ''|' ') + case "$hintfile" in + ''|' '|none) dflt=none ;; + *) dflt=`echo $hintfile | $sed -e 's/\.sh$//' -e 's/_.*$//'` ;; + esac + ;; + *) dflt="$osname" ;; +esac +rp="Operating system name?" +. ./myread +case "$ans" in +none) osname='' ;; +*) osname=`echo "$ans" | $sed -e 's/[ ][ ]*/_/g' | ./tr '[A-Z]' '[a-z]'`;; +esac +echo " " +case "$osvers" in + ''|' ') + case "$hintfile" in + ''|' '|none) dflt=none ;; + *) dflt=`echo $hintfile | $sed -e 's/\.sh$//' -e 's/^[^_]*//'` + dflt=`echo $dflt | $sed -e 's/^_//' -e 's/_/./g'` + case "$dflt" in + ''|' ') dflt=none ;; + esac + ;; + esac + ;; + *) dflt="$osvers" ;; +esac +rp="Operating system version?" +. ./myread +case "$ans" in +none) osvers='' ;; +*) osvers="$ans" ;; +esac + + +. ./posthint.sh + +: who configured the system +cf_time=`LC_ALL=C; LANGUAGE=C; export LC_ALL; export LANGUAGE; $date 2>&1` +case "$cf_by" in +"") + cf_by=`(logname) 2>/dev/null` + case "$cf_by" in + "") + cf_by=`(whoami) 2>/dev/null` + case "$cf_by" in + "") cf_by=unknown ;; + esac ;; + esac ;; +esac + +: decide how portable to be. Allow command line overrides. +case "$d_portable" in +"$undef") ;; +*) d_portable="$define" ;; +esac + +: set up shell script to do ~ expansion +cat >filexp <&2 + exit 1 + fi + case "\$1" in + */*) + echo \$dir/\`$expr x\$1 : '..[^/]*/\(.*\)'\` + ;; + *) + echo \$dir + ;; + esac + fi + ;; +*) + echo \$1 + ;; +esac +EOSS +chmod +x filexp +$eunicefix filexp + +: now set up to get a file name +cat <getfile +$startsh +EOS +cat <<'EOSC' >>getfile +tilde='' +fullpath='' +already='' +skip='' +none_ok='' +exp_file='' +nopath_ok='' +orig_rp="$rp" +orig_dflt="$dflt" +case "$gfpth" in +'') gfpth='.' ;; +esac + +case "$fn" in +*\(*) + : getfile will accept an answer from the comma-separated list + : enclosed in parentheses even if it does not meet other criteria. + expr "$fn" : '.*(\(.*\)).*' | $tr ',' $trnl >getfile.ok + fn=`echo $fn | sed 's/(.*)//'` + ;; +esac + +case "$fn" in +*:*) + loc_file=`expr $fn : '.*:\(.*\)'` + fn=`expr $fn : '\(.*\):.*'` + ;; +esac + +case "$fn" in +*~*) tilde=true;; +esac +case "$fn" in +*/*) fullpath=true;; +esac +case "$fn" in +*+*) skip=true;; +esac +case "$fn" in +*n*) none_ok=true;; +esac +case "$fn" in +*e*) exp_file=true;; +esac +case "$fn" in +*p*) nopath_ok=true;; +esac + +case "$fn" in +*f*) type='File';; +*d*) type='Directory';; +*l*) type='Locate';; +esac + +what="$type" +case "$what" in +Locate) what='File';; +esac + +case "$exp_file" in +'') + case "$d_portable" in + "$define") ;; + *) exp_file=true;; + esac + ;; +esac + +cd .. +while test "$type"; do + redo='' + rp="$orig_rp" + dflt="$orig_dflt" + case "$tilde" in + true) rp="$rp (~name ok)";; + esac + . UU/myread + if test -f UU/getfile.ok && \ + $contains "^$ans\$" UU/getfile.ok >/dev/null 2>&1 + then + value="$ans" + ansexp="$ans" + break + fi + case "$ans" in + none) + value='' + ansexp='' + case "$none_ok" in + true) type='';; + esac + ;; + *) + case "$tilde" in + '') value="$ans" + ansexp="$ans";; + *) + value=`UU/filexp $ans` + case $? in + 0) + if test "$ans" != "$value"; then + echo "(That expands to $value on this system.)" + fi + ;; + *) value="$ans";; + esac + ansexp="$value" + case "$exp_file" in + '') value="$ans";; + esac + ;; + esac + case "$fullpath" in + true) + case "$ansexp" in + /*) value="$ansexp" ;; + [a-zA-Z]:/*) value="$ansexp" ;; + *) + redo=true + case "$already" in + true) + echo "I shall only accept a full path name, as in /bin/ls." >&4 + echo "Use a ! shell escape if you wish to check pathnames." >&4 + ;; + *) + echo "Please give a full path name, starting with slash." >&4 + case "$tilde" in + true) + echo "Note that using ~name is ok provided it expands well." >&4 + already=true + ;; + esac + esac + ;; + esac + ;; + esac + case "$redo" in + '') + case "$type" in + File) + for fp in $gfpth; do + if test "X$fp" = X.; then + pf="$ansexp" + else + pf="$fp/$ansexp" + fi + if test -f "$pf"; then + type='' + elif test -r "$pf" || (test -h "$pf") >/dev/null 2>&1 + then + echo "($value is not a plain file, but that's ok.)" + type='' + fi + if test X"$type" = X; then + value="$pf" + break + fi + done + ;; + Directory) + for fp in $gfpth; do + if test "X$fp" = X.; then + dir="$ans" + direxp="$ansexp" + else + dir="$fp/$ansexp" + direxp="$fp/$ansexp" + fi + if test -d "$direxp"; then + type='' + value="$dir" + break + fi + done + ;; + Locate) + if test -d "$ansexp"; then + echo "(Looking for $loc_file in directory $value.)" + value="$value/$loc_file" + ansexp="$ansexp/$loc_file" + fi + if test -f "$ansexp"; then + type='' + fi + case "$nopath_ok" in + true) case "$value" in + */*) ;; + *) echo "Assuming $value will be in people's path." + type='' + ;; + esac + ;; + esac + ;; + esac + + case "$skip" in + true) type=''; + esac + + case "$type" in + '') ;; + *) + if test "$fastread" = yes; then + dflt=y + else + dflt=n + fi + rp="$what $value doesn't exist. Use that name anyway?" + . UU/myread + dflt='' + case "$ans" in + y*) type='';; + *) echo " ";; + esac + ;; + esac + ;; + esac + ;; + esac +done +cd UU +ans="$value" +rp="$orig_rp" +dflt="$orig_dflt" +rm -f getfile.ok +test "X$gfpthkeep" != Xy && gfpth="" +EOSC + +: determine root of directory hierarchy where package will be installed. +case "$prefix" in +'') + dflt=`./loc . /usr/local /usr/local /local /opt /usr` + ;; +*?/) + dflt=`echo "$prefix" | sed 's/.$//'` + ;; +*) + 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 <installprefix +$startsh +EOS +cat <<'EOSC' >>installprefix +: Change installation prefix, if necessary. +if $test X"$prefix" != X"$installprefix"; then + eval "install${prefixvar}=\`echo \$${prefixvar}exp | sed \"s#^\$prefixexp#\$installprefixexp#\"\`" +else + eval "install${prefixvar}=\"\$${prefixvar}exp\"" +fi +EOSC +chmod +x installprefix +$eunicefix installprefix + +: Set variables such as privlib and privlibexp from the output of ./getfile +: performing the prefixexp/installprefixexp correction if necessary. +cat <setprefixvar +$startsh +EOS +cat <<'EOSC' >>setprefixvar +eval "${prefixvar}=\"\$ans\"" +eval "${prefixvar}exp=\"\$ansexp\"" +. ./installprefix +EOSC +chmod +x setprefixvar +$eunicefix setprefixvar + +: set up the script used to warn in case of inconsistency +cat <whoa +$startsh +EOS +cat <<'EOSC' >>whoa +dflt=y +case "$hint" in + recommended) + case "$hintfile" in + '') echo "The $hint value for \$$var on this machine was \"$was\"!" >&4 + ;; + *) echo "Hmm. Based on the hints in hints/$hintfile.sh, " >&4 + echo "the $hint value for \$$var on this machine was \"$was\"!" >&4 + ;; + esac + ;; + *) echo " " + echo "*** WHOA THERE!!! ***" >&4 + echo " The $hint value for \$$var on this machine was \"$was\"!" >&4 + ;; +esac +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' + +: get the patchlevel +echo " " +echo "Getting the current patchlevel..." >&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` + perl_patchlevel=`egrep ',"(MAINT|SMOKE)[0-9][0-9]*"' $rsrc/patchlevel.h|tail -1|sed 's/[^0-9]//g'` +else + revision=0 + patchlevel=0 + subversion=0 + api_revision=0 + api_version=0 + api_subversion=0 + perl_patchlevel=0 + $echo "(You do not have patchlevel.h. Eek.)" +fi +: Define a handy string here to avoid duplication in myconfig.SH and configpm. +version_patchlevel_string="version $patchlevel subversion $subversion" +case "$perl_patchlevel" in +0|'') ;; +*) perl_patchlevel=`echo $perl_patchlevel | sed 's/.* //'` + version_patchlevel_string="$version_patchlevel_string patch $perl_patchlevel" + ;; +esac + +$echo "(You have $package $version_patchlevel_string.)" + +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 + +: Do we want threads support and if so, what type +case "$usethreads" in +$define|true|[yY]*) dflt='y';; +*) # Catch case where user specified ithreads or 5005threads but + # forgot -Dusethreads (A.D. 4/2002) + case "$useithreads$use5005threads" in + *$define*) dflt='y';; + *) dflt='n';; + esac + ;; +esac +cat <&4 <&4 <bsd +echo exit 1 >usg +echo exit 1 >v7 +echo exit 1 >osf1 +echo exit 1 >eunice +echo exit 1 >xenix +echo exit 1 >venix +echo exit 1 >os2 +d_bsd="$undef" +$cat /usr/include/signal.h /usr/include/sys/signal.h >foo 2>/dev/null +if test -f /osf_boot || $contains 'OSF/1' /usr/include/ctype.h >/dev/null 2>&1 +then + echo "Looks kind of like an OSF/1 system, but we'll see..." + echo exit 0 >osf1 +elif test `echo abc | $tr a-z A-Z` = Abc ; then + xxx=`./loc addbib blurfl $pth` + if $test -f $xxx; then + echo "Looks kind of like a USG system with BSD features, but we'll see..." + echo exit 0 >bsd + echo exit 0 >usg + else + if $contains SIGTSTP foo >/dev/null 2>&1 ; then + echo "Looks kind of like an extended USG system, but we'll see..." + else + echo "Looks kind of like a USG system, but we'll see..." + fi + echo exit 0 >usg + fi +elif $contains SIGTSTP foo >/dev/null 2>&1 ; then + echo "Looks kind of like a BSD system, but we'll see..." + d_bsd="$define" + echo exit 0 >bsd +else + echo "Looks kind of like a Version 7 system, but we'll see..." + echo exit 0 >v7 +fi +case "$eunicefix" in +*unixtovms*) + $cat <<'EOI' +There is, however, a strange, musty smell in the air that reminds me of +something...hmm...yes...I've got it...there's a VMS nearby, or I'm a Blit. +EOI + echo exit 0 >eunice + d_eunice="$define" +: it so happens the Eunice I know will not run shell scripts in Unix format + ;; +*) + echo " " + echo "Congratulations. You aren't running Eunice." + d_eunice="$undef" + ;; +esac +: Detect OS2. The p_ variable is set above in the Head.U unit. +: Note that this also -- wrongly -- detects e.g. dos-djgpp, which also uses +: semicolon as a patch separator +case "$p_" in +:) ;; +*) + $cat <<'EOI' +I have the feeling something is not exactly right, however...don't tell me... +lemme think...does HAL ring a bell?...no, of course, you're only running OS/2! +(Or you may be running DOS with DJGPP.) +EOI + echo exit 0 >os2 + ;; +esac +if test -f /xenix; then + echo "Actually, this looks more like a XENIX system..." + echo exit 0 >xenix + d_xenix="$define" +else + echo " " + echo "It's not Xenix..." + d_xenix="$undef" +fi +chmod +x xenix +$eunicefix xenix +if test -f /venix; then + echo "Actually, this looks more like a VENIX system..." + echo exit 0 >venix +else + echo " " + if ./xenix; then + : null + else + echo "Nor is it Venix..." + fi +fi +chmod +x bsd usg v7 osf1 eunice xenix venix os2 +$eunicefix bsd usg v7 osf1 eunice xenix venix os2 +$rm -f foo + +: Check if we are using GNU gcc and what its version is +echo " " +echo "Checking for GNU cc in disguise and/or its version number..." >&4 +$cat >try.c < +int main() { +#if defined(__GNUC__) && !defined(__INTEL_COMPILER) +#ifdef __VERSION__ + printf("%s\n", __VERSION__); +#else + printf("%s\n", "1"); +#endif +#endif + return(0); +} +EOM +if $cc -o try $ccflags $ldflags try.c; then + gccversion=`$run ./try` + case "$gccversion" in + '') echo "You are not using GNU cc." ;; + *) echo "You are using GNU cc $gccversion." + ccname=gcc + ;; + esac +else + echo " " + echo "*** WHOA THERE!!! ***" >&4 + echo " Your C compiler \"$cc\" doesn't seem to be working!" >&4 + case "$knowitall" in + '') + echo " You'd better start hunting for one and let me know about it." >&4 + exit 1 + ;; + esac +fi +$rm -f try try.* +case "$gccversion" in +1*) cpp=`./loc gcc-cpp $cpp $pth` ;; +esac +case "$gccversion" in +'') gccosandvers='' ;; +*) gccshortvers=`echo "$gccversion"|sed 's/ .*//'` + gccosandvers=`$cc -v 2>&1|grep '/specs$'|sed "s!.*/[^-/]*-[^-/]*-\([^-/]*\)/$gccshortvers/specs!\1!"` + gccshortvers='' + case "$gccosandvers" in + $osname) gccosandvers='' ;; # linux gccs seem to have no linux osvers, grr + $osname$osvers) ;; # looking good + $osname*) cat <&4 + +*** WHOA THERE!!! *** + + Your gcc has not been compiled for the exact release of + your operating system ($gccosandvers versus $osname$osvers). + + In general it is a good idea to keep gcc synchronized with + the operating system because otherwise serious problems + may ensue when trying to compile software, like Perl. + + I'm trying to be optimistic here, though, and will continue. + If later during the configuration and build icky compilation + problems appear (headerfile conflicts being the most common + manifestation), I suggest reinstalling the gcc to match + your operating system release. + +EOM + ;; + *) gccosandvers='' ;; # failed to parse, better be silent + esac + ;; +esac +case "$ccname" in +'') ccname="$cc" ;; +esac + +# gcc 3.* complain about adding -Idirectories that they already know about, +# so we will take those off from locincpth. +case "$gccversion" in +3*) + echo "main(){}">try.c + for incdir in $locincpth; do + warn=`$cc $ccflags -I$incdir -c try.c 2>&1 | \ + grep '^c[cp]p*[01]: warning: changing search order '` + if test "X$warn" != X; then + locincpth=`echo " $locincpth " | sed "s! $incdir ! !"` + fi + done + $rm -f try try.* +esac + +: What should the include directory be ? +echo " " +$echo $n "Hmm... $c" +dflt='/usr/include' +incpath='' +mips_type='' +if $test -f /bin/mips && /bin/mips; then + echo "Looks like a MIPS system..." + $cat >usr.c <<'EOCP' +#ifdef SYSTYPE_BSD43 +/bsd43 +#endif +EOCP + if cc -E usr.c > usr.out && $contains / usr.out >/dev/null 2>&1; then + dflt='/bsd43/usr/include' + incpath='/bsd43' + mips_type='BSD 4.3' + else + mips_type='System V' + fi + $rm -f usr.c usr.out + echo "and you're compiling with the $mips_type compiler and libraries." + xxx_prompt=y + echo "exit 0" >mips +else + echo "Doesn't look like a MIPS system." + xxx_prompt=n + echo "exit 1" >mips +fi +chmod +x mips +$eunicefix mips +case "$usrinc" in +'') ;; +*) dflt="$usrinc";; +esac +case "$xxx_prompt" in +y) fn=d/ + echo " " + rp='Where are the include files you want to use?' + . ./getfile + usrinc="$ans" + ;; +*) usrinc="$dflt" + ;; +esac + +: see how we invoke the C preprocessor +echo " " +echo "Now, how can we feed standard input to your C preprocessor..." >&4 +cat <<'EOT' >testcpp.c +#define ABC abc +#define XYZ xyz +ABC.XYZ +EOT +cd .. +if test ! -f cppstdin; then + if test "X$osname" = "Xaix" -a "X$gccversion" = X; then + # AIX cc -E doesn't show the absolute headerfile + # locations but we'll cheat by using the -M flag. + echo 'cat >.$$.c; rm -f .$$.u; '"$cc"' ${1+"$@"} -M -c .$$.c 2>/dev/null; test -s .$$.u && awk '"'"'$2 ~ /\.h$/ { print "# 0 \""$2"\"" }'"'"' .$$.u; rm -f .$$.o .$$.u; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' > cppstdin + else + echo 'cat >.$$.c; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' >cppstdin + fi +else + echo "Keeping your $hint cppstdin wrapper." +fi +chmod 755 cppstdin +wrapper=`pwd`/cppstdin +ok='false' +cd UU + +if $test "X$cppstdin" != "X" && \ + $cppstdin $cppminus testcpp.out 2>&1 && \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 +then + echo "You used to use $cppstdin $cppminus so we'll use that again." + case "$cpprun" in + '') echo "But let's see if we can live without a wrapper..." ;; + *) + if $cpprun $cpplast testcpp.out 2>&1 && \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 + then + echo "(And we'll use $cpprun $cpplast to preprocess directly.)" + ok='true' + else + echo "(However, $cpprun $cpplast does not work, let's see...)" + fi + ;; + esac +else + case "$cppstdin" in + '') ;; + *) + echo "Good old $cppstdin $cppminus does not seem to be of any help..." + ;; + esac +fi + +if $ok; then + : nothing +elif echo 'Maybe "'"$cc"' -E" will work...'; \ + $cc -E testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "Yup, it does." + x_cpp="$cc -E" + x_minus=''; +elif echo 'Nope...maybe "'"$cc"' -E -" will work...'; \ + $cc -E - testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "Yup, it does." + x_cpp="$cc -E" + x_minus='-'; +elif echo 'Nope...maybe "'"$cc"' -P" will work...'; \ + $cc -P testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "Yipee, that works!" + x_cpp="$cc -P" + x_minus=''; +elif echo 'Nope...maybe "'"$cc"' -P -" will work...'; \ + $cc -P - testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "At long last!" + x_cpp="$cc -P" + x_minus='-'; +elif echo 'No such luck, maybe "'$cpp'" will work...'; \ + $cpp testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "It works!" + x_cpp="$cpp" + x_minus=''; +elif echo 'Nixed again...maybe "'$cpp' -" will work...'; \ + $cpp - testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "Hooray, it works! I was beginning to wonder." + x_cpp="$cpp" + x_minus='-'; +elif echo 'Uh-uh. Time to get fancy. Trying a wrapper...'; \ + $wrapper testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + x_cpp="$wrapper" + x_minus='' + echo "Eureka!" +else + dflt='' + rp="No dice. I can't find a C preprocessor. Name one:" + . ./myread + x_cpp="$ans" + x_minus='' + $x_cpp testcpp.out 2>&1 + if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then + echo "OK, that will do." >&4 + else +echo "Sorry, I can't get that to work. Go find one and rerun Configure." >&4 + exit 1 + fi +fi + +case "$ok" in +false) + cppstdin="$x_cpp" + cppminus="$x_minus" + cpprun="$x_cpp" + cpplast="$x_minus" + set X $x_cpp + shift + case "$1" in + "$cpp") + echo "Perhaps can we force $cc -E using a wrapper..." + if $wrapper testcpp.out 2>&1; \ + $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 + then + echo "Yup, we can." + cppstdin="$wrapper" + cppminus=''; + else + echo "Nope, we'll have to live without it..." + fi + ;; + esac + case "$cpprun" in + "$wrapper") + cpprun='' + cpplast='' + ;; + esac + ;; +esac + +case "$cppstdin" in +"$wrapper"|'cppstdin') ;; +*) $rm -f $wrapper;; +esac +$rm -f testcpp.c testcpp.out + +: Set private lib path +case "$plibpth" in +'') if ./mips; then + plibpth="$incpath/usr/lib /usr/local/lib /usr/ccs/lib" + fi;; +esac +case "$libpth" in +' ') dlist='';; +'') dlist="$loclibpth $plibpth $glibpth";; +*) dlist="$libpth";; +esac + +: Now check and see which directories actually exist, avoiding duplicates +libpth='' +for xxx in $dlist +do + if $test -d $xxx; then + case " $libpth " in + *" $xxx "*) ;; + *) libpth="$libpth $xxx";; + esac + fi +done +$cat <<'EOM' + +Some systems have incompatible or broken versions of libraries. Among +the directories listed in the question below, please remove any you +know not to be holding relevant libraries, and add any that are needed. +Say "none" for none. + +EOM +case "$libpth" in +'') dflt='none';; +*) + set X $libpth + shift + dflt=${1+"$@"} + ;; +esac +rp="Directories to use for library searches?" +. ./myread +case "$ans" in +none) libpth=' ';; +*) libpth="$ans";; +esac + +: compute shared library extension +case "$so" in +'') + if xxx=`./loc libc.sl X $libpth`; $test -f "$xxx"; then + dflt='sl' + else + dflt='so' + fi + ;; +*) dflt="$so";; +esac +$cat <&4 +case "$libs" in +' '|'') dflt='';; +*) dflt="$libs";; +esac +case "$libswanted" in +'') libswanted='c_s';; +esac +case "$usesocks" in +"$define") libswanted="$libswanted socks5 socks5_sh" ;; +esac +libsfound='' +libsfiles='' +libsdirs='' +libspath='' +for thisdir in $libpth $xlibpth; do + test -d $thisdir && libspath="$libspath $thisdir" +done +for thislib in $libswanted; do + for thisdir in $libspath; do + xxx='' + if $test ! -f "$xxx" -a "X$ignore_versioned_solibs" = "X"; then + xxx=`ls $thisdir/lib$thislib.$so.[0-9] 2>/dev/null|sed -n '$p'` + $test -f "$xxx" && eval $libscheck + $test -f "$xxx" && libstyle=shared + fi + if test ! -f "$xxx"; then + xxx=$thisdir/lib$thislib.$so + $test -f "$xxx" && eval $libscheck + $test -f "$xxx" && libstyle=shared + fi + if test ! -f "$xxx"; then + xxx=$thisdir/lib$thislib$_a + $test -f "$xxx" && eval $libscheck + $test -f "$xxx" && libstyle=static + fi + if test ! -f "$xxx"; then + xxx=$thisdir/$thislib$_a + $test -f "$xxx" && eval $libscheck + $test -f "$xxx" && libstyle=static + fi + if test ! -f "$xxx"; then + xxx=$thisdir/lib${thislib}_s$_a + $test -f "$xxx" && eval $libscheck + $test -f "$xxx" && libstyle=static + $test -f "$xxx" && thislib=${thislib}_s + fi + if test ! -f "$xxx"; then + xxx=$thisdir/Slib$thislib$_a + $test -f "$xxx" && eval $libscheck + $test -f "$xxx" && libstyle=static + fi + if $test -f "$xxx"; then + case "$libstyle" in + shared) echo "Found -l$thislib (shared)." ;; + static) echo "Found -l$thislib." ;; + *) echo "Found -l$thislib ($libstyle)." ;; + esac + case " $dflt " in + *"-l$thislib "*);; + *) dflt="$dflt -l$thislib" + libsfound="$libsfound $xxx" + yyy=`basename $xxx` + libsfiles="$libsfiles $yyy" + yyy=`echo $xxx|$sed -e "s%/$yyy\\$%%"` + case " $libsdirs " in + *" $yyy "*) ;; + *) libsdirs="$libsdirs $yyy" ;; + esac + ;; + esac + break + fi + done + if $test ! -f "$xxx"; then + echo "No -l$thislib." + fi +done +set X $dflt +shift +dflt="$*" +case "$libs" in +'') dflt="$dflt";; +*) dflt="$libs";; +esac +case "$dflt" in +' '|'') dflt='none';; +esac + +$cat </dev/null 2>&1 + then + # Interactive Systems (ISC) POSIX mode. + dflt="$dflt -posix" + fi + ;; + esac + case "$gccversion" in + 1*) ;; + 2.[0-8]*) ;; + ?*) set strict-aliasing -fno-strict-aliasing + eval $checkccflag + ;; + esac + # For gcc, adding -pipe speeds up compilations for some, but apparently + # some assemblers can't read from stdin. (It also slows down compilations + # in other cases, but those are apparently rarer these days.) AD 5/2004. + case "$gccversion" in + ?*) set pipe -pipe + eval $checkccflag + ;; + esac + + # on x86_64 (at least) we require an extra library (libssp) in the + # link command line. This library is not named, so I infer that it is + # an implementation detail that may change. Hence the safest approach + # is to add the flag to the flags passed to the compiler at link time, + # as that way the compiler can do the right implementation dependant + # thing. (NWC) + case "$gccversion" in + ?*) set stack-protector -fstack-protector + eval $checkccflag + ;; + esac + ;; +esac + +case "$mips_type" in +*BSD*|'') inclwanted="$locincpth $usrinc";; +*) inclwanted="$locincpth $inclwanted $usrinc/bsd";; +esac +for thisincl in $inclwanted; do + if $test -d $thisincl; then + if $test x$thisincl != x$usrinc; then + case "$dflt" in + *" -I$thisincl "*);; + *) dflt="$dflt -I$thisincl ";; + esac + fi + fi +done + +inctest='if $contains $2 $usrinc/$1 >/dev/null 2>&1; then + xxx=true; +elif $contains $2 $usrinc/sys/$1 >/dev/null 2>&1; then + xxx=true; +else + xxx=false; +fi; +if $xxx; then + case "$dflt" in + *$2*);; + *) dflt="$dflt -D$2";; + esac; +fi' + +set signal.h LANGUAGE_C; eval $inctest + +case "$usesocks" in +$define) + ccflags="$ccflags -DSOCKS" + ;; +esac + +case "$hint" in +default|recommended) dflt="$ccflags $dflt" ;; +*) dflt="$ccflags";; +esac + +case "$dflt" in +''|' ') dflt=none;; +esac + +$cat <&4 + set X $cppflags + shift + cppflags='' + $cat >cpp.c <<'EOM' +#define BLURFL foo + +BLURFL xx LFRULB +EOM + previous='' + for flag in $* + do + case "$flag" in + -*) ftry="$flag";; + *) ftry="$previous $flag";; + esac + if $cppstdin -DLFRULB=bar $cppflags $ftry $cppminus cpp1.out 2>/dev/null && \ + $cpprun -DLFRULB=bar $cppflags $ftry $cpplast cpp2.out 2>/dev/null && \ + $contains 'foo.*xx.*bar' cpp1.out >/dev/null 2>&1 && \ + $contains 'foo.*xx.*bar' cpp2.out >/dev/null 2>&1 + then + cppflags="$cppflags $ftry" + previous='' + else + previous="$flag" + fi + done + set X $cppflags + shift + cppflags=${1+"$@"} + case "$cppflags" in + *-*) echo "They appear to be: $cppflags";; + esac + $rm -f cpp.c cpp?.out + ;; +esac + +: flags used in final linking phase +case "$ldflags" in +'') if ./venix; then + dflt='-i -z' + else + dflt='' + fi + case "$ccflags" in + *-posix*) dflt="$dflt -posix" ;; + esac + ;; +*) dflt="$ldflags";; +esac +# See note above about -fstack-protector +case "$ccflags" in +*-fstack-protector*) + case "$dflt" in + *-fstack-protector*) ;; # Don't add it again + *) dflt="$dflt -fstack-protector" ;; + esac + ;; +esac + +: Try to guess additional flags to pick up local libraries. +for thislibdir in $libpth; do + case " $loclibpth " in + *" $thislibdir "*) + case "$dflt " in + *"-L$thislibdir "*) ;; + *) dflt="$dflt -L$thislibdir" ;; + esac + ;; + esac +done + +case "$dflt" in +'') dflt='none' ;; +esac + +$cat <&4 +$cat > try.c <<'EOF' +#include +int main() { printf("Ok\n"); return(0); } +EOF +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: + +EOM +$cat try.c >> try.msg + +$cat >> try.msg <>try.msg 2>&1; then + if $sh -c "$run ./try " >>try.msg 2>&1; then + xxx=`$run ./try` + case "$xxx" in + "Ok") dflt=n ;; + *) echo 'The program compiled OK, but produced no output.' >> try.msg + case " $libs " in + *" -lsfio "*) + cat >> try.msg <<'EOQS' +If $libs contains -lsfio, and sfio is mis-configured, then it +sometimes (apparently) runs and exits with a 0 status, but with no +output! It may have to do with sfio's use of _exit vs. exit. + +EOQS + rp="You have a big problem. Shall I abort Configure" + dflt=y + ;; + esac + ;; + esac + else + echo "The program compiled OK, but exited with status $?." >>try.msg + rp="You have a problem. Shall I abort Configure" + dflt=y + fi +else + echo "I can't compile the test program." >>try.msg + rp="You have a BIG problem. Shall I abort Configure" + dflt=y +fi +case "$dflt" in +y) + $cat try.msg >&4 + case "$knowitall" in + '') + echo "(The supplied flags or libraries might be incorrect.)" + ;; + *) dflt=n;; + esac + echo " " + . ./myread + case "$ans" in + n*|N*) ;; + *) echo "Ok. Stopping Configure." >&4 + exit 1 + ;; + esac + ;; +n) echo "OK, that should do.";; +esac +$rm_try gcctest gcctest.out + +: define a shorthand compile call +compile=' +mc_file=$1; +shift; +case "$usedevel" in $define|true|[yY]*) if $test ! -f "${mc_file}.c"; then +echo "Internal Configure script bug - compiler test file ${mc_file}.c is missing. Please report this to perlbug@perl.org" >&4; +exit 1; +fi; +esac; +$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 -o ${mc_file} $optimize $ccflags $ldflags $* ${mc_file}.c $libs;' + +: determine filename position in cpp output +echo " " +echo "Computing filename position in cpp output for #include directives..." >&4 +case "$osname" in +vos) testaccess=-e ;; +*) testaccess=-r ;; +esac +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 $testaccess \`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." + +case "$osname" in +vos) cppfilter="tr '\\\\>' '/' |" ;; # path component separator is > +os2) cppfilter="sed -e 's|\\\\\\\\|/|g' |" ;; # path component separator is \ +*) cppfilter='' ;; +esac +: locate header file +$cat >findhdr <" > foo\$\$.c +$cppstdin $cppminus $cppflags < foo\$\$.c 2>/dev/null | \ +$cppfilter $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 stdlib is available +set stdlib.h i_stdlib +eval $inhdr + +: check for lengths of integral types +echo " " +case "$intsize" in +'') + echo "Checking to see how big your integers are..." >&4 + $cat >try.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +int main() +{ + 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 try + if eval $compile_ok && $run ./try > /dev/null; then + eval `$run ./try` + 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 +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=`$run ./try` + 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_try + +: 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_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_try +set d_int64_t +eval $setvar + +: Check if 64bit ints have a quad type +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" + ;; +*) echo "We could use '$quadtype' for 64-bit integers." >&4 + d_quad="$define" + ;; +esac + +: Do we want 64bit support +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 <&4 + $cat >try.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +int main() +{ + printf("%d\n", (int)sizeof(double)); + exit(0); +} +EOCP + set try + if eval $compile_ok; then + doublesize=`$run ./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_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=`$run ./try` + 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." + echo "I'll keep your setting anyway, but you may see some" + echo "harmless compilation warnings." + fi + ;; +esac +$rm_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 +case "$targetarch" in +'') ;; +*) archname=`echo $targetarch|sed 's,^[^-]*-,,'` ;; +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) + echo "...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 +if $test -f archname.cbu; then + echo "Your platform has some specific hints for architecture name, using them..." + . ./archname.cbu +fi + +: set the prefixit variable, to compute a suitable default value +prefixit='case "$3" in +""|none) + case "$oldprefix" in + "") eval "$1=\"\$$2\"";; + *) + case "$3" in + "") eval "$1=";; + none) + eval "tp=\"\$$2\""; + case "$tp" in + ""|" ") eval "$1=\"\$$2\"";; + *) eval "$1=";; + esac;; + esac;; + esac;; +*) + eval "tp=\"$oldprefix-\$$2-\""; eval "tp=\"$tp\""; + case "$tp" in + --|/*--|\~*--) eval "$1=\"$prefix/$3\"";; + /*-$oldprefix/*|\~*-$oldprefix/*) + eval "$1=\`echo \$$2 | sed \"s,^$oldprefix,$prefix,\"\`";; + *) eval "$1=\"\$$2\"";; + esac;; +esac' + +: 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 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 +prefixvar=bin +: XXX Bug? -- ignores Configure -Dinstallprefix setting. +: XXX If this is fixed, also fix the "start perl" hunk below, which relies on +: this via initialinstalllocation +. ./setprefixvar + +case "$userelocatableinc" in +$define|true|[yY]*) dflt='y' ;; +*) dflt='n' ;; +esac +cat <reflect + chmod +x,u+s reflect + ./reflect >flect 2>&1 + if $contains "/dev/fd" flect >/dev/null; then + echo "Congratulations, your kernel has secure setuid scripts!" >&4 + val="$define" + else + $cat <&4 + dflt=n;; + "$undef") + echo "Well, the $hint value is *not* secure." >&4 + dflt=n;; + *) echo "Well, the $hint value *is* secure." >&4 + dflt=y;; + esac + ;; + *) + $rm -f reflect flect + echo "#!$ls" >reflect + chmod +x,u+s reflect + echo >flect + chmod a+w flect + echo '"su" will (probably) prompt you for '"$ans's password." + su $ans -c './reflect >flect' + if $contains "/dev/fd" flect >/dev/null; then + echo "Okay, it looks like setuid scripts are secure." >&4 + dflt=y + else + echo "I don't think setuid scripts are secure." >&4 + dflt=n + fi + ;; + esac + rp='Does your kernel have *secure* setuid scripts?' + . ./myread + case "$ans" in + [yY]*) val="$define";; + *) val="$undef";; + esac + fi +else + echo "I don't think setuid scripts are secure (no /dev/fd directory)." >&4 + 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 +if $test $patchlevel -lt 11; then +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 </dev/null 2>&1; then + perl5=$tdir/perl + break; + elif $test -x $tdir/perl5$exe_ext && $tdir/perl5 -Mless -e 'use 5.005;' >/dev/null 2>&1; then + perl5=$tdir/perl5 + break; + fi + done + ;; +*) perl5="$perl5" + ;; +esac +case "$perl5" in +'') echo "None found. That's ok.";; +*) echo "Using $perl5." ;; +esac + +: Set the siteprefix variables +$cat < getverlist <> getverlist <<'EOPL' +# The list found is store twice for each entry: the original name, and +# the binary broken down version as pack "sss", so sorting is easy and +# unambiguous. This will work for all versions that have a maximum of +# three digit groups, separate by '.'s or '_'s. Names are extended with +# ".0.0" to ensure at least three elements for the pack. +# -- H.Merijn Brand (m)'06 23-10-2006 + +# 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 = map { + [ $_, pack "sss", split m/[._]/, "$_.0.0" ] } glob("5.*"); + ;@candidates = sort { $a->[1] cmp $b->[1]} @candidates; +} +else { + ;@candidates = (); +} + +($pversion, $aversion, $vsn5005) = map { + pack "sss", split m/[._]/, "$_.0.0" } $version, $api_versionstring, "5.005"; +foreach $d (@candidates) { + if ($d->[1] lt $pversion) { + if ($d->[1] ge $aversion) { + unshift(@inc_version_list, grep { -d } $d->[0]."/$archname", $d->[0]); + } + elsif ($d->[1] ge $vsn5005) { + unshift(@inc_version_list, grep { -d } $d->[0]); + } + } + 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$exe_ext"; then + dflt=`$perl5 getverlist` + else + dflt='none' + fi + ;; +$undef) dflt='none' ;; +*) eval dflt=\"$inc_version_list\" ;; +esac +case "$dflt" in +''|' ') dflt=none ;; +esac +case "$dflt" in +5.005) dflt=none ;; +esac +$cat <try.c < +#include +#$i_mallocmalloc I_MALLOCMALLOC +#ifdef I_MALLOCMALLOC +# include +#endif + +int main () { return 0; } +EOCP +set try +if eval $compile; then + echo " found." >&4 + val="$define" +else + echo " NOT found." >&4 + val="$undef" +fi +$rm_try +set i_malloc +eval $setvar + +: 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 < +#endif +#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_try + +: check for length of pointer +echo " " +case "$ptrsize" in +'') + echo "Checking to see how big your pointers are..." >&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 < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +int main() +{ + printf("%d\n", (int)sizeof(VOID_PTR)); + exit(0); +} +EOCP + set try + if eval $compile_ok; then + ptrsize=`$run ./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_try +case "$use64bitall" in +"$define"|true|[yY]*) + case "$ptrsize" in + 4) cat <&4 + +*** You have chosen a maximally 64-bit build, +*** but your pointers are only 4 bytes wide. +*** Please rerun Configure without -Duse64bitall. +EOM + case "$d_quad" in + define) + cat <&4 +*** Since you have quads, you could possibly try with -Duse64bitint. +EOM + ;; + esac + cat <&4 +*** Cannot continue, aborting. + +EOM + + exit 1 + ;; + esac + ;; +esac + + +: determine whether to use malloc wrapping +echo " " +case "$usemallocwrap" in +[yY]*|true|$define) dflt='y' ;; +[nN]*|false|$undef) dflt='n' ;; +*) case "$usedevel" in + [yY]*|true|$define) dflt='y' ;; + *) dflt='n' ;; + esac + ;; +esac +rp="Do you wish to wrap malloc calls to protect against potential overflows?" +. ./myread +usemallocwrap="$ans" +case "$ans" in +y*|true) + usemallocwrap="$define" ;; +*) + usemallocwrap="$undef" ;; +esac + +: determine which malloc to compile in +echo " " +case "$usemymalloc" in +[yY]*|true|$define) dflt='y' ;; +[nN]*|false|$undef) dflt='n' ;; +*) case "$ptrsize" in + 4) dflt='y' ;; + *) dflt='n' ;; + esac + if test "$useithreads" = "$define"; then dflt='n'; fi + ;; +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] +: determine where site specific architecture-dependent libraries go. +: sitelib default is /usr/local/lib/perl5/site_perl/$version +: sitearch default is /usr/local/lib/perl5/site_perl/$version/$archname +: sitelib may have an optional trailing /share. +case "$sitearch" in +'') dflt=`echo $sitelib | $sed 's,/share$,,'` + dflt="$dflt/$archname" + ;; +*) dflt="$sitearch" + ;; +esac +set sitearch sitearch none +eval $prefixit +$cat <&4 +$cat >prototype.c < +#endif +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* + +: Check if ansi2knr is required +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 + +: DTrace support +dflt_dtrace='/usr/sbin/dtrace' +$test -x /usr/bin/dtrace && dflt_dtrace='/usr/bin/dtrace' + +cat </dev/null 2>&1 \ + && rm -f perldtrace.tmp + then + echo " " + echo "Good: your $dtrace knows about the -h flag." + else + cat >&2 <&2 < ../extras.lst + val="'$extras'" + ;; +esac +set extras +eval $setvar +echo " " + +: determine where html pages for programs go +set html1dir html1dir none +eval $prefixit +$cat <&4 +cat >try.c <<'EOCP' +/* Find out version of GNU C library. __GLIBC__ and __GLIBC_MINOR__ + alone are insufficient to distinguish different versions, such as + 2.0.6 and 2.0.7. The function gnu_get_libc_version() appeared in + libc version 2.1.0. A. Dougherty, June 3, 2002. +*/ +#include +int main(void) +{ +#ifdef __GLIBC__ +# ifdef __GLIBC_MINOR__ +# if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1 && !defined(__cplusplus) +# include + printf("%s\n", gnu_get_libc_version()); +# else + printf("%d.%d\n", __GLIBC__, __GLIBC_MINOR__); +# endif +# else + printf("%d\n", __GLIBC__); +# endif + return 0; +#else + return 1; +#endif +} +EOCP +set try +if eval $compile_ok && $run ./try > glibc.ver; then + val="$define" + gnulibc_version=`$cat glibc.ver` + echo "You are using the GNU C Library version $gnulibc_version" +else + val="$undef" + gnulibc_version='' + echo "You are not using the GNU C Library" +fi +$rm_try glibc.ver +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") + echo " " + echo "nm probably won't work on the GNU C Library." >&4 + dflt=n + ;; + esac + case "$dflt" in + '') + if $test "$osname" = aix -a "X$PASE" != "Xdefine" -a ! -f /lib/syscalls.exp; then + echo " " + echo "Whoops! This is an AIX system without /lib/syscalls.exp!" >&4 + echo "'nm' won't be sufficient on this sytem." >&4 + dflt=n + fi + ;; + esac + case "$dflt" in + '') dflt=`$egrep 'inlibc|csym' $rsrc/Configure | wc -l 2>/dev/null` + if $test $dflt -gt 20; then + dflt=y + else + dflt=n + fi + ;; + esac + ;; +*) + case "$usenm" in + true|$define) dflt=y;; + *) dflt=n;; + esac + ;; +esac +$cat < /dev/null 2>&1; then + nm_so_opt='--dynamic' + fi + ;; + esac + ;; +esac + +: Figure out where the libc is located +case "$runnm" in +true) +: get list of predefined functions in a handy place +echo " " +case "$libc" in +'') libc=unknown + case "$libs" in + *-lc_s*) libc=`./loc libc_s$_a $libc $libpth` + esac + ;; +esac +case "$libs" in +'') ;; +*) for thislib in $libs; do + case "$thislib" in + -lc|-lc_s) + : Handle C library specially below. + ;; + -l*) + thislib=`echo $thislib | $sed -e 's/^-l//'` + if try=`./loc lib$thislib.$so.'*' X $libpth`; $test -f "$try"; then + : + elif try=`./loc lib$thislib.$so X $libpth`; $test -f "$try"; then + : + elif try=`./loc lib$thislib$_a X $libpth`; $test -f "$try"; then + : + elif try=`./loc $thislib$_a X $libpth`; $test -f "$try"; then + : + elif try=`./loc lib$thislib X $libpth`; $test -f "$try"; then + : + elif try=`./loc $thislib X $libpth`; $test -f "$try"; then + : + elif try=`./loc Slib$thislib$_a X $xlibpth`; $test -f "$try"; then + : + else + try='' + fi + libnames="$libnames $try" + ;; + *) libnames="$libnames $thislib" ;; + esac + done + ;; +esac +xxx=normal +case "$libc" in +unknown) + set /lib/libc.$so + for xxx in $libpth; do + $test -r $1 || set $xxx/libc.$so + : The messy sed command sorts on library version numbers. + $test -r $1 || \ + set `echo blurfl; echo $xxx/libc.$so.[0-9]* | \ + tr ' ' $trnl | egrep -v '\.[A-Za-z]*$' | $sed -e ' + h + s/[0-9][0-9]*/0000&/g + s/0*\([0-9][0-9][0-9][0-9][0-9]\)/\1/g + G + s/\n/ /' | \ + $sort | $sed -e 's/^.* //'` + eval set \$$# + done + $test -r $1 || set /usr/ccs/lib/libc.$so + $test -r $1 || set /lib/libsys_s$_a + ;; +*) + set blurfl + ;; +esac +if $test -r "$1"; then + echo "Your (shared) C library seems to be in $1." + libc="$1" +elif $test -r /lib/libc && $test -r /lib/clib; then + echo "Your C library seems to be in both /lib/clib and /lib/libc." + xxx=apollo + libc='/lib/clib /lib/libc' + if $test -r /lib/syslib; then + echo "(Your math library is in /lib/syslib.)" + libc="$libc /lib/syslib" + fi +elif $test -r "$libc" || (test -h "$libc") >/dev/null 2>&1; then + echo "Your C library seems to be in $libc, as you said before." +elif $test -r $incpath/usr/lib/libc$_a; then + libc=$incpath/usr/lib/libc$_a; + echo "Your C library seems to be in $libc. That's fine." +elif $test -r /lib/libc$_a; then + libc=/lib/libc$_a; + echo "Your C library seems to be in $libc. You're normal." +else + if tans=`./loc libc$_a blurfl/dyick $libpth`; $test -r "$tans"; then + : + elif tans=`./loc libc blurfl/dyick $libpth`; $test -r "$tans"; then + libnames="$libnames "`./loc clib blurfl/dyick $libpth` + elif tans=`./loc clib blurfl/dyick $libpth`; $test -r "$tans"; then + : + elif tans=`./loc Slibc$_a blurfl/dyick $xlibpth`; $test -r "$tans"; then + : + elif tans=`./loc Mlibc$_a blurfl/dyick $xlibpth`; $test -r "$tans"; then + : + else + tans=`./loc Llibc$_a blurfl/dyick $xlibpth` + fi + if $test -r "$tans"; then + echo "Your C library seems to be in $tans, of all places." + libc=$tans + else + libc='blurfl' + fi +fi +if $test $xxx = apollo -o -r "$libc" || (test -h "$libc") >/dev/null 2>&1; then + dflt="$libc" + cat < libpath + cat >&4 < libnames +set X `cat libnames` +shift +xxx=files +case $# in 1) xxx=file; esac +echo "Extracting names from the following $xxx for later perusal:" >&4 +echo " " +$sed 's/^/ /' libnames >&4 +echo " " +$echo $n "This may take a while...$c" >&4 + +for file in $*; do + case $file in + *$so*) $nm $nm_so_opt $nm_opt $file 2>/dev/null;; + *) $nm $nm_opt $file 2>/dev/null;; + esac +done >libc.tmp + +$echo $n ".$c" +$grep fprintf libc.tmp > libc.ptf +xscan='eval "libc.list"; $echo $n ".$c" >&4' +xrun='eval "libc.list"; echo "done." >&4' +xxx='[ADTSIWi]' +if com="$sed -n -e 's/__IO//' -e 's/^.* $xxx *//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^__*//' -e 's/^\([a-zA-Z_0-9$]*\).*xtern.*/\1/p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e '/|UNDEF/d' -e '/FUNC..GL/s/^.*|__*//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^.* D __*//p' -e 's/^.* D //p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^_//' -e 's/^\([a-zA-Z_0-9]*\).*xtern.*text.*/\1/p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^.*|FUNC |GLOB .*|//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$grep '|' | $sed -n -e '/|COMMON/d' -e '/|DATA/d' \ + -e '/ file/d' -e 's/^\([^ ]*\).*/\1/p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^.*|FUNC |GLOB .*|//p' -e 's/^.*|FUNC |WEAK .*|//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^__//' -e '/|Undef/d' -e '/|Proc/s/ .*//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^.*|Proc .*|Text *| *//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e '/Def. Text/s/.* \([^ ]*\)\$/\1/p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/^[-0-9a-f ]*_\(.*\)=.*/\1/p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="$sed -n -e 's/.*\.text n\ \ \ \.//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +elif com="sed -n -e 's/^__.*//' -e 's/[ ]*D[ ]*[0-9]*.*//p'";\ + eval $xscan;\ + $contains '^fprintf$' libc.list >/dev/null 2>&1; then + eval $xrun +else + $nm -p $* 2>/dev/null >libc.tmp + $grep fprintf libc.tmp > libc.ptf + if com="$sed -n -e 's/^.* [ADTSIW] *_[_.]*//p' -e 's/^.* [ADTSIW] //p'";\ + eval $xscan; $contains '^fprintf$' libc.list >/dev/null 2>&1 + then + nm_opt='-p' + eval $xrun + else + echo " " + echo "$nm didn't seem to work right. Trying $ar instead..." >&4 + com='' + if $ar t $libc > libc.tmp && \ + $contains '^fprintf$' libc.tmp >/dev/null 2>&1 + then + for thisname in $libnames $libc; do + $ar t $thisname >>libc.tmp + done + $sed -e "s/\\$_o\$//" < libc.tmp > libc.list + echo "Ok." >&4 + elif test "X$osname" = "Xos2" && $ar tv $libc > libc.tmp; then + for thisname in $libnames $libc; do + $ar tv $thisname >>libc.tmp + emximp -o tmp.imp $thisname \ + 2>/dev/null && \ + $sed -e 's/^\([_a-zA-Z0-9]*\) .*$/\1/p' \ + < tmp.imp >>libc.tmp + $rm -f tmp.imp + done + $sed -e "s/\\$_o\$//" -e 's/^ \+//' < libc.tmp > libc.list + echo "Ok." >&4 + else + echo "$ar didn't seem to work right." >&4 + echo "Maybe this is a Cray...trying bld instead..." >&4 + if bld t $libc | \ + $sed -e 's/.*\///' -e "s/\\$_o:.*\$//" > libc.list && + $test -s libc.list + then + for thisname in $libnames; do + bld t $libnames | \ + $sed -e 's/.*\///' -e "s/\\$_o:.*\$//" >>libc.list + $ar t $thisname >>libc.tmp + done + echo "Ok." >&4 + else + echo "That didn't work either. Giving up." >&4 + exit 1 + fi + fi + fi +fi +nm_extract="$com" +case "$PASE" in +define) + echo " " + echo "Since you are compiling for PASE, extracting more symbols from libc.a ...">&4 + dump -Tv /lib/libc.a | awk '$7 == "/unix" {print $5 " " $8}' | grep "^SV" | awk '{print $2}' >> libc.list + ;; +*) if $test -f /lib/syscalls.exp; then + echo " " + echo "Also extracting names from /lib/syscalls.exp for good ole AIX..." >&4 + $sed -n 's/^\([^ ]*\)[ ]*syscall[0-9]*[ ]*$/\1/p' \ + /lib/syscalls.exp >>libc.list + fi + ;; +esac +;; +esac +$rm -f libnames libpath + +: see if dld is available +set dld.h i_dld +eval $inhdr + +: Check if we are using C++ +echo " " +echo "Checking for C++..." >&4 +$cat >try.c <<'EOCP' +#include +int main(void) +{ +#ifdef __cplusplus + return 0; +#else + return 1; +#endif +} +EOCP +set try +if eval $compile_ok && $run ./try; then + val="$define" + echo "You are using a C++ compiler." +else + val="$undef" + echo "You are not using a C++ compiler." +fi +$rm_try cplusplus$$ +set d_cplusplus +eval $setvar + +: is a C symbol defined? +csym='tlook=$1; +case "$3" in +-v) tf=libc.tmp; tdc="";; +-a) tf=libc.tmp; tdc="[]";; +*) tlook="^$1\$"; tf=libc.list; tdc="()";; +esac; +case "$d_cplusplus" in + $define) extern_C="extern \"C\"" ;; + *) extern_C="extern" ;; +esac; +tx=yes; +case "$reuseval-$4" in +true-) ;; +true-*) tx=no; eval "tval=\$$4"; case "$tval" in "") tx=yes;; esac;; +esac; +case "$tx" in +yes) + tval=false; + if $test "$runnm" = true; then + if $contains $tlook $tf >/dev/null 2>&1; then + tval=true; + elif $test "$mistrustnm" = compile -o "$mistrustnm" = run; then + echo "$extern_C void *$1$tdc; void *(*(p()))$tdc { return &$1; } int main() { if(p()) return(0); else return(1); }"> try.c; + $cc -o try $optimize $ccflags $ldflags try.c >/dev/null 2>&1 $libs && tval=true; + $test "$mistrustnm" = run -a -x try && { $run ./try$_exe >/dev/null 2>&1 || tval=false; }; + $rm_try; + fi; + else + echo "$extern_C void *$1$tdc; void *(*(p()))$tdc { return &$1; } int main() { if(p()) return(0); else return(1); }"> try.c; + $cc -o try $optimize $ccflags $ldflags try.c $libs >/dev/null 2>&1 && tval=true; + $rm_try; + fi; + ;; +*) + case "$tval" in + $define) tval=true;; + *) tval=false;; + esac; + ;; +esac; +eval "$2=$tval"' + +: define an is-in-libc? function +inlibc='echo " "; td=$define; tu=$undef; +sym=$1; var=$2; eval "was=\$$2"; +tx=yes; +case "$reuseval$was" in +true) ;; +true*) tx=no;; +esac; +case "$tx" in +yes) + set $sym tres -f; + eval $csym; + case "$tres" in + true) + echo "$sym() found." >&4; + case "$was" in $undef) . ./whoa; esac; eval "$var=\$td";; + *) + echo "$sym() NOT found." >&4; + case "$was" in $define) . ./whoa; esac; eval "$var=\$tu";; + esac;; +*) + case "$was" in + $define) echo "$sym() found." >&4;; + *) echo "$sym() NOT found." >&4;; + esac;; +esac' + +: see if dlopen exists +xxx_runnm="$runnm" +xxx_ccflags="$ccflags" +runnm=false +: with g++ one needs -shared to get is-in-libc to work for dlopen +case "$gccversion" in +'') ;; +*) case "$d_cplusplus" in + "$define") ccflags="$ccflags -shared" ;; + esac + ;; +esac +set dlopen d_dlopen +eval $inlibc +runnm="$xxx_runnm" +ccflags="$xxx_ccflags" + +: see if this is a unistd.h system +set unistd.h i_unistd +eval $inhdr + +: 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' + ;; +esac +rp="Do you wish to use dynamic loading?" +. ./myread +usedl="$ans" +bin_ELF="$undef" +case "$ans" in +y*) usedl="$define" + case "$dlsrc" in + '') + if $test -f $rsrc/$dldir/dl_${osname}.xs ; then + dflt="$dldir/dl_${osname}.xs" + elif $test "$d_dlopen" = "$define" ; then + dflt="$dldir/dl_dlopen.xs" + elif $test "$i_dld" = "$define" ; then + dflt="$dldir/dl_dld.xs" + else + dflt='' + fi + ;; + *) dflt="$dldir/$dlsrc" + ;; + esac + echo "The following dynamic loading files are available:" + : Can not go over to $dldir because getfile has path hard-coded in. + tdir=`pwd`; cd "$rsrc"; $ls -C $dldir/dl*.xs; cd "$tdir" + rp="Source file to use for dynamic loading" + fn="fne" + gfpth="$src" + . ./getfile + usedl="$define" + : emulate basename + dlsrc=`echo $ans | $sed -e 's%.*/\([^/]*\)$%\1%'` + + $cat << EOM + +Some systems may require passing special flags to $cc -c to +compile modules that will be used to create a shared library. +To use no flags, say "none". + +EOM + case "$cccdlflags" in + '') case "$gccversion" in + '') case "$osname" in + hpux) dflt='+z' ;; + next) dflt='none' ;; + irix*) dflt='-KPIC' ;; + svr4*|esix*|solaris|nonstopux) dflt='-KPIC' ;; + sunos) dflt='-pic' ;; + *) dflt='none' ;; + esac + ;; + *) case "$osname" in + darwin) dflt='none' ;; + linux*|svr4*|esix*|solaris|nonstopux) 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 + + cat << EOM + +Some systems use ld to create libraries that can be dynamically loaded, +while other systems (such as those using ELF) use $cc. + +EOM + +: Determine if this is ELF + $cat >try.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#$i_unistd I_UNISTD +#ifdef I_UNISTD +#include +#endif +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 is ELF) */ + else + exit(1); /* fail */ +} +EOM + if $cc $ccflags $ldflags try.c >/dev/null 2>&1 && $run ./a.out; then + bin_ELF="$define" + fi + $rm_try + + case "$ld" in + '') if $test $bin_ELF = "$define"; then + cat <try.c <try.h </dev/null 2>&1 \ + && $test -s a.out ; then + echo "ld supports scripting" >&4 + ld_can_script="$define" + else + echo "ld does not support scripting" >&4 + fi + $rm_try + ;; +esac + +: Do we want a shared libperl? +also='' +case "$usedl" in +$undef) + # No dynamic loading being used, so don't bother even to prompt. + useshrplib='false' + ;; +*) case "$useshrplib" in + '') case "$osname" in + svr4*|nonstopux|dgux|dynixptx|esix|powerux|beos|haiku|cygwin*) + dflt=y + also='Building a shared libperl is required for dynamic loading to work on your system.' + ;; + next*) + case "$osvers" in + 4*) dflt=y + also='Building a shared libperl is needed for MAB support.' + ;; + *) dflt=n + ;; + esac + ;; + *) dflt=n + ;; + esac + ;; + $define|true|[Yy]*) + dflt=y + ;; + *) dflt=n + ;; + esac + $cat << EOM + +The perl executable is normally obtained by linking perlmain.c with +libperl${_a}, any static extensions (usually just DynaLoader), and +any other libraries needed on this system (such as -lm, etc.). Since +your system supports dynamic loading, it is probably possible to build +a shared libperl.$so. If you will have more than one executable linked +to libperl.$so, this will significantly reduce the size of each +executable, but it may have a noticeable effect on performance. The +default is probably sensible for your system. +$also + +EOM + rp="Build a shared libperl.$so (y/n)" + . ./myread + case "$ans" in + true|$define|[Yy]*) + useshrplib='true' ;; + *) useshrplib='false' ;; + esac + ;; +esac + +case "$useshrplib" in +true) + case "$userelocatableinc" in + true|define) + echo "Cannot build with both -Duserelocatableinc and -Duseshrplib" >&4 + echo "See INSTALL for an explanation why that won't work." >&4 + exit 4 + ;; + esac + case "$libperl" in + '') + # Figure out a good name for libperl.so. Since it gets stored in + # a version-specific architecture-dependent library, the version + # number isn't really that important, except for making cc/ld happy. + # + # A name such as libperl.so.10.1 + majmin="libperl.$so.$patchlevel.$subversion" + # A name such as libperl.so.100 + majonly=`echo $patchlevel $subversion | + $awk '{printf "%d%02d", $1, $2}'` + majonly=libperl.$so.$majonly + # I'd prefer to keep the os-specific stuff here to a minimum, and + # rely on figuring it out from the naming of libc. + case "${osname}${osvers}" in + next4*) + dflt=libperl.5.$so + # XXX How handle the --version stuff for MAB? + ;; + linux*|gnu*) # ld won't link with a bare -lperl otherwise. + dflt=libperl.$so + ;; + cygwin*) # ld links now against the dll directly + majmin="cygperl5_${patchlevel}_${subversion}.${so}" + majonly=`echo $patchlevel $subversion | + $awk '{printf "%03d%03d", $1, $2}'` + majonly=cygperl5.$majonly.$so + dflt=$majmin + ;; + *) # Try to guess based on whether libc has major.minor. + case "$libc" in + *libc.$so.[0-9]*.[0-9]*) dflt=$majmin ;; + *libc.$so.[0-9]*) dflt=$majonly ;; + *) dflt=libperl.$so ;; + esac + ;; + esac + ;; + *) dflt=$libperl + ;; + esac + cat << EOM + +I need to select a good name for the shared libperl. If your system uses +library names with major and minor numbers, then you might want something +like $majmin. Alternatively, if your system uses a single version +number for shared libraries, then you might want to use $majonly. +Or, your system might be quite happy with a simple libperl.$so. + +Since the shared libperl will get installed into a version-specific +architecture-dependent directory, the version number of the shared perl +library probably isn't important, so the default should be o.k. + +EOM + rp='What name do you want to give to the shared libperl?' + . ./myread + libperl=$ans + echo "Ok, I'll use $libperl" + ;; +*) + libperl="libperl${_a}" + ;; +esac + +# Detect old use of shrpdir via undocumented Configure -Dshrpdir +case "$shrpdir" in +'') ;; +*) $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/share/man/man1 /usr/man/man1' + syspath="$syspath /usr/man/mann /usr/man/manl /usr/man/local/man1" + syspath="$syspath /usr/man/u_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 +prefixvar=man3dir +. ./setprefixvar + +case "$man3dir" in +'') man3dir=' ' + installman3dir='';; +esac + +: 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 || $test -d /usr/lib/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 +case "$myhostname" in +'') myhostname=noname ;; +esac +: 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 \ + -e 1q 2>/dev/null` + case "$dflt" in + .) dflt=.`$sed -n -e 's/ / /g' \ + -e 's/^domain *\([^ ]*\).*/\1/p' $tans \ + -e 1q 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$osname" in + .os390) echo "(Attempting domain name extraction from //'SYS1.TCPPARMS(TCPDATA)')" + dflt=.`awk '/^DOMAINORIGIN/ {print $2}' "//'SYS1.TCPPARMS(TCPDATA)'" 2>/dev/null` + ;; + esac + case "$dflt" in + .) echo "(Lost all hope -- silly guess then)" + dflt='.nonet' + ;; + 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 + +: determine the e-mail address of the user who is running us +$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=`$run ./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_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 + +: Check size for Fpos_t +echo " " +case "$fpostype" in +*_t) zzz="$fpostype" ;; +*) zzz="fpos_t" ;; +esac +echo "Checking the size of $zzz..." >&4 +cat > try.c < +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +int main() { + printf("%d\n", (int)sizeof($fpostype)); + exit(0); +} +EOCP +set try +if eval $compile_ok; then + yyy=`$run ./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 + +: Check for large file support +# 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=`$run ./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 +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +int main() { + printf("%d\n", (int)sizeof($fpostype)); + return(0); +} +EOCP + set try + if eval $compile_ok; then + yyy=`$run ./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_try + fi + ;; +esac + +: Check if we want perlio +useperlio="$define" + +: Set the vendorbin variables +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 +prefixvar=vendorbin +. ./installprefix + +: Set the vendorhtml1dir variables +case "$vendorprefix" in +'') vendorhtml1dir='' + vendorhtml1direxp='' + ;; +*) : determine where vendor-supplied html pages go. + : There is no standard location, so try to copy the previously-selected + : directory structure for the core html pages. + : XXX Better default suggestions would be welcome. + case "$vendorhtml1dir" in + '') dflt=`echo "$html1dir" | $sed "s#^$prefix#$vendorprefix#"` ;; + *) dflt=$vendorhtml1dir ;; + esac + case "$dflt" in + ''|' ') dflt=none ;; + esac + fn=dn+~ + rp='Pathname for the vendor-supplied html pages?' + . ./getfile + vendorhtml1dir="$ans" + vendorhtml1direxp="$ansexp" + ;; +esac +: Use ' ' for none so value is preserved next time through Configure +$test X"$vendorhtml1dir" = "X" && vendorhtml1dir=' ' +prefixvar=vendorhtml1dir +. ./installprefix + +: Set the vendorhtml3dir variables +case "$vendorprefix" in +'') vendorhtml3dir='' + vendorhtml3direxp='' + ;; +*) : determine where vendor-supplied module html pages go. + : There is no standard location, so try to copy the previously-selected + : directory structure for the core html pages. + : XXX Better default suggestions would be welcome. + case "$vendorhtml3dir" in + '') dflt=`echo "$html3dir" | $sed "s#^$prefix#$vendorprefix#"` ;; + *) dflt=$vendorhtml3dir ;; + esac + case "$dflt" in + ''|' ') dflt=none ;; + esac + fn=dn+~ + rp='Pathname for the vendor-supplied html pages?' + . ./getfile + vendorhtml3dir="$ans" + vendorhtml3direxp="$ansexp" + ;; +esac +: Use ' ' for none so value is preserved next time through Configure +$test X"$vendorhtml3dir" = "X" && vendorhtml3dir=' ' +prefixvar=vendorhtml3dir +. ./installprefix + +: Set the vendorman1dir variables +case "$vendorprefix" in +'') vendorman1dir='' + vendorman1direxp='' + ;; +*) : determine where vendor-supplied manual pages go. + case "$vendorman1dir" in + '') dflt=`echo "$man1dir" | $sed "s#^$prefix#$vendorprefix#"` ;; + *) dflt=$vendorman1dir ;; + esac + case "$dflt" in + ''|' ') dflt=none ;; + esac + fn=nd~+ + rp='Pathname for the vendor-supplied manual section 1 pages?' + . ./getfile + vendorman1dir="$ans" + vendorman1direxp="$ansexp" + ;; +esac +: Use ' ' for none so value is preserved next time through Configure +$test X"$vendorman1dir" = "X" && vendorman1dir=' ' +prefixvar=vendorman1dir +. ./installprefix + +: Set the vendorman3dir variables +case "$vendorprefix" in +'') vendorman3dir='' + vendorman3direxp='' + ;; +*) : determine where vendor-supplied module manual pages go. + case "$vendorman3dir" in + '') dflt=`echo "$man3dir" | $sed "s#^$prefix#$vendorprefix#"` ;; + *) dflt=$vendorman3dir ;; + esac + case "$dflt" in + ''|' ') dflt=none ;; + esac + fn=nd~+ + rp='Pathname for the vendor-supplied manual section 3 pages?' + . ./getfile + vendorman3dir="$ans" + vendorman3direxp="$ansexp" + ;; +esac +: Use ' ' for none so value is preserved next time through Configure +$test X"$vendorman3dir" = "X" && vendorman3dir=' ' +prefixvar=vendorman3dir +. ./installprefix + +: Set the vendorscript variables +case "$vendorprefix" in +'') d_vendorscript="$undef" + vendorscript='' + vendorscriptexp='' + ;; +*) d_vendorscript="$define" + : determine where vendor-supplied scripts go. + case "$vendorscript" in + '') dflt=$vendorprefix/script + $test -d $dflt || dflt=$vendorbin ;; + *) dflt="$vendorscript" ;; + esac + $cat <warn <msg +else + cat >msg +fi +echo "*** WARNING:" >&4 +sed -e 's/^/*** /' &4 +echo "*** " >&4 +cat msg >>config.msg +echo " " >>config.msg +rm -f msg +EOS +chmod +x warn +$eunicefix warn + +: 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 + ./warn "No string header found -- You'll surely have problems." + fi +fi +set i_string +eval $setvar +case "$i_string" in +"$undef") strings=`./findhdr strings.h`;; +*) strings=`./findhdr string.h`;; +esac + +: see if qgcvt exists +set qgcvt d_qgcvt +eval $inlibc + +: Check print/scan long double stuff +echo " " + +if $test X"$d_longdbl" = X"$define"; then + +echo "Checking how to print long doubles..." >&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=`$run ./try` + 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("%.3Lf\n", d); +} +EOCP + set try + if eval $compile; then + yyy=`$run ./try` + 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("%.3llf\n", d); +} +EOCP + set try + if eval $compile; then + yyy=`$run ./try` + 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=`$run ./try` + 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_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. + +if test "X$d_Gconvert" = X; then + +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 < + +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#$i_string I_STRING +#ifdef I_STRING +# include +#else +# include +#endif + +int checkit(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)0.01, 8, 0, buf); + checkit("0.01", buf); + + Gconvert((DOUBLETYPE)0.001, 8, 0, buf); + checkit("0.001", buf); + + Gconvert((DOUBLETYPE)0.0001, 8, 0, buf); + checkit("0.0001", buf); + + Gconvert((DOUBLETYPE)0.00009, 8, 0, buf); + if (strlen(buf) > 5) + checkit("9e-005", buf); /* for Microsoft ?? */ + else + checkit("9e-05", 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); + + /* Testing of 1e+129 in bigintpm.t must not get extra '.' here. */ + Gconvert((DOUBLETYPE)1e34, 8, 0, buf); + /* 34 should be enough to scare even long double + * places into using the e notation. */ + if (strlen(buf) > 5) + checkit("1e+034", buf); /* for Microsoft */ + else + checkit("1e+34", buf); + + /* For Perl, if you add additional tests here, also add them to + * t/base/num.t for benefit of platforms not using Configure or + * overriding d_Gconvert */ + + exit(0); +} +EOP +: first add preferred functions to our list +xxx_list="" +for xxx_convert in $gconvert_preference; do + case $xxx_convert in + gcvt|gconvert|sprintf) xxx_list="$xxx_list $xxx_convert" ;; + *) echo "Discarding unrecognized gconvert_preference $xxx_convert" >&4 ;; + esac +done +: then add any others +for xxx_convert in gconvert gcvt sprintf; do + case "$xxx_list" in + *$xxx_convert*) ;; + *) xxx_list="$xxx_list $xxx_convert" ;; + esac +done + +case "$d_longdbl$uselongdouble" in +"$define$define") + : again, add preferred functions to our list first + xxx_ld_list="" + for xxx_convert in $gconvert_ld_preference; do + case $xxx_convert in + qgcvt|gcvt|gconvert|sprintf) xxx_ld_list="$xxx_ld_list $xxx_convert" ;; + *) echo "Discarding unrecognized gconvert_ld_preference $xxx_convert" ;; + esac + done + : then add qgcvt, sprintf--then, in xxx_list order, gconvert and gcvt + for xxx_convert in qgcvt sprintf $xxx_list; do + case "$xxx_ld_list" in + $xxx_convert*|*" $xxx_convert"*) ;; + *) xxx_ld_list="$xxx_ld_list $xxx_convert" ;; + esac + done + : if sprintf cannot do long doubles, move it to the end + if test "$d_PRIgldbl" != "$define"; then + xxx_ld_list="`echo $xxx_ld_list|sed s/sprintf//` sprintf" + fi + : if no qgcvt, remove it + if test "$d_qgcvt" != "$define"; then + xxx_ld_list="`echo $xxx_ld_list|sed s/qgcvt//`" + fi + : use the ld_list + xxx_list="$xxx_ld_list" + ;; +esac + +for xxx_convert in $xxx_list; do + echo "Trying $xxx_convert..." + $rm -f try try$_o core + set try -DTRY_$xxx_convert + if eval $compile; then + echo "$xxx_convert() found." >&4 + if $run ./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." + xxx_convert='' + fi + else + echo "$xxx_convert NOT found." >&4 + fi +done + +if test X$xxx_convert = X; then + echo "*** WHOA THERE!!! ***" >&4 + echo "None of ($xxx_list) seemed to work properly. I'll use sprintf." >&4 + xxx_convert=sprintf +fi + +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))" ;; + "$define$define$undef") + d_Gconvert='sprintf((b),"%.*g",(n),(double)(x))' ;; + *) d_Gconvert='sprintf((b),"%.*g",(n),(x))' ;; + esac + ;; +esac + +fi +$rm_try + +: see if _fwalk exists +set fwalk d__fwalk +eval $inlibc + +: 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 < +#ifdef I_FCNTL +#include +#endif +#ifdef I_SYS_FILE +#include +#endif +#ifdef I_UNISTD +#include +#endif +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#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 aintl exists +set aintl d_aintl +eval $inlibc + +: see if alarm exists +set alarm d_alarm +eval $inlibc + +: see if 64bit time functions exists + +set ctime64 d_ctime64 +eval $inlibc + +set localtime64 d_localtime64 +eval $inlibc + +set gmtime64 d_gmtime64 +eval $inlibc + +set mktime64 d_mktime64 +eval $inlibc + +set difftime64 d_difftime64 +eval $inlibc + +set asctime64 d_asctime64 +eval $inlibc + +: see if POSIX threads are available +set pthread.h i_pthread +eval $inhdr + +: define a function to check prototypes +$cat > protochk <> protochk <<'EOSH' + +$rm_try +foo="$1" +shift +while test $# -ge 2; do + case "$1" in + $define) echo "#include <$2>" >> try.c ;; + literal) echo "$2" >> try.c ;; + esac + # Extra magic for the benefit of systems that need pthread.h + # to be included early to correctly detect threadsafe functions. + # Such functions must guarantee themselves, though, that the usethreads + # and i_pthread have been defined, before calling protochk. + if test "$usethreads" = "$define" -a "$i_pthread" = "$define" -a "$pthread_h_first" = "$define" -a "$pthread_h_done" = ""; then + echo "#include " >> try.c + pthread_h_done=yes + fi + 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_try +exit $status +EOSH +chmod +x protochk +$eunicefix protochk + +: Define hasproto macro for Configure internal use +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_try tryout.c' + +: see if sys/types.h has to be included +set sys/types.h i_systypes +eval $inhdr + +: see if sys/select.h has to be included +set sys/select.h i_sysselct +eval $inhdr + +: Define hasfield macro for Configure internal use +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_try' + +: 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 < +#ifdef I_TIME +#include +#endif +#ifdef I_SYSTIME +#ifdef SYSTIMEKERNEL +#define KERNEL +#endif +#include +#endif +#ifdef I_SYSSELECT +#include +#endif +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#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_try +fi +: see if struct tm knows about tm_zone +case "$i_systime$i_time" in +*$define*) + echo " " + echo "Checking to see if your struct tm has tm_zone field..." >&4 + set d_tm_tm_zone tm tm_zone $i_systime sys/time.h $i_time time.h + eval $hasfield + ;; +*) val="$undef" + set d_tm_tm_zone + eval $setvar + ;; +esac +case "$d_tm_tm_zone" in +"$define") echo "Yes, it does." ;; +*) echo "No, it doesn't." ;; +esac +: see if struct tm knows about tm_gmtoff +case "$i_systime$i_time" in +*$define*) + echo " " + echo "Checking to see if your struct tm has tm_gmtoff field..." >&4 + set d_tm_tm_gmtoff tm tm_gmtoff $i_systime sys/time.h $i_time time.h + eval $hasfield + ;; +*) val="$undef" + set d_tm_tm_gmtoff + eval $setvar + ;; +esac +case "$d_tm_tm_gmtoff" in +"$define") echo "Yes, it does." ;; +*) echo "No, it doesn't." ;; +esac + +: see if asctime_r exists +set asctime_r d_asctime_r +eval $inlibc +case "$d_asctime_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_time time.h $i_systime sys/time.h" + case "$d_asctime_r_proto:$usethreads" in + ":define") d_asctime_r_proto=define + set d_asctime_r_proto asctime_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_asctime_r_proto" in + define) + case "$asctime_r_proto" in + ''|0) try='char* asctime_r(const struct tm*, char*);' + ./protochk "$extern_C $try" $hdrs && asctime_r_proto=B_SB ;; + esac + case "$asctime_r_proto" in + ''|0) try='char* asctime_r(const struct tm*, char*, int);' + ./protochk "$extern_C $try" $hdrs && asctime_r_proto=B_SBI ;; + esac + case "$asctime_r_proto" in + ''|0) try='int asctime_r(const struct tm*, char*);' + ./protochk "$extern_C $try" $hdrs && asctime_r_proto=I_SB ;; + esac + case "$asctime_r_proto" in + ''|0) try='int asctime_r(const struct tm*, char*, int);' + ./protochk "$extern_C $try" $hdrs && asctime_r_proto=I_SBI ;; + esac + case "$asctime_r_proto" in + ''|0) d_asctime_r=undef + asctime_r_proto=0 + echo "Disabling asctime_r, cannot determine prototype." >&4 ;; + * ) case "$asctime_r_proto" in + REENTRANT_PROTO*) ;; + *) asctime_r_proto="REENTRANT_PROTO_$asctime_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "asctime_r has no prototype, not using it." >&4 ;; + esac + d_asctime_r=undef + asctime_r_proto=0 + ;; + esac + ;; +*) asctime_r_proto=0 + ;; +esac + +: see if atolf exists +set atolf d_atolf +eval $inlibc + +: see if atoll exists +set atoll d_atoll +eval $inlibc + +: Look for GCC-style attribute format +case "$d_attribute_format" in +'') +echo " " +echo "Checking whether your compiler can handle __attribute__((format)) ..." >&4 +$cat >attrib.c <<'EOCP' +#include +void my_special_printf(char* pat,...) __attribute__((__format__(__printf__,1,2))); +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 support __attribute__((format))." + val="$undef" + else + echo "Your C compiler supports __attribute__((format))." + val="$define" + fi +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" +fi +;; +*) val="$d_attribute_format" ;; +esac +set d_attribute_format +eval $setvar +$rm -f attrib* + +: Look for GCC-style attribute format with null format allowed +case "$d_printf_format_null" in +'') case "$d_attribute_format" in + $define) + echo " " + echo "Checking whether your compiler allows __printf__ format to be null ..." >&4 +$cat >attrib.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +int null_printf (char* pat,...) __attribute__((__format__(__printf__,1,2))); +int null_printf (char* pat,...) { return (int)pat; } +int main () { exit(null_printf(NULL)); } +EOCP + if $cc $ccflags -o attrib attrib.c >attrib.out 2>&1 ; then + : run the executable in case it produces a run-time warning + if $run ./attrib >>attrib.out 2>&1; then + if $contains 'warning' attrib.out >/dev/null 2>&1; then + echo "Your C compiler doesn't allow __printf__ format to be null." + val="$undef" + else + echo "Your C compiler allows __printf__ format to be null." + val="$define" + fi + else + echo "Your C compiler executable failed with __printf__ format null." + val="$undef" + fi + else + echo "Your C compiler fails with __printf__ format null." + val="$undef" + fi + ;; + *) val="$undef" ;; + esac +;; +*) val="$d_printf_format_null" ;; +esac +set d_printf_format_null +eval $setvar +$rm -f attrib* + +: Look for GCC-style attribute malloc +case "$d_attribute_malloc" in +'') +echo " " +echo "Checking whether your compiler can handle __attribute__((malloc)) ..." >&4 +$cat >attrib.c <<'EOCP' +#include +char *go_get_some_memory( int how_many_bytes ) __attribute__((malloc)); +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 support __attribute__((malloc))." + val="$undef" + else + echo "Your C compiler supports __attribute__((malloc))." + val="$define" + fi +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" +fi +;; +*) val="$d_attribute_malloc" ;; +esac +set d_attribute_malloc +eval $setvar +$rm -f attrib* + +: Look for GCC-style attribute nonnull +case "$d_attribute_nonnull" in +'') +echo " " +echo "Checking whether your compiler can handle __attribute__((nonnull(1))) ..." >&4 +$cat >attrib.c <<'EOCP' +#include +void do_something (char *some_pointer,...) __attribute__((nonnull(1))); +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 support __attribute__((nonnull))." + val="$undef" + else + echo "Your C compiler supports __attribute__((nonnull))." + val="$define" + fi +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" +fi +;; +*) val="$d_attribute_nonnull" ;; +esac +set d_attribute_nonnull +eval $setvar +$rm -f attrib* + +: Look for GCC-style attribute noreturn +case "$d_attribute_noreturn" in +'') +echo " " +echo "Checking whether your compiler can handle __attribute__((noreturn)) ..." >&4 +$cat >attrib.c <<'EOCP' +#include +void fall_over_dead( void ) __attribute__((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 support __attribute__((noreturn))." + val="$undef" + else + echo "Your C compiler supports __attribute__((noreturn))." + val="$define" + fi +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" +fi +;; +*) val="$d_attribute_noreturn" ;; +esac +set d_attribute_noreturn +eval $setvar +$rm -f attrib* + +: Look for GCC-style attribute pure +case "$d_attribute_pure" in +'') +echo " " +echo "Checking whether your compiler can handle __attribute__((pure)) ..." >&4 +$cat >attrib.c <<'EOCP' +#include +int square( int n ) __attribute__((pure)); +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 support __attribute__((pure))." + val="$undef" + else + echo "Your C compiler supports __attribute__((pure))." + val="$define" + fi +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" +fi +;; +*) val="$d_attribute_pure" ;; +esac +set d_attribute_pure +eval $setvar +$rm -f attrib* + +: Look for GCC-style attribute unused +case "$d_attribute_unused" in +'') +echo " " +echo "Checking whether your compiler can handle __attribute__((unused)) ..." >&4 +$cat >attrib.c <<'EOCP' +#include +int do_something( int dummy __attribute__((unused)), int n ); +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 support __attribute__((unused))." + val="$undef" + else + echo "Your C compiler supports __attribute__((unused))." + val="$define" + fi +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" +fi +;; +*) val="$d_attribute_unused" ;; +esac +set d_attribute_unused +eval $setvar +$rm -f attrib* + +: Look for GCC-style attribute deprecated +case "$d_attribute_deprecated" in +'') +echo " " +echo "Checking whether your compiler can handle __attribute__((deprecated)) ..." >&4 +$cat >attrib.c <<'EOCP' +#include +int I_am_deprecated(void) __attribute__((deprecated)); +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 support __attribute__((deprecated))." + val="$undef" + else + echo "Your C compiler supports __attribute__((deprecated))." + val="$define" + fi +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" +fi +;; +*) val="$d_attribute_deprecated" ;; +esac +set d_attribute_deprecated +eval $setvar +$rm -f attrib* + +: Look for GCC-style attribute warn_unused_result +case "$d_attribute_warn_unused_result" in +'') +echo " " +echo "Checking whether your compiler can handle __attribute__((warn_unused_result)) ..." >&4 +$cat >attrib.c <<'EOCP' +#include +int I_will_not_be_ignored(void) __attribute__((warn_unused_result)); +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 support __attribute__((warn_unused_result))." + val="$undef" + else + echo "Your C compiler supports __attribute__((warn_unused_result))." + val="$define" + fi +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" +fi +;; +*) val="$d_attribute_warn_unused_result" ;; +esac +set d_attribute_warn_unused_result +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 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 >try.c < +#ifdef I_UNISTD +# include +#endif +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#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 try -DTRY_BSD_PGRP $ccflags $ldflags try.c $libs >/dev/null 2>&1 && $run ./try; then + echo "You have to use getpgrp(pid) instead of getpgrp()." >&4 + val="$define" + elif $cc -o try $ccflags $ldflags try.c $libs >/dev/null 2>&1 && $run ./try; 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_try + +: 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 >try.c < +#ifdef I_UNISTD +# include +#endif +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#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 try -DTRY_BSD_PGRP $ccflags $ldflags try.c $libs >/dev/null 2>&1 && $run ./try; then + echo 'You have to use setpgrp(pid,pgrp) instead of setpgrp().' >&4 + val="$define" + elif $cc -o try $ccflags $ldflags try.c $libs >/dev/null 2>&1 && $run ./try; 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_try + +: Look for GCC-style __builtin_choose_expr +case "$d_builtin_choose_expr" in +'') + echo " " + echo "Checking whether your compiler can handle __builtin_choose_expr ..." >&4 + $cat >try.c <<'EOCP' +#include +#include +#include + +#define SYRINX(x) __builtin_choose_expr( x, (1056*2), (103*50) ) + +int main(void) { + assert( SYRINX(1) == 2112 ); + assert( SYRINX(1) != 5150 ); + assert( SYRINX(0) == 5150 ); + assert( SYRINX(0) != 2112 ); + puts( "All good!" ); + exit(0); +} + +EOCP + set try + if eval $compile && $run ./try; then + echo "Your C compiler supports __builtin_choose_expr." + val="$define" + else + echo "Your C compiler doesn't seem to understand __builtin_choose_expr." + val="$undef" + fi +;; +*) val="$d_builtin_choose_expr" ;; +esac + +set d_builtin_choose_expr +eval $setvar +$rm_try + +: Look for GCC-style __builtin_expect +case "$d_builtin_expect" in +'') + echo " " + echo "Checking whether your compiler can handle __builtin_expect ..." >&4 + $cat >try.c <<'EOCP' +int main(void) { + int n = 50; + if ( __builtin_expect(n, 0) ) n = 1; + /* Remember shell exit code truth is 0, C truth is non-zero */ + return !(n == 1); +} +EOCP + set try + if eval $compile && $run ./try; then + echo "Your C compiler supports __builtin_expect." + val="$define" + else + echo "Your C compiler doesn't seem to understand __builtin_expect." + val="$undef" + fi + ;; +*) val="$d_builtin_expect" ;; +esac + +set d_builtin_expect +eval $setvar +$rm_try + +: see if bzero exists +set bzero d_bzero +eval $inlibc + +: 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); + return 0; +} +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* + +: see if the Compiler supports C99 variadic macros +case "$i_stdarg$i_stdlib" in + "$define$define") + echo "You have and , so checking for C99 variadic macros." >&4 + $cat >try.c < +#include + +#define foo(buffer, format, ...) sprintf(buffer, format, __VA_ARGS__) + +int main() { + char buf[20]; + foo(buf, "%d %g %.*s", 123, 456.0, (int)3, "789fail"); + puts(buf); + return 0; +} +EOCP + set try + if eval $compile && $run ./try 2>&1 >/dev/null; then + case "`$run ./try`" in + "123 456 789") + echo "You have C99 variadic macros." >&4 + d_c99_variadic_macros="$define" + ;; + *) + echo "You don't have functional C99 variadic macros." >&4 + d_c99_variadic_macros="$undef" + ;; + esac + else + echo "I couldn't compile and run the test program, so I assume that you don't have functional C99 variadic macros." >&4 + d_c99_variadic_macros="$undef" + fi + $rm_try + ;; + *) + echo "You don't have and , so not checking for C99 variadic macros." >&4 + d_c99_variadic_macros="$undef" + ;; +esac + +: 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 < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#include +#include +$signal_t blech(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 + $run ./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_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 < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#include +#include +$signal_t blech(int s) { exit(7); } +$signal_t blech_in_list(int s) { exit(4); } +unsigned long dummy_long(unsigned long p) { return p; } +unsigned int dummy_int(unsigned int p) { return p; } +unsigned short dummy_short(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 + $run ./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_try + +: see if vprintf exists +echo " " +if set vprintf val -f d_vprintf; eval $csym; $val; then + echo 'vprintf() found.' >&4 + val="$define" + $cat >try.c < +#else /* I_VARARGS */ +# include +#endif + +#ifdef I_UNISTD +# include +#endif + +#ifdef I_STDLIB +# include +#endif + +#include /* vsprintf prototype */ + +#ifdef I_STDARG +void xxx(int n, ...) +{ + va_list args; + char buf[10]; + va_start(args, n); + exit((unsigned long)vsprintf(buf,"%s",args) > 10L); +} +int main() { xxx(1, "foo"); } + +#else /* I_VARARGS */ + +xxx(va_alist) +va_dcl +{ + va_list args; + char buf[10]; + va_start(args); + exit((unsigned long)vsprintf(buf,"%s",args) > 10L); +} +int main() { xxx("foo"); } + +#endif + +EOF + set try + if eval $compile_ok; then + if $run ./try; then + echo "Your vsprintf() returns (int)." >&4 + val2="$undef" + else + echo "Your vsprintf() returns (char*)." >&4 + val2="$define" + fi + else + echo 'I am unable to compile the vsprintf() test program.' >&4 + # We shouldn't get here. If we do, assume the standard signature, + # not the old BSD one. + echo 'Guessing that vsprintf() returns (int).' >&4 + val2="$undef" + fi +else + echo 'vprintf() NOT found.' >&4 + val="$undef" + val2="$undef" +fi +$rm_try +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 + +: see if class exists +set class d_class +eval $inlibc + +: see if clearenv exists +set clearenv d_clearenv +eval $inlibc + +: Define hasstruct macro for Configure internal use +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_try' + +: see whether socket exists +socketlib='' +sockethdr='' +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 sa_len in the sock struct ..." >&4 +$cat >try.c < +#include +int main() { +struct sockaddr sa; +return (sa.sa_len); +} +EOF +val="$undef" +set try; if eval $compile; then + val="$define" +fi +set d_sockaddr_sa_len; eval $setvar +$rm_try + +echo " " +echo "Checking the availability struct sockaddr_in6 ..." >&4 +$cat >try.c < +#include +#include +int main() { +struct sockaddr_in6 sin6; +return (sin6.sin6_family); +} +EOF +val="$undef" +set try; if eval $compile; then + val="$define" +fi +set d_sockaddr_in6; eval $setvar +$rm_try + +echo " " +echo "Checking the availability sin6_scope_id in struct sockaddr_in6 ..." >&4 +$cat >try.c < +#include +#include +int main() { +struct sockaddr_in6 sin6; +return (sin6.sin6_scope_id); +} +EOF +val="$undef" +set try; if eval $compile; then + val="$define" +fi +set d_sin6_scope_id; eval $setvar +$rm_try + +echo " " +echo "Checking the availability struct ipv6_mreq ..." >&4 +$cat >try.c < +#include +#include +int main() { +struct ipv6_mreq mreq; +return (mreq.ipv6mr_interface); +} +EOF +val="$undef" +set try; if eval $compile; then + val="$define" +fi +set d_ipv6_mreq; eval $setvar +$rm_try + +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_try +done + +: see if this is a sys/uio.h system +set sys/uio.h i_sysuio +eval $inhdr + +: Check for cmsghdr support +echo " " +echo "Checking to see if your system supports struct cmsghdr..." >&4 +set d_cmsghdr_s cmsghdr $i_systypes sys/types.h $d_socket sys/socket.h $i_sysuio sys/uio.h +eval $hasstruct +case "$d_cmsghdr_s" in +"$define") echo "Yes, it does." ;; +*) echo "No, it doesn't." ;; +esac + + +: 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 = { 0 }; +} +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 copysignl exists +set copysignl d_copysignl +eval $inlibc + +: see if crypt exists +echo " " +set crypt d_crypt +eval $inlibc +case "$d_crypt" in +$define) cryptlib='' ;; +*) 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 + ;; +esac + +: see if this is a crypt.h system +set crypt.h i_crypt +eval $inhdr + +: see if crypt_r exists +set crypt_r d_crypt_r +eval $inlibc +case "$d_crypt_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_crypt crypt.h" + case "$d_crypt_r_proto:$usethreads" in + ":define") d_crypt_r_proto=define + set d_crypt_r_proto crypt_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_crypt_r_proto" in + define) + case "$crypt_r_proto" in + ''|0) try='char* crypt_r(const char*, const char*, struct crypt_data*);' + ./protochk "$extern_C $try" $hdrs && crypt_r_proto=B_CCS ;; + esac + case "$crypt_r_proto" in + ''|0) try='char* crypt_r(const char*, const char*, CRYPTD*);' + ./protochk "$extern_C $try" $hdrs && crypt_r_proto=B_CCD ;; + esac + case "$crypt_r_proto" in + ''|0) d_crypt_r=undef + crypt_r_proto=0 + echo "Disabling crypt_r, cannot determine prototype." >&4 ;; + * ) case "$crypt_r_proto" in + REENTRANT_PROTO*) ;; + *) crypt_r_proto="REENTRANT_PROTO_$crypt_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "crypt_r has no prototype, not using it." >&4 ;; + esac + d_crypt_r=undef + crypt_r_proto=0 + ;; + esac + ;; +*) crypt_r_proto=0 + ;; +esac + +: 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 ctermid exists +set ctermid d_ctermid +eval $inlibc + +: see if ctermid_r exists +set ctermid_r d_ctermid_r +eval $inlibc +case "$d_ctermid_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h " + case "$d_ctermid_r_proto:$usethreads" in + ":define") d_ctermid_r_proto=define + set d_ctermid_r_proto ctermid_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_ctermid_r_proto" in + define) + case "$ctermid_r_proto" in + ''|0) try='char* ctermid_r(char*);' + ./protochk "$extern_C $try" $hdrs && ctermid_r_proto=B_B ;; + esac + case "$ctermid_r_proto" in + ''|0) d_ctermid_r=undef + ctermid_r_proto=0 + echo "Disabling ctermid_r, cannot determine prototype." >&4 ;; + * ) case "$ctermid_r_proto" in + REENTRANT_PROTO*) ;; + *) ctermid_r_proto="REENTRANT_PROTO_$ctermid_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "ctermid_r has no prototype, not using it." >&4 ;; + esac + d_ctermid_r=undef + ctermid_r_proto=0 + ;; + esac + ;; +*) ctermid_r_proto=0 + ;; +esac + +: see if ctime_r exists +set ctime_r d_ctime_r +eval $inlibc +case "$d_ctime_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_time time.h $i_systime sys/time.h" + case "$d_ctime_r_proto:$usethreads" in + ":define") d_ctime_r_proto=define + set d_ctime_r_proto ctime_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_ctime_r_proto" in + define) + case "$ctime_r_proto" in + ''|0) try='char* ctime_r(const time_t*, char*);' + ./protochk "$extern_C $try" $hdrs && ctime_r_proto=B_SB ;; + esac + case "$ctime_r_proto" in + ''|0) try='char* ctime_r(const time_t*, char*, int);' + ./protochk "$extern_C $try" $hdrs && ctime_r_proto=B_SBI ;; + esac + case "$ctime_r_proto" in + ''|0) try='int ctime_r(const time_t*, char*);' + ./protochk "$extern_C $try" $hdrs && ctime_r_proto=I_SB ;; + esac + case "$ctime_r_proto" in + ''|0) try='int ctime_r(const time_t*, char*, int);' + ./protochk "$extern_C $try" $hdrs && ctime_r_proto=I_SBI ;; + esac + case "$ctime_r_proto" in + ''|0) d_ctime_r=undef + ctime_r_proto=0 + echo "Disabling ctime_r, cannot determine prototype." >&4 ;; + * ) case "$ctime_r_proto" in + REENTRANT_PROTO*) ;; + *) ctime_r_proto="REENTRANT_PROTO_$ctime_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "ctime_r has no prototype, not using it." >&4 ;; + esac + d_ctime_r=undef + ctime_r_proto=0 + ;; + esac + ;; +*) ctime_r_proto=0 + ;; +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 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 prototype for dbminit is available +echo " " +set d_dbminitproto dbminit $i_dbm dbm.h +eval $hasproto + +: 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_try + +: 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_try + +: Look for DIR.dd_fd +case "$i_dirent" in +"$define") + echo "Checking to see if DIR has a dd_fd member variable" >&4 + $cat >try.c < +#endif +#include + +int main() { + DIR dir; + dir.dd_fd = 1; + return 0; +} +EOCP + val=$undef + set try + if eval $compile; then + echo "Yes, it does." + val="$define" + else + echo "No, it does not." + val="$undef" + fi + ;; +*) + echo "You don't have a , so not checking for dd_fd." >&4 + val="$undef" + ;; +esac +set d_dir_dd_fd +eval $setvar +$rm_try + +: 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 + +: Look for dirfd +echo " " +$cat >dirfd.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#$i_dirent I_DIRENT /**/ +#$i_sysdir I_SYS_DIR /**/ +#$i_sysndir I_SYS_NDIR /**/ +#$i_systypes I_SYS_TYPES /**/ +#if defined(I_SYS_TYPES) +#include +#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() { + DIR *dirp = opendir("."); + if (dirfd(dirp) >= 0) + exit(0); + else + exit(1); +} +EOM +val=$undef +set dirfd +if eval $compile; then + val="$define" +fi +case "$val" in +$define) echo "dirfd() found." >&4 ;; +*) echo "dirfd() NOT found." >&4 ;; +esac +set d_dirfd +eval $setvar +$rm -f dirfd* + +: 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 + +: Check what extension to use for shared libs +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_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#$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 $ldflags $lddlflags tmp-dyna${_o} > /dev/null 2>&1 && + $cc -o fred $ccflags $ldflags $cccdlflags $ccdlflags fred.c $libs > /dev/null 2>&1 && $to dyna.$dlext; then + xxx=`$run ./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 + +: see if drand48_r exists +set drand48_r d_drand48_r +eval $inlibc +case "$d_drand48_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_stdlib stdlib.h" + case "$d_drand48_r_proto:$usethreads" in + ":define") d_drand48_r_proto=define + set d_drand48_r_proto drand48_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_drand48_r_proto" in + define) + case "$drand48_r_proto" in + ''|0) try='int drand48_r(struct drand48_data*, double*);' + ./protochk "$extern_C $try" $hdrs && drand48_r_proto=I_ST ;; + esac + case "$drand48_r_proto" in + ''|0) d_drand48_r=undef + drand48_r_proto=0 + echo "Disabling drand48_r, cannot determine prototype." >&4 ;; + * ) case "$drand48_r_proto" in + REENTRANT_PROTO*) ;; + *) drand48_r_proto="REENTRANT_PROTO_$drand48_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "drand48_r has no prototype, not using it." >&4 ;; + esac + d_drand48_r=undef + drand48_r_proto=0 + ;; + esac + ;; +*) drand48_r_proto=0 + ;; +esac + +: 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 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 endgrent_r exists +set endgrent_r d_endgrent_r +eval $inlibc +case "$d_endgrent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_grp grp.h" + case "$d_endgrent_r_proto:$usethreads" in + ":define") d_endgrent_r_proto=define + set d_endgrent_r_proto endgrent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_endgrent_r_proto" in + define) + case "$endgrent_r_proto" in + ''|0) try='int endgrent_r(FILE**);' + ./protochk "$extern_C $try" $hdrs && endgrent_r_proto=I_H ;; + esac + case "$endgrent_r_proto" in + ''|0) try='void endgrent_r(FILE**);' + ./protochk "$extern_C $try" $hdrs && endgrent_r_proto=V_H ;; + esac + case "$endgrent_r_proto" in + ''|0) d_endgrent_r=undef + endgrent_r_proto=0 + echo "Disabling endgrent_r, cannot determine prototype." >&4 ;; + * ) case "$endgrent_r_proto" in + REENTRANT_PROTO*) ;; + *) endgrent_r_proto="REENTRANT_PROTO_$endgrent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "endgrent_r has no prototype, not using it." >&4 ;; + esac + d_endgrent_r=undef + endgrent_r_proto=0 + ;; + esac + ;; +*) endgrent_r_proto=0 + ;; +esac + +: see if endhostent exists +set endhostent d_endhent +eval $inlibc + +: see if this is a netdb.h system +set netdb.h i_netdb +eval $inhdr + +: see if endhostent_r exists +set endhostent_r d_endhostent_r +eval $inlibc +case "$d_endhostent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_endhostent_r_proto:$usethreads" in + ":define") d_endhostent_r_proto=define + set d_endhostent_r_proto endhostent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_endhostent_r_proto" in + define) + case "$endhostent_r_proto" in + ''|0) try='int endhostent_r(struct hostent_data*);' + ./protochk "$extern_C $try" $hdrs && endhostent_r_proto=I_D ;; + esac + case "$endhostent_r_proto" in + ''|0) try='void endhostent_r(struct hostent_data*);' + ./protochk "$extern_C $try" $hdrs && endhostent_r_proto=V_D ;; + esac + case "$endhostent_r_proto" in + ''|0) d_endhostent_r=undef + endhostent_r_proto=0 + echo "Disabling endhostent_r, cannot determine prototype." >&4 ;; + * ) case "$endhostent_r_proto" in + REENTRANT_PROTO*) ;; + *) endhostent_r_proto="REENTRANT_PROTO_$endhostent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "endhostent_r has no prototype, not using it." >&4 ;; + esac + d_endhostent_r=undef + endhostent_r_proto=0 + ;; + esac + ;; +*) endhostent_r_proto=0 + ;; +esac + +: see if endnetent exists +set endnetent d_endnent +eval $inlibc + +: see if endnetent_r exists +set endnetent_r d_endnetent_r +eval $inlibc +case "$d_endnetent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_endnetent_r_proto:$usethreads" in + ":define") d_endnetent_r_proto=define + set d_endnetent_r_proto endnetent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_endnetent_r_proto" in + define) + case "$endnetent_r_proto" in + ''|0) try='int endnetent_r(struct netent_data*);' + ./protochk "$extern_C $try" $hdrs && endnetent_r_proto=I_D ;; + esac + case "$endnetent_r_proto" in + ''|0) try='void endnetent_r(struct netent_data*);' + ./protochk "$extern_C $try" $hdrs && endnetent_r_proto=V_D ;; + esac + case "$endnetent_r_proto" in + ''|0) d_endnetent_r=undef + endnetent_r_proto=0 + echo "Disabling endnetent_r, cannot determine prototype." >&4 ;; + * ) case "$endnetent_r_proto" in + REENTRANT_PROTO*) ;; + *) endnetent_r_proto="REENTRANT_PROTO_$endnetent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "endnetent_r has no prototype, not using it." >&4 ;; + esac + d_endnetent_r=undef + endnetent_r_proto=0 + ;; + esac + ;; +*) endnetent_r_proto=0 + ;; +esac + +: see if endprotoent exists +set endprotoent d_endpent +eval $inlibc + +: see if endprotoent_r exists +set endprotoent_r d_endprotoent_r +eval $inlibc +case "$d_endprotoent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_endprotoent_r_proto:$usethreads" in + ":define") d_endprotoent_r_proto=define + set d_endprotoent_r_proto endprotoent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_endprotoent_r_proto" in + define) + case "$endprotoent_r_proto" in + ''|0) try='int endprotoent_r(struct protoent_data*);' + ./protochk "$extern_C $try" $hdrs && endprotoent_r_proto=I_D ;; + esac + case "$endprotoent_r_proto" in + ''|0) try='void endprotoent_r(struct protoent_data*);' + ./protochk "$extern_C $try" $hdrs && endprotoent_r_proto=V_D ;; + esac + case "$endprotoent_r_proto" in + ''|0) d_endprotoent_r=undef + endprotoent_r_proto=0 + echo "Disabling endprotoent_r, cannot determine prototype." >&4 ;; + * ) case "$endprotoent_r_proto" in + REENTRANT_PROTO*) ;; + *) endprotoent_r_proto="REENTRANT_PROTO_$endprotoent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "endprotoent_r has no prototype, not using it." >&4 ;; + esac + d_endprotoent_r=undef + endprotoent_r_proto=0 + ;; + esac + ;; +*) endprotoent_r_proto=0 + ;; +esac + +: see if endpwent exists +set endpwent d_endpwent +eval $inlibc + +: 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 endpwent_r exists +set endpwent_r d_endpwent_r +eval $inlibc +case "$d_endpwent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_pwd pwd.h" + case "$d_endpwent_r_proto:$usethreads" in + ":define") d_endpwent_r_proto=define + set d_endpwent_r_proto endpwent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_endpwent_r_proto" in + define) + case "$endpwent_r_proto" in + ''|0) try='int endpwent_r(FILE**);' + ./protochk "$extern_C $try" $hdrs && endpwent_r_proto=I_H ;; + esac + case "$endpwent_r_proto" in + ''|0) try='void endpwent_r(FILE**);' + ./protochk "$extern_C $try" $hdrs && endpwent_r_proto=V_H ;; + esac + case "$endpwent_r_proto" in + ''|0) d_endpwent_r=undef + endpwent_r_proto=0 + echo "Disabling endpwent_r, cannot determine prototype." >&4 ;; + * ) case "$endpwent_r_proto" in + REENTRANT_PROTO*) ;; + *) endpwent_r_proto="REENTRANT_PROTO_$endpwent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "endpwent_r has no prototype, not using it." >&4 ;; + esac + d_endpwent_r=undef + endpwent_r_proto=0 + ;; + esac + ;; +*) endpwent_r_proto=0 + ;; +esac + +: see if endservent exists +set endservent d_endsent +eval $inlibc + +: see if endservent_r exists +set endservent_r d_endservent_r +eval $inlibc +case "$d_endservent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_endservent_r_proto:$usethreads" in + ":define") d_endservent_r_proto=define + set d_endservent_r_proto endservent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_endservent_r_proto" in + define) + case "$endservent_r_proto" in + ''|0) try='int endservent_r(struct servent_data*);' + ./protochk "$extern_C $try" $hdrs && endservent_r_proto=I_D ;; + esac + case "$endservent_r_proto" in + ''|0) try='void endservent_r(struct servent_data*);' + ./protochk "$extern_C $try" $hdrs && endservent_r_proto=V_D ;; + esac + case "$endservent_r_proto" in + ''|0) d_endservent_r=undef + endservent_r_proto=0 + echo "Disabling endservent_r, cannot determine prototype." >&4 ;; + * ) case "$endservent_r_proto" in + REENTRANT_PROTO*) ;; + *) endservent_r_proto="REENTRANT_PROTO_$endservent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "endservent_r has no prototype, not using it." >&4 ;; + esac + d_endservent_r=undef + endservent_r_proto=0 + ;; + esac + ;; +*) endservent_r_proto=0 + ;; +esac + +: Locate the flags for 'open()' +echo " " +$cat >try.c < +#ifdef I_FCNTL +#include +#endif +#ifdef I_SYS_FILE +#include +#endif +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#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 try -DI_SYS_FILE && eval $compile; then + h_sysfile=true; + echo " defines the O_* constants..." >&4 + if $run ./try; 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 try -DI_FCNTL && eval $compile; then + h_fcntl=true; + echo " defines the O_* constants..." >&4 + if $run ./try; 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_try + +: 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 fork exists +set fork d_fork +eval $inlibc + +: see if pipe exists +set pipe d_pipe +eval $inlibc + +: 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 < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#$i_fcntl I_FCNTL +#ifdef I_FCNTL +#include +#endif +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=`$run ./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_try + +echo " " +echo "Let's see what value errno gets from read() on a $o_nonblock file..." >&4 +case "$eagain" in +'') + case "$d_fork:$d_pipe" in + define:define) + $cat head.c > try.c + $cat >>try.c < +#include +#include +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#$i_fcntl I_FCNTL +#ifdef I_FCNTL +#include +#endif +#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(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] */ +#ifdef F_SETFL + if (-1 == fcntl(pd[0], F_SETFL, MY_O_NONBLOCK)) + exit(1); +#else + exit(4); +#endif + 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(4, 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 "$run ./try >try.out 2>try.ret 4>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!";; + 4) echo "Could not find F_SETFL!";; + *) 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 + ;; + *) echo "Can't figure out how to test this--assuming errno EAGAIN will do." + eagain=EAGAIN + val="$define" + ;; + esac + 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_try head.c mtry + +: see if _ptr and _cnt from stdio act std +echo " " + +if $contains '_lbfsize' `./findhdr stdio.h` >/dev/null 2>&1 ; then + echo "(Looks like you have stdio.h from BSD.)" + case "$stdio_ptr" in + '') stdio_ptr='((fp)->_p)' + ptr_lval=$define + ;; + *) ptr_lval=$d_stdio_ptr_lval;; + esac + case "$stdio_cnt" in + '') stdio_cnt='((fp)->_r)' + cnt_lval=$define + ;; + *) cnt_lval=$d_stdio_cnt_lval;; + esac + case "$stdio_base" in + '') stdio_base='((fp)->_ub._base ? (fp)->_ub._base : (fp)->_bf._base)';; + esac + case "$stdio_bufsiz" in + '') stdio_bufsiz='((fp)->_ub._base ? (fp)->_ub._size : (fp)->_bf._size)';; + esac +elif $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 < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#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 && $to try.c; then + if $run ./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_try + +# glibc 2.2.90 and above apparently change stdio streams so Perl's +# direct buffer manipulation no longer works. The Configure tests +# should be changed to correctly detect this, but until then, +# the following check should at least let perl compile and run. +# (This quick fix should be updated before 5.8.1.) +# To be defensive, reject all unknown versions, and all versions > 2.2.9. +# A. Dougherty, June 3, 2002. +case "$d_gnulibc" in +$define) + case "$gnulibc_version" in + 2.[01]*) ;; + 2.2) ;; + 2.2.[0-9]) ;; + *) echo "But I will not snoop inside glibc $gnulibc_version stdio buffers." + val="$undef" + ;; + esac + ;; +esac +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 :-) */ +/* In the buffer space, no one can hear you scream. */ +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#define FILE_ptr(fp) $stdio_ptr +#define FILE_cnt(fp) $stdio_cnt +#include +int main() { + FILE *fp = fopen("try.c", "r"); + int c; + char *ptr; + size_t cnt; + if (!fp) { + puts("Fail even to read"); + exit(1); + } + c = getc(fp); /* Read away the first # */ + if (c == EOF) { + puts("Fail even to read"); + exit(1); + } + if (!( + 18 <= FILE_cnt(fp) && + strncmp(FILE_ptr(fp), "include \n", 18) == 0 + )) { + puts("Fail even to read"); + exit (1); + } + ptr = (char*) FILE_ptr(fp); + cnt = (size_t)FILE_cnt(fp); + + FILE_ptr(fp) += 42; + + if ((char*)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 && $to try.c; then + case `$run ./try` 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_try + ;; +esac + +: see if _base is also standard +val="$undef" +case "$d_stdstdio" in +$define) + $cat >try.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#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 && $to try.c; then + if $run ./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_try + ;; +esac +set d_stdiobase +eval $setvar + +: see if fast_stdio exists +val="$undef" +case "$d_stdstdio:$d_stdio_ptr_lval" in +"$define:$define") + case "$d_stdio_cnt_lval$d_stdio_ptr_lval_sets_cnt" in + *$define*) + echo "You seem to have 'fast stdio' to directly manipulate the stdio buffers." >& 4 + val="$define" + ;; + esac + ;; +esac +set d_faststdio +eval $setvar + + + +: see if fchdir exists +set fchdir d_fchdir +eval $inlibc + +: 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 + +: See if fcntl-based locking works. +echo " " +$cat >try.c < +#endif +#include +#include +#include +$signal_t blech(int x) { exit(3); } +int main() { +#if defined(F_SETLK) && defined(F_SETLKW) + struct flock flock; + int retval, fd; + fd = open("try.c", O_RDONLY); + flock.l_type = F_RDLCK; + flock.l_whence = SEEK_SET; + flock.l_start = flock.l_len = 0; + signal(SIGALRM, blech); + alarm(10); + retval = fcntl(fd, F_SETLK, &flock); + close(fd); + (retval < 0 ? exit(2) : exit(0)); +#else + exit(2); +#endif +} +EOCP +echo "Checking if fcntl-based file locking works... " +case "$d_fcntl" in +"$define") + set try + if eval $compile_ok; then + if $run ./try; then + echo "Yes, it seems to work." + val="$define" + else + echo "Nope, it didn't work." + val="$undef" + case "$?" in + 3) $cat >&4 <try.c < +#endif +#$i_systime I_SYS_TIME +#$i_sysselct I_SYS_SELECT +#$d_socket HAS_SOCKET +#include +#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 try -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 $run ./try; 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 try + 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 $run ./try; 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_try + +: see if fgetpos exists +set fgetpos d_fgetpos +eval $inlibc + +: see if finite exists +set finite d_finite +eval $inlibc + +: see if finitel exists +set finitel d_finitel +eval $inlibc + +: see if flock exists +set flock d_flock +eval $inlibc + +: see if prototype for flock is available +echo " " +set d_flockproto flock $i_sysfile sys/file.h +eval $hasproto + +: see if fp_class exists +set fp_class d_fp_class +eval $inlibc + +: see if pathconf exists +set pathconf d_pathconf +eval $inlibc + +: see if fpathconf exists +set fpathconf d_fpathconf +eval $inlibc + +: see if fpclass exists +set fpclass d_fpclass +eval $inlibc + +: see if fpclassify exists +set fpclassify d_fpclassify +eval $inlibc + +: see if fpclassl exists +set fpclassl d_fpclassl +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_try +set d_fpos64_t +eval $setvar + +: see if frexpl exists +set frexpl d_frexpl +eval $inlibc + +: 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 + +: Check for fs_data_s +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 fsync exists +set fsync d_fsync +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 + +: check for a working futimes +d_futimes="$undef" +echo " " +echo "Checking if you have a working futimes()" >&4 +$cat >try.c < +#include +#include +#include + +int main () +{ + int fd, rv; + fd = open ("try.c", O_RDWR); + if (-1 == fd) exit (1); + rv = futimes (fd, NULL); + exit (rv == -1 ? errno : 0); +} +EOCP +set try +if eval $compile; then + `$run ./try` + rc=$? + case "$rc" in + 0) echo "Yes, you have" >&4 + d_futimes="$define" + ;; + *) echo "No, you have futimes, but it isn't working ($rc) (probably harmless)" >&4 + ;; + esac +else + echo "No, it does not (probably harmless)" >&4 +fi +$rm_try + +: see if ndbm.h is available +set ndbm.h i_ndbm +eval $inhdr +: Compatibility location for RedHat 7.1 +set gdbm/ndbm.h i_gdbmndbm +eval $inhdr +: Compatibility location for Debian 4.0 +set gdbm-ndbm.h i_gdbm_ndbm +eval $inhdr + +val="$undef" +if $test "$i_ndbm" = "$define" -o "$i_gdbmndbm" = "$define" -o "$i_gdbm_ndbm" = "$define"; then + : see if dbm_open exists + set dbm_open d_dbm_open + eval $inlibc + case "$d_dbm_open" in + $undef) + i_ndbm="$undef" + i_gdbmndbm="$undef" + i_gdbm_ndbm="$undef" + echo "We won't be including " + val="$undef" + ;; + *) val="$define" + ;; + esac +fi +set d_ndbm +eval $setvar + +ndbm_hdr_protochk='name=$1; hdr=$2; +eval "ihdr=\$""i_$name"; +val="$undef"; +if $test "$ihdr" = "$define"; then + $echo "Checking if your <$hdr> uses prototypes..." >&4; + case "$d_cplusplus" in + $define) ./protochk "$extern_C void dbm_close(DBM *);" literal "extern \"C\" {" $ihdr $hdr literal "}" && val="$define" ;; + *) ./protochk "$extern_C void dbm_close(int, int);" $ihdr $hdr || val="$define" ;; + esac; + case "$val" in + $define) $echo "Your <$hdr> seems to have prototypes";; + *) $echo "Your <$hdr> does not seem to have prototypes";; + esac; +fi; +set "d_${name}_h_uses_prototypes"; +eval $setvar' + +set ndbm ndbm.h +eval $ndbm_hdr_protochk +set gdbmndbm gdbm/ndbm.h +eval $ndbm_hdr_protochk +set gdbm_ndbm gdbm-ndbm.h +eval $ndbm_hdr_protochk + +: see if getaddrinfo exists +set getaddrinfo d_getaddrinfo +eval $inlibc + +: 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 getgrent_r exists +set getgrent_r d_getgrent_r +eval $inlibc +case "$d_getgrent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_grp grp.h" + case "$d_getgrent_r_proto:$usethreads" in + ":define") d_getgrent_r_proto=define + set d_getgrent_r_proto getgrent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getgrent_r_proto" in + define) + case "$getgrent_r_proto" in + ''|0) try='int getgrent_r(struct group*, char*, size_t, struct group**);' + ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=I_SBWR ;; + esac + case "$getgrent_r_proto" in + ''|0) try='int getgrent_r(struct group*, char*, int, struct group**);' + ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=I_SBIR ;; + esac + case "$getgrent_r_proto" in + ''|0) try='struct group* getgrent_r(struct group*, char*, size_t);' + ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=S_SBW ;; + esac + case "$getgrent_r_proto" in + ''|0) try='struct group* getgrent_r(struct group*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=S_SBI ;; + esac + case "$getgrent_r_proto" in + ''|0) try='int getgrent_r(struct group*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=I_SBI ;; + esac + case "$getgrent_r_proto" in + ''|0) try='int getgrent_r(struct group*, char*, int, FILE**);' + ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=I_SBIH ;; + esac + case "$getgrent_r_proto" in + ''|0) d_getgrent_r=undef + getgrent_r_proto=0 + echo "Disabling getgrent_r, cannot determine prototype." >&4 ;; + * ) case "$getgrent_r_proto" in + REENTRANT_PROTO*) ;; + *) getgrent_r_proto="REENTRANT_PROTO_$getgrent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getgrent_r has no prototype, not using it." >&4 ;; + esac + d_getgrent_r=undef + getgrent_r_proto=0 + ;; + esac + ;; +*) getgrent_r_proto=0 + ;; +esac + +: see if getgrgid_r exists +set getgrgid_r d_getgrgid_r +eval $inlibc +case "$d_getgrgid_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_grp grp.h" + case "$d_getgrgid_r_proto:$usethreads" in + ":define") d_getgrgid_r_proto=define + set d_getgrgid_r_proto getgrgid_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getgrgid_r_proto" in + define) + case "$getgrgid_r_proto" in + ''|0) try='int getgrgid_r(gid_t, struct group*, char*, size_t, struct group**);' + ./protochk "$extern_C $try" $hdrs && getgrgid_r_proto=I_TSBWR ;; + esac + case "$getgrgid_r_proto" in + ''|0) try='int getgrgid_r(gid_t, struct group*, char*, int, struct group**);' + ./protochk "$extern_C $try" $hdrs && getgrgid_r_proto=I_TSBIR ;; + esac + case "$getgrgid_r_proto" in + ''|0) try='int getgrgid_r(gid_t, struct group*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getgrgid_r_proto=I_TSBI ;; + esac + case "$getgrgid_r_proto" in + ''|0) try='struct group* getgrgid_r(gid_t, struct group*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getgrgid_r_proto=S_TSBI ;; + esac + case "$getgrgid_r_proto" in + ''|0) d_getgrgid_r=undef + getgrgid_r_proto=0 + echo "Disabling getgrgid_r, cannot determine prototype." >&4 ;; + * ) case "$getgrgid_r_proto" in + REENTRANT_PROTO*) ;; + *) getgrgid_r_proto="REENTRANT_PROTO_$getgrgid_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getgrgid_r has no prototype, not using it." >&4 ;; + esac + d_getgrgid_r=undef + getgrgid_r_proto=0 + ;; + esac + ;; +*) getgrgid_r_proto=0 + ;; +esac + +: see if getgrnam_r exists +set getgrnam_r d_getgrnam_r +eval $inlibc +case "$d_getgrnam_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_grp grp.h" + case "$d_getgrnam_r_proto:$usethreads" in + ":define") d_getgrnam_r_proto=define + set d_getgrnam_r_proto getgrnam_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getgrnam_r_proto" in + define) + case "$getgrnam_r_proto" in + ''|0) try='int getgrnam_r(const char*, struct group*, char*, size_t, struct group**);' + ./protochk "$extern_C $try" $hdrs && getgrnam_r_proto=I_CSBWR ;; + esac + case "$getgrnam_r_proto" in + ''|0) try='int getgrnam_r(const char*, struct group*, char*, int, struct group**);' + ./protochk "$extern_C $try" $hdrs && getgrnam_r_proto=I_CSBIR ;; + esac + case "$getgrnam_r_proto" in + ''|0) try='struct group* getgrnam_r(const char*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getgrnam_r_proto=S_CBI ;; + esac + case "$getgrnam_r_proto" in + ''|0) try='int getgrnam_r(const char*, struct group*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getgrnam_r_proto=I_CSBI ;; + esac + case "$getgrnam_r_proto" in + ''|0) try='struct group* getgrnam_r(const char*, struct group*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getgrnam_r_proto=S_CSBI ;; + esac + case "$getgrnam_r_proto" in + ''|0) d_getgrnam_r=undef + getgrnam_r_proto=0 + echo "Disabling getgrnam_r, cannot determine prototype." >&4 ;; + * ) case "$getgrnam_r_proto" in + REENTRANT_PROTO*) ;; + *) getgrnam_r_proto="REENTRANT_PROTO_$getgrnam_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getgrnam_r has no prototype, not using it." >&4 ;; + esac + d_getgrnam_r=undef + getgrnam_r_proto=0 + ;; + esac + ;; +*) getgrnam_r_proto=0 + ;; +esac + +: 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 gethostbyaddr_r exists +set gethostbyaddr_r d_gethostbyaddr_r +eval $inlibc +case "$d_gethostbyaddr_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_gethostbyaddr_r_proto:$usethreads" in + ":define") d_gethostbyaddr_r_proto=define + set d_gethostbyaddr_r_proto gethostbyaddr_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_gethostbyaddr_r_proto" in + define) + case "$gethostbyaddr_r_proto" in + ''|0) try='int gethostbyaddr_r(const char*, size_t, int, struct hostent*, char*, size_t, struct hostent**, int*);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=I_CWISBWRE ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='struct hostent* gethostbyaddr_r(const char*, size_t, int, struct hostent*, char*, size_t, int, int*);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_CWISBWIE ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='struct hostent* gethostbyaddr_r(const char*, size_t, int, struct hostent*, char*, int, int*);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_CWISBIE ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='struct hostent* gethostbyaddr_r(const void*, size_t, int, struct hostent*, char*, int, int*);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_TWISBIE ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='struct hostent* gethostbyaddr_r(const char*, int, int, struct hostent*, char*, int, int*);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_CIISBIE ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='struct hostent* gethostbyaddr_r(const char*, struct hostent*, char*, int, int*);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_CSBIE ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='struct hostent* gethostbyaddr_r(const void*, struct hostent*, char*, int, int*);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_TSBIE ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='int gethostbyaddr_r(const char*, size_t, int, struct hostent*, struct hostent_data*);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=I_CWISD ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='int gethostbyaddr_r(const char*, int, int, struct hostent*, struct hostent_data*);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=I_CIISD ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='int gethostbyaddr_r(const char*, int, int);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=I_CII ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='int gethostbyaddr_r(const void*, socklen_t, int, struct hostent*, char*, size_t, struct hostent**, int*);' + ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=I_TsISBWRE ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) d_gethostbyaddr_r=undef + gethostbyaddr_r_proto=0 + echo "Disabling gethostbyaddr_r, cannot determine prototype." >&4 ;; + * ) case "$gethostbyaddr_r_proto" in + REENTRANT_PROTO*) ;; + *) gethostbyaddr_r_proto="REENTRANT_PROTO_$gethostbyaddr_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "gethostbyaddr_r has no prototype, not using it." >&4 ;; + esac + d_gethostbyaddr_r=undef + gethostbyaddr_r_proto=0 + ;; + esac + ;; +*) gethostbyaddr_r_proto=0 + ;; +esac + +: see if gethostbyname_r exists +set gethostbyname_r d_gethostbyname_r +eval $inlibc +case "$d_gethostbyname_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_gethostbyname_r_proto:$usethreads" in + ":define") d_gethostbyname_r_proto=define + set d_gethostbyname_r_proto gethostbyname_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_gethostbyname_r_proto" in + define) + case "$gethostbyname_r_proto" in + ''|0) try='int gethostbyname_r(const char*, struct hostent*, char*, size_t, struct hostent**, int*);' + ./protochk "$extern_C $try" $hdrs && gethostbyname_r_proto=I_CSBWRE ;; + esac + case "$gethostbyname_r_proto" in + ''|0) try='struct hostent* gethostbyname_r(const char*, struct hostent*, char*, int, int*);' + ./protochk "$extern_C $try" $hdrs && gethostbyname_r_proto=S_CSBIE ;; + esac + case "$gethostbyname_r_proto" in + ''|0) try='int gethostbyname_r(const char*, struct hostent*, struct hostent_data*);' + ./protochk "$extern_C $try" $hdrs && gethostbyname_r_proto=I_CSD ;; + esac + case "$gethostbyname_r_proto" in + ''|0) d_gethostbyname_r=undef + gethostbyname_r_proto=0 + echo "Disabling gethostbyname_r, cannot determine prototype." >&4 ;; + * ) case "$gethostbyname_r_proto" in + REENTRANT_PROTO*) ;; + *) gethostbyname_r_proto="REENTRANT_PROTO_$gethostbyname_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "gethostbyname_r has no prototype, not using it." >&4 ;; + esac + d_gethostbyname_r=undef + gethostbyname_r_proto=0 + ;; + esac + ;; +*) gethostbyname_r_proto=0 + ;; +esac + +: see if gethostent_r exists +set gethostent_r d_gethostent_r +eval $inlibc +case "$d_gethostent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_gethostent_r_proto:$usethreads" in + ":define") d_gethostent_r_proto=define + set d_gethostent_r_proto gethostent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_gethostent_r_proto" in + define) + case "$gethostent_r_proto" in + ''|0) try='int gethostent_r(struct hostent*, char*, size_t, struct hostent**, int*);' + ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=I_SBWRE ;; + esac + case "$gethostent_r_proto" in + ''|0) try='int gethostent_r(struct hostent*, char*, int, int*);' + ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=I_SBIE ;; + esac + case "$gethostent_r_proto" in + ''|0) try='struct hostent* gethostent_r(struct hostent*, char*, int, int*);' + ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=S_SBIE ;; + esac + case "$gethostent_r_proto" in + ''|0) try='struct hostent* gethostent_r(struct hostent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=S_SBI ;; + esac + case "$gethostent_r_proto" in + ''|0) try='int gethostent_r(struct hostent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=I_SBI ;; + esac + case "$gethostent_r_proto" in + ''|0) try='int gethostent_r(struct hostent*, struct hostent_data*);' + ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=I_SD ;; + esac + case "$gethostent_r_proto" in + ''|0) d_gethostent_r=undef + gethostent_r_proto=0 + echo "Disabling gethostent_r, cannot determine prototype." >&4 ;; + * ) case "$gethostent_r_proto" in + REENTRANT_PROTO*) ;; + *) gethostent_r_proto="REENTRANT_PROTO_$gethostent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "gethostent_r has no prototype, not using it." >&4 ;; + esac + d_gethostent_r=undef + gethostent_r_proto=0 + ;; + esac + ;; +*) gethostent_r_proto=0 + ;; +esac + +: see if prototypes for various gethostxxx netdb.h functions are available +echo " " +set d_gethostprotos gethostent $i_netdb netdb.h +eval $hasproto + +: see if getitimer exists +set getitimer d_getitimer +eval $inlibc + +: see if getlogin exists +set getlogin d_getlogin +eval $inlibc + +: see if getlogin_r exists +set getlogin_r d_getlogin_r +eval $inlibc +case "$d_getlogin_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_unistd unistd.h" + case "$d_getlogin_r_proto:$usethreads" in + ":define") d_getlogin_r_proto=define + set d_getlogin_r_proto getlogin_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getlogin_r_proto" in + define) + case "$getlogin_r_proto" in + ''|0) try='int getlogin_r(char*, size_t);' + ./protochk "$extern_C $try" $hdrs && getlogin_r_proto=I_BW ;; + esac + case "$getlogin_r_proto" in + ''|0) try='int getlogin_r(char*, int);' + ./protochk "$extern_C $try" $hdrs && getlogin_r_proto=I_BI ;; + esac + case "$getlogin_r_proto" in + ''|0) try='char* getlogin_r(char*, size_t);' + ./protochk "$extern_C $try" $hdrs && getlogin_r_proto=B_BW ;; + esac + case "$getlogin_r_proto" in + ''|0) try='char* getlogin_r(char*, int);' + ./protochk "$extern_C $try" $hdrs && getlogin_r_proto=B_BI ;; + esac + case "$getlogin_r_proto" in + ''|0) d_getlogin_r=undef + getlogin_r_proto=0 + echo "Disabling getlogin_r, cannot determine prototype." >&4 ;; + * ) case "$getlogin_r_proto" in + REENTRANT_PROTO*) ;; + *) getlogin_r_proto="REENTRANT_PROTO_$getlogin_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getlogin_r has no prototype, not using it." >&4 ;; + esac + d_getlogin_r=undef + getlogin_r_proto=0 + ;; + esac + ;; +*) getlogin_r_proto=0 + ;; +esac + +: see if getmnt exists +set getmnt d_getmnt +eval $inlibc + +: see if getmntent exists +set getmntent d_getmntent +eval $inlibc + +: see if getnameinfo exists +set getnameinfo d_getnameinfo +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 getnetbyaddr_r exists +set getnetbyaddr_r d_getnetbyaddr_r +eval $inlibc +case "$d_getnetbyaddr_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_getnetbyaddr_r_proto:$usethreads" in + ":define") d_getnetbyaddr_r_proto=define + set d_getnetbyaddr_r_proto getnetbyaddr_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getnetbyaddr_r_proto" in + define) + case "$getnetbyaddr_r_proto" in + ''|0) try='int getnetbyaddr_r(unsigned long, int, struct netent*, char*, size_t, struct netent**, int*);' + ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_UISBWRE ;; + esac + case "$getnetbyaddr_r_proto" in + ''|0) try='int getnetbyaddr_r(long, int, struct netent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_LISBI ;; + esac + case "$getnetbyaddr_r_proto" in + ''|0) try='struct netent* getnetbyaddr_r(in_addr_t, int, struct netent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=S_TISBI ;; + esac + case "$getnetbyaddr_r_proto" in + ''|0) try='struct netent* getnetbyaddr_r(long, int, struct netent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=S_LISBI ;; + esac + case "$getnetbyaddr_r_proto" in + ''|0) try='int getnetbyaddr_r(in_addr_t, int, struct netent*, struct netent_data*);' + ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_TISD ;; + esac + case "$getnetbyaddr_r_proto" in + ''|0) try='int getnetbyaddr_r(long, int, struct netent*, struct netent_data*);' + ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_LISD ;; + esac + case "$getnetbyaddr_r_proto" in + ''|0) try='int getnetbyaddr_r(int, int, struct netent*, struct netent_data*);' + ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_IISD ;; + esac + case "$getnetbyaddr_r_proto" in + ''|0) try='int getnetbyaddr_r(uint32_t, int, struct netent*, char*, size_t, struct netent**, int*);' + ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_uISBWRE ;; + esac + case "$getnetbyaddr_r_proto" in + ''|0) d_getnetbyaddr_r=undef + getnetbyaddr_r_proto=0 + echo "Disabling getnetbyaddr_r, cannot determine prototype." >&4 ;; + * ) case "$getnetbyaddr_r_proto" in + REENTRANT_PROTO*) ;; + *) getnetbyaddr_r_proto="REENTRANT_PROTO_$getnetbyaddr_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getnetbyaddr_r has no prototype, not using it." >&4 ;; + esac + d_getnetbyaddr_r=undef + getnetbyaddr_r_proto=0 + ;; + esac + ;; +*) getnetbyaddr_r_proto=0 + ;; +esac + +: see if getnetbyname_r exists +set getnetbyname_r d_getnetbyname_r +eval $inlibc +case "$d_getnetbyname_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_getnetbyname_r_proto:$usethreads" in + ":define") d_getnetbyname_r_proto=define + set d_getnetbyname_r_proto getnetbyname_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getnetbyname_r_proto" in + define) + case "$getnetbyname_r_proto" in + ''|0) try='int getnetbyname_r(const char*, struct netent*, char*, size_t, struct netent**, int*);' + ./protochk "$extern_C $try" $hdrs && getnetbyname_r_proto=I_CSBWRE ;; + esac + case "$getnetbyname_r_proto" in + ''|0) try='int getnetbyname_r(const char*, struct netent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getnetbyname_r_proto=I_CSBI ;; + esac + case "$getnetbyname_r_proto" in + ''|0) try='struct netent* getnetbyname_r(const char*, struct netent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getnetbyname_r_proto=S_CSBI ;; + esac + case "$getnetbyname_r_proto" in + ''|0) try='int getnetbyname_r(const char*, struct netent*, struct netent_data*);' + ./protochk "$extern_C $try" $hdrs && getnetbyname_r_proto=I_CSD ;; + esac + case "$getnetbyname_r_proto" in + ''|0) d_getnetbyname_r=undef + getnetbyname_r_proto=0 + echo "Disabling getnetbyname_r, cannot determine prototype." >&4 ;; + * ) case "$getnetbyname_r_proto" in + REENTRANT_PROTO*) ;; + *) getnetbyname_r_proto="REENTRANT_PROTO_$getnetbyname_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getnetbyname_r has no prototype, not using it." >&4 ;; + esac + d_getnetbyname_r=undef + getnetbyname_r_proto=0 + ;; + esac + ;; +*) getnetbyname_r_proto=0 + ;; +esac + +: see if getnetent_r exists +set getnetent_r d_getnetent_r +eval $inlibc +case "$d_getnetent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_getnetent_r_proto:$usethreads" in + ":define") d_getnetent_r_proto=define + set d_getnetent_r_proto getnetent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getnetent_r_proto" in + define) + case "$getnetent_r_proto" in + ''|0) try='int getnetent_r(struct netent*, char*, size_t, struct netent**, int*);' + ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=I_SBWRE ;; + esac + case "$getnetent_r_proto" in + ''|0) try='int getnetent_r(struct netent*, char*, int, int*);' + ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=I_SBIE ;; + esac + case "$getnetent_r_proto" in + ''|0) try='struct netent* getnetent_r(struct netent*, char*, int, int*);' + ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=S_SBIE ;; + esac + case "$getnetent_r_proto" in + ''|0) try='struct netent* getnetent_r(struct netent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=S_SBI ;; + esac + case "$getnetent_r_proto" in + ''|0) try='int getnetent_r(struct netent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=I_SBI ;; + esac + case "$getnetent_r_proto" in + ''|0) try='int getnetent_r(struct netent*, struct netent_data*);' + ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=I_SD ;; + esac + case "$getnetent_r_proto" in + ''|0) d_getnetent_r=undef + getnetent_r_proto=0 + echo "Disabling getnetent_r, cannot determine prototype." >&4 ;; + * ) case "$getnetent_r_proto" in + REENTRANT_PROTO*) ;; + *) getnetent_r_proto="REENTRANT_PROTO_$getnetent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getnetent_r has no prototype, not using it." >&4 ;; + esac + d_getnetent_r=undef + getnetent_r_proto=0 + ;; + esac + ;; +*) getnetent_r_proto=0 + ;; +esac + +: see if prototypes for various getnetxxx netdb.h functions are available +echo " " +set d_getnetprotos getnetent $i_netdb netdb.h +eval $hasproto + +: see if getpagesize exists +set getpagesize d_getpagsz +eval $inlibc + +: Optional checks for getprotobyname and getprotobynumber + +: 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 getprotobyname_r exists +set getprotobyname_r d_getprotobyname_r +eval $inlibc +case "$d_getprotobyname_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_getprotobyname_r_proto:$usethreads" in + ":define") d_getprotobyname_r_proto=define + set d_getprotobyname_r_proto getprotobyname_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getprotobyname_r_proto" in + define) + case "$getprotobyname_r_proto" in + ''|0) try='int getprotobyname_r(const char*, struct protoent*, char*, size_t, struct protoent**);' + ./protochk "$extern_C $try" $hdrs && getprotobyname_r_proto=I_CSBWR ;; + esac + case "$getprotobyname_r_proto" in + ''|0) try='struct protoent* getprotobyname_r(const char*, struct protoent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getprotobyname_r_proto=S_CSBI ;; + esac + case "$getprotobyname_r_proto" in + ''|0) try='int getprotobyname_r(const char*, struct protoent*, struct protoent_data*);' + ./protochk "$extern_C $try" $hdrs && getprotobyname_r_proto=I_CSD ;; + esac + case "$getprotobyname_r_proto" in + ''|0) d_getprotobyname_r=undef + getprotobyname_r_proto=0 + echo "Disabling getprotobyname_r, cannot determine prototype." >&4 ;; + * ) case "$getprotobyname_r_proto" in + REENTRANT_PROTO*) ;; + *) getprotobyname_r_proto="REENTRANT_PROTO_$getprotobyname_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getprotobyname_r has no prototype, not using it." >&4 ;; + esac + d_getprotobyname_r=undef + getprotobyname_r_proto=0 + ;; + esac + ;; +*) getprotobyname_r_proto=0 + ;; +esac + +: see if getprotobynumber_r exists +set getprotobynumber_r d_getprotobynumber_r +eval $inlibc +case "$d_getprotobynumber_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_getprotobynumber_r_proto:$usethreads" in + ":define") d_getprotobynumber_r_proto=define + set d_getprotobynumber_r_proto getprotobynumber_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getprotobynumber_r_proto" in + define) + case "$getprotobynumber_r_proto" in + ''|0) try='int getprotobynumber_r(int, struct protoent*, char*, size_t, struct protoent**);' + ./protochk "$extern_C $try" $hdrs && getprotobynumber_r_proto=I_ISBWR ;; + esac + case "$getprotobynumber_r_proto" in + ''|0) try='struct protoent* getprotobynumber_r(int, struct protoent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getprotobynumber_r_proto=S_ISBI ;; + esac + case "$getprotobynumber_r_proto" in + ''|0) try='int getprotobynumber_r(int, struct protoent*, struct protoent_data*);' + ./protochk "$extern_C $try" $hdrs && getprotobynumber_r_proto=I_ISD ;; + esac + case "$getprotobynumber_r_proto" in + ''|0) d_getprotobynumber_r=undef + getprotobynumber_r_proto=0 + echo "Disabling getprotobynumber_r, cannot determine prototype." >&4 ;; + * ) case "$getprotobynumber_r_proto" in + REENTRANT_PROTO*) ;; + *) getprotobynumber_r_proto="REENTRANT_PROTO_$getprotobynumber_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getprotobynumber_r has no prototype, not using it." >&4 ;; + esac + d_getprotobynumber_r=undef + getprotobynumber_r_proto=0 + ;; + esac + ;; +*) getprotobynumber_r_proto=0 + ;; +esac + +: see if getprotoent_r exists +set getprotoent_r d_getprotoent_r +eval $inlibc +case "$d_getprotoent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_getprotoent_r_proto:$usethreads" in + ":define") d_getprotoent_r_proto=define + set d_getprotoent_r_proto getprotoent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getprotoent_r_proto" in + define) + case "$getprotoent_r_proto" in + ''|0) try='int getprotoent_r(struct protoent*, char*, size_t, struct protoent**);' + ./protochk "$extern_C $try" $hdrs && getprotoent_r_proto=I_SBWR ;; + esac + case "$getprotoent_r_proto" in + ''|0) try='int getprotoent_r(struct protoent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getprotoent_r_proto=I_SBI ;; + esac + case "$getprotoent_r_proto" in + ''|0) try='struct protoent* getprotoent_r(struct protoent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getprotoent_r_proto=S_SBI ;; + esac + case "$getprotoent_r_proto" in + ''|0) try='int getprotoent_r(struct protoent*, struct protoent_data*);' + ./protochk "$extern_C $try" $hdrs && getprotoent_r_proto=I_SD ;; + esac + case "$getprotoent_r_proto" in + ''|0) d_getprotoent_r=undef + getprotoent_r_proto=0 + echo "Disabling getprotoent_r, cannot determine prototype." >&4 ;; + * ) case "$getprotoent_r_proto" in + REENTRANT_PROTO*) ;; + *) getprotoent_r_proto="REENTRANT_PROTO_$getprotoent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getprotoent_r has no prototype, not using it." >&4 ;; + esac + d_getprotoent_r=undef + getprotoent_r_proto=0 + ;; + esac + ;; +*) getprotoent_r_proto=0 + ;; +esac + +: 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 getpwent_r exists +set getpwent_r d_getpwent_r +eval $inlibc +case "$d_getpwent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_pwd pwd.h" + case "$d_getpwent_r_proto:$usethreads" in + ":define") d_getpwent_r_proto=define + set d_getpwent_r_proto getpwent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getpwent_r_proto" in + define) + case "$getpwent_r_proto" in + ''|0) try='int getpwent_r(struct passwd*, char*, size_t, struct passwd**);' + ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=I_SBWR ;; + esac + case "$getpwent_r_proto" in + ''|0) try='int getpwent_r(struct passwd*, char*, int, struct passwd**);' + ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=I_SBIR ;; + esac + case "$getpwent_r_proto" in + ''|0) try='struct passwd* getpwent_r(struct passwd*, char*, size_t);' + ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=S_SBW ;; + esac + case "$getpwent_r_proto" in + ''|0) try='struct passwd* getpwent_r(struct passwd*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=S_SBI ;; + esac + case "$getpwent_r_proto" in + ''|0) try='int getpwent_r(struct passwd*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=I_SBI ;; + esac + case "$getpwent_r_proto" in + ''|0) try='int getpwent_r(struct passwd*, char*, int, FILE**);' + ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=I_SBIH ;; + esac + case "$getpwent_r_proto" in + ''|0) d_getpwent_r=undef + getpwent_r_proto=0 + echo "Disabling getpwent_r, cannot determine prototype." >&4 ;; + * ) case "$getpwent_r_proto" in + REENTRANT_PROTO*) ;; + *) getpwent_r_proto="REENTRANT_PROTO_$getpwent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getpwent_r has no prototype, not using it." >&4 ;; + esac + d_getpwent_r=undef + getpwent_r_proto=0 + ;; + esac + ;; +*) getpwent_r_proto=0 + ;; +esac + +: see if getpwnam_r exists +set getpwnam_r d_getpwnam_r +eval $inlibc +case "$d_getpwnam_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_pwd pwd.h" + case "$d_getpwnam_r_proto:$usethreads" in + ":define") d_getpwnam_r_proto=define + set d_getpwnam_r_proto getpwnam_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getpwnam_r_proto" in + define) + case "$getpwnam_r_proto" in + ''|0) try='int getpwnam_r(const char*, struct passwd*, char*, size_t, struct passwd**);' + ./protochk "$extern_C $try" $hdrs && getpwnam_r_proto=I_CSBWR ;; + esac + case "$getpwnam_r_proto" in + ''|0) try='int getpwnam_r(const char*, struct passwd*, char*, int, struct passwd**);' + ./protochk "$extern_C $try" $hdrs && getpwnam_r_proto=I_CSBIR ;; + esac + case "$getpwnam_r_proto" in + ''|0) try='struct passwd* getpwnam_r(const char*, struct passwd*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getpwnam_r_proto=S_CSBI ;; + esac + case "$getpwnam_r_proto" in + ''|0) try='int getpwnam_r(const char*, struct passwd*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getpwnam_r_proto=I_CSBI ;; + esac + case "$getpwnam_r_proto" in + ''|0) d_getpwnam_r=undef + getpwnam_r_proto=0 + echo "Disabling getpwnam_r, cannot determine prototype." >&4 ;; + * ) case "$getpwnam_r_proto" in + REENTRANT_PROTO*) ;; + *) getpwnam_r_proto="REENTRANT_PROTO_$getpwnam_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getpwnam_r has no prototype, not using it." >&4 ;; + esac + d_getpwnam_r=undef + getpwnam_r_proto=0 + ;; + esac + ;; +*) getpwnam_r_proto=0 + ;; +esac + +: see if getpwuid_r exists +set getpwuid_r d_getpwuid_r +eval $inlibc +case "$d_getpwuid_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_pwd pwd.h" + case "$d_getpwuid_r_proto:$usethreads" in + ":define") d_getpwuid_r_proto=define + set d_getpwuid_r_proto getpwuid_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getpwuid_r_proto" in + define) + case "$getpwuid_r_proto" in + ''|0) try='int getpwuid_r(uid_t, struct passwd*, char*, size_t, struct passwd**);' + ./protochk "$extern_C $try" $hdrs && getpwuid_r_proto=I_TSBWR ;; + esac + case "$getpwuid_r_proto" in + ''|0) try='int getpwuid_r(uid_t, struct passwd*, char*, int, struct passwd**);' + ./protochk "$extern_C $try" $hdrs && getpwuid_r_proto=I_TSBIR ;; + esac + case "$getpwuid_r_proto" in + ''|0) try='int getpwuid_r(uid_t, struct passwd*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getpwuid_r_proto=I_TSBI ;; + esac + case "$getpwuid_r_proto" in + ''|0) try='struct passwd* getpwuid_r(uid_t, struct passwd*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getpwuid_r_proto=S_TSBI ;; + esac + case "$getpwuid_r_proto" in + ''|0) d_getpwuid_r=undef + getpwuid_r_proto=0 + echo "Disabling getpwuid_r, cannot determine prototype." >&4 ;; + * ) case "$getpwuid_r_proto" in + REENTRANT_PROTO*) ;; + *) getpwuid_r_proto="REENTRANT_PROTO_$getpwuid_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getpwuid_r has no prototype, not using it." >&4 ;; + esac + d_getpwuid_r=undef + getpwuid_r_proto=0 + ;; + esac + ;; +*) getpwuid_r_proto=0 + ;; +esac + +: Optional checks for getsbyname and getsbyport + +: 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 getservbyname_r exists +set getservbyname_r d_getservbyname_r +eval $inlibc +case "$d_getservbyname_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_getservbyname_r_proto:$usethreads" in + ":define") d_getservbyname_r_proto=define + set d_getservbyname_r_proto getservbyname_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getservbyname_r_proto" in + define) + case "$getservbyname_r_proto" in + ''|0) try='int getservbyname_r(const char*, const char*, struct servent*, char*, size_t, struct servent**);' + ./protochk "$extern_C $try" $hdrs && getservbyname_r_proto=I_CCSBWR ;; + esac + case "$getservbyname_r_proto" in + ''|0) try='struct servent* getservbyname_r(const char*, const char*, struct servent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getservbyname_r_proto=S_CCSBI ;; + esac + case "$getservbyname_r_proto" in + ''|0) try='int getservbyname_r(const char*, const char*, struct servent*, struct servent_data*);' + ./protochk "$extern_C $try" $hdrs && getservbyname_r_proto=I_CCSD ;; + esac + case "$getservbyname_r_proto" in + ''|0) d_getservbyname_r=undef + getservbyname_r_proto=0 + echo "Disabling getservbyname_r, cannot determine prototype." >&4 ;; + * ) case "$getservbyname_r_proto" in + REENTRANT_PROTO*) ;; + *) getservbyname_r_proto="REENTRANT_PROTO_$getservbyname_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getservbyname_r has no prototype, not using it." >&4 ;; + esac + d_getservbyname_r=undef + getservbyname_r_proto=0 + ;; + esac + ;; +*) getservbyname_r_proto=0 + ;; +esac + +: see if getservbyport_r exists +set getservbyport_r d_getservbyport_r +eval $inlibc +case "$d_getservbyport_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_getservbyport_r_proto:$usethreads" in + ":define") d_getservbyport_r_proto=define + set d_getservbyport_r_proto getservbyport_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getservbyport_r_proto" in + define) + case "$getservbyport_r_proto" in + ''|0) try='int getservbyport_r(int, const char*, struct servent*, char*, size_t, struct servent**);' + ./protochk "$extern_C $try" $hdrs && getservbyport_r_proto=I_ICSBWR ;; + esac + case "$getservbyport_r_proto" in + ''|0) try='struct servent* getservbyport_r(int, const char*, struct servent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getservbyport_r_proto=S_ICSBI ;; + esac + case "$getservbyport_r_proto" in + ''|0) try='int getservbyport_r(int, const char*, struct servent*, struct servent_data*);' + ./protochk "$extern_C $try" $hdrs && getservbyport_r_proto=I_ICSD ;; + esac + case "$getservbyport_r_proto" in + ''|0) d_getservbyport_r=undef + getservbyport_r_proto=0 + echo "Disabling getservbyport_r, cannot determine prototype." >&4 ;; + * ) case "$getservbyport_r_proto" in + REENTRANT_PROTO*) ;; + *) getservbyport_r_proto="REENTRANT_PROTO_$getservbyport_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getservbyport_r has no prototype, not using it." >&4 ;; + esac + d_getservbyport_r=undef + getservbyport_r_proto=0 + ;; + esac + ;; +*) getservbyport_r_proto=0 + ;; +esac + +: see if getservent_r exists +set getservent_r d_getservent_r +eval $inlibc +case "$d_getservent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_getservent_r_proto:$usethreads" in + ":define") d_getservent_r_proto=define + set d_getservent_r_proto getservent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getservent_r_proto" in + define) + case "$getservent_r_proto" in + ''|0) try='int getservent_r(struct servent*, char*, size_t, struct servent**);' + ./protochk "$extern_C $try" $hdrs && getservent_r_proto=I_SBWR ;; + esac + case "$getservent_r_proto" in + ''|0) try='int getservent_r(struct servent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getservent_r_proto=I_SBI ;; + esac + case "$getservent_r_proto" in + ''|0) try='struct servent* getservent_r(struct servent*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getservent_r_proto=S_SBI ;; + esac + case "$getservent_r_proto" in + ''|0) try='int getservent_r(struct servent*, struct servent_data*);' + ./protochk "$extern_C $try" $hdrs && getservent_r_proto=I_SD ;; + esac + case "$getservent_r_proto" in + ''|0) d_getservent_r=undef + getservent_r_proto=0 + echo "Disabling getservent_r, cannot determine prototype." >&4 ;; + * ) case "$getservent_r_proto" in + REENTRANT_PROTO*) ;; + *) getservent_r_proto="REENTRANT_PROTO_$getservent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getservent_r has no prototype, not using it." >&4 ;; + esac + d_getservent_r=undef + getservent_r_proto=0 + ;; + esac + ;; +*) getservent_r_proto=0 + ;; +esac + +: 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 this is a shadow.h system +set shadow.h i_shadow +eval $inhdr + +: see if getspnam_r exists +set getspnam_r d_getspnam_r +eval $inlibc +case "$d_getspnam_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_shadow shadow.h" + case "$d_getspnam_r_proto:$usethreads" in + ":define") d_getspnam_r_proto=define + set d_getspnam_r_proto getspnam_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_getspnam_r_proto" in + define) + case "$getspnam_r_proto" in + ''|0) try='int getspnam_r(const char*, struct spwd*, char*, size_t, struct spwd**);' + ./protochk "$extern_C $try" $hdrs && getspnam_r_proto=I_CSBWR ;; + esac + case "$getspnam_r_proto" in + ''|0) try='struct spwd* getspnam_r(const char*, struct spwd*, char*, int);' + ./protochk "$extern_C $try" $hdrs && getspnam_r_proto=S_CSBI ;; + esac + case "$getspnam_r_proto" in + ''|0) d_getspnam_r=undef + getspnam_r_proto=0 + echo "Disabling getspnam_r, cannot determine prototype." >&4 ;; + * ) case "$getspnam_r_proto" in + REENTRANT_PROTO*) ;; + *) getspnam_r_proto="REENTRANT_PROTO_$getspnam_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "getspnam_r has no prototype, not using it." >&4 ;; + esac + d_getspnam_r=undef + getspnam_r_proto=0 + ;; + esac + ;; +*) getspnam_r_proto=0 + ;; +esac + +: 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 gmtime_r exists +set gmtime_r d_gmtime_r +eval $inlibc +case "$d_gmtime_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_time time.h $i_systime sys/time.h" + case "$d_gmtime_r_proto:$usethreads" in + ":define") d_gmtime_r_proto=define + set d_gmtime_r_proto gmtime_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_gmtime_r_proto" in + define) + case "$gmtime_r_proto" in + ''|0) try='struct tm* gmtime_r(const time_t*, struct tm*);' + ./protochk "$extern_C $try" $hdrs && gmtime_r_proto=S_TS ;; + esac + case "$gmtime_r_proto" in + ''|0) try='int gmtime_r(const time_t*, struct tm*);' + ./protochk "$extern_C $try" $hdrs && gmtime_r_proto=I_TS ;; + esac + case "$gmtime_r_proto" in + ''|0) d_gmtime_r=undef + gmtime_r_proto=0 + echo "Disabling gmtime_r, cannot determine prototype." >&4 ;; + * ) case "$gmtime_r_proto" in + REENTRANT_PROTO*) ;; + *) gmtime_r_proto="REENTRANT_PROTO_$gmtime_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "gmtime_r has no prototype, not using it." >&4 ;; + esac + d_gmtime_r=undef + gmtime_r_proto=0 + ;; + esac + ;; +*) gmtime_r_proto=0 + ;; +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 ilogbl exists +set ilogbl d_ilogbl +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 inet_ntop exists +set inet_ntop d_inetntop +eval $inlibc + +: see if inet_pton exists +set inet_pton d_inetpton +eval $inlibc + +: Look for isascii +echo " " +$cat >isascii.c < +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +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* + +: Look for isblank +echo " " +$cat >isblank.c <<'EOCP' +#include +#include +int main() { + int c = ' '; + if (isblank(c)) + exit(0); + else + exit(1); +} +EOCP +if $cc $ccflags $ldflags -o isblank isblank.c $libs >/dev/null 2>&1 ; then + echo "isblank() found." >&4 + val="$define" +else + echo "isblank() NOT found." >&4 + val="$undef" +fi +set d_isblank +eval $setvar +$rm -f isblank* + +: see if isfinite exists +set isfinite d_isfinite +eval $inlibc + +: see if isinf exists +set isinf d_isinf +eval $inlibc + +: 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 this is a math.h system +set math.h i_math +eval $inhdr + +: check to see if math.h defines _LIB_VERSION +d_libm_lib_version="$undef" +case $i_math in + $define) + echo " " + echo "Checking to see if your libm supports _LIB_VERSION..." >&4 + $cat >try.c < +#include +int main (int argc, char *argv[]) +{ + printf ("%d\n", _LIB_VERSION); + return (0); + } /* main */ +EOCP + set try + if eval $compile; then + foo=`$run ./try` + echo "Yes, it does ($foo)" >&4 + d_libm_lib_version="$define" + else + echo "No, it does not (probably harmless)" >&4 + fi + $rm_try + ;; + + esac + +: see if link exists +set link d_link +eval $inlibc + +: see if localtime_r exists +set localtime_r d_localtime_r +eval $inlibc +case "$d_localtime_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_time time.h $i_systime sys/time.h" + case "$d_localtime_r_proto:$usethreads" in + ":define") d_localtime_r_proto=define + set d_localtime_r_proto localtime_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_localtime_r_proto" in + define) + case "$localtime_r_proto" in + ''|0) try='struct tm* localtime_r(const time_t*, struct tm*);' + ./protochk "$extern_C $try" $hdrs && localtime_r_proto=S_TS ;; + esac + case "$localtime_r_proto" in + ''|0) try='int localtime_r(const time_t*, struct tm*);' + ./protochk "$extern_C $try" $hdrs && localtime_r_proto=I_TS ;; + esac + case "$localtime_r_proto" in + ''|0) d_localtime_r=undef + localtime_r_proto=0 + echo "Disabling localtime_r, cannot determine prototype." >&4 ;; + * ) case "$localtime_r_proto" in + REENTRANT_PROTO*) ;; + *) localtime_r_proto="REENTRANT_PROTO_$localtime_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "localtime_r has no prototype, not using it." >&4 ;; + esac + d_localtime_r=undef + localtime_r_proto=0 + ;; + esac + ;; +*) localtime_r_proto=0 + ;; +esac + +: see if localtime_r calls tzset +case "$localtime_r_proto" in +REENTRANT_PROTO*) + $cat >try.c < +#endif +#ifdef I_UNISTD +# include +#endif +#ifdef I_TIME +# include +#endif +#ifdef I_STDLIB +#include +#endif +#ifdef I_STRING +# include +#else +# include +#endif +#ifdef I_MALLOC +# include +#endif +int main() +{ + time_t t = time(0L); + char w_tz[]="TZ" "=GMT+5", + e_tz[]="TZ" "=GMT-5", + *tz_e = (char*)malloc(16), + *tz_w = (char*)malloc(16); + struct tm tm_e, tm_w; + memset(&tm_e,'\0',sizeof(struct tm)); + memset(&tm_w,'\0',sizeof(struct tm)); + strcpy(tz_e,e_tz); + strcpy(tz_w,w_tz); + + putenv(tz_e); + localtime_r(&t, &tm_e); + + putenv(tz_w); + localtime_r(&t, &tm_w); + + if( memcmp(&tm_e, &tm_w, sizeof(struct tm)) == 0 ) + return 1; + return 0; +} +EOCP + set try + if eval $compile; then + if $run ./try; then + d_localtime_r_needs_tzset=undef; + else + d_localtime_r_needs_tzset=define; + fi; + else + d_localtime_r_needs_tzset=undef; + fi; + ;; + *) + d_localtime_r_needs_tzset=undef; + ;; +esac +$rm_try + +: see if localeconv exists +set localeconv d_locconv +eval $inlibc + +: see if lockf exists +set lockf d_lockf +eval $inlibc + +: 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 malloc_size exists +set malloc_size d_malloc_size +eval $inlibc + +: see if malloc_size_good exists +set malloc_good_size d_malloc_good_size +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 sqrtl exists +set sqrtl d_sqrtl +eval $inlibc + +: see if scalbnl exists +set scalbnl d_scalbnl +eval $inlibc + +: see if modfl exists +set modfl d_modfl +eval $inlibc + +: see if prototype for modfl is available +echo " " +set d_modflproto modfl $i_math math.h +eval $hasproto + +d_modfl_pow32_bug="$undef" + +case "$d_longdbl$d_modfl" in +$define$define) + $cat <try.c < +#include +EOCP +if $test "X$d_modflproto" != "X$define"; then + $cat >>try.c <>try.c <&4 "Your modfl() is broken for large values." + d_modfl_pow32_bug="$define" + case "$foo" in + glibc) echo >&4 "You should upgrade your glibc to at least 2.2.2 to get a fixed modfl()." + ;; + esac + ;; + *" 4294967303.150000 0.150000 4294967303.000000") + echo >&4 "Your modfl() seems okay for large values." + ;; + *) echo >&4 "I don't understand your modfl() at all." + d_modfl="$undef" + ;; + esac + $rm_try + else + echo "I cannot figure out whether your modfl() is okay, assuming it isn't." + d_modfl="$undef" + fi + case "$osname:$gccversion" in + aix:) ccflags="$saveccflags" ;; # restore + esac + ;; +esac + +if $test "$uselongdouble" = "$define"; then + message="" + if $test "$d_sqrtl" != "$define"; then + message="$message sqrtl" + fi + if $test "$d_modfl" != "$define"; then + if $test "$d_aintl:$d_copysignl" = "$define:$define"; then + echo "You have both aintl and copysignl, so I can emulate modfl." + else + message="$message modfl" + fi + fi + if $test "$d_frexpl" != "$define"; then + if $test "$d_ilogbl:$d_scalbnl" = "$define:$define"; then + echo "You have both ilogbl and scalbnl, so I can emulate frexpl." + else + message="$message frexpl" + fi + fi + + if $test "$message" != ""; then + $cat <&4 + +*** You requested the use of long doubles but you do not seem to have +*** the following mathematical functions needed for long double support: +*** $message +*** Please rerun Configure without -Duselongdouble and/or -Dusemorebits. +*** Cannot continue, aborting. + +EOM + + exit 1 + fi +fi + +: 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 + +: Check for msghdr_s +echo " " +echo "Checking to see if your system supports struct msghdr..." >&4 +set d_msghdr_s msghdr $i_systypes sys/types.h $d_socket sys/socket.h $i_sysuio sys/uio.h +eval $hasstruct +case "$d_msghdr_s" in +"$define") echo "Yes, it does." ;; +*) echo "No, it doesn't." ;; +esac + + +: 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 + +: see if this is a langinfo.h system +set langinfo.h i_langinfo +eval $inhdr + +: see if nl_langinfo exists +set nl_langinfo d_nl_langinfo +eval $inlibc + +: 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_try + +: Check basic sizes +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 + +i8type="signed char" +u8type="unsigned char" +i8size=1 +u8size=1 + +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 "`$run ./try`" 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 "`$run ./try`" 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 how many bits of your UVs your NVs can preserve..." >&4 +: volatile so that the compiler has to store it out to memory. +if test X"$d_volatile" = X"$define"; then + volatile=volatile +fi +$cat <try.c +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#include +#include +#ifdef SIGFPE +$volatile int bletched = 0; +$signal_t blech(int s) { bletched = 1; } +#endif +int main() { + $uvtype u = 0; + $nvtype d; + int n = 8 * $uvsize; + int i; +#ifdef SIGFPE + signal(SIGFPE, blech); +#endif + + for (i = 0; i < n; i++) { + u = u << 1 | ($uvtype)1; + d = ($nvtype)u; + if (($uvtype)d != u) + break; + if (d <= 0) + break; + d = ($nvtype)(u - 1); + if (($uvtype)d != (u - 1)) + break; +#ifdef SIGFPE + if (bletched) + break; +#endif + } + printf("%d\n", ((i == n) ? -n : i)); + exit(0); +} +EOP +set try + +d_nv_preserves_uv="$undef" +if eval $compile; then + nv_preserves_uv_bits="`$run ./try`" +fi +case "$nv_preserves_uv_bits" in +\-[1-9]*) + nv_preserves_uv_bits=`expr 0 - $nv_preserves_uv_bits` + $echo "Your NVs can preserve all $nv_preserves_uv_bits bits of your UVs." 2>&1 + d_nv_preserves_uv="$define" + ;; +[1-9]*) $echo "Your NVs can preserve only $nv_preserves_uv_bits bits of your UVs." 2>&1 + d_nv_preserves_uv="$undef" ;; +*) $echo "Can't figure out how many bits your NVs preserve." 2>&1 + nv_preserves_uv_bits="0" ;; +esac +$rm_try + +$echo "Checking to find the largest integer value your NVs can hold..." >&4 +: volatile so that the compiler has to store it out to memory. +if test X"$d_volatile" = X"$define"; then + volatile=volatile +fi +$cat <try.c +#include + +typedef $nvtype NV; + +int +main() { + NV value = 2; + int count = 1; + + while(count < 256) { + $volatile NV up = value + 1.0; + $volatile NV negated = -value; + $volatile NV down = negated - 1.0; + $volatile NV got_up = up - value; + int up_good = got_up == 1.0; + int got_down = down - negated; + int down_good = got_down == -1.0; + + if (down_good != up_good) { + fprintf(stderr, + "Inconsistency - up %d %f; down %d %f; for 2**%d (%.20f)\n", + up_good, (double) got_up, down_good, (double) got_down, + count, (double) value); + return 1; + } + if (!up_good) { + while (1) { + if (count > 8) { + count -= 8; + fputs("256.0", stdout); + } else { + count--; + fputs("2.0", stdout); + } + if (!count) { + puts(""); + return 0; + } + fputs("*", stdout); + } + } + value *= 2; + ++count; + } + fprintf(stderr, "Cannot overflow integer range, even at 2**%d (%.20f)\n", + count, (double) value); + return 1; +} +EOP +set try + +nv_overflows_integers_at='0' +if eval $compile; then + xxx="`$run ./try`" + case "$?" in + 0) + case "$xxx" in + 2*) cat >&4 <&4 <&4 <&4 +: volatile so that the compiler has to store it out to memory. +if test X"$d_volatile" = X"$define"; then + volatile=volatile +fi +$cat <try.c +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#$i_string I_STRING +#ifdef I_STRING +# include +#else +# include +#endif +#include +#include +#ifdef SIGFPE +$volatile int bletched = 0; +$signal_t blech(int s) { bletched = 1; } +#endif + +int checkit($nvtype d, char *where) { + unsigned char *p = (char *)&d; + unsigned char *end = p + sizeof(d); + int fail = 0; + + while (p < end) + fail += *p++; + + if (!fail) + return 0; + + p = (char *)&d; + printf("No - %s: 0x", where); + while (p < end) + printf ("%02X", *p++); + printf("\n"); + return 1; +} + +int main(int argc, char **argv) { + $nvtype d = 0.0; + int fail = 0; + fail += checkit(d, "0.0"); + + /* The compiler shouldn't be assuming that bletched is 0 */ + d = bletched; + + fail += checkit(d, "bleched"); + +#ifdef SIGFPE + signal(SIGFPE, blech); +#endif + + /* Paranoia - the compiler should have no way of knowing that ANSI says + that argv[argc] will always be NULL. Actually, if it did assume this it + would be buggy, as this is C and main() can be called from elsewhere in + the program. */ + d = argv[argc] ? 1 : 0; + + if (d) { + printf("Odd argv[argc]=%p, d=%g\n", argv[argc], d); + } + + fail += checkit(d, "ternary"); + + memset(&d, sizeof(d), argv[argc] ? 1 : 0); + + if (d != 0.0) { + printf("No - memset doesn't give 0.0\n"); + /* This might just blow up: */ + printf("(gives %g)\n", d); + return 1; + } + +#ifdef SIGFPE + if (bletched) { + printf("No - something bleched\n"); + return 1; + } +#endif + if (fail) { + printf("No - %d fail(s)\n", fail); + return 1; + } + printf("Yes\n"); + return 0; +} +EOP +set try + +d_nv_zero_is_allbits_zero="$undef" +if eval $compile; then + xxx="`$run ./try`" + case "$?" in + 0) + case "$xxx" in + Yes) cat >&4 <&4 <&4 <&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_try +set d_off64_t +eval $setvar + +: 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_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 poll exists +set poll d_poll +eval $inlibc + +: see if prctl exists +set prctl d_prctl +eval $inlibc + +: see if prctl supports PR_SET_NAME +d_prctl_set_name=$undef +case $d_prctl in + $define) + $cat >try.c < + +int main (int argc, char *argv[]) +{ + return (prctl (PR_SET_NAME, "Test")); + } /* main */ +EOM + set try + if eval $compile_ok && $run ./try; then + echo "Your prctl (PR_SET_NAME, ...) works" + d_prctl_set_name=$define + fi + $rm_try + ;; + esac + +: see if readlink exists +set readlink d_readlink +eval $inlibc + +: Check if exe is symlink to abs path of executing program +echo " " +procselfexe='' +val="$undef" +case "$d_readlink" in + "$define") + : NetBSD first as /proc/self is a symlink to /proc/curproc, and it feels + : more tidy to avoid an extra level of symlink + set NetBSD /proc/curproc/exe Linux /proc/self/exe FreeBSD /proc/curproc/file Solaris /proc/self/path/a.out + while test $# -gt 0; do + type=$1; try=$2 + shift; shift + if $issymlink $try; then + $ls -l $try > reflect + if $contains /`basename $ls` reflect >/dev/null 2>&1; then + echo "You have $type-like $try." + procselfexe='"'$try'"' + val="$define" + : This will break out of the loop + set X; shift + fi + fi + done + ;; +esac +$rm -f reflect +set d_procselfexe +eval $setvar + +: 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 + +d_pseudofork=$undef + +: 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 whether the pthread_atfork exists +$cat >try.c < +#include +int main() { +#ifdef PTHREAD_ATFORK + pthread_atfork(NULL,NULL,NULL); +#endif +} +EOP + +: see if pthread_atfork exists +set try -DPTHREAD_ATFORK +if eval $compile; then + val="$define" +else + val="$undef" +fi +case "$usethreads" in +$define) + case "$val" in + $define) echo 'pthread_atfork found.' >&4 ;; + *) echo 'pthread_atfork NOT found.' >&4 ;; + esac +esac +set d_pthread_atfork +eval $setvar + +: see if pthread_attr_setscope exists +set pthread_attr_setscope d_pthread_attr_setscope +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_try + +: see if random_r exists +set random_r d_random_r +eval $inlibc +case "$d_random_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_stdlib stdlib.h" + case "$d_random_r_proto:$usethreads" in + ":define") d_random_r_proto=define + set d_random_r_proto random_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_random_r_proto" in + define) + case "$random_r_proto" in + ''|0) try='int random_r(int*, struct random_data*);' + ./protochk "$extern_C $try" $hdrs && random_r_proto=I_iS ;; + esac + case "$random_r_proto" in + ''|0) try='int random_r(long*, struct random_data*);' + ./protochk "$extern_C $try" $hdrs && random_r_proto=I_lS ;; + esac + case "$random_r_proto" in + ''|0) try='int random_r(struct random_data*, int32_t*);' + ./protochk "$extern_C $try" $hdrs && random_r_proto=I_St ;; + esac + case "$random_r_proto" in + ''|0) d_random_r=undef + random_r_proto=0 + echo "Disabling random_r, cannot determine prototype." >&4 ;; + * ) case "$random_r_proto" in + REENTRANT_PROTO*) ;; + *) random_r_proto="REENTRANT_PROTO_$random_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "random_r has no prototype, not using it." >&4 ;; + esac + d_random_r=undef + random_r_proto=0 + ;; + esac + ;; +*) random_r_proto=0 + ;; +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 readdir64_r exists +set readdir64_r d_readdir64_r +eval $inlibc +case "$d_readdir64_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_dirent dirent.h" + case "$d_readdir64_r_proto:$usethreads" in + ":define") d_readdir64_r_proto=define + set d_readdir64_r_proto readdir64_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_readdir64_r_proto" in + define) + case "$readdir64_r_proto" in + ''|0) try='int readdir64_r(DIR*, struct dirent64*, struct dirent64**);' + ./protochk "$extern_C $try" $hdrs && readdir64_r_proto=I_TSR ;; + esac + case "$readdir64_r_proto" in + ''|0) try='int readdir64_r(DIR*, struct dirent64*);' + ./protochk "$extern_C $try" $hdrs && readdir64_r_proto=I_TS ;; + esac + case "$readdir64_r_proto" in + ''|0) d_readdir64_r=undef + readdir64_r_proto=0 + echo "Disabling readdir64_r, cannot determine prototype." >&4 ;; + * ) case "$readdir64_r_proto" in + REENTRANT_PROTO*) ;; + *) readdir64_r_proto="REENTRANT_PROTO_$readdir64_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "readdir64_r has no prototype, not using it." >&4 ;; + esac + d_readdir64_r=undef + readdir64_r_proto=0 + ;; + esac + ;; +*) readdir64_r_proto=0 + ;; +esac + +: see if readdir_r exists +set readdir_r d_readdir_r +eval $inlibc +case "$d_readdir_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_dirent dirent.h" + case "$d_readdir_r_proto:$usethreads" in + ":define") d_readdir_r_proto=define + set d_readdir_r_proto readdir_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_readdir_r_proto" in + define) + case "$readdir_r_proto" in + ''|0) try='int readdir_r(DIR*, struct dirent*, struct dirent**);' + ./protochk "$extern_C $try" $hdrs && readdir_r_proto=I_TSR ;; + esac + case "$readdir_r_proto" in + ''|0) try='int readdir_r(DIR*, struct dirent*);' + ./protochk "$extern_C $try" $hdrs && readdir_r_proto=I_TS ;; + esac + case "$readdir_r_proto" in + ''|0) d_readdir_r=undef + readdir_r_proto=0 + echo "Disabling readdir_r, cannot determine prototype." >&4 ;; + * ) case "$readdir_r_proto" in + REENTRANT_PROTO*) ;; + *) readdir_r_proto="REENTRANT_PROTO_$readdir_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "readdir_r has no prototype, not using it." >&4 ;; + esac + d_readdir_r=undef + readdir_r_proto=0 + ;; + esac + ;; +*) readdir_r_proto=0 + ;; +esac + +: see if readv exists +set readv d_readv +eval $inlibc + +: see if recvmsg exists +set recvmsg d_recvmsg +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? +echo " " +val="$undef" +case "$d_memmove" in +"$define") echo "I'll use memmove() instead of bcopy() for overlapping copies." ;; +*) case "$d_bcopy" in + "$define") + echo "Checking to see if 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; + +/* Copy "abcde..." string to char abc[] so that gcc doesn't + try to store the string in read-only memory. */ +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 $run ./try 2>/dev/null; then + echo "Yes, it can." + val="$define" + else + echo "It can't, sorry." + fi + else + echo "(I can't compile the test program, so we'll assume not...)" + fi + ;; + esac + $rm_try + ;; +esac +set d_safebcpy +eval $setvar + +: can memcpy handle overlapping blocks? +echo " " +val="$undef" +case "$d_memmove" in +"$define") echo "I'll use memmove() instead of memcpy() for overlapping copies." ;; +*) case "$d_memcpy" in + "$define") + echo "Checking to see if 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 $run ./try 2>/dev/null; then + echo "Yes, it can." + val="$define" + else + echo "It can't, sorry." + fi + else + echo "(I can't compile the test program, so we'll assume not...)" + fi + ;; + esac + $rm_try + ;; +esac +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 $run ./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_try +set d_sanemcmp +eval $setvar + +: see if prototype for sbrk is available +echo " " +set d_sbrkproto sbrk $i_unistd unistd.h +eval $hasproto + +: 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_try +set d_union_semun +eval $setvar + +: see how to do semctl IPC_STAT +case "$d_sem" in +$define) + echo " " + $cat > tryh.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 + : see whether semctl IPC_STAT can use union semun + case "$d_semctl_semun" in + '') + val="$undef" + $cat > try.c < +#include +#include +#include +#include +#include +#include "tryh.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 + set try + if eval $compile; then + xxx=`$run ./try` + case "$xxx" in + semun) val="$define" ;; + esac + fi + $rm_try + set d_semctl_semun + eval $setvar + ;; + esac + 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 + case "$d_semctl_semid_ds" in + '') + val="$undef" + $cat > try.c <<'END' +#include +#include +#include +#include +#include "tryh.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 + set try + if eval $compile; then + xxx=`$run ./try` + case "$xxx" in + semid_ds) val="$define" ;; + esac + fi + $rm_try + set d_semctl_semid_ds + eval $setvar + ;; + esac + 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 + ;; +*) 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 +$rm_try tryh.h + +: see if sendmsg exists +set sendmsg d_sendmsg +eval $inlibc + +: 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 setgrent_r exists +set setgrent_r d_setgrent_r +eval $inlibc +case "$d_setgrent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_grp grp.h" + case "$d_setgrent_r_proto:$usethreads" in + ":define") d_setgrent_r_proto=define + set d_setgrent_r_proto setgrent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_setgrent_r_proto" in + define) + case "$setgrent_r_proto" in + ''|0) try='int setgrent_r(FILE**);' + ./protochk "$extern_C $try" $hdrs && setgrent_r_proto=I_H ;; + esac + case "$setgrent_r_proto" in + ''|0) try='void setgrent_r(FILE**);' + ./protochk "$extern_C $try" $hdrs && setgrent_r_proto=V_H ;; + esac + case "$setgrent_r_proto" in + ''|0) d_setgrent_r=undef + setgrent_r_proto=0 + echo "Disabling setgrent_r, cannot determine prototype." >&4 ;; + * ) case "$setgrent_r_proto" in + REENTRANT_PROTO*) ;; + *) setgrent_r_proto="REENTRANT_PROTO_$setgrent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "setgrent_r has no prototype, not using it." >&4 ;; + esac + d_setgrent_r=undef + setgrent_r_proto=0 + ;; + esac + ;; +*) setgrent_r_proto=0 + ;; +esac + +: see if sethostent exists +set sethostent d_sethent +eval $inlibc + +: see if sethostent_r exists +set sethostent_r d_sethostent_r +eval $inlibc +case "$d_sethostent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_sethostent_r_proto:$usethreads" in + ":define") d_sethostent_r_proto=define + set d_sethostent_r_proto sethostent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_sethostent_r_proto" in + define) + case "$sethostent_r_proto" in + ''|0) try='int sethostent_r(int, struct hostent_data*);' + ./protochk "$extern_C $try" $hdrs && sethostent_r_proto=I_ID ;; + esac + case "$sethostent_r_proto" in + ''|0) try='void sethostent_r(int, struct hostent_data*);' + ./protochk "$extern_C $try" $hdrs && sethostent_r_proto=V_ID ;; + esac + case "$sethostent_r_proto" in + ''|0) d_sethostent_r=undef + sethostent_r_proto=0 + echo "Disabling sethostent_r, cannot determine prototype." >&4 ;; + * ) case "$sethostent_r_proto" in + REENTRANT_PROTO*) ;; + *) sethostent_r_proto="REENTRANT_PROTO_$sethostent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "sethostent_r has no prototype, not using it." >&4 ;; + esac + d_sethostent_r=undef + sethostent_r_proto=0 + ;; + esac + ;; +*) sethostent_r_proto=0 + ;; +esac + +: see if setitimer exists +set setitimer d_setitimer +eval $inlibc + +: see if setlinebuf exists +set setlinebuf d_setlinebuf +eval $inlibc + +: see if setlocale exists +set setlocale d_setlocale +eval $inlibc + +: see if locale.h is available +set locale.h i_locale +eval $inhdr + +: see if setlocale_r exists +set setlocale_r d_setlocale_r +eval $inlibc +case "$d_setlocale_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_locale locale.h" + case "$d_setlocale_r_proto:$usethreads" in + ":define") d_setlocale_r_proto=define + set d_setlocale_r_proto setlocale_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_setlocale_r_proto" in + define) + case "$setlocale_r_proto" in + ''|0) try='int setlocale_r(int, const char*, char*, int);' + ./protochk "$extern_C $try" $hdrs && setlocale_r_proto=I_ICBI ;; + esac + case "$setlocale_r_proto" in + ''|0) d_setlocale_r=undef + setlocale_r_proto=0 + echo "Disabling setlocale_r, cannot determine prototype." >&4 ;; + * ) case "$setlocale_r_proto" in + REENTRANT_PROTO*) ;; + *) setlocale_r_proto="REENTRANT_PROTO_$setlocale_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "setlocale_r has no prototype, not using it." >&4 ;; + esac + d_setlocale_r=undef + setlocale_r_proto=0 + ;; + esac + ;; +*) setlocale_r_proto=0 + ;; +esac + +: see if setnetent exists +set setnetent d_setnent +eval $inlibc + +: see if setnetent_r exists +set setnetent_r d_setnetent_r +eval $inlibc +case "$d_setnetent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_setnetent_r_proto:$usethreads" in + ":define") d_setnetent_r_proto=define + set d_setnetent_r_proto setnetent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_setnetent_r_proto" in + define) + case "$setnetent_r_proto" in + ''|0) try='int setnetent_r(int, struct netent_data*);' + ./protochk "$extern_C $try" $hdrs && setnetent_r_proto=I_ID ;; + esac + case "$setnetent_r_proto" in + ''|0) try='void setnetent_r(int, struct netent_data*);' + ./protochk "$extern_C $try" $hdrs && setnetent_r_proto=V_ID ;; + esac + case "$setnetent_r_proto" in + ''|0) d_setnetent_r=undef + setnetent_r_proto=0 + echo "Disabling setnetent_r, cannot determine prototype." >&4 ;; + * ) case "$setnetent_r_proto" in + REENTRANT_PROTO*) ;; + *) setnetent_r_proto="REENTRANT_PROTO_$setnetent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "setnetent_r has no prototype, not using it." >&4 ;; + esac + d_setnetent_r=undef + setnetent_r_proto=0 + ;; + esac + ;; +*) setnetent_r_proto=0 + ;; +esac + +: 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 setprotoent_r exists +set setprotoent_r d_setprotoent_r +eval $inlibc +case "$d_setprotoent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_setprotoent_r_proto:$usethreads" in + ":define") d_setprotoent_r_proto=define + set d_setprotoent_r_proto setprotoent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_setprotoent_r_proto" in + define) + case "$setprotoent_r_proto" in + ''|0) try='int setprotoent_r(int, struct protoent_data*);' + ./protochk "$extern_C $try" $hdrs && setprotoent_r_proto=I_ID ;; + esac + case "$setprotoent_r_proto" in + ''|0) try='void setprotoent_r(int, struct protoent_data*);' + ./protochk "$extern_C $try" $hdrs && setprotoent_r_proto=V_ID ;; + esac + case "$setprotoent_r_proto" in + ''|0) d_setprotoent_r=undef + setprotoent_r_proto=0 + echo "Disabling setprotoent_r, cannot determine prototype." >&4 ;; + * ) case "$setprotoent_r_proto" in + REENTRANT_PROTO*) ;; + *) setprotoent_r_proto="REENTRANT_PROTO_$setprotoent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "setprotoent_r has no prototype, not using it." >&4 ;; + esac + d_setprotoent_r=undef + setprotoent_r_proto=0 + ;; + esac + ;; +*) setprotoent_r_proto=0 + ;; +esac + +: see if setpwent exists +set setpwent d_setpwent +eval $inlibc + +: see if setpwent_r exists +set setpwent_r d_setpwent_r +eval $inlibc +case "$d_setpwent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_pwd pwd.h" + case "$d_setpwent_r_proto:$usethreads" in + ":define") d_setpwent_r_proto=define + set d_setpwent_r_proto setpwent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_setpwent_r_proto" in + define) + case "$setpwent_r_proto" in + ''|0) try='int setpwent_r(FILE**);' + ./protochk "$extern_C $try" $hdrs && setpwent_r_proto=I_H ;; + esac + case "$setpwent_r_proto" in + ''|0) try='void setpwent_r(FILE**);' + ./protochk "$extern_C $try" $hdrs && setpwent_r_proto=V_H ;; + esac + case "$setpwent_r_proto" in + ''|0) d_setpwent_r=undef + setpwent_r_proto=0 + echo "Disabling setpwent_r, cannot determine prototype." >&4 ;; + * ) case "$setpwent_r_proto" in + REENTRANT_PROTO*) ;; + *) setpwent_r_proto="REENTRANT_PROTO_$setpwent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "setpwent_r has no prototype, not using it." >&4 ;; + esac + d_setpwent_r=undef + setpwent_r_proto=0 + ;; + esac + ;; +*) setpwent_r_proto=0 + ;; +esac + +: 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 setservent_r exists +set setservent_r d_setservent_r +eval $inlibc +case "$d_setservent_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" + case "$d_setservent_r_proto:$usethreads" in + ":define") d_setservent_r_proto=define + set d_setservent_r_proto setservent_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_setservent_r_proto" in + define) + case "$setservent_r_proto" in + ''|0) try='int setservent_r(int, struct servent_data*);' + ./protochk "$extern_C $try" $hdrs && setservent_r_proto=I_ID ;; + esac + case "$setservent_r_proto" in + ''|0) try='void setservent_r(int, struct servent_data*);' + ./protochk "$extern_C $try" $hdrs && setservent_r_proto=V_ID ;; + esac + case "$setservent_r_proto" in + ''|0) d_setservent_r=undef + setservent_r_proto=0 + echo "Disabling setservent_r, cannot determine prototype." >&4 ;; + * ) case "$setservent_r_proto" in + REENTRANT_PROTO*) ;; + *) setservent_r_proto="REENTRANT_PROTO_$setservent_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "setservent_r has no prototype, not using it." >&4 ;; + esac + d_setservent_r=undef + setservent_r_proto=0 + ;; + esac + ;; +*) setservent_r_proto=0 + ;; +esac + +: 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." + rp="You seem to have sfio available, do you want to try using it?" + . ./myread + case "$ans" in + y|Y) echo "Ok, turning on sfio then." + val="$define" + ;; + *) echo "Ok, avoiding sfio this time. I'll use stdio instead." + val="$undef" + ;; + 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 +case "$d_sfio" in +$define) ;; +*) : Remove sfio from list of libraries to use + case "$libs" in + *-lsfio*) + echo "Removing unneeded -lsfio from library list" >&4 + set `echo X $libs | $sed -e 's/-lsfio / /' -e 's/-lsfio$//'` + shift + libs="$*" + echo "libs = $libs" >&4 + ;; + esac +;; +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 + +: see if we have sigaction +echo " " +if set sigaction val -f d_sigaction; eval $csym; $val; then + echo 'sigaction() found.' >&4 + $cat > try.c < +#include +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +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_try + +: see if this is a sunmath.h system +set sunmath.h i_sunmath +eval $inhdr + +: see if signbit exists +$echo $n "Checking to see if you have signbit() available to work on $nvtype... $c" >&4 +$cat >try.c < +#endif +#ifdef I_SUNMATH /* Solaris special math library */ +# include +#endif +#define NV $nvtype +int main(int argc, char **argv) +{ + NV x = 0.0; + NV y = -0.0; + if ((signbit(x) == 0) && (signbit(y) != 0)) + return 0; + else + return 1; +} +EOCP +val="$undef" +set try +if eval $compile; then + if $run ./try; then + $echo "Yes." >&4 + val="$define" + else + $echo "Signbit seems to be available, but doesn't work as I expected." + $echo "I won't use it." >&4 + val="$undef" + fi +else + $echo "Nope." >&4 + dflt="$undef" +fi +set d_signbit +eval $setvar +$rm_try + +: see if sigprocmask exists +set sigprocmask d_sigprocmask +eval $inlibc + +: see if sigsetjmp exists +echo " " +case "$d_sigsetjmp" in +'') + $cat >try.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +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 $run ./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_try + +: see if snprintf exists +set snprintf d_snprintf +eval $inlibc + +: see if vsnprintf exists +set vsnprintf d_vsnprintf +eval $inlibc + +case "$d_snprintf-$d_vsnprintf" in +"$define-$define") + $cat <try.c <<'EOCP' +/* v?snprintf testing logic courtesy of Russ Allbery. + * According to C99: + * - if the buffer is too short it still must be \0-terminated + * - if the buffer is too short the potentially required length + * must be returned and not -1 + * - if the buffer is NULL the potentially required length + * must be returned and not -1 or core dump + */ +#include +#include + +char buf[2]; + +int test (char *format, ...) +{ + va_list args; + int count; + + va_start (args, format); + count = vsnprintf (buf, sizeof buf, format, args); + va_end (args); + return count; +} + +int main () +{ + return ((test ("%s", "abcd") == 4 && buf[0] == 'a' && buf[1] == '\0' + && snprintf (NULL, 0, "%s", "abcd") == 4) ? 0 : 1); +} +EOCP + set try + if eval $compile; then + `$run ./try` + case "$?" in + 0) echo "Your snprintf() and vsnprintf() seem to be working okay." ;; + *) cat <&4 +Your snprintf() and snprintf() don't seem to be working okay. +EOM + d_snprintf="$undef" + d_vsnprintf="$undef" + ;; + esac + else + echo "(I can't seem to compile the test program--assuming they don't)" + d_snprintf="$undef" + d_vsnprintf="$undef" + fi + $rm_try + ;; +esac + +: see if sockatmark exists +set sockatmark d_sockatmark +eval $inlibc + +: see if prototype for sockatmark is available +echo " " +set d_sockatmarkproto sockatmark $d_socket sys/socket.h +eval $hasproto + +: see if socks5_init exists +set socks5_init d_socks5_init +eval $inlibc + +: see if sprintf returns the length of the string in the buffer as per ANSI +$echo "Checking whether sprintf returns the length of the string..." >&4 +$cat <try.c +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#$i_string I_STRING +#ifdef I_STRING +# include +#else +# include +#endif +#$i_math I_MATH +#ifdef I_MATH +#include +#endif + +char buffer[256]; + +int check (size_t expect, int test) { + size_t got = strlen(buffer); + if (expect == got) + return 0; + + printf("expected %ld, got %ld in test %d '%s'\n", (long) expect, (long) got, + test, buffer); + exit (test); +} + +int main(int argc, char **argv) { + int test = 0; + + check(sprintf(buffer, ""), ++test); + check(sprintf(buffer, "%s %s", "perl", "rules"), ++test); + check(sprintf(buffer, "I like %g", atan2(0,-1)), ++test); + + return 0; +} +EOP +set try + +if eval $compile; then + xxx="`$run ./try`" + case "$?" in + 0) cat >&4 <&4 <&4 + d_sprintf_returns_strlen="$undef" +fi +$rm_try + +: see if srand48_r exists +set srand48_r d_srand48_r +eval $inlibc +case "$d_srand48_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_stdlib stdlib.h" + case "$d_srand48_r_proto:$usethreads" in + ":define") d_srand48_r_proto=define + set d_srand48_r_proto srand48_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_srand48_r_proto" in + define) + case "$srand48_r_proto" in + ''|0) try='int srand48_r(long, struct drand48_data*);' + ./protochk "$extern_C $try" $hdrs && srand48_r_proto=I_LS ;; + esac + case "$srand48_r_proto" in + ''|0) d_srand48_r=undef + srand48_r_proto=0 + echo "Disabling srand48_r, cannot determine prototype." >&4 ;; + * ) case "$srand48_r_proto" in + REENTRANT_PROTO*) ;; + *) srand48_r_proto="REENTRANT_PROTO_$srand48_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "srand48_r has no prototype, not using it." >&4 ;; + esac + d_srand48_r=undef + srand48_r_proto=0 + ;; + esac + ;; +*) srand48_r_proto=0 + ;; +esac + +: see if srandom_r exists +set srandom_r d_srandom_r +eval $inlibc +case "$d_srandom_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_stdlib stdlib.h" + case "$d_srandom_r_proto:$usethreads" in + ":define") d_srandom_r_proto=define + set d_srandom_r_proto srandom_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_srandom_r_proto" in + define) + case "$srandom_r_proto" in + ''|0) try='int srandom_r(unsigned int, struct random_data*);' + ./protochk "$extern_C $try" $hdrs && srandom_r_proto=I_TS ;; + esac + case "$srandom_r_proto" in + ''|0) d_srandom_r=undef + srandom_r_proto=0 + echo "Disabling srandom_r, cannot determine prototype." >&4 ;; + * ) case "$srandom_r_proto" in + REENTRANT_PROTO*) ;; + *) srandom_r_proto="REENTRANT_PROTO_$srandom_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "srandom_r has no prototype, not using it." >&4 ;; + esac + d_srandom_r=undef + srandom_r_proto=0 + ;; + esac + ;; +*) srandom_r_proto=0 + ;; +esac + +: see if prototype for setresgid is available +echo " " +set d_sresgproto setresgid $i_unistd unistd.h +eval $hasproto + +: see if prototype for setresuid is available +echo " " +set d_sresuproto setresuid $i_unistd unistd.h +eval $hasproto + +: 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 + +: Check for statfs_s +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 what flavor, if any, of static inline is supported +echo " " +echo "Checking to see if your system supports static inline..." +$cat > try.c <<'EOCP' +#include +extern int f_via_a(int x); +extern int f_via_b(int x); +int main(int argc, char **argv) +{ + int y; + + y = f_via_a(0); +#ifdef USE_B + y = f_via_b(0); +#endif + if (y == 42) { + return EXIT_SUCCESS; + } + else { + return EXIT_FAILURE; + } +} +EOCP +$cat > a.c <<'EOCP' +static INLINE int f(int x) { + int y; + y = x + 42; + return y; +} + +int f_via_a(int x) +{ + return f(x); +} +EOCP +$cat > b.c <<'EOCP' +extern int f(int x); + +int f_via_b(int x) +{ + return f(x); +} +EOCP + +# Respect a hint (or previous) value for perl_static_inline, if there is one. +case "$perl_static_inline" in +'') # Check the various possibilities, and break out on success. + # For gcc, prefer __inline__, which will still permit + # cflags.SH to add in -ansi. + case "$gccversion" in + '') xxx="inline __inline__ __inline _inline";; + *) xxx="__inline__ inline __inline _inline";; + esac + for inline in $xxx; do + set try -DINLINE=$inline a.c + if eval $compile && $run ./try; then + # Now make sure there is no external linkage of static + # functions + set try -DINLINE=$inline -DUSE_B a.c b.c + if eval $compile && $run ./try; then + $echo "Your compiler supports static $inline, " >&4 + $echo "but it also creates an external definition," >&4 + $echo "so I won't use it." >&4 + val=$undef + else + $echo "Your compiler supports static $inline." >&4 + val=$define + perl_static_inline="static $inline"; + break; + fi + else + $echo "Your compiler does NOT support static $inline." >&4 + val="$undef" + fi + done + ;; +*inline*) # Some variant of inline exists. + echo "Keeping your $hint value of $perl_static_inline." + val=$define + ;; +static) # No inline capabilities + echo "Keeping your $hint value of $perl_static_inline." + val=$undef + ;; +*) # Unrecognized previous value -- blindly trust the supplied + # value and hope it makes sense. Use old value for + # d_static_inline, if there is one. + echo "Keeping your $hint value of $perl_static_inline." + case "$d_static_inline" in + '') val=$define ;; + *) val=$d_static_inline ;; + esac + ;; +esac +# Fallback to plain 'static' if nothing worked. +case "$perl_static_inline" in +'') + perl_static_inline="static" + val=$undef + ;; +esac +set d_static_inline +eval $setvar +$rm -f a.[co] b.[co] +$rm_try + +: Check stream access +$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 "`$run ./try`" in + yes) stdio_stream_array=$s; break ;; + esac + fi + done + $rm_try +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_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 strerror_r exists +set strerror_r d_strerror_r +eval $inlibc +case "$d_strerror_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_string string.h" + case "$d_strerror_r_proto:$usethreads" in + ":define") d_strerror_r_proto=define + set d_strerror_r_proto strerror_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_strerror_r_proto" in + define) + case "$strerror_r_proto" in + ''|0) try='int strerror_r(int, char*, size_t);' + ./protochk "$extern_C $try" $hdrs && strerror_r_proto=I_IBW ;; + esac + case "$strerror_r_proto" in + ''|0) try='int strerror_r(int, char*, int);' + ./protochk "$extern_C $try" $hdrs && strerror_r_proto=I_IBI ;; + esac + case "$strerror_r_proto" in + ''|0) try='char* strerror_r(int, char*, size_t);' + ./protochk "$extern_C $try" $hdrs && strerror_r_proto=B_IBW ;; + esac + case "$strerror_r_proto" in + ''|0) d_strerror_r=undef + strerror_r_proto=0 + echo "Disabling strerror_r, cannot determine prototype." >&4 ;; + * ) case "$strerror_r_proto" in + REENTRANT_PROTO*) ;; + *) strerror_r_proto="REENTRANT_PROTO_$strerror_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "strerror_r has no prototype, not using it." >&4 ;; + esac + d_strerror_r=undef + strerror_r_proto=0 + ;; + esac + ;; +*) strerror_r_proto=0 + ;; +esac + +: see if strftime exists +set strftime d_strftime +eval $inlibc + +: see if strlcat exists +set strlcat d_strlcat +eval $inlibc + +: see if strlcpy exists +set strlcpy d_strlcpy +eval $inlibc + +: 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=`$run ./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 strtoq exists +set strtoq d_strtoq +eval $inlibc + +: see if strtoul exists +set strtoul d_strtoul +eval $inlibc + +case "$d_strtoul" in +"$define") + $cat <try.c <<'EOCP' +#include +#include +extern unsigned long int strtoul(char *s, char **, int); +static int bad = 0; +void check(char *s, unsigned long eul, int een) { + unsigned long gul; + errno = 0; + gul = strtoul(s, 0, 10); + if (!((gul == eul) && (errno == een))) + bad++; +} +int main() { + check(" 1", 1L, 0); + check(" 0", 0L, 0); +EOCP + case "$longsize" in + 8) + $cat >>try.c <<'EOCP' + check("18446744073709551615", 18446744073709551615UL, 0); + check("18446744073709551616", 18446744073709551615UL, ERANGE); +#if 0 /* strtoul() for /^-/ strings is undefined. */ + check("-1", 18446744073709551615UL, 0); + check("-18446744073709551614", 2, 0); + check("-18446744073709551615", 1, 0); + check("-18446744073709551616", 18446744073709551615UL, ERANGE); + check("-18446744073709551617", 18446744073709551615UL, ERANGE); +#endif +EOCP + ;; + 4) + $cat >>try.c <<'EOCP' + check("4294967295", 4294967295UL, 0); + check("4294967296", 4294967295UL, ERANGE); +#if 0 /* strtoul() for /^-/ strings is undefined. */ + check("-1", 4294967295UL, 0); + check("-4294967294", 2, 0); + check("-4294967295", 1, 0); + check("-4294967296", 4294967295UL, ERANGE); + check("-4294967297", 4294967295UL, ERANGE); +#endif +EOCP + ;; + *) +: Should we write these tests to be more portable by sprintf-ing +: ~0 and then manipulating that char string as input for strtol? + ;; + esac + $cat >>try.c <<'EOCP' + if (!bad) + printf("ok\n"); + return 0; +} +EOCP + set try + if eval $compile; then + case "`$run ./try`" in + ok) echo "Your strtoul() seems to be working okay." ;; + *) cat <&4 +Your strtoul() doesn't seem to be working okay. +EOM + d_strtoul="$undef" + ;; + esac + else + echo "(I can't seem to compile the test program--assuming it doesn't)" + d_strtoul="$undef" + fi + ;; +esac + +: 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 0 /* strtoull() for /^-/ strings is undefined. */ + check("-1", 18446744073709551615ULL, 0); + check("-18446744073709551614", 2LL, 0); + check("-18446744073709551615", 1LL, 0); + check("-18446744073709551616", 18446744073709551615ULL, ERANGE); + check("-18446744073709551617", 18446744073709551615ULL, ERANGE); +#endif + if (!bad) + printf("ok\n"); +} +EOCP + set try + if eval $compile; then + case "`$run ./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 + else + echo "(I can't seem to compile the test program--assuming it doesn't)" + d_strtoull="$undef" + fi + ;; +esac + +: see if strtouq exists +set strtouq d_strtouq +eval $inlibc + +case "$d_strtouq" in +"$define") + $cat <try.c <<'EOCP' +#include +#include +extern unsigned long long int strtouq(char *s, char **, int); +static int bad = 0; +void check(char *s, unsigned long long eull, int een) { + unsigned long long gull; + errno = 0; + gull = strtouq(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 0 /* strtouq() for /^-/ strings is undefined. */ + check("-1", 18446744073709551615ULL, 0); + check("-18446744073709551614", 2LL, 0); + check("-18446744073709551615", 1LL, 0); + check("-18446744073709551616", 18446744073709551615ULL, ERANGE); + check("-18446744073709551617", 18446744073709551615ULL, ERANGE); +#endif + if (!bad) + printf("ok\n"); + return 0; +} +EOCP + set try + if eval $compile; then + case "`$run ./try`" in + ok) echo "Your strtouq() seems to be working okay." ;; + *) cat <&4 +Your strtouq() doesn't seem to be working okay. +EOM + d_strtouq="$undef" + ;; + esac + else + echo "(I can't seem to compile the test program--assuming it doesn't)" + d_strtouq="$undef" + fi + ;; +esac + +: 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 prototype for syscall is available +echo " " +set d_syscallproto syscall $i_unistd unistd.h +eval $hasproto + +: 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 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 if timegm exists +set timegm d_timegm +eval $inlibc + +: 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 tmpnam_r exists +set tmpnam_r d_tmpnam_r +eval $inlibc +case "$d_tmpnam_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h " + case "$d_tmpnam_r_proto:$usethreads" in + ":define") d_tmpnam_r_proto=define + set d_tmpnam_r_proto tmpnam_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_tmpnam_r_proto" in + define) + case "$tmpnam_r_proto" in + ''|0) try='char* tmpnam_r(char*);' + ./protochk "$extern_C $try" $hdrs && tmpnam_r_proto=B_B ;; + esac + case "$tmpnam_r_proto" in + ''|0) d_tmpnam_r=undef + tmpnam_r_proto=0 + echo "Disabling tmpnam_r, cannot determine prototype." >&4 ;; + * ) case "$tmpnam_r_proto" in + REENTRANT_PROTO*) ;; + *) tmpnam_r_proto="REENTRANT_PROTO_$tmpnam_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "tmpnam_r has no prototype, not using it." >&4 ;; + esac + d_tmpnam_r=undef + tmpnam_r_proto=0 + ;; + esac + ;; +*) tmpnam_r_proto=0 + ;; +esac + +: see if truncate exists +set truncate d_truncate +eval $inlibc + +: see if ttyname_r exists +set ttyname_r d_ttyname_r +eval $inlibc +case "$d_ttyname_r" in +"$define") + hdrs="$i_systypes sys/types.h define stdio.h $i_unistd unistd.h" + case "$d_ttyname_r_proto:$usethreads" in + ":define") d_ttyname_r_proto=define + set d_ttyname_r_proto ttyname_r $hdrs + eval $hasproto ;; + *) ;; + esac + case "$d_ttyname_r_proto" in + define) + case "$ttyname_r_proto" in + ''|0) try='int ttyname_r(int, char*, size_t);' + ./protochk "$extern_C $try" $hdrs && ttyname_r_proto=I_IBW ;; + esac + case "$ttyname_r_proto" in + ''|0) try='int ttyname_r(int, char*, int);' + ./protochk "$extern_C $try" $hdrs && ttyname_r_proto=I_IBI ;; + esac + case "$ttyname_r_proto" in + ''|0) try='char* ttyname_r(int, char*, int);' + ./protochk "$extern_C $try" $hdrs && ttyname_r_proto=B_IBI ;; + esac + case "$ttyname_r_proto" in + ''|0) d_ttyname_r=undef + ttyname_r_proto=0 + echo "Disabling ttyname_r, cannot determine prototype." >&4 ;; + * ) case "$ttyname_r_proto" in + REENTRANT_PROTO*) ;; + *) ttyname_r_proto="REENTRANT_PROTO_$ttyname_r_proto" ;; + esac + echo "Prototype: $try" ;; + esac + ;; + *) case "$usethreads" in + define) echo "ttyname_r has no prototype, not using it." >&4 ;; + esac + d_ttyname_r=undef + ttyname_r_proto=0 + ;; + esac + ;; +*) ttyname_r_proto=0 + ;; +esac + +: see if tzname[] exists +echo " " +if set tzname val -a d_tzname; eval $csym; $val; then + val="$define" + echo 'tzname[] found.' >&4 +else + val="$undef" + echo 'tzname[] NOT found.' >&4 +fi +set d_tzname +eval $setvar + +: Check if is a multiplatform env +case "$osname" in +next|rhapsody|darwin) multiarch="$define" ;; +esac +case "$multiarch" in +''|[nN]*) multiarch="$undef" ;; +esac + +: check for ordering of bytes in a UV +echo " " +case "$usecrosscompile$multiarch" in +*$define*) + $cat <try.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#include +typedef $uvtype UV; +int main() +{ + int i; + union { + UV l; + char c[$uvsize]; + } u; + + if ($uvsize > 4) + u.l = (((UV)0x08070605) << 32) | (UV)0x04030201; + else + u.l = (UV)0x04030201; + for (i = 0; i < $uvsize; i++) + printf("%c", u.c[i]+'0'); + printf("\n"); + exit(0); +} +EOCP + xxx_prompt=y + set try + if eval $compile && $run ./try > /dev/null; then + dflt=`$run ./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 $uvtype?" + . ./myread + byteorder="$ans" + ;; + *) byteorder=$dflt + ;; + esac + ;; + esac + $rm_try + ;; +esac + +: Checking 32bit alignedness +$cat <try.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#define U32 $u32type +#define BYTEORDER 0x$byteorder +#define U8 $u8type +#include +#ifdef SIGBUS +$signal_t bletch(int s) { exit(4); } +#endif +int main() { +#if BYTEORDER == 0x1234 || BYTEORDER == 0x4321 + volatile U8 buf[8]; + volatile U32 *up; + int i; + + if (sizeof(U32) != 4) { + printf("sizeof(U32) is not 4, but %d\n", sizeof(U32)); + exit(1); + } + + fflush(stdout); + +#ifdef SIGBUS + signal(SIGBUS, bletch); +#endif + + buf[0] = 0; + buf[1] = 0; + buf[2] = 0; + buf[3] = 1; + buf[4] = 0; + buf[5] = 0; + buf[6] = 0; + buf[7] = 1; + + for (i = 0; i < 4; i++) { + up = (U32*)(buf + i); + if (! ((*up == 1 << (8*i)) || /* big-endian */ + (*up == 1 << (8*(3-i))) /* little-endian */ + ) + ) + { + printf("read failed (%x)\n", *up); + exit(2); + } + } + + /* write test */ + for (i = 0; i < 4; i++) { + up = (U32*)(buf + i); + *up = 0xBeef; + if (*up != 0xBeef) { + printf("write failed (%x)\n", *up); + exit(3); + } + } + + exit(0); +#else + printf("1\n"); + exit(1); +#endif + return 0; +} +EOCP +set try +if eval $compile_ok; then + echo "(Testing for character data alignment may crash the test. That's okay.)" >&4 + $run ./try 2>&1 >/dev/null + case "$?" in + 0) cat >&4 <&4 <&4 + cat > try.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 try + if eval $compile_ok; then + if $run ./try > /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_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 + +: see if writev exists +set writev d_writev +eval $inlibc + +: preserve RCS keywords in files with variable substitution, grrr +Date='$Date' +Id='$Id' +Log='$Log' +RCSfile='$RCSfile' +Revision='$Revision' + +: check for alignment requirements +echo " " +case "$usecrosscompile$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=`$run ./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_try + ;; +esac + + +: set the base revision +baserev=5.0 + +: length of character in bytes. Is always 1, otherwise it isnt C +: This used to be a test using sizeof +charsize=1 + +: Check for the number of bits in a character +case "$charbits" in +'') echo "Checking how long a character is (in bits)..." >&4 + $cat >try.c < +int main () +{ + int n; + unsigned char c; + for (c = 1, n = 0; c; c <<= 1, n++) ; + printf ("%d\n", n); + return (0); + } +EOCP + set try + if eval $compile_ok; then + dflt=`$run ./try` + else + dflt='8' + echo "(I can't seem to compile the test program. Guessing...)" + fi + ;; +*) + dflt="$charbits" + ;; +esac +rp="What is the length of a character (in bits)?" +. ./myread +charbits="$ans" +$rm_try +case "$charbits" in +8) ;; +*) cat >&4 << EOM +Your system has an unsigned character size of $charbits bits, which +is rather unusual (normally it is 8 bits). Perl likely will not work +correctly on your system, with subtle bugs in various places. +EOM + rp='Do you really want to continue?' + dflt='n' + . ./myread + case "$ans" in + [yY]) echo >&4 "Okay, continuing." ;; + *) exit 1 ;; + esac +esac + +: how do we concatenate cpp tokens here? +echo " " +echo "Checking to see how your cpp does stuff like concatenate 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 +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#include +int main(int argc, char *argv[]) +{ +#ifdef DB_VERSION_MAJOR /* DB version >= 2 */ + int Major, Minor, Patch ; + unsigned long Version ; + (void)db_version(&Major, &Minor, &Patch) ; + if (argc == 2) { + printf("%d %d %d %d %d %d\n", + DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH, + Major, Minor, Patch); + exit(0); + } + 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("Perl needs Berkeley DB 2.3.4 or greater.\n") ; + exit(2); + } + + exit(0); +#else +#if defined(_DB_H_) && defined(BTREEMAGIC) && defined(HASHMAGIC) + if (argc == 2) { + printf("1 0 0\n"); + exit(0); + } + 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 && $run ./try; then + echo 'Looks OK.' >&4 + set `$run ./try 1` + db_version_major=$1 + db_version_minor=$2 + db_version_patch=$3 + 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_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_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_try + echo "Your version of Berkeley DB uses $db_prefixtype for prefix." + ;; +*) db_prefixtype='size_t' + ;; +esac + +: 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_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 + +: Determine if this is an EBCDIC system +echo " " +echo "Determining whether or not we are on an EBCDIC system..." >&4 +$cat >try.c <<'EOM' +int main() +{ + if ('M'==0xd4) return 0; + return 1; +} +EOM + +val=$undef +set try +if eval $compile_ok; then + if $run ./try; then + echo "You seem to speak EBCDIC." >&4 + val="$define" + else + echo "Nope, no EBCDIC, probably ASCII or some ISO Latin. Or UTF-8." >&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_try +set ebcdic +eval $setvar + +: Check how to flush +echo " " +$cat >&4 < try.c ;; +esac +$cat >>try.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#$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; + unlink("try.out"); + 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 +$to try.c +if $test "X$fflushNULL" = X -o "X$fflushall" = X; then + output='' + set try -DTRY_FPUTC + if eval $compile; then + $run ./try 2>/dev/null + code="$?" + $from try.out + if $test ! -s try.out -a "X$code" = X42; then + output=-DTRY_FPUTC + fi + fi + case "$output" in + '') + set try -DTRY_FPRINTF + if eval $compile; then + $run ./try 2>/dev/null + code="$?" + $from try.out + if $test ! -s try.out -a "X$code" = 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 + $run ./try 2>/dev/null + code="$?" + $from try.out + 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 | $run ./tryp 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 | $run ./tryp 2>/dev/null > tryp.out + if cmp tryp.c tryp.out >/dev/null 2>&1; then + $cat >&4 <&4 </dev/null + code=$? + $from try.out + if $test -s try.out -a "X$code" = X42; then + fflushall="`$cat try.out`" + fi + fi + $rm_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 + +: Check the size of GID +echo " " +case "$gidtype" in +*_t) zzz="$gidtype" ;; +*) zzz="gid" ;; +esac +echo "Checking the size of $zzz..." >&4 +cat > try.c < +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +int main() { + printf("%d\n", (int)sizeof($gidtype)); + exit(0); +} +EOCP +set try +if eval $compile_ok; then + yyy=`$run ./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 + + +: Check if GID is signed +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=`$run ./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 + + +: Check 64bit sizes +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=`$run ./try` + 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=`$run ./try` + 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=`$run ./try` + 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; then + $cat >try.c < +#include +int main() { + $quadtype q = 12345678901; + printf("%Ld\n", q); +} +EOCP + set try + if eval $compile; then + yyy=`$run ./try` + 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"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=`$run ./try` + 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("%qd\n", q); +} +EOCP + set try + if eval $compile; then + yyy=`$run ./try` + 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_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 + +: Check format strings for internal types +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 + +: Check format string for GID + +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 + +: see if we need va_copy +echo " " +case "$i_stdarg" in +"$define") + $cat >try.c < +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#include + +int +ivfprintf(FILE *f, const char *fmt, va_list *valp) +{ + return vfprintf(f, fmt, *valp); +} + +int +myvfprintf(FILE *f, const char *fmt, va_list val) +{ + return ivfprintf(f, fmt, &val); +} + +int +myprintf(char *fmt, ...) +{ + va_list val; + va_start(val, fmt); + return myvfprintf(stdout, fmt, val); +} + +int +main(int ac, char **av) +{ + signal(SIGSEGV, exit); + + myprintf("%s%cs all right, then\n", "that", '\''); + exit(0); +} +EOCP + set try + if eval $compile && $run ./try 2>&1 >/dev/null; then + case "`$run ./try`" in + "that's all right, then") + okay=yes + ;; + esac + fi + case "$okay" in + yes) echo "It seems that you don't need va_copy()." >&4 + need_va_copy="$undef" + ;; + *) echo "It seems that va_copy() or similar will be needed." >&4 + need_va_copy="$define" + ;; + esac + $rm_try + ;; +*) echo "You don't have , not checking for va_copy()." >&4 + ;; +esac + +: 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 +echo 'int bar1() { return bar2(); }' > bar1.c +echo 'int bar2() { return 2; }' > bar2.c +$cat > foo.c < +#endif +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 && + $run ./foobar >/dev/null 2>&1; then + echo "$ar appears to generate random libraries itself." + orderlib=false + if [ "X$ranlib" = "X" ]; then + ranlib=":" + fi +elif $ar s bar$_a >/dev/null 2>&1 && + $cc -o foobar $ccflags $ldflags foo$_o bar$_a $libs > /dev/null 2>&1 && + $run ./foobar >/dev/null 2>&1; then + echo "a table of contents needs to be added with '$ar s'." + orderlib=false + ranlib="$ar s" +elif $ar ts bar$_a >/dev/null 2>&1 && + $cc -o foobar $ccflags $ldflags foo$_o bar$_a $libs > /dev/null 2>&1 && + $run ./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* + +: see if this is a values.h system +set values.h i_values +eval $inhdr + +: Check the max offset that gmtime and localtime accept +echo "Checking max offsets that gmtime () accepts" + +case $i_values in + define) yyy="#include " ;; + *) yyy="" ;; + esac + +case "$sGMTIME_min/$sGMTIME_max" in + 0/0|/) + $cat >try.c < +#include +#include +$yyy + +int i; +struct tm *tmp; +time_t pt; + +void gm_check (time_t t, int min_year, int max_year) +{ + tmp = gmtime (&t); + if ( tmp == NULL || + /* Check tm_year overflow */ + tmp->tm_year < min_year || tmp->tm_year > max_year) + tmp = NULL; + else + pt = t; + } /* gm_check */ + +int check_max () +{ + tmp = NULL; + pt = 0; +#ifdef MAXLONG + gm_check (MAXLONG, 69, 0x7fffffff); +#endif + if (tmp == NULL || tmp->tm_year < 0) { + for (i = 63; i >= 0; i--) { + time_t x = pt | ((time_t)1 << i); + if (x < 0 || x < pt) continue; + gm_check (x, 69, 0x7fffffff); + } + } + printf ("sGMTIME_max=%ld\n", pt); + return (0); + } /* check_max */ + +int check_min () +{ + tmp = NULL; + pt = 0; +#ifdef MINLONG + gm_check (MINLONG, -1900, 70); +#endif + if (tmp == NULL) { + for (i = 36; i >= 0; i--) { + time_t x = pt - ((time_t)1 << i); + if (x > 0) continue; + gm_check (x, -1900, 70); + } + } + printf ("sGMTIME_min=%ld\n", pt); + return (0); + } /* check_min */ + +int main (int argc, char *argv[]) +{ + fprintf (stderr, "Sizeof time_t = %ld\n", sizeof (time_t)); + check_max (); + check_min (); + return (0); + } /* main */ +EOCP + set try + if eval $compile; then + eval `$run ./try` + else + echo "Cannot determine sGMTIME_max and sGMTIME_min." >&4 + fi + $rm_try + ;; + esac + +echo "Checking max offsets that localtime () accepts" + +case "$sLOCALTIME_min/$sLOCALTIME_max" in + 0/0|/) + $cat >try.c < +#include +#include +$yyy + +int i; +struct tm *tmp; +time_t pt; + +void local_check (time_t t, int min_year, int max_year) +{ + if (sizeof (time_t) > 4 && t > 0x7ffffffffffff000LL) + tmp = NULL; + else + tmp = localtime (&t); + if ( tmp == NULL || + /* Check tm_year overflow */ + tmp->tm_year < min_year || tmp->tm_year > max_year) + tmp = NULL; + else + pt = t; + } /* local_check */ + +int check_max () +{ + tmp = NULL; + pt = 0; +#ifdef MAXLONG + local_check (MAXLONG, 69, 0x7fffffff); +#endif + if (tmp == NULL || tmp->tm_year < 0) { + for (i = 63; i >= 0; i--) { + time_t x = pt | ((time_t)1 << i); + if (x < 0 || x < pt) continue; + local_check (x, 69, 0x7fffffff); + } + } + printf ("sLOCALTIME_max=%ld\n", pt); + return (0); + } /* check_max */ + +int check_min () +{ + tmp = NULL; + pt = 0; +#ifdef MINLONG + local_check (MINLONG, -1900, 70); +#endif + if (tmp == NULL) { + for (i = 36; i >= 0; i--) { + time_t x = pt - ((time_t)1 << i); + if (x > 0) continue; + local_check (x, -1900, 70); + } + } + printf ("sLOCALTIME_min=%ld\n", pt); + return (0); + } /* check_min */ + +int main (int argc, char *argv[]) +{ + check_max (); + check_min (); + return (0); + } /* main */ +EOCP + set try + if eval $compile; then + eval `$run ./try` + else + echo "Cannot determine sLOCALTIME_max and sLOCALTIME_min." >&4 + fi + $rm_try + ;; + esac + +: 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 +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +$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 = (char *)malloc(NBYTES); + struct timeval t; + int i; + FILE* fp; + int fd; + + if (!s) + exit(1); + fclose(stdin); + fp = fopen("try.c", "r"); + if (fp == 0) + exit(2); + fd = fileno(fp); + if (fd < 0) + exit(3); + 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--); + free(s); + printf("%d\n", i + 1); + return 0; +} +EOCP + set try + if eval $compile_ok; then + selectminbits=`$run ./try` + case "$selectminbits" in + '') cat >&4 <&4 + else + rp='What is the minimum number of bits your select() operates on?' + case "$byteorder" in + 12345678) dflt=64 ;; + 1234) dflt=32 ;; + *) dflt=1 ;; + esac + . ./myread + val=$ans + selectminbits="$val" + fi + $rm_try + ;; + *) : no select, so pick a harmless default + selectminbits=$safebits + ;; + esac + ;; +esac + +: Trace out the files included by signal.h, then look for SIGxxx names. +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' |\ + $sed 's!\\\\\\\\!/!g' | $sort | $uniq` +fi +xxxfiles='' +for xx in $xxx /dev/null ; do + $test -f "$xx" && xxxfiles="$xxxfiles $xx" +done +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 < +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#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 _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 /* Assume ary[SIGARRAYSIZE] */ +# 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) && ($2 ~ /^[0-9][0-9]*$/) { + 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 + $run ./signal$_exe | ($sort -n -k 2 2>/dev/null || $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 + $run ./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." + $run ./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 | $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" +}' +sig_size=`echo $sig_name | awk '{print NF}'` +$rm -f signal signal.c signal.awk signal.lst signal_cmd + +: Check size of size +echo " " +case "$sizetype" in +*_t) zzz="$sizetype" ;; +*) zzz="filesize" ;; +esac +echo "Checking the size of $zzz..." >&4 +cat > try.c < +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +int main() { + printf("%d\n", (int)sizeof($sizetype)); + exit(0); +} +EOCP +set try +if eval $compile_ok; then + yyy=`$run ./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_try +set d_socklen_t +eval $setvar + +: see if this is a socks.h system +set socks.h i_socks +eval $inhdr + +: check for type of the size argument to socket calls +case "$d_socket" in +"$define") + $cat < try.c < +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +#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 try +if eval $compile_ok && $run ./try > /dev/null; then + ssizetype=`$run ./try` + echo "I'll be using $ssizetype for functions returning a byte count." >&4 +else + $cat >&4 <&4 +$cat > try.c < +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +int main() { + struct stat st; + printf("%d\n", (int)sizeof(st.st_ino)); + exit(0); +} +EOCP +set try +if eval $compile_ok; then + val=`$run ./try` + case "$val" in + '') st_ino_size=4 + $echo "(I can't execute the test program--guessing $st_ino_size.)" >&4 + ;; + *) st_ino_size=$val + $echo "Your st_ino is $st_ino_size bytes long." + ;; + esac +else + st_ino_size=4 + $echo "(I can't compile the test program--guessing $st_ino_size.)" >&4 +fi +$rm_try + +: Check if st_ino is signed +$echo " " +$echo "Checking the sign of st_ino..." >&4 +$cat > try.c < +#include +int main() { + struct stat foo; + foo.st_ino = -1; + if (foo.st_ino < 0) + printf("-1\n"); + else + printf("1\n"); +} +EOCP +set try +if eval $compile; then + val=`$run ./try` + case "$val" in + '') st_ino_sign=1 + $echo "(I can't execute the test program--guessing unsigned.)" >&4 + ;; + *) st_ino_sign=$val + case "$st_ino_sign" in + 1) $echo "Your st_ino is unsigned." ;; + -1) $echo "Your st_ino is signed." ;; + esac + ;; + esac +else + st_ino_sign=1 + $echo "(I can't compile the test program--guessing unsigned.)" >&4 +fi +$rm_try + +: see what type of char stdio uses. +echo " " +echo '#include ' | $cppstdin $cppminus > stdioh +if $contains 'unsigned.*char.*_ptr;' stdioh >/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 +$rm -f stdioh + +: 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 + +: Check size of UID +echo " " +case "$uidtype" in +*_t) zzz="$uidtype" ;; +*) zzz="uid" ;; +esac +echo "Checking the size of $zzz..." >&4 +cat > try.c < +#include +#$i_stdlib I_STDLIB +#ifdef I_STDLIB +#include +#endif +int main() { + printf("%d\n", (int)sizeof($uidtype)); + exit(0); +} +EOCP +set try +if eval $compile_ok; then + yyy=`$run ./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 + +: Check if UID is signed +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=`$run ./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 + + +: Check format string for UID +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 + +: Determine if we can use sysctl with KERN_PROC_PATHNAME to find executing program +echo " " +echo "Determining whether we can use sysctl with KERN_PROC_PATHNAME to find executing program..." >&4 +$cat >try.c <<'EOM' +/* Intentionally a long probe as I'd like to sanity check that the exact + approach is going to work, as thinking it will work, but only having it + part working at runtime is worse than not having it. */ + +#include +#include +#include +#include +#include +#include +#include + +int +main(int argc, char **argv) { + char *buffer; + char *argv_leaf = strrchr(argv[0], '/'); + char *buffer_leaf; + size_t size = 0; + int mib[4]; + + mib[0] = CTL_KERN; + mib[1] = KERN_PROC; + mib[2] = KERN_PROC_PATHNAME; + mib[3] = -1; + + if (!argv_leaf) { + fprintf(stderr, "Can't locate / in '%s'\n", argv[0]); + return 1; + } + + if (sysctl(mib, 4, NULL, &size, NULL, 0)) { + perror("sysctl"); + return 2; + } + + if (size < strlen(argv_leaf) + 1) { + fprintf(stderr, "size %lu is too short for a path\n", + (unsigned long) size); + return 3; + } + + if (size > MAXPATHLEN * MAXPATHLEN) { + fprintf(stderr, "size %lu is too long for a path\n", + (unsigned long) size); + return 4; + } + + buffer = malloc(size); + if (!buffer) { + perror("malloc"); + return 5; + } + + if (sysctl(mib, 4, buffer, &size, NULL, 0)) { + perror("sysctl"); + return 6; + } + + if (strlen(buffer) + 1 != size) { + fprintf(stderr, "size != strlen(buffer) + 1 (%lu != %lu)\n", + (unsigned long)size, (unsigned long)strlen(buffer) + 1); + return 7; + } + + + if (*buffer != '/') { + fprintf(stderr, "Not an absolute path: '%s'\n", buffer); + return 8; + } + + if (strstr(buffer, "/./")) { + fprintf(stderr, "Contains /./: '%s'\n", buffer); + return 9; + } + + if (strstr(buffer, "/../")) { + fprintf(stderr, "Contains /../: '%s'\n", buffer); + return 10; + } + + buffer_leaf = strrchr(buffer, '/'); + if (strcmp(buffer_leaf, argv_leaf) != 0) { + fprintf(stderr, "Leafnames differ: '%s' vs '%s'\n", argv[0], buffer); + return 11; + } + + free(buffer); + + return 0; +} +EOM + +val=$undef +set try +if eval $compile_ok; then + if $run ./try; then + echo "You can use sysctl with KERN_PROC_PATHNAME to find the executing program." >&4 + val="$define" + else + echo "Nope, sysctl with KERN_PROC_PATHNAME doesn't work here." >&4 + val="$undef" + fi +else + echo "I'm unable to compile the test program." >&4 + echo "I'll assume no sysctl with KERN_PROC_PATHNAME here." >&4 + val="$undef" +fi +$rm_try +set usekernprocpathname +eval $setvar + +: Determine if we can use _NSGetExecutablePath to find executing program +echo " " +echo "Determining whether we can use _NSGetExecutablePath to find executing program..." >&4 +$cat >try.c <<'EOM' +/* Intentionally a long probe as I'd like to sanity check that the exact + approach is going to work, as thinking it will work, but only having it + part working at runtime is worse than not having it. */ +#include +#include +#include +#include +#include + +int +main(int argc, char **argv) { + char buf[1]; + uint32_t size = sizeof(buf); + int result; + char *buffer; + char *tidied; + char *argv_leaf = strrchr(argv[0], '/'); + char *tidied_leaf; + + if (!argv_leaf) { + fprintf(stderr, "Can't locate / in '%s'\n", argv[0]); + return 1; + } + + _NSGetExecutablePath(buf, &size); + if (size > MAXPATHLEN * MAXPATHLEN) { + fprintf(stderr, "_NSGetExecutablePath size %u is too long for a path\n", + (unsigned int) size); + return 2; + } + + buffer = malloc(size); + if (!buffer) { + perror("malloc"); + return 3; + } + + result = _NSGetExecutablePath(buffer, &size); + if (result != 0) { + fprintf(stderr, "_NSGetExecutablePath returned %i for a size of %u\n", + result, (unsigned int) size); + return 4; + } + + tidied = realpath(buffer, NULL); + if (!tidied) { + perror("realpath"); + return 5; + } + + free(buffer); + + if (*tidied != '/') { + fprintf(stderr, "Not an absolute path: '%s'\n", tidied); + return 6; + } + + if (strstr(tidied, "/./")) { + fprintf(stderr, "Contains /./: '%s'\n", tidied); + return 7; + } + + if (strstr(tidied, "/../")) { + fprintf(stderr, "Contains /../: '%s'\n", tidied); + return 8; + } + + tidied_leaf = strrchr(tidied, '/'); + if (strcmp(tidied_leaf, argv_leaf) != 0) { + fprintf(stderr, "Leafnames differ: '%s' vs '%s'\n", argv[0], tidied); + return 9; + } + + free(tidied); + + return 0; +} +EOM + +val=$undef +set try +if eval $compile_ok; then + if $run ./try; then + echo "You can use _NSGetExecutablePath to find the executing program." >&4 + val="$define" + else + echo "Nope, _NSGetExecutablePath doesn't work here." >&4 + fi +else + echo "I'm unable to compile the test program." >&4 + echo "I'll assume no _NSGetExecutablePath here." >&4 +fi +$rm_try +set usensgetexecutablepath +eval $setvar + +: Check if site customization support was requested +case "$usesitecustomize" in + $define|true|[Yy]*) + usesitecustomize="$define" + ;; + *) + usesitecustomize="$undef" + ;; + esac + +: see if prototypes support variable argument declarations +echo " " +case "$prototype$i_stdarg" in +$define$define) + echo "It appears we'll be able to prototype varargs functions." >&4 + val="$define" + ;; +*) + echo "Too bad... We won't be using prototyped varargs functions..." >&4 + val="$undef" + ;; +esac +set vaproto +eval $setvar + +: determine compiler compiler +case "$yacc" in +'') + dflt=yacc;; +*) + dflt="$yacc";; +esac +echo " " +comp='yacc' +if $test -f "$byacc$_exe"; then + dflt="$byacc" + comp="byacc or $comp" +fi +if $test -f "$bison$_exe"; then + comp="$comp or bison -y" +fi +rp="Which compiler compiler ($comp) shall I use?" +. ./myread +yacc="$ans" +case "$yacc" in +*bis*) + case "$yacc" in + *-y*) ;; + *) + yacc="$yacc -y" + echo "(Adding -y option to bison to get yacc-compatible behaviour.)" + ;; + esac + ;; +esac + +: see if this is a assert.h system +set assert.h i_assert +eval $inhdr + +: see if this is a fp.h system +set fp.h i_fp +eval $inhdr + +: see if this is a fp_class.h system +set fp_class.h i_fp_class +eval $inhdr + +: see if gdbm.h is available +set gdbm.h t_gdbm +eval $inhdr +case "$t_gdbm" in +$define) + : see if gdbm_open exists + set gdbm_open d_gdbm_open + eval $inlibc + case "$d_gdbm_open" in + $undef) + t_gdbm="$undef" + echo "We won't be including " + ;; + esac + ;; +esac +val="$t_gdbm" +set i_gdbm +eval $setvar + +: see if this is a ieeefp.h system +case "$i_ieeefp" in +'' ) set ieeefp.h i_ieeefp + eval $inhdr + ;; +esac + +: see if this is a libutil.h system +set libutil.h i_libutil +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 mntent.h system +set mntent.h i_mntent +eval $inhdr + +: 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_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 + +: Preprocessor symbols +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 AMD64 amd64 amiga AMIGAOS AMIX +ansi ANSI_C_SOURCE apollo ardent ARM32 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 DECC DGUX DGUX_SOURCE DJGPP dmert DOLPHIN DPX2 DSO +Dynix DynixPTX ELF encore EPI EXTENSIONS FAVOR_BSD +FILE_OFFSET_BITS FreeBSD GCC_NEW_VARARGS gcos gcx gimpel +GLIBC GLIBC_MINOR +GNU_SOURCE GNUC GNUC_MINOR GNU_LIBRARY 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 +IA64 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 +LIBCATAMOUNT 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 QK_USER R3000 REENTRANT RES Rhapsody RISC6000 +riscix riscos RT S390 SA110 scs SCO sequent sgi SGI_SOURCE SH3 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 +TM3200 TM5400 TM5600 +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 +USE_BSD USE_FILE_OFFSET64 USE_GNU USE_ISOC9X USE_LARGEFILE USE_LARGEFILE64 +USE_MISC USE_POSIX USE_POSIX199309 USE_POSIX199506 USE_POSIX2 +USE_REENTRANT USE_SVID USE_UNIX98 USE_XOPEN USE_XOPEN_EXTENDED +USGr4 USGr4_2 +Utek UTek UTS UWIN uxpm uxps vax venix VMESA vms x86_64 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 +#if cpp_stuff == 1 +#define STRINGIFY(a) "a" +#endif +#if cpp_stuff == 42 +#define StGiFy(a) #a +#define STRINGIFY(a) StGiFy(a) +#endif +#if $cpp_stuff != 1 && $cpp_stuff != 42 +# include "Bletch: How does this C preprocessor stringify macros?" +#endif +int main() { +EOCP +$awk \\ +EOSH +cat <<'EOSH' >> Cppsym.try +'length($1) > 0 { + printf "#ifdef %s\nprintf(\"%s=%%s\\n\", STRINGIFY(%s));\n#endif\n", $1, $1, $1 + printf "#ifdef _%s\nprintf(\"_%s=%%s\\n\", STRINGIFY(_%s));\n#endif\n", $1, $1, $1 + printf "#ifdef __%s\nprintf(\"__%s=%%s\\n\", STRINGIFY(__%s));\n#endif\n", $1, $1, $1 + printf "#ifdef __%s__\nprintf(\"__%s__=%%s\\n\", STRINGIFY(__%s__));\n#endif\n", $1, $1, $1 +}' >> try.c +echo 'return 0;}' >> 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 -Dcpp_stuff=$cpp_stuff $optimize \$ccflags $ldflags try.c $libs && $run ./try | $sed 's/ /\\\\ /g' +EOSH +chmod +x Cppsym.try +$eunicefix Cppsym.try +./Cppsym < Cppsym.know > Cppsym.true +: Add in any linux cpp "predefined macros": +case "$osname::$gccversion" in + *linux*::*.*|*gnukfreebsd*::*.*|gnu::*.*) + tHdrH=_tmpHdr + rm -f $tHdrH'.h' $tHdrH + touch $tHdrH'.h' + if $cpp -dM $tHdrH'.h' > $tHdrH'_cppsym.h' && [ -s $tHdrH'_cppsym.h' ]; then + sed 's/#define[\ \ ]*//;s/[\ \ ].*$//' <$tHdrH'_cppsym.h' >$tHdrH'_cppsym.real' + if [ -s $tHdrH'_cppsym.real' ]; then + cat $tHdrH'_cppsym.real' Cppsym.know | sort | uniq | ./Cppsym | sort | uniq > Cppsym.true + fi + fi + rm -f $tHdrH'.h' $tHdrH'_cppsym.h' $tHdrH'_cppsym.real' + ;; +esac +: 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//' | $sed 's/\(.*\)(\(.*\))/\1=\2/';; + esac +done +$rm_try +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 +$comm -13 Cppsym.true ccsym.list >ccsym.own +$comm -12 Cppsym.true ccsym.list >ccsym.com +$comm -23 Cppsym.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 + +: 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." + ./warn " not found--you could have problems." + fi;; + *) if $test `./findhdr termio.h`; then + val="$define" + echo " found." >&4 + else + echo "System is pyramid with USG universe." + ./warn " not found--you could have problems." + 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 + ./warn "Neither nor found--cross fingers!" + 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 + ./warn "Neither nor found--cross fingers!" + fi + fi;; +esac +set i_termio; eval $setvar +val=$val2; set i_sgtty; eval $setvar +val=$val3; set i_termios; eval $setvar + +: see if stdbool is available +: we want a real compile instead of Inhdr because some Solaris systems +: have stdbool.h, but it can only be used if the compiler indicates it +: is sufficiently c99-compliant. +echo " " +$cat >try.c < +#include +int func(bool x) +{ + return x ? 1 : 0; +} +int main(int argc, char **argv) +{ + return func(0); +} +EOCP +set try +if eval $compile; then + echo " found." >&4 + val="$define" +else + echo " NOT found." >&4 + val="$undef" +fi +$rm_try +set i_stdbool +eval $setvar + +: see if stddef is available +set stddef.h i_stddef +eval $inhdr + +: 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 + $test $i_sgtty = "$define" && xxx="sgtty.h" + $test $i_termio = "$define" && xxx="termio.h" + $test $i_termios = "$define" && xxx="termios.h" +echo "No found, assuming ioctl args are defined in <$xxx>." >&4 + fi +fi +set i_sysioctl +eval $setvar + +: see if socket ioctl defs are in sys/sockio.h +echo " " +xxx=`./findhdr sys/sockio.h` +if $test "$xxx"; then + if $contains SIOCATMARK $xxx >/dev/null 2>&1; then + val="$define" + echo "You have socket ioctls defined in ." >&4 + else + val="$undef" + echo "No socket ioctls found in ." >&4 + fi +else + val="$undef" + $cat < not found, assuming socket ioctls are in . +EOM +fi +set i_syssockio +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 there is a sys/poll.h file +set sys/poll.h i_syspoll +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/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 vfork system +case "$d_vfork" in +"$define") + set vfork.h i_vfork + eval $inhdr + ;; +*) + i_vfork="$undef" + ;; +esac + +: Check extensions +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 +: In 5.10.1 and later, extensions are stored in directories +: like File-Glob instead of the older File/Glob/. +find_extensions=' + for xxx in *; do + case "$xxx" in + DynaLoader|dynaload) ;; + *) + this_ext=`echo $xxx | $sed -e s/-/\\\//g`; + leaf=`echo $xxx | $sed -e s/.*-//`; + if $test -d File; then + if $test -f $xxx/$leaf.xs -o -f $xxx/$leaf.c; then + known_extensions="$known_extensions $1$this_ext"; + elif $test -f $xxx/Makefile.PL; then + nonxs_extensions="$nonxs_extensions $1$this_ext"; + else + if $test -d $xxx -a $# -lt 10; then + set $1$xxx/ $*; + cd "$xxx"; + eval $find_extensions; + cd ..; + shift; + fi; + fi; + else + echo " $known_extensions $nonxs_extensions" > $$.tmp; + if $contains " $this_ext " $$.tmp; then + echo >&4; + echo "Duplicate directories detected for extension $xxx" >&4; + echo "Configure cannot correctly recover from this - shall I abort?" >&4; + case "$knowitall" in + "") dflt=y;; + *) dflt=n;; + esac; + . ../UU/myread; + case "$ans" in + n*|N*) ;; + *) echo >&4; + echo "Ok. Stopping Configure." >&4; + echo "Please remove the duplicate directory (eg using git clean) and then re-run Configure" >&4; + exit 1;; + esac; + echo "Ok. You will need to correct config.sh before running make." >&4; + fi; + $ls -1 $xxx > $$.tmp; + if $contains "\.xs$" $$.tmp > /dev/null 2>&1; then + known_extensions="$known_extensions $this_ext"; + elif $contains "\.c$" $$.tmp > /dev/null 2>&1; then + known_extensions="$known_extensions $this_ext"; + elif $test -d $xxx; then + nonxs_extensions="$nonxs_extensions $this_ext"; + fi; + $rm -f $$.tmp; + fi + ;; + esac; + done' +tdir=`pwd` +cd "$rsrc/cpan" +set X +shift +eval $find_extensions +cd "$rsrc/dist" +set X +shift +eval $find_extensions +cd "$rsrc/ext" +set X +shift +eval $find_extensions +if $test -d File-Glob; then + : All ext/ flattened +else + # Special case: Add in modules that nest beyond the first level. + # Currently threads/shared and Hash/Util/FieldHash, since they are + # not picked up by the recursive find above (and adding in general + # recursive finding breaks SDBM_File/sdbm). + # A.D. 20011025 (SDBM), ajgough 20071008 (FieldHash) + known_extensions="$known_extensions threads/shared Hash/Util/FieldHash" +fi +set X $known_extensions +shift +known_extensions=`echo "$*" | tr ' ' $trnl | $sort | tr $trnl ' '` +set X $nonxs_extensions +shift +nonxs_extensions=`echo "$*" | tr ' ' $trnl | $sort | tr $trnl ' '` +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 + ;; + I18N/Langinfo|i18n_lan) + case "$i_langinfo$d_nl_langinfo" in + $define$define) 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 + ;; + NDBM_File|ndbm_fil) + case "$d_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 "$d_cplusplus" in + define) ;; # delete as a function name will not work + *) case "$osname-$use64bitint" in + hpux-define) + case "$libs" in + *-ldbm*) avail_ext="$avail_ext $xxx" ;; + esac + ;; + *) avail_ext="$avail_ext $xxx" ;; + esac + ;; + esac + ;; + esac + ;; + Opcode|opcode) + case "$useopcode" in + true|define|y) avail_ext="$avail_ext $xxx" ;; + esac + ;; + POSIX|posix) + case "$useposix" in + true|define|y) avail_ext="$avail_ext $xxx" ;; + esac + ;; + Socket|socket) + case "$d_socket" in + true|$define|y) + case "$osname" in + beos) ;; # not unless BONE + *) avail_ext="$avail_ext $xxx" ;; + esac + ;; + 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) + case "$use5005threads" in + $define|true|[yY]*) avail_ext="$avail_ext $xxx" ;; + esac + esac + ;; + threads|threads/shared) + # threads and threads::shared are special cases. + # To stop people from asking "Perl 5.8.0 was supposed + # to have this new fancy threads implementation but my + # perl doesn't have it" and from people trying to + # (re)install the threads module using CPAN.pm and + # CPAN.pm then offering to reinstall Perl 5.8.0, + # the threads.pm and threads/shared.pm will always be + # there, croaking informatively ("you need to rebuild + # all of Perl with threads, sorry") when threads haven't + # been compiled in. + # --jhi + avail_ext="$avail_ext $xxx" + ;; + VMS*) + ;; + Win32*) + case "$osname" in + cygwin) avail_ext="$avail_ext $xxx" ;; + esac + ;; + XS/APItest|xs/apitest) + # This is just for testing. Skip it unless we have dynamic loading. + + case "$usedl" in + $define) avail_ext="$avail_ext $xxx" ;; + esac + ;; + XS/Typemap|xs/typemap) + # This is just for testing. Skip it unless we have dynamic loading. + case "$usedl" in + $define) avail_ext="$avail_ext $xxx" ;; + esac + ;; + *) avail_ext="$avail_ext $xxx" + ;; + esac +done + +set X $avail_ext +shift +avail_ext="$*" + +case "$onlyextensions" in +'') ;; +*) keepextensions='' + echo "You have requested that only certain extensions be included..." >&4 + for i in $onlyextensions; do + case " $avail_ext " in + *" $i "*) + echo "Keeping extension $i." + keepextensions="$keepextensions $i" + ;; + *) echo "Ignoring extension $i." ;; + esac + done + avail_ext="$keepextensions" + ;; +esac + +case "$noextensions" in +'') ;; +*) keepextensions='' + echo "You have requested that certain extensions be ignored..." >&4 + for i in $avail_ext; do + case " $noextensions " in + *" $i "*) echo "Ignoring extension $i." ;; + *) echo "Keeping extension $i."; + keepextensions="$keepextensions $i" + ;; + esac + done + avail_ext="$keepextensions" + ;; +esac + +: 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 + +set X $nonxs_ext +shift +nonxs_ext="$*" + +case $usedl in +$define) + $cat <&4 + echo "WARNING: The Perl you are building will be quite crippled." >& 4 + ;; +esac + +: Remove libraries needed only for extensions +: The appropriate ext/Foo/Makefile.PL will add them back in, if necessary. +: The exception is SunOS 4.x, which needs them. +case "${osname}X${osvers}" in +sunos*X4*) + perllibs="$libs" + ;; +*) case "$usedl" in + $define|true|[yY]*) + set X `echo " $libs " | sed -e 's@ -lndbm @ @' -e 's@ -lgdbm @ @' -e 's@ -lgdbm_compat @ @' -e 's@ -ldbm @ @' -e 's@ -ldb @ @'` + shift + perllibs="$*" + ;; + *) perllibs="$libs" + ;; + esac + ;; +esac + +: Remove build directory name from cppstdin so it can be used from +: either the present location or the final installed location. +echo " " +: Get out of the UU directory to get correct path name. +cd .. +case "$cppstdin" in +`pwd`/cppstdin) + echo "Stripping down cppstdin path name" + cppstdin=cppstdin + ;; +esac +cd UU + +: end of configuration questions +echo " " +echo "End of configuration questions." +echo " " + +: back to where it started +if test -d ../UU; then + cd .. +fi + +: configuration may be unconditionally patched via a 'config.arch' file +if $test -f config.arch; then + echo "I see a config.arch file, loading it." >&4 + . ./config.arch +fi + +: configuration may be patched via a 'config.over' file +if $test -f config.over; then + echo " " + dflt=y + rp='I see a config.over file. Do you wish to load it?' + . UU/myread + case "$ans" in + n*) echo "OK, I'll ignore it.";; + *) . ./config.over + echo "Configuration override changes have been loaded." + ;; + esac +fi + +: in case they want portability, strip down executable paths +case "$d_portable" in +"$define") + echo " " + echo "Stripping down executable paths..." >&4 + for file in $loclist $trylist; do + eval temp=\$$file + eval $file=`basename $temp` + done + ;; +esac + +: create config.sh file +echo " " +echo "Creating config.sh..." >&4 +$spitshell <config.sh +$startsh +# +# This file was produced by running the Configure script. It holds all the +# definitions figured out by Configure. Should you modify one of these values, +# do not forget to propagate your changes by running "Configure -der". You may +# instead choose to run each of the .SH files by yourself, or "Configure -S". +# + +# Package name : $package +# Source directory : $src +# Configuration time: $cf_time +# Configured by : $cf_by +# Target system : $myuname + +EOT +: Add in command line options if available +$test -f UU/cmdline.opt && $cat UU/cmdline.opt >> config.sh + +$spitshell <>config.sh + +Author='$Author' +Date='$Date' +Header='$Header' +Id='$Id' +Locker='$Locker' +Log='$Log' +RCSfile='$RCSfile' +Revision='$Revision' +Source='$Source' +State='$State' +_a='$_a' +_exe='$_exe' +_o='$_o' +afs='$afs' +afsroot='$afsroot' +alignbytes='$alignbytes' +ansi2knr='$ansi2knr' +aphostname='$aphostname' +api_revision='$api_revision' +api_subversion='$api_subversion' +api_version='$api_version' +api_versionstring='$api_versionstring' +ar='$ar' +archlib='$archlib' +archlibexp='$archlibexp' +archname64='$archname64' +archname='$archname' +archobjs='$archobjs' +asctime_r_proto='$asctime_r_proto' +awk='$awk' +baserev='$baserev' +bash='$bash' +bin='$bin' +bin_ELF='$bin_ELF' +binexp='$binexp' +bison='$bison' +byacc='$byacc' +byteorder='$byteorder' +c='$c' +castflags='$castflags' +cat='$cat' +cc='$cc' +cccdlflags='$cccdlflags' +ccdlflags='$ccdlflags' +ccflags='$ccflags' +ccflags_uselargefiles='$ccflags_uselargefiles' +ccname='$ccname' +ccsymbols='$ccsymbols' +ccversion='$ccversion' +cf_by='$cf_by' +cf_email='$cf_email' +cf_time='$cf_time' +charbits='$charbits' +charsize='$charsize' +chgrp='$chgrp' +chmod='$chmod' +chown='$chown' +clocktype='$clocktype' +comm='$comm' +compress='$compress' +contains='$contains' +cp='$cp' +cpio='$cpio' +cpp='$cpp' +cpp_stuff='$cpp_stuff' +cppccsymbols='$cppccsymbols' +cppflags='$cppflags' +cpplast='$cpplast' +cppminus='$cppminus' +cpprun='$cpprun' +cppstdin='$cppstdin' +cppsymbols='$cppsymbols' +crypt_r_proto='$crypt_r_proto' +cryptlib='$cryptlib' +csh='$csh' +ctermid_r_proto='$ctermid_r_proto' +ctime_r_proto='$ctime_r_proto' +d_Gconvert='$d_Gconvert' +d_PRIEUldbl='$d_PRIEUldbl' +d_PRIFUldbl='$d_PRIFUldbl' +d_PRIGUldbl='$d_PRIGUldbl' +d_PRIXU64='$d_PRIXU64' +d_PRId64='$d_PRId64' +d_PRIeldbl='$d_PRIeldbl' +d_PRIfldbl='$d_PRIfldbl' +d_PRIgldbl='$d_PRIgldbl' +d_PRIi64='$d_PRIi64' +d_PRIo64='$d_PRIo64' +d_PRIu64='$d_PRIu64' +d_PRIx64='$d_PRIx64' +d_SCNfldbl='$d_SCNfldbl' +d__fwalk='$d__fwalk' +d_access='$d_access' +d_accessx='$d_accessx' +d_aintl='$d_aintl' +d_alarm='$d_alarm' +d_archlib='$d_archlib' +d_asctime64='$d_asctime64' +d_asctime_r='$d_asctime_r' +d_atolf='$d_atolf' +d_atoll='$d_atoll' +d_attribute_deprecated='$d_attribute_deprecated' +d_attribute_format='$d_attribute_format' +d_attribute_malloc='$d_attribute_malloc' +d_attribute_nonnull='$d_attribute_nonnull' +d_attribute_noreturn='$d_attribute_noreturn' +d_attribute_pure='$d_attribute_pure' +d_attribute_unused='$d_attribute_unused' +d_attribute_warn_unused_result='$d_attribute_warn_unused_result' +d_bcmp='$d_bcmp' +d_bcopy='$d_bcopy' +d_bsd='$d_bsd' +d_bsdgetpgrp='$d_bsdgetpgrp' +d_bsdsetpgrp='$d_bsdsetpgrp' +d_builtin_choose_expr='$d_builtin_choose_expr' +d_builtin_expect='$d_builtin_expect' +d_bzero='$d_bzero' +d_c99_variadic_macros='$d_c99_variadic_macros' +d_casti32='$d_casti32' +d_castneg='$d_castneg' +d_charvspr='$d_charvspr' +d_chown='$d_chown' +d_chroot='$d_chroot' +d_chsize='$d_chsize' +d_class='$d_class' +d_clearenv='$d_clearenv' +d_closedir='$d_closedir' +d_cmsghdr_s='$d_cmsghdr_s' +d_const='$d_const' +d_copysignl='$d_copysignl' +d_cplusplus='$d_cplusplus' +d_crypt='$d_crypt' +d_crypt_r='$d_crypt_r' +d_csh='$d_csh' +d_ctermid='$d_ctermid' +d_ctermid_r='$d_ctermid_r' +d_ctime64='$d_ctime64' +d_ctime_r='$d_ctime_r' +d_cuserid='$d_cuserid' +d_dbl_dig='$d_dbl_dig' +d_dbminitproto='$d_dbminitproto' +d_difftime64='$d_difftime64' +d_difftime='$d_difftime' +d_dir_dd_fd='$d_dir_dd_fd' +d_dirfd='$d_dirfd' +d_dirnamlen='$d_dirnamlen' +d_dlerror='$d_dlerror' +d_dlopen='$d_dlopen' +d_dlsymun='$d_dlsymun' +d_dosuid='$d_dosuid' +d_drand48_r='$d_drand48_r' +d_drand48proto='$d_drand48proto' +d_dup2='$d_dup2' +d_eaccess='$d_eaccess' +d_endgrent='$d_endgrent' +d_endgrent_r='$d_endgrent_r' +d_endhent='$d_endhent' +d_endhostent_r='$d_endhostent_r' +d_endnent='$d_endnent' +d_endnetent_r='$d_endnetent_r' +d_endpent='$d_endpent' +d_endprotoent_r='$d_endprotoent_r' +d_endpwent='$d_endpwent' +d_endpwent_r='$d_endpwent_r' +d_endsent='$d_endsent' +d_endservent_r='$d_endservent_r' +d_eofnblk='$d_eofnblk' +d_eunice='$d_eunice' +d_faststdio='$d_faststdio' +d_fchdir='$d_fchdir' +d_fchmod='$d_fchmod' +d_fchown='$d_fchown' +d_fcntl='$d_fcntl' +d_fcntl_can_lock='$d_fcntl_can_lock' +d_fd_macros='$d_fd_macros' +d_fd_set='$d_fd_set' +d_fds_bits='$d_fds_bits' +d_fgetpos='$d_fgetpos' +d_finite='$d_finite' +d_finitel='$d_finitel' +d_flexfnam='$d_flexfnam' +d_flock='$d_flock' +d_flockproto='$d_flockproto' +d_fork='$d_fork' +d_fp_class='$d_fp_class' +d_fpathconf='$d_fpathconf' +d_fpclass='$d_fpclass' +d_fpclassify='$d_fpclassify' +d_fpclassl='$d_fpclassl' +d_fpos64_t='$d_fpos64_t' +d_frexpl='$d_frexpl' +d_fs_data_s='$d_fs_data_s' +d_fseeko='$d_fseeko' +d_fsetpos='$d_fsetpos' +d_fstatfs='$d_fstatfs' +d_fstatvfs='$d_fstatvfs' +d_fsync='$d_fsync' +d_ftello='$d_ftello' +d_ftime='$d_ftime' +d_futimes='$d_futimes' +d_gdbm_ndbm_h_uses_prototypes='$d_gdbm_ndbm_h_uses_prototypes' +d_gdbmndbm_h_uses_prototypes='$d_gdbmndbm_h_uses_prototypes' +d_getaddrinfo='$d_getaddrinfo' +d_getcwd='$d_getcwd' +d_getespwnam='$d_getespwnam' +d_getfsstat='$d_getfsstat' +d_getgrent='$d_getgrent' +d_getgrent_r='$d_getgrent_r' +d_getgrgid_r='$d_getgrgid_r' +d_getgrnam_r='$d_getgrnam_r' +d_getgrps='$d_getgrps' +d_gethbyaddr='$d_gethbyaddr' +d_gethbyname='$d_gethbyname' +d_gethent='$d_gethent' +d_gethname='$d_gethname' +d_gethostbyaddr_r='$d_gethostbyaddr_r' +d_gethostbyname_r='$d_gethostbyname_r' +d_gethostent_r='$d_gethostent_r' +d_gethostprotos='$d_gethostprotos' +d_getitimer='$d_getitimer' +d_getlogin='$d_getlogin' +d_getlogin_r='$d_getlogin_r' +d_getmnt='$d_getmnt' +d_getmntent='$d_getmntent' +d_getnameinfo='$d_getnameinfo' +d_getnbyaddr='$d_getnbyaddr' +d_getnbyname='$d_getnbyname' +d_getnent='$d_getnent' +d_getnetbyaddr_r='$d_getnetbyaddr_r' +d_getnetbyname_r='$d_getnetbyname_r' +d_getnetent_r='$d_getnetent_r' +d_getnetprotos='$d_getnetprotos' +d_getpagsz='$d_getpagsz' +d_getpbyname='$d_getpbyname' +d_getpbynumber='$d_getpbynumber' +d_getpent='$d_getpent' +d_getpgid='$d_getpgid' +d_getpgrp2='$d_getpgrp2' +d_getpgrp='$d_getpgrp' +d_getppid='$d_getppid' +d_getprior='$d_getprior' +d_getprotobyname_r='$d_getprotobyname_r' +d_getprotobynumber_r='$d_getprotobynumber_r' +d_getprotoent_r='$d_getprotoent_r' +d_getprotoprotos='$d_getprotoprotos' +d_getprpwnam='$d_getprpwnam' +d_getpwent='$d_getpwent' +d_getpwent_r='$d_getpwent_r' +d_getpwnam_r='$d_getpwnam_r' +d_getpwuid_r='$d_getpwuid_r' +d_getsbyname='$d_getsbyname' +d_getsbyport='$d_getsbyport' +d_getsent='$d_getsent' +d_getservbyname_r='$d_getservbyname_r' +d_getservbyport_r='$d_getservbyport_r' +d_getservent_r='$d_getservent_r' +d_getservprotos='$d_getservprotos' +d_getspnam='$d_getspnam' +d_getspnam_r='$d_getspnam_r' +d_gettimeod='$d_gettimeod' +d_gmtime64='$d_gmtime64' +d_gmtime_r='$d_gmtime_r' +d_gnulibc='$d_gnulibc' +d_grpasswd='$d_grpasswd' +d_hasmntopt='$d_hasmntopt' +d_htonl='$d_htonl' +d_ilogbl='$d_ilogbl' +d_inc_version_list='$d_inc_version_list' +d_index='$d_index' +d_inetaton='$d_inetaton' +d_inetntop='$d_inetntop' +d_inetpton='$d_inetpton' +d_int64_t='$d_int64_t' +d_ipv6_mreq='$d_ipv6_mreq' +d_isascii='$d_isascii' +d_isblank='$d_isblank' +d_isfinite='$d_isfinite' +d_isinf='$d_isinf' +d_isnan='$d_isnan' +d_isnanl='$d_isnanl' +d_killpg='$d_killpg' +d_lchown='$d_lchown' +d_ldbl_dig='$d_ldbl_dig' +d_libm_lib_version='$d_libm_lib_version' +d_link='$d_link' +d_localtime64='$d_localtime64' +d_localtime_r='$d_localtime_r' +d_localtime_r_needs_tzset='$d_localtime_r_needs_tzset' +d_locconv='$d_locconv' +d_lockf='$d_lockf' +d_longdbl='$d_longdbl' +d_longlong='$d_longlong' +d_lseekproto='$d_lseekproto' +d_lstat='$d_lstat' +d_madvise='$d_madvise' +d_malloc_good_size='$d_malloc_good_size' +d_malloc_size='$d_malloc_size' +d_mblen='$d_mblen' +d_mbstowcs='$d_mbstowcs' +d_mbtowc='$d_mbtowc' +d_memchr='$d_memchr' +d_memcmp='$d_memcmp' +d_memcpy='$d_memcpy' +d_memmove='$d_memmove' +d_memset='$d_memset' +d_mkdir='$d_mkdir' +d_mkdtemp='$d_mkdtemp' +d_mkfifo='$d_mkfifo' +d_mkstemp='$d_mkstemp' +d_mkstemps='$d_mkstemps' +d_mktime64='$d_mktime64' +d_mktime='$d_mktime' +d_mmap='$d_mmap' +d_modfl='$d_modfl' +d_modfl_pow32_bug='$d_modfl_pow32_bug' +d_modflproto='$d_modflproto' +d_mprotect='$d_mprotect' +d_msg='$d_msg' +d_msg_ctrunc='$d_msg_ctrunc' +d_msg_dontroute='$d_msg_dontroute' +d_msg_oob='$d_msg_oob' +d_msg_peek='$d_msg_peek' +d_msg_proxy='$d_msg_proxy' +d_msgctl='$d_msgctl' +d_msgget='$d_msgget' +d_msghdr_s='$d_msghdr_s' +d_msgrcv='$d_msgrcv' +d_msgsnd='$d_msgsnd' +d_msync='$d_msync' +d_munmap='$d_munmap' +d_mymalloc='$d_mymalloc' +d_ndbm='$d_ndbm' +d_ndbm_h_uses_prototypes='$d_ndbm_h_uses_prototypes' +d_nice='$d_nice' +d_nl_langinfo='$d_nl_langinfo' +d_nv_preserves_uv='$d_nv_preserves_uv' +d_nv_zero_is_allbits_zero='$d_nv_zero_is_allbits_zero' +d_off64_t='$d_off64_t' +d_old_pthread_create_joinable='$d_old_pthread_create_joinable' +d_oldpthreads='$d_oldpthreads' +d_oldsock='$d_oldsock' +d_open3='$d_open3' +d_pathconf='$d_pathconf' +d_pause='$d_pause' +d_perl_otherlibdirs='$d_perl_otherlibdirs' +d_phostname='$d_phostname' +d_pipe='$d_pipe' +d_poll='$d_poll' +d_portable='$d_portable' +d_prctl='$d_prctl' +d_prctl_set_name='$d_prctl_set_name' +d_printf_format_null='$d_printf_format_null' +d_procselfexe='$d_procselfexe' +d_pseudofork='$d_pseudofork' +d_pthread_atfork='$d_pthread_atfork' +d_pthread_attr_setscope='$d_pthread_attr_setscope' +d_pthread_yield='$d_pthread_yield' +d_pwage='$d_pwage' +d_pwchange='$d_pwchange' +d_pwclass='$d_pwclass' +d_pwcomment='$d_pwcomment' +d_pwexpire='$d_pwexpire' +d_pwgecos='$d_pwgecos' +d_pwpasswd='$d_pwpasswd' +d_pwquota='$d_pwquota' +d_qgcvt='$d_qgcvt' +d_quad='$d_quad' +d_random_r='$d_random_r' +d_readdir64_r='$d_readdir64_r' +d_readdir='$d_readdir' +d_readdir_r='$d_readdir_r' +d_readlink='$d_readlink' +d_readv='$d_readv' +d_recvmsg='$d_recvmsg' +d_rename='$d_rename' +d_rewinddir='$d_rewinddir' +d_rmdir='$d_rmdir' +d_safebcpy='$d_safebcpy' +d_safemcpy='$d_safemcpy' +d_sanemcmp='$d_sanemcmp' +d_sbrkproto='$d_sbrkproto' +d_scalbnl='$d_scalbnl' +d_sched_yield='$d_sched_yield' +d_scm_rights='$d_scm_rights' +d_seekdir='$d_seekdir' +d_select='$d_select' +d_sem='$d_sem' +d_semctl='$d_semctl' +d_semctl_semid_ds='$d_semctl_semid_ds' +d_semctl_semun='$d_semctl_semun' +d_semget='$d_semget' +d_semop='$d_semop' +d_sendmsg='$d_sendmsg' +d_setegid='$d_setegid' +d_seteuid='$d_seteuid' +d_setgrent='$d_setgrent' +d_setgrent_r='$d_setgrent_r' +d_setgrps='$d_setgrps' +d_sethent='$d_sethent' +d_sethostent_r='$d_sethostent_r' +d_setitimer='$d_setitimer' +d_setlinebuf='$d_setlinebuf' +d_setlocale='$d_setlocale' +d_setlocale_r='$d_setlocale_r' +d_setnent='$d_setnent' +d_setnetent_r='$d_setnetent_r' +d_setpent='$d_setpent' +d_setpgid='$d_setpgid' +d_setpgrp2='$d_setpgrp2' +d_setpgrp='$d_setpgrp' +d_setprior='$d_setprior' +d_setproctitle='$d_setproctitle' +d_setprotoent_r='$d_setprotoent_r' +d_setpwent='$d_setpwent' +d_setpwent_r='$d_setpwent_r' +d_setregid='$d_setregid' +d_setresgid='$d_setresgid' +d_setresuid='$d_setresuid' +d_setreuid='$d_setreuid' +d_setrgid='$d_setrgid' +d_setruid='$d_setruid' +d_setsent='$d_setsent' +d_setservent_r='$d_setservent_r' +d_setsid='$d_setsid' +d_setvbuf='$d_setvbuf' +d_sfio='$d_sfio' +d_shm='$d_shm' +d_shmat='$d_shmat' +d_shmatprototype='$d_shmatprototype' +d_shmctl='$d_shmctl' +d_shmdt='$d_shmdt' +d_shmget='$d_shmget' +d_sigaction='$d_sigaction' +d_signbit='$d_signbit' +d_sigprocmask='$d_sigprocmask' +d_sigsetjmp='$d_sigsetjmp' +d_sin6_scope_id='$d_sin6_scope_id' +d_sitearch='$d_sitearch' +d_snprintf='$d_snprintf' +d_sockaddr_in6='$d_sockaddr_in6' +d_sockaddr_sa_len='$d_sockaddr_sa_len' +d_sockatmark='$d_sockatmark' +d_sockatmarkproto='$d_sockatmarkproto' +d_socket='$d_socket' +d_socklen_t='$d_socklen_t' +d_sockpair='$d_sockpair' +d_socks5_init='$d_socks5_init' +d_sprintf_returns_strlen='$d_sprintf_returns_strlen' +d_sqrtl='$d_sqrtl' +d_srand48_r='$d_srand48_r' +d_srandom_r='$d_srandom_r' +d_sresgproto='$d_sresgproto' +d_sresuproto='$d_sresuproto' +d_statblks='$d_statblks' +d_statfs_f_flags='$d_statfs_f_flags' +d_statfs_s='$d_statfs_s' +d_static_inline='$d_static_inline' +d_statvfs='$d_statvfs' +d_stdio_cnt_lval='$d_stdio_cnt_lval' +d_stdio_ptr_lval='$d_stdio_ptr_lval' +d_stdio_ptr_lval_nochange_cnt='$d_stdio_ptr_lval_nochange_cnt' +d_stdio_ptr_lval_sets_cnt='$d_stdio_ptr_lval_sets_cnt' +d_stdio_stream_array='$d_stdio_stream_array' +d_stdiobase='$d_stdiobase' +d_stdstdio='$d_stdstdio' +d_strchr='$d_strchr' +d_strcoll='$d_strcoll' +d_strctcpy='$d_strctcpy' +d_strerrm='$d_strerrm' +d_strerror='$d_strerror' +d_strerror_r='$d_strerror_r' +d_strftime='$d_strftime' +d_strlcat='$d_strlcat' +d_strlcpy='$d_strlcpy' +d_strtod='$d_strtod' +d_strtol='$d_strtol' +d_strtold='$d_strtold' +d_strtoll='$d_strtoll' +d_strtoq='$d_strtoq' +d_strtoul='$d_strtoul' +d_strtoull='$d_strtoull' +d_strtouq='$d_strtouq' +d_strxfrm='$d_strxfrm' +d_suidsafe='$d_suidsafe' +d_symlink='$d_symlink' +d_syscall='$d_syscall' +d_syscallproto='$d_syscallproto' +d_sysconf='$d_sysconf' +d_sysernlst='$d_sysernlst' +d_syserrlst='$d_syserrlst' +d_system='$d_system' +d_tcgetpgrp='$d_tcgetpgrp' +d_tcsetpgrp='$d_tcsetpgrp' +d_telldir='$d_telldir' +d_telldirproto='$d_telldirproto' +d_time='$d_time' +d_timegm='$d_timegm' +d_times='$d_times' +d_tm_tm_gmtoff='$d_tm_tm_gmtoff' +d_tm_tm_zone='$d_tm_tm_zone' +d_tmpnam_r='$d_tmpnam_r' +d_truncate='$d_truncate' +d_ttyname_r='$d_ttyname_r' +d_tzname='$d_tzname' +d_u32align='$d_u32align' +d_ualarm='$d_ualarm' +d_umask='$d_umask' +d_uname='$d_uname' +d_union_semun='$d_union_semun' +d_unordered='$d_unordered' +d_unsetenv='$d_unsetenv' +d_usleep='$d_usleep' +d_usleepproto='$d_usleepproto' +d_ustat='$d_ustat' +d_vendorarch='$d_vendorarch' +d_vendorbin='$d_vendorbin' +d_vendorlib='$d_vendorlib' +d_vendorscript='$d_vendorscript' +d_vfork='$d_vfork' +d_void_closedir='$d_void_closedir' +d_voidsig='$d_voidsig' +d_voidtty='$d_voidtty' +d_volatile='$d_volatile' +d_vprintf='$d_vprintf' +d_vsnprintf='$d_vsnprintf' +d_wait4='$d_wait4' +d_waitpid='$d_waitpid' +d_wcstombs='$d_wcstombs' +d_wctomb='$d_wctomb' +d_writev='$d_writev' +d_xenix='$d_xenix' +date='$date' +db_hashtype='$db_hashtype' +db_prefixtype='$db_prefixtype' +db_version_major='$db_version_major' +db_version_minor='$db_version_minor' +db_version_patch='$db_version_patch' +defvoidused='$defvoidused' +direntrytype='$direntrytype' +dlext='$dlext' +dlsrc='$dlsrc' +doublesize='$doublesize' +drand01='$drand01' +drand48_r_proto='$drand48_r_proto' +dtrace='$dtrace' +dynamic_ext='$dynamic_ext' +eagain='$eagain' +ebcdic='$ebcdic' +echo='$echo' +egrep='$egrep' +emacs='$emacs' +endgrent_r_proto='$endgrent_r_proto' +endhostent_r_proto='$endhostent_r_proto' +endnetent_r_proto='$endnetent_r_proto' +endprotoent_r_proto='$endprotoent_r_proto' +endpwent_r_proto='$endpwent_r_proto' +endservent_r_proto='$endservent_r_proto' +eunicefix='$eunicefix' +exe_ext='$exe_ext' +expr='$expr' +extensions='$extensions' +extern_C='$extern_C' +extras='$extras' +fflushNULL='$fflushNULL' +fflushall='$fflushall' +find='$find' +firstmakefile='$firstmakefile' +flex='$flex' +fpossize='$fpossize' +fpostype='$fpostype' +freetype='$freetype' +from='$from' +full_ar='$full_ar' +full_csh='$full_csh' +full_sed='$full_sed' +gccansipedantic='$gccansipedantic' +gccosandvers='$gccosandvers' +gccversion='$gccversion' +getgrent_r_proto='$getgrent_r_proto' +getgrgid_r_proto='$getgrgid_r_proto' +getgrnam_r_proto='$getgrnam_r_proto' +gethostbyaddr_r_proto='$gethostbyaddr_r_proto' +gethostbyname_r_proto='$gethostbyname_r_proto' +gethostent_r_proto='$gethostent_r_proto' +getlogin_r_proto='$getlogin_r_proto' +getnetbyaddr_r_proto='$getnetbyaddr_r_proto' +getnetbyname_r_proto='$getnetbyname_r_proto' +getnetent_r_proto='$getnetent_r_proto' +getprotobyname_r_proto='$getprotobyname_r_proto' +getprotobynumber_r_proto='$getprotobynumber_r_proto' +getprotoent_r_proto='$getprotoent_r_proto' +getpwent_r_proto='$getpwent_r_proto' +getpwnam_r_proto='$getpwnam_r_proto' +getpwuid_r_proto='$getpwuid_r_proto' +getservbyname_r_proto='$getservbyname_r_proto' +getservbyport_r_proto='$getservbyport_r_proto' +getservent_r_proto='$getservent_r_proto' +getspnam_r_proto='$getspnam_r_proto' +gidformat='$gidformat' +gidsign='$gidsign' +gidsize='$gidsize' +gidtype='$gidtype' +glibpth='$glibpth' +gmake='$gmake' +gmtime_r_proto='$gmtime_r_proto' +gnulibc_version='$gnulibc_version' +grep='$grep' +groupcat='$groupcat' +groupstype='$groupstype' +gzip='$gzip' +h_fcntl='$h_fcntl' +h_sysfile='$h_sysfile' +hint='$hint' +hostcat='$hostcat' +html1dir='$html1dir' +html1direxp='$html1direxp' +html3dir='$html3dir' +html3direxp='$html3direxp' +i16size='$i16size' +i16type='$i16type' +i32size='$i32size' +i32type='$i32type' +i64size='$i64size' +i64type='$i64type' +i8size='$i8size' +i8type='$i8type' +i_arpainet='$i_arpainet' +i_assert='$i_assert' +i_bsdioctl='$i_bsdioctl' +i_crypt='$i_crypt' +i_db='$i_db' +i_dbm='$i_dbm' +i_dirent='$i_dirent' +i_dld='$i_dld' +i_dlfcn='$i_dlfcn' +i_fcntl='$i_fcntl' +i_float='$i_float' +i_fp='$i_fp' +i_fp_class='$i_fp_class' +i_gdbm='$i_gdbm' +i_gdbm_ndbm='$i_gdbm_ndbm' +i_gdbmndbm='$i_gdbmndbm' +i_grp='$i_grp' +i_ieeefp='$i_ieeefp' +i_inttypes='$i_inttypes' +i_langinfo='$i_langinfo' +i_libutil='$i_libutil' +i_limits='$i_limits' +i_locale='$i_locale' +i_machcthr='$i_machcthr' +i_malloc='$i_malloc' +i_mallocmalloc='$i_mallocmalloc' +i_math='$i_math' +i_memory='$i_memory' +i_mntent='$i_mntent' +i_ndbm='$i_ndbm' +i_netdb='$i_netdb' +i_neterrno='$i_neterrno' +i_netinettcp='$i_netinettcp' +i_niin='$i_niin' +i_poll='$i_poll' +i_prot='$i_prot' +i_pthread='$i_pthread' +i_pwd='$i_pwd' +i_rpcsvcdbm='$i_rpcsvcdbm' +i_sfio='$i_sfio' +i_sgtty='$i_sgtty' +i_shadow='$i_shadow' +i_socks='$i_socks' +i_stdarg='$i_stdarg' +i_stdbool='$i_stdbool' +i_stddef='$i_stddef' +i_stdlib='$i_stdlib' +i_string='$i_string' +i_sunmath='$i_sunmath' +i_sysaccess='$i_sysaccess' +i_sysdir='$i_sysdir' +i_sysfile='$i_sysfile' +i_sysfilio='$i_sysfilio' +i_sysin='$i_sysin' +i_sysioctl='$i_sysioctl' +i_syslog='$i_syslog' +i_sysmman='$i_sysmman' +i_sysmode='$i_sysmode' +i_sysmount='$i_sysmount' +i_sysndir='$i_sysndir' +i_sysparam='$i_sysparam' +i_syspoll='$i_syspoll' +i_sysresrc='$i_sysresrc' +i_syssecrt='$i_syssecrt' +i_sysselct='$i_sysselct' +i_syssockio='$i_syssockio' +i_sysstat='$i_sysstat' +i_sysstatfs='$i_sysstatfs' +i_sysstatvfs='$i_sysstatvfs' +i_systime='$i_systime' +i_systimek='$i_systimek' +i_systimes='$i_systimes' +i_systypes='$i_systypes' +i_sysuio='$i_sysuio' +i_sysun='$i_sysun' +i_sysutsname='$i_sysutsname' +i_sysvfs='$i_sysvfs' +i_syswait='$i_syswait' +i_termio='$i_termio' +i_termios='$i_termios' +i_time='$i_time' +i_unistd='$i_unistd' +i_ustat='$i_ustat' +i_utime='$i_utime' +i_values='$i_values' +i_varargs='$i_varargs' +i_varhdr='$i_varhdr' +i_vfork='$i_vfork' +ignore_versioned_solibs='$ignore_versioned_solibs' +inc_version_list='$inc_version_list' +inc_version_list_init='$inc_version_list_init' +incpath='$incpath' +inews='$inews' +initialinstalllocation='$initialinstalllocation' +installarchlib='$installarchlib' +installbin='$installbin' +installhtml1dir='$installhtml1dir' +installhtml3dir='$installhtml3dir' +installman1dir='$installman1dir' +installman3dir='$installman3dir' +installprefix='$installprefix' +installprefixexp='$installprefixexp' +installprivlib='$installprivlib' +installscript='$installscript' +installsitearch='$installsitearch' +installsitebin='$installsitebin' +installsitehtml1dir='$installsitehtml1dir' +installsitehtml3dir='$installsitehtml3dir' +installsitelib='$installsitelib' +installsiteman1dir='$installsiteman1dir' +installsiteman3dir='$installsiteman3dir' +installsitescript='$installsitescript' +installstyle='$installstyle' +installusrbinperl='$installusrbinperl' +installvendorarch='$installvendorarch' +installvendorbin='$installvendorbin' +installvendorhtml1dir='$installvendorhtml1dir' +installvendorhtml3dir='$installvendorhtml3dir' +installvendorlib='$installvendorlib' +installvendorman1dir='$installvendorman1dir' +installvendorman3dir='$installvendorman3dir' +installvendorscript='$installvendorscript' +intsize='$intsize' +issymlink='$issymlink' +ivdformat='$ivdformat' +ivsize='$ivsize' +ivtype='$ivtype' +known_extensions='$known_extensions' +ksh='$ksh' +ld='$ld' +ld_can_script='$ld_can_script' +lddlflags='$lddlflags' +ldflags='$ldflags' +ldflags_uselargefiles='$ldflags_uselargefiles' +ldlibpthname='$ldlibpthname' +less='$less' +lib_ext='$lib_ext' +libc='$libc' +libperl='$libperl' +libpth='$libpth' +libs='$libs' +libsdirs='$libsdirs' +libsfiles='$libsfiles' +libsfound='$libsfound' +libspath='$libspath' +libswanted='$libswanted' +libswanted_uselargefiles='$libswanted_uselargefiles' +line='$line' +lint='$lint' +lkflags='$lkflags' +ln='$ln' +lns='$lns' +localtime_r_proto='$localtime_r_proto' +locincpth='$locincpth' +loclibpth='$loclibpth' +longdblsize='$longdblsize' +longlongsize='$longlongsize' +longsize='$longsize' +lp='$lp' +lpr='$lpr' +ls='$ls' +lseeksize='$lseeksize' +lseektype='$lseektype' +mad='$mad' +madlyh='$madlyh' +madlyobj='$madlyobj' +madlysrc='$madlysrc' +mail='$mail' +mailx='$mailx' +make='$make' +make_set_make='$make_set_make' +mallocobj='$mallocobj' +mallocsrc='$mallocsrc' +malloctype='$malloctype' +man1dir='$man1dir' +man1direxp='$man1direxp' +man1ext='$man1ext' +man3dir='$man3dir' +man3direxp='$man3direxp' +man3ext='$man3ext' +mips_type='$mips_type' +mistrustnm='$mistrustnm' +mkdir='$mkdir' +mmaptype='$mmaptype' +modetype='$modetype' +more='$more' +multiarch='$multiarch' +mv='$mv' +myarchname='$myarchname' +mydomain='$mydomain' +myhostname='$myhostname' +myuname='$myuname' +n='$n' +need_va_copy='$need_va_copy' +netdb_hlen_type='$netdb_hlen_type' +netdb_host_type='$netdb_host_type' +netdb_name_type='$netdb_name_type' +netdb_net_type='$netdb_net_type' +nm='$nm' +nm_opt='$nm_opt' +nm_so_opt='$nm_so_opt' +nonxs_ext='$nonxs_ext' +nroff='$nroff' +nvEUformat='$nvEUformat' +nvFUformat='$nvFUformat' +nvGUformat='$nvGUformat' +nv_overflows_integers_at='$nv_overflows_integers_at' +nv_preserves_uv_bits='$nv_preserves_uv_bits' +nveformat='$nveformat' +nvfformat='$nvfformat' +nvgformat='$nvgformat' +nvsize='$nvsize' +nvtype='$nvtype' +o_nonblock='$o_nonblock' +obj_ext='$obj_ext' +old_pthread_create_joinable='$old_pthread_create_joinable' +optimize='$optimize' +orderlib='$orderlib' +osname='$osname' +osvers='$osvers' +otherlibdirs='$otherlibdirs' +package='$package' +pager='$pager' +passcat='$passcat' +patchlevel='$patchlevel' +path_sep='$path_sep' +perl5='$perl5' +perl='$perl' +perl_patchlevel='$perl_patchlevel' +perl_static_inline='$perl_static_inline' +perladmin='$perladmin' +perllibs='$perllibs' +perlpath='$perlpath' +pg='$pg' +phostname='$phostname' +pidtype='$pidtype' +plibpth='$plibpth' +pmake='$pmake' +pr='$pr' +prefix='$prefix' +prefixexp='$prefixexp' +privlib='$privlib' +privlibexp='$privlibexp' +procselfexe='$procselfexe' +prototype='$prototype' +ptrsize='$ptrsize' +quadkind='$quadkind' +quadtype='$quadtype' +randbits='$randbits' +randfunc='$randfunc' +random_r_proto='$random_r_proto' +randseedtype='$randseedtype' +ranlib='$ranlib' +rd_nodata='$rd_nodata' +readdir64_r_proto='$readdir64_r_proto' +readdir_r_proto='$readdir_r_proto' +revision='$revision' +rm='$rm' +rm_try='$rm_try' +rmail='$rmail' +run='$run' +runnm='$runnm' +sGMTIME_max='$sGMTIME_max' +sGMTIME_min='$sGMTIME_min' +sLOCALTIME_max='$sLOCALTIME_max' +sLOCALTIME_min='$sLOCALTIME_min' +sPRIEUldbl='$sPRIEUldbl' +sPRIFUldbl='$sPRIFUldbl' +sPRIGUldbl='$sPRIGUldbl' +sPRIXU64='$sPRIXU64' +sPRId64='$sPRId64' +sPRIeldbl='$sPRIeldbl' +sPRIfldbl='$sPRIfldbl' +sPRIgldbl='$sPRIgldbl' +sPRIi64='$sPRIi64' +sPRIo64='$sPRIo64' +sPRIu64='$sPRIu64' +sPRIx64='$sPRIx64' +sSCNfldbl='$sSCNfldbl' +sched_yield='$sched_yield' +scriptdir='$scriptdir' +scriptdirexp='$scriptdirexp' +sed='$sed' +seedfunc='$seedfunc' +selectminbits='$selectminbits' +selecttype='$selecttype' +sendmail='$sendmail' +setgrent_r_proto='$setgrent_r_proto' +sethostent_r_proto='$sethostent_r_proto' +setlocale_r_proto='$setlocale_r_proto' +setnetent_r_proto='$setnetent_r_proto' +setprotoent_r_proto='$setprotoent_r_proto' +setpwent_r_proto='$setpwent_r_proto' +setservent_r_proto='$setservent_r_proto' +sh='$sh' +shar='$shar' +sharpbang='$sharpbang' +shmattype='$shmattype' +shortsize='$shortsize' +shrpenv='$shrpenv' +shsharp='$shsharp' +sig_count='$sig_count' +sig_name='$sig_name' +sig_name_init='$sig_name_init' +sig_num='$sig_num' +sig_num_init='$sig_num_init' +sig_size='$sig_size' +signal_t='$signal_t' +sitearch='$sitearch' +sitearchexp='$sitearchexp' +sitebin='$sitebin' +sitebinexp='$sitebinexp' +sitehtml1dir='$sitehtml1dir' +sitehtml1direxp='$sitehtml1direxp' +sitehtml3dir='$sitehtml3dir' +sitehtml3direxp='$sitehtml3direxp' +sitelib='$sitelib' +sitelib_stem='$sitelib_stem' +sitelibexp='$sitelibexp' +siteman1dir='$siteman1dir' +siteman1direxp='$siteman1direxp' +siteman3dir='$siteman3dir' +siteman3direxp='$siteman3direxp' +siteprefix='$siteprefix' +siteprefixexp='$siteprefixexp' +sitescript='$sitescript' +sitescriptexp='$sitescriptexp' +sizesize='$sizesize' +sizetype='$sizetype' +sleep='$sleep' +smail='$smail' +so='$so' +sockethdr='$sockethdr' +socketlib='$socketlib' +socksizetype='$socksizetype' +sort='$sort' +spackage='$spackage' +spitshell='$spitshell' +srand48_r_proto='$srand48_r_proto' +srandom_r_proto='$srandom_r_proto' +src='$src' +ssizetype='$ssizetype' +st_ino_sign='$st_ino_sign' +st_ino_size='$st_ino_size' +startperl='$startperl' +startsh='$startsh' +static_ext='$static_ext' +stdchar='$stdchar' +stdio_base='$stdio_base' +stdio_bufsiz='$stdio_bufsiz' +stdio_cnt='$stdio_cnt' +stdio_filbuf='$stdio_filbuf' +stdio_ptr='$stdio_ptr' +stdio_stream_array='$stdio_stream_array' +strerror_r_proto='$strerror_r_proto' +strings='$strings' +submit='$submit' +subversion='$subversion' +sysman='$sysman' +tail='$tail' +tar='$tar' +targetarch='$targetarch' +tbl='$tbl' +tee='$tee' +test='$test' +timeincl='$timeincl' +timetype='$timetype' +tmpnam_r_proto='$tmpnam_r_proto' +to='$to' +touch='$touch' +tr='$tr' +trnl='$trnl' +troff='$troff' +ttyname_r_proto='$ttyname_r_proto' +u16size='$u16size' +u16type='$u16type' +u32size='$u32size' +u32type='$u32type' +u64size='$u64size' +u64type='$u64type' +u8size='$u8size' +u8type='$u8type' +uidformat='$uidformat' +uidsign='$uidsign' +uidsize='$uidsize' +uidtype='$uidtype' +uname='$uname' +uniq='$uniq' +uquadtype='$uquadtype' +use5005threads='$use5005threads' +use64bitall='$use64bitall' +use64bitint='$use64bitint' +usecrosscompile='$usecrosscompile' +usedevel='$usedevel' +usedl='$usedl' +usedtrace='$usedtrace' +usefaststdio='$usefaststdio' +useithreads='$useithreads' +usekernprocpathname='$usekernprocpathname' +uselargefiles='$uselargefiles' +uselongdouble='$uselongdouble' +usemallocwrap='$usemallocwrap' +usemorebits='$usemorebits' +usemultiplicity='$usemultiplicity' +usemymalloc='$usemymalloc' +usenm='$usenm' +usensgetexecutablepath='$usensgetexecutablepath' +useopcode='$useopcode' +useperlio='$useperlio' +useposix='$useposix' +usereentrant='$usereentrant' +userelocatableinc='$userelocatableinc' +usesfio='$usesfio' +useshrplib='$useshrplib' +usesitecustomize='$usesitecustomize' +usesocks='$usesocks' +usethreads='$usethreads' +usevendorprefix='$usevendorprefix' +usevfork='$usevfork' +usrinc='$usrinc' +uuname='$uuname' +uvXUformat='$uvXUformat' +uvoformat='$uvoformat' +uvsize='$uvsize' +uvtype='$uvtype' +uvuformat='$uvuformat' +uvxformat='$uvxformat' +vaproto='$vaproto' +vendorarch='$vendorarch' +vendorarchexp='$vendorarchexp' +vendorbin='$vendorbin' +vendorbinexp='$vendorbinexp' +vendorhtml1dir='$vendorhtml1dir' +vendorhtml1direxp='$vendorhtml1direxp' +vendorhtml3dir='$vendorhtml3dir' +vendorhtml3direxp='$vendorhtml3direxp' +vendorlib='$vendorlib' +vendorlib_stem='$vendorlib_stem' +vendorlibexp='$vendorlibexp' +vendorman1dir='$vendorman1dir' +vendorman1direxp='$vendorman1direxp' +vendorman3dir='$vendorman3dir' +vendorman3direxp='$vendorman3direxp' +vendorprefix='$vendorprefix' +vendorprefixexp='$vendorprefixexp' +vendorscript='$vendorscript' +vendorscriptexp='$vendorscriptexp' +version='$version' +version_patchlevel_string='$version_patchlevel_string' +versiononly='$versiononly' +vi='$vi' +voidflags='$voidflags' +xlibpth='$xlibpth' +yacc='$yacc' +yaccflags='$yaccflags' +zcat='$zcat' +zip='$zip' +EOT + +: add special variables +$test -f $src/patchlevel.h && \ +awk '/^#define[ ]+PERL_/ {printf "%s=%s\n",$2,$3}' $src/patchlevel.h >>config.sh +echo "PERL_PATCHLEVEL='$perl_patchlevel'" >>config.sh +echo "PERL_CONFIG_SH=true" >>config.sh + +: propagate old symbols +if $test -f UU/config.sh; then + UU/oldconfig.sh + $sed -n 's/^\([a-zA-Z_0-9]*\)=.*/\1/p' \ + config.sh config.sh UU/oldconfig.sh |\ + $sort | $uniq -u >UU/oldsyms + set X `$cat UU/oldsyms` + shift + case $# in + 0) ;; + *) + $cat <>config.sh + for sym in `$cat UU/oldsyms`; do + echo " Propagating $hint variable "'$'"$sym..." + eval 'tmp="$'"${sym}"'"' + echo "$tmp" | \ + sed -e "s/'/'\"'\"'/g" -e "s/^/$sym='/" -e "s/$/'/" >>config.sh + done + ;; + esac +fi + +: Finish up by extracting the .SH files +case "$alldone" in +exit) + $rm -rf UU + echo "Extraction done." + exit 0 + ;; +cont) + ;; +'') + dflt='' + nostick=true + $cat <&4 -c "$ans";; + esac + ;; +esac + +: if this fails, just run all the .SH files by hand +. ./config.sh + +echo " " +exec 1>&4 +pwd=`pwd` +. ./UU/extract +cd "$pwd" + +if $contains '^depend:' [Mm]akefile >/dev/null 2>&1; then + dflt=y + case "$silent" in + true) ;; + *) + $cat < makedepend.out &" +It can take a while, so you might not want to run it right now. + +EOM + ;; + esac + rp="Run $make depend now?" + . UU/myread + case "$ans" in + y*) + $make depend && echo "Now you must run '$make'." + ;; + *) + echo "You must run '$make depend' then '$make'." + ;; + esac +elif test -f [Mm]akefile; then + echo " " + echo "Now you must run a $make." +else + echo "Configure done." +fi + +if $test -f Policy.sh; then + $cat <&4 + $rm -f config.msg +fi +$rm -f kit*isdone ark*isdone +$rm -rf UU + +: End of Configure +