X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/506faf56dfc5fbabb52996eac45fa2d064bcf4ba..3ca7705ebd432c2fb3599731fec8760f14fddd0f:/Configure diff --git a/Configure b/Configure index 21cf09e..fa59b5f 100755 --- a/Configure +++ b/Configure @@ -20,7 +20,7 @@ # $Id: Head.U,v 3.0.1.9 1997/02/28 15:02:09 ram Exp $ # -# Generated on Fri Mar 1 20:03:36 EET 2002 [metaconfig 3.0 PL70] +# Generated on Thu May 16 17:03:39 EET DST 2002 [metaconfig 3.0 PL70] # (with additional metaconfig patches by perlbug@perl.org) cat >c1$$ </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'. @@ -2288,7 +2390,16 @@ EOM fi fi case "$ans" in - [yY]*) cc=gcc; ccname=gcc; ccflags=''; despair=no ;; + [yY]*) cc=gcc; ccname=gcc; ccflags=''; despair=no; + if $test -f usethreads.cbu; then + $cat >&4 <&4 -case "$voidflags" in -'') - $cat >try.c <<'EOCP' -#if TRY & 1 -void sub() { -#else -sub() { -#endif - extern void moo(); /* function returning void */ - void (*goo)(); /* ptr to func returning void */ -#if TRY & 8 - void *hue; /* generic ptr */ -#endif -#if TRY & 2 - void (*foo[10])(); -#endif - -#if TRY & 4 - if(goo == moo) { - exit(0); - } -#endif - exit(0); -} -int main() { sub(); } -EOCP - if $cc $ccflags -c -DTRY=$defvoidused try.c >.out 2>&1 ; then - voidflags=$defvoidused - echo "Good. It appears to support void to the level $package wants.">&4 - if $contains warning .out >/dev/null 2>&1; then - echo "However, you might get some warnings that look like this:" - $cat .out - fi - else -echo "Hmm, your compiler has some difficulty with void. Checking further..." >&4 - if $cc $ccflags -c -DTRY=1 try.c >/dev/null 2>&1; then - echo "It supports 1..." - if $cc $ccflags -c -DTRY=3 try.c >/dev/null 2>&1; then - echo "It also supports 2..." - if $cc $ccflags -c -DTRY=7 try.c >/dev/null 2>&1; then - voidflags=7 - echo "And it supports 4 but not 8 definitely." - else - echo "It doesn't support 4..." - if $cc $ccflags -c -DTRY=11 try.c >/dev/null 2>&1; then - voidflags=11 - echo "But it supports 8." - else - voidflags=3 - echo "Neither does it support 8." - fi - fi - else - echo "It does not support 2..." - if $cc $ccflags -c -DTRY=13 try.c >/dev/null 2>&1; then - voidflags=13 - echo "But it supports 4 and 8." - else - if $cc $ccflags -c -DTRY=5 try.c >/dev/null 2>&1; then - voidflags=5 - echo "And it supports 4 but has not heard about 8." - else - echo "However it supports 8 but not 4." - fi - fi - fi - else - echo "There is no support at all for void." - voidflags=0 - fi - fi -esac -case "$voidflags" in -"$defvoidused") ;; -*) $cat >&4 <<'EOM' - Support flag bits are: - 1: basic void declarations. - 2: arrays of pointers to functions returning void. - 4: operations between pointers to and addresses of void functions. - 8: generic void pointers. -EOM - dflt="$voidflags"; - rp="Your void support flags add up to what?" - . ./myread - voidflags="$ans" - ;; -esac -$rm -f try.* .out - -: 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 <<'EOCP' -#include -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 -f try.c try - : check for long long echo " " echo "Checking to see if you have long long..." >&4 @@ -5260,31 +5252,6 @@ EOM ;; esac -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, disabling maximal 64-bitness. - -EOM - use64bitall="$undef" - case "$use64bitint" in - "$define"|true|[yY]*) ;; - *) cat <&4 - -*** Downgrading from maximal 64-bitness to using 64-bit integers. - -EOM - use64bitint="$define" - ;; - esac - ;; - esac - ;; -esac - case "$use64bitint" in "$define"|true|[yY]*) : Look for a hint-file generated 'call-back-unit'. If the @@ -5595,7 +5562,7 @@ 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' +xrun='eval "libc.list"; echo "done." >&4' xxx='[ADTSIW]' if com="$sed -n -e 's/__IO//' -e 's/^.* $xxx *_[_.]*//p' -e 's/^.* $xxx *//p'";\ eval $xscan;\ @@ -6529,45 +6496,6 @@ else installarchlib="$archlibexp" fi - -: Binary compatibility with 5.005 is not possible for builds -: with advanced features -case "$usethreads$usemultiplicity" in -*define*) - bincompat5005="$undef" - d_bincompat5005="$undef" - ;; -*) $cat <&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 +: check for void type echo " " -$cat >malloc.c < -#include -#ifdef I_MALLOC -#include +echo "Checking to see how well your C compiler groks the void type..." >&4 +case "$voidflags" in +'') + $cat >try.c <<'EOCP' +#if TRY & 1 +void sub() { +#else +sub() { #endif -#ifdef I_STDLIB -#include + extern void moo(); /* function returning void */ + void (*goo)(); /* ptr to func returning void */ +#if TRY & 8 + void *hue; /* generic ptr */ #endif -#ifdef TRY_MALLOC -void *malloc(); +#if TRY & 2 + void (*foo[10])(); #endif -#ifdef TRY_FREE -void free(); + +#if TRY & 4 + if(goo == moo) { + exit(0); + } #endif -END -case "$malloctype" in -'') - if $cc $ccflags -c -DTRY_MALLOC malloc.c >/dev/null 2>&1; then - malloctype='void *' + exit(0); +} +int main() { sub(); } +EOCP + if $cc $ccflags -c -DTRY=$defvoidused try.c >.out 2>&1 ; then + voidflags=$defvoidused + echo "Good. It appears to support void to the level $package wants.">&4 + if $contains warning .out >/dev/null 2>&1; then + echo "However, you might get some warnings that look like this:" + $cat .out + fi + else +echo "Hmm, your compiler has some difficulty with void. Checking further..." >&4 + if $cc $ccflags -c -DTRY=1 try.c >/dev/null 2>&1; then + echo "It supports 1..." + if $cc $ccflags -c -DTRY=3 try.c >/dev/null 2>&1; then + echo "It also supports 2..." + if $cc $ccflags -c -DTRY=7 try.c >/dev/null 2>&1; then + voidflags=7 + echo "And it supports 4 but not 8 definitely." + else + echo "It doesn't support 4..." + if $cc $ccflags -c -DTRY=11 try.c >/dev/null 2>&1; then + voidflags=11 + echo "But it supports 8." + else + voidflags=3 + echo "Neither does it support 8." + fi + fi + else + echo "It does not support 2..." + if $cc $ccflags -c -DTRY=13 try.c >/dev/null 2>&1; then + voidflags=13 + echo "But it supports 4 and 8." + else + if $cc $ccflags -c -DTRY=5 try.c >/dev/null 2>&1; then + voidflags=5 + echo "And it supports 4 but has not heard about 8." + else + echo "However it supports 8 but not 4." + fi + fi + fi + else + echo "There is no support at all for void." + voidflags=0 + fi + fi +esac +case "$voidflags" in +"$defvoidused") ;; +*) $cat >&4 <<'EOM' + Support flag bits are: + 1: basic void declarations. + 2: arrays of pointers to functions returning void. + 4: operations between pointers to and addresses of void functions. + 8: generic void pointers. +EOM + dflt="$voidflags"; + rp="Your void support flags add up to what?" + . ./myread + voidflags="$ans" + ;; +esac +$rm -f try.* .out + +: 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 <<'EOCP' +#include +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 -f try.c 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, disabling maximal 64-bitness. + +EOM + use64bitall="$undef" + case "$use64bitint" in + "$define"|true|[yY]*) ;; + *) cat <&4 + +*** Downgrading from maximal 64-bitness to using 64-bit integers. + +EOM + use64bitint="$define" + ;; + esac + ;; + esac + ;; +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 + ;; +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 @@ -7224,11 +7302,7 @@ case "$dflt" in ''|' ') dflt=none ;; esac case "$dflt" in -5.005) case "$bincompat5005" in - $define|true|[yY]*) ;; - *) dflt=none ;; - esac - ;; +5.005) dflt=none ;; esac $cat <<'EOM' @@ -8283,6 +8357,12 @@ esac set versiononly eval $setvar +case "$versiononly" in +"$define") inc_version_list='' + inc_version_list_init=0 + ;; +esac + : figure out how to guarantee perl startup case "$startperl" in '') @@ -8810,11 +8890,17 @@ int main() checkit("123.456", buf); /* Testing of 1e+129 in bigintpm.t must not get extra '.' here. */ - Gconvert((DOUBLETYPE)1e30, 8, 0, buf); + 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+030", buf); /* for Microsoft */ + checkit("1e+034", buf); /* for Microsoft */ else - checkit("1e+30", buf); + 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); } @@ -8965,58 +9051,330 @@ eval $inlibc set alarm d_alarm eval $inlibc -: see if atolf exists -set atolf d_atolf -eval $inlibc - -: see if atoll exists -set atoll d_atoll -eval $inlibc - -: Look for GNU-cc style attribute checking -echo " " -echo "Checking whether your compiler can handle __attribute__ ..." >&4 -$cat >attrib.c <<'EOCP' -#include -void croak (char* pat,...) __attribute__((format(printf,1,2),noreturn)); -EOCP -if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then - if $contains 'warning' attrib.out >/dev/null 2>&1; then - echo "Your C compiler doesn't fully support __attribute__." - val="$undef" - else - echo "Your C compiler supports __attribute__." - val="$define" - fi -else - echo "Your C compiler doesn't seem to understand __attribute__ at all." - val="$undef" -fi -set d_attribut -eval $setvar -$rm -f attrib* - -: see if bcmp exists -set bcmp d_bcmp -eval $inlibc - -: see if bcopy exists -set bcopy d_bcopy -eval $inlibc - -: see if this is a unistd.h system -set unistd.h i_unistd +: see if POSIX threads are available +set pthread.h i_pthread eval $inhdr -: see if getpgrp exists -set getpgrp d_getpgrp -eval $inlibc +: define a fucntion to check prototypes +$cat > protochk <try.c <> protochk <<'EOSH' + +$rm -f try.c +foo="$1" +shift +while test $# -ge 2; do + case "$1" in + $define) echo "#include <$2>" >> try.c ;; + literal) echo "$2" >> try.c ;; + esac + # 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 -f try.[co] +exit $status +EOSH +chmod +x protochk +$eunicefix protochk + +hasproto='varname=$1; func=$2; shift; shift; +while $test $# -ge 2; do + case "$1" in + $define) echo "#include <$2>";; + esac ; + shift 2; +done > try.c; +$cppstdin $cppflags $cppminus < try.c > tryout.c 2>/dev/null; +if $contains "$func.*(" tryout.c >/dev/null 2>&1; then + echo "$func() prototype found."; + val="$define"; +else + echo "$func() prototype NOT found."; + val="$undef"; +fi; +set $varname; +eval $setvar; +$rm -f try.c tryout.c' + +: see if 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 + +hasfield='varname=$1; struct=$2; field=$3; shift; shift; shift; +while $test $# -ge 2; do + case "$1" in + $define) echo "#include <$2>";; + esac ; + shift 2; +done > try.c; +echo "int main () { struct $struct foo; char* bar; bar = (char*)foo.$field; }" >> try.c; +set try; +if eval $compile; then + val="$define"; +else + val="$undef"; +fi; +set $varname; +eval $setvar; +$rm -f try.c try.o' + +: see if we should include time.h, sys/time.h, or both +echo " " +if test "X$timeincl" = X; then + echo "Testing to see if we should include , or both." >&4 + $echo $n "I'm now running the test program...$c" + $cat >try.c <<'EOCP' +#include +#ifdef I_TIME +#include +#endif +#ifdef I_SYSTIME +#ifdef SYSTIMEKERNEL +#define KERNEL +#endif +#include +#endif +#ifdef I_SYSSELECT +#include +#endif +int main() +{ + struct tm foo; +#ifdef S_TIMEVAL + struct timeval bar; +#endif +#ifdef S_TIMEZONE + struct timezone tzp; +#endif + if (foo.tm_sec == foo.tm_sec) + exit(0); +#ifdef S_TIMEVAL + if (bar.tv_sec == bar.tv_sec) + exit(0); +#endif + exit(1); +} +EOCP + flags='' + for s_timezone in '-DS_TIMEZONE' ''; do + sysselect='' + for s_timeval in '-DS_TIMEVAL' ''; do + for i_systimek in '' '-DSYSTIMEKERNEL'; do + for i_time in '' '-DI_TIME'; do + for i_systime in '-DI_SYSTIME' ''; do + case "$flags" in + '') $echo $n ".$c" + set try $i_time $i_systime $i_systimek $sysselect $s_timeval $s_timezone + if eval $compile; then + set X $i_time $i_systime $i_systimek $sysselect $s_timeval + shift + flags="$*" + echo " " + $echo $n "Succeeded with $flags$c" + fi + ;; + esac + done + done + done + done + done + timeincl='' + echo " " + case "$flags" in + *SYSTIMEKERNEL*) i_systimek="$define" + timeincl=`./findhdr sys/time.h` + echo "We'll include with KERNEL defined." >&4;; + *) i_systimek="$undef";; + esac + case "$flags" in + *I_TIME*) i_time="$define" + timeincl=`./findhdr time.h`" $timeincl" + echo "We'll include ." >&4;; + *) i_time="$undef";; + esac + case "$flags" in + *I_SYSTIME*) i_systime="$define" + timeincl=`./findhdr sys/time.h`" $timeincl" + echo "We'll include ." >&4;; + *) i_systime="$undef";; + esac + $rm -f try.c try +fi +: 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 $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 $try" $hdrs && asctime_r_proto=B_SBI ;; + esac + case "$asctime_r_proto" in + ''|0) try='int asctime_r(const struct tm*, char*);' + ./protochk "extern $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 $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 GNU-cc style attribute checking +echo " " +echo "Checking whether your compiler can handle __attribute__ ..." >&4 +$cat >attrib.c <<'EOCP' +#include +void croak (char* pat,...) __attribute__((format(printf,1,2),noreturn)); +EOCP +if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then + if $contains 'warning' attrib.out >/dev/null 2>&1; then + echo "Your C compiler doesn't fully support __attribute__." + val="$undef" + else + echo "Your C compiler supports __attribute__." + val="$define" + fi +else + echo "Your C compiler doesn't seem to understand __attribute__ at all." + val="$undef" +fi +set d_attribut +eval $setvar +$rm -f attrib* + +: see if bcmp exists +set bcmp d_bcmp +eval $inlibc + +: see if bcopy exists +set bcopy d_bcopy +eval $inlibc + +: see if this is a unistd.h system +set unistd.h i_unistd +eval $inhdr + +: see if getpgrp exists +set getpgrp d_getpgrp +eval $inlibc + +case "$d_getpgrp" in +"$define") + echo " " + echo "Checking to see which flavor of getpgrp is in use..." + $cat >try.c < #ifdef I_UNISTD @@ -9408,28 +9766,6 @@ set $varname; eval $setvar; $rm -f try.c try.o' -: see if sys/types.h has to be included -set sys/types.h i_systypes -eval $inhdr - -hasfield='varname=$1; struct=$2; field=$3; shift; shift; shift; -while $test $# -ge 2; do - case "$1" in - $define) echo "#include <$2>";; - esac ; - shift 2; -done > try.c; -echo "int main () { struct $struct foo; char* bar; bar = (char*)foo.$field; }" >> try.c; -set try; -if eval $compile; then - val="$define"; -else - val="$undef"; -fi; -set $varname; -eval $setvar; -$rm -f try.c try.o' - socketlib='' sockethdr='' : see whether socket exists @@ -9588,6 +9924,55 @@ $define) cryptlib='' ;; ;; 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 $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 $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" ;; @@ -9600,6 +9985,100 @@ case "$full_csh" in '') full_csh=$csh ;; esac +: 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 $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 $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 $try" $hdrs && ctime_r_proto=B_SBI ;; + esac + case "$ctime_r_proto" in + ''|0) try='int ctime_r(const time_t*, char*);' + ./protochk "extern $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 $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 @@ -9639,25 +10118,6 @@ $rm -f dbl_dig.? set d_dbl_dig eval $setvar -hasproto='varname=$1; func=$2; shift; shift; -while $test $# -ge 2; do - case "$1" in - $define) echo "#include <$2>";; - esac ; - shift 2; -done > try.c; -$cppstdin $cppflags $cppminus < try.c > tryout.c 2>/dev/null; -if $contains "$func.*(" tryout.c >/dev/null 2>&1; then - echo "$func() prototype found."; - val="$define"; -else - echo "$func() prototype NOT found."; - val="$undef"; -fi; -set $varname; -eval $setvar; -$rm -f try.c tryout.c' - : see if dbm.h is available : see if dbmclose exists set dbmclose d_dbmclose @@ -9939,6 +10399,47 @@ $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 $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 @@ -9956,93 +10457,480 @@ eval $inlibc 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 $try" $hdrs && endgrent_r_proto=I_H ;; + esac + case "$endgrent_r_proto" in + ''|0) try='void endgrent_r(FILE**);' + ./protochk "extern $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 $try" $hdrs && endhostent_r_proto=I_D ;; + esac + case "$endhostent_r_proto" in + ''|0) try='void endhostent_r(struct hostent_data*);' + ./protochk "extern $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 $try" $hdrs && endnetent_r_proto=I_D ;; + esac + case "$endnetent_r_proto" in + ''|0) try='void endnetent_r(struct netent_data*);' + ./protochk "extern $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 $try" $hdrs && endprotoent_r_proto=I_D ;; + esac + case "$endprotoent_r_proto" in + ''|0) try='void endprotoent_r(struct protoent_data*);' + ./protochk "extern $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 endservent exists -set endservent d_endsent -eval $inlibc +: see if this is a pwd.h system +set pwd.h i_pwd +eval $inhdr -: Locate the flags for 'open()' -echo " " -$cat >try.c <<'EOCP' -#include -#ifdef I_FCNTL -#include -#endif -#ifdef I_SYS_FILE -#include -#endif -int main() { - if(O_RDONLY); -#ifdef O_TRUNC - exit(0); -#else - exit(1); -#endif -} -EOCP -: check sys/file.h first to get FREAD on Sun -if $test `./findhdr sys/file.h` && \ - set 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 +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 - 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 + set d_pwquota + eval $setvar + + if $contains 'pw_age' $$.h >/dev/null 2>&1; then val="$define" else - echo "but not the 3 argument form of open(). Oh, well." >&4 val="$undef" fi -else - val="$undef" - echo "I can't find the O_* constant definitions! You got problems." >&4 -fi -set d_open3 -eval $setvar -$rm -f try try.* + set d_pwage + eval $setvar -: 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 + if $contains 'pw_change' $$.h >/dev/null 2>&1; then + val="$define" else - echo "No string header found -- You'll surely have problems." >&4 + val="$undef" fi -fi -set i_string -eval $setvar + 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 $try" $hdrs && endpwent_r_proto=I_H ;; + esac + case "$endpwent_r_proto" in + ''|0) try='void endpwent_r(FILE**);' + ./protochk "extern $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 $try" $hdrs && endservent_r_proto=I_D ;; + esac + case "$endservent_r_proto" in + ''|0) try='void endservent_r(struct servent_data*);' + ./protochk "extern $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 <<'EOCP' +#include +#ifdef I_FCNTL +#include +#endif +#ifdef I_SYS_FILE +#include +#endif +int main() { + if(O_RDONLY); +#ifdef O_TRUNC + exit(0); +#else + exit(1); +#endif +} +EOCP +: check sys/file.h first to get FREAD on Sun +if $test `./findhdr sys/file.h` && \ + set 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 -f try try.* + +: see which of string.h or strings.h is needed +echo " " +strings=`./findhdr string.h` +if $test "$strings" && $test -r "$strings"; then + echo "Using instead of ." >&4 + val="$define" +else + val="$undef" + strings=`./findhdr strings.h` + if $test "$strings" && $test -r "$strings"; then + echo "Using instead of ." >&4 + else + echo "No string header found -- You'll surely have problems." >&4 + fi +fi +set i_string +eval $setvar case "$i_string" in "$undef") strings=`./findhdr strings.h`;; *) strings=`./findhdr string.h`;; @@ -10385,94 +11273,6 @@ eval $setvar $rm -f try* -: see if sys/select.h has to be included -set sys/select.h i_sysselct -eval $inhdr - -: see if we should include time.h, sys/time.h, or both -echo " " -if test "X$timeincl" = X; then - echo "Testing to see if we should include , or both." >&4 - $echo $n "I'm now running the test program...$c" - $cat >try.c <<'EOCP' -#include -#ifdef I_TIME -#include -#endif -#ifdef I_SYSTIME -#ifdef SYSTIMEKERNEL -#define KERNEL -#endif -#include -#endif -#ifdef I_SYSSELECT -#include -#endif -int main() -{ - struct tm foo; -#ifdef S_TIMEVAL - struct timeval bar; -#endif -#ifdef S_TIMEZONE - struct timezone tzp; -#endif - if (foo.tm_sec == foo.tm_sec) - exit(0); -#ifdef S_TIMEVAL - if (bar.tv_sec == bar.tv_sec) - exit(0); -#endif - exit(1); -} -EOCP - flags='' - for s_timezone in '-DS_TIMEZONE' ''; do - sysselect='' - for s_timeval in '-DS_TIMEVAL' ''; do - for i_systimek in '' '-DSYSTIMEKERNEL'; do - for i_time in '' '-DI_TIME'; do - for i_systime in '-DI_SYSTIME' ''; do - case "$flags" in - '') $echo $n ".$c" - set try $i_time $i_systime $i_systimek $sysselect $s_timeval $s_timezone - if eval $compile; then - set X $i_time $i_systime $i_systimek $sysselect $s_timeval - shift - flags="$*" - echo " " - $echo $n "Succeeded with $flags$c" - fi - ;; - esac - done - done - done - done - done - timeincl='' - echo " " - case "$flags" in - *SYSTIMEKERNEL*) i_systimek="$define" - timeincl=`./findhdr sys/time.h` - echo "We'll include with KERNEL defined." >&4;; - *) i_systimek="$undef";; - esac - case "$flags" in - *I_TIME*) i_time="$define" - timeincl=`./findhdr time.h`" $timeincl" - echo "We'll include ." >&4;; - *) i_time="$undef";; - esac - case "$flags" in - *I_SYSTIME*) i_systime="$define" - timeincl=`./findhdr sys/time.h`" $timeincl" - echo "We'll include ." >&4;; - *) i_systime="$undef";; - esac - $rm -f try.c try -fi - : check for fd_set items $cat <&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 $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 $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 $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 $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 $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 $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 $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 $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 $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 @@ -10792,9 +11763,192 @@ case "$d_phostname" in '') d_phostname="$undef";; esac -: see if this is a netdb.h system -set netdb.h i_netdb -eval $inhdr +: see if 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 $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 $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 $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 $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 $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 $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 $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 $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 $try" $hdrs && gethostbyaddr_r_proto=I_CIISD ;; + esac + case "$gethostbyaddr_r_proto" in + ''|0) try='int gethostbyaddr_r(const char*, int, int);' + ./protochk "extern $try" $hdrs && gethostbyaddr_r_proto=I_CII ;; + 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 $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 $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 $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 $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 $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 $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 $try" $hdrs && gethostent_r_proto=S_SBI ;; + esac + case "$gethostent_r_proto" in + ''|0) try='int gethostent_r(struct hostent*, char*, int);' + ./protochk "extern $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 $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 " " @@ -10809,6 +11963,59 @@ eval $inlibc 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 $try" $hdrs && getlogin_r_proto=I_BW ;; + esac + case "$getlogin_r_proto" in + ''|0) try='int getlogin_r(char*, int);' + ./protochk "extern $try" $hdrs && getlogin_r_proto=I_BI ;; + esac + case "$getlogin_r_proto" in + ''|0) try='char* getlogin_r(char*, size_t);' + ./protochk "extern $try" $hdrs && getlogin_r_proto=B_BW ;; + esac + case "$getlogin_r_proto" in + ''|0) try='char* getlogin_r(char*, int);' + ./protochk "extern $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 @@ -10829,6 +12036,185 @@ eval $inlibc 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 $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 $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 $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 $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 $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 $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 $try" $hdrs && getnetbyaddr_r_proto=I_IISD ;; + 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 $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 $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 $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 $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 $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 $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 $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 $try" $hdrs && getnetent_r_proto=S_SBI ;; + esac + case "$getnetent_r_proto" in + ''|0) try='int getnetent_r(struct netent*, char*, int);' + ./protochk "extern $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 $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 @@ -10867,6 +12253,157 @@ eval $inlibc 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 $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 $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 $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 $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 $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 $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 $try" $hdrs && getprotoent_r_proto=I_SBWR ;; + esac + case "$getprotoent_r_proto" in + ''|0) try='int getprotoent_r(struct protoent*, char*, int);' + ./protochk "extern $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 $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 $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 @@ -10880,6 +12417,173 @@ eval $inlibc 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 $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 $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 $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 $try" $hdrs && getpwent_r_proto=S_SBI ;; + esac + case "$getpwent_r_proto" in + ''|0) try='int getpwent_r(struct passwd*, char*, int);' + ./protochk "extern $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 $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 $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 $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 $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 $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 $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 $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 $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 $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 + : see if getservbyname exists set getservbyname d_getsbyname @@ -10889,9 +12593,160 @@ eval $inlibc set getservbyport d_getsbyport eval $inlibc -: see if getservent exists -set getservent d_getsent +: 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 $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 $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 $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 $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 $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 $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 $try" $hdrs && getservent_r_proto=I_SBWR ;; + esac + case "$getservent_r_proto" in + ''|0) try='int getservent_r(struct servent*, char*, int);' + ./protochk "extern $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 $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 $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 " " @@ -10902,6 +12757,55 @@ eval $hasproto 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 $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 $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 @@ -10921,28 +12825,48 @@ case "$d_gettimeod$d_ftime" in ;; esac -: see if this is an grp system -set grp.h i_grp -eval $inhdr - -case "$i_grp" in -$define) - xxx=`./findhdr grp.h` - $cppstdin $cppflags $cppminus < $xxx >$$.h - - if $contains 'gr_passwd' $$.h >/dev/null 2>&1; then - val="$define" - else - val="$undef" - fi - set d_grpasswd - eval $setvar - - $rm -f $$.h +: 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 $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 $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 ;; -*) - val="$undef"; - set d_grpasswd; eval $setvar + *) 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 @@ -11141,6 +13065,51 @@ eval $setvar 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 $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 $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 localeconv exists set localeconv d_locconv eval $inlibc @@ -11617,18 +13586,18 @@ set try d_nv_preserves_uv="$undef" if eval $compile; then - d_nv_preserves_uv_bits="`$run ./try`" + nv_preserves_uv_bits="`$run ./try`" fi -case "$d_nv_preserves_uv_bits" in +case "$nv_preserves_uv_bits" in \-[1-9]*) - d_nv_preserves_uv_bits=`expr 0 - $d_nv_preserves_uv_bits` - $echo "Your NVs can preserve all $d_nv_preserves_uv_bits bits of your UVs." 2>&1 + 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 $d_nv_preserves_uv_bits bits of your UVs." 2>&1 +[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 - d_nv_preserves_uv_bits="$undef" ;; + nv_preserves_uv_bits="$undef" ;; esac $rm -f try.* try @@ -11657,13 +13626,6 @@ $rm -f try.* try set d_off64_t eval $setvar -: see if POSIX threads are available -set pthread.h i_pthread -eval $inhdr - - - - : how to create joinable pthreads if test "X$usethreads" = "X$define" -a "X$i_pthread" = "X$define"; then echo " " @@ -11763,9 +13725,33 @@ $rm -f reflect set d_procselfexe eval $setvar +: 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 pthread_atfork d_pthread_atfork -eval $inlibc +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 whether the various POSIXish _yields exist @@ -11839,91 +13825,44 @@ esac $rm -f try try.* -: see if this is a pwd.h system -set pwd.h i_pwd -eval $inhdr - -case "$i_pwd" in -$define) - xxx=`./findhdr pwd.h` - $cppstdin $cppflags $cppminus < $xxx >$$.h - - if $contains 'pw_quota' $$.h >/dev/null 2>&1; then - val="$define" - else - val="$undef" - fi - set d_pwquota - eval $setvar - - if $contains 'pw_age' $$.h >/dev/null 2>&1; then - val="$define" - else - val="$undef" - fi - set d_pwage - eval $setvar - - if $contains 'pw_change' $$.h >/dev/null 2>&1; then - val="$define" - else - val="$undef" - fi - set d_pwchange - eval $setvar - - if $contains 'pw_class' $$.h >/dev/null 2>&1; then - val="$define" - else - val="$undef" - fi - set d_pwclass - eval $setvar - - if $contains 'pw_expire' $$.h >/dev/null 2>&1; then - val="$define" - else - val="$undef" - fi - set d_pwexpire - eval $setvar - - if $contains 'pw_comment' $$.h >/dev/null 2>&1; then - val="$define" - else - val="$undef" - fi - set d_pwcomment - eval $setvar - - if $contains 'pw_gecos' $$.h >/dev/null 2>&1; then - val="$define" - else - val="$undef" - fi - set d_pwgecos - eval $setvar - - if $contains 'pw_passwd' $$.h >/dev/null 2>&1; then - val="$define" - else - val="$undef" - fi - set d_pwpasswd - eval $setvar - - $rm -f $$.h +: 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 $try" $hdrs && random_r_proto=I_TS ;; + 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 ;; -*) - 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 + *) 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 @@ -11937,6 +13876,96 @@ 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 $try" $hdrs && readdir64_r_proto=I_TSR ;; + esac + case "$readdir64_r_proto" in + ''|0) try='int readdir64_r(DIR*, struct dirent64*);' + ./protochk "extern $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 $try" $hdrs && readdir_r_proto=I_TSR ;; + esac + case "$readdir_r_proto" in + ''|0) try='int readdir_r(DIR*, struct dirent*);' + ./protochk "extern $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 @@ -12441,10 +14470,100 @@ eval $inlibc 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 $try" $hdrs && setgrent_r_proto=I_H ;; + esac + case "$setgrent_r_proto" in + ''|0) try='void setgrent_r(FILE**);' + ./protochk "extern $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 $try" $hdrs && sethostent_r_proto=I_ID ;; + esac + case "$sethostent_r_proto" in + ''|0) try='void sethostent_r(int, struct hostent_data*);' + ./protochk "extern $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 @@ -12457,10 +14576,100 @@ eval $inlibc 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 $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 $try" $hdrs && setnetent_r_proto=I_ID ;; + esac + case "$setnetent_r_proto" in + ''|0) try='void setnetent_r(int, struct netent_data*);' + ./protochk "extern $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 @@ -12481,10 +14690,100 @@ eval $inlibc 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 $try" $hdrs && setprotoent_r_proto=I_ID ;; + esac + case "$setprotoent_r_proto" in + ''|0) try='void setprotoent_r(int, struct protoent_data*);' + ./protochk "extern $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 $try" $hdrs && setpwent_r_proto=I_H ;; + esac + case "$setpwent_r_proto" in + ''|0) try='void setpwent_r(FILE**);' + ./protochk "extern $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 @@ -12509,6 +14808,51 @@ eval $inlibc 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 $try" $hdrs && setservent_r_proto=I_ID ;; + esac + case "$setservent_r_proto" in + ''|0) try='void setservent_r(int, struct servent_data*);' + ./protochk "extern $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 @@ -12764,6 +15108,88 @@ eval $hasproto set socks5_init d_socks5_init eval $inlibc +: 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 $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 $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 @@ -13163,6 +15589,55 @@ if test "X$d_strerror" = X -o "X$d_syserrlst" = X; then 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 $try" $hdrs && strerror_r_proto=I_IBW ;; + esac + case "$strerror_r_proto" in + ''|0) try='int strerror_r(int, char*, int);' + ./protochk "extern $try" $hdrs && strerror_r_proto=I_IBI ;; + esac + case "$strerror_r_proto" in + ''|0) try='char* strerror_r(int, char*, size_t);' + ./protochk "extern $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 @@ -13463,6 +15938,24 @@ 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 this is a sys/times.h system set sys/times.h i_systimes eval $inhdr @@ -13485,10 +15978,100 @@ else 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 $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 $try" $hdrs && ttyname_r_proto=I_IBW ;; + esac + case "$ttyname_r_proto" in + ''|0) try='int ttyname_r(int, char*, int);' + ./protochk "extern $try" $hdrs && ttyname_r_proto=I_IBI ;; + esac + case "$ttyname_r_proto" in + ''|0) try='char* ttyname_r(int, char*, int);' + ./protochk "extern $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 @@ -13508,7 +16091,7 @@ case "$multiarch" in ''|[nN]*) multiarch="$undef" ;; esac -: check for ordering of bytes in a long +: check for ordering of bytes in a UV echo " " case "$usecrosscompile$multiarch" in *$define*) @@ -13531,21 +16114,23 @@ an Alpha will report 12345678. If the test program works the default is probably right. I'm now running the test program... EOM - $cat >try.c <<'EOCP' + $cat >try.c < +#include +typedef $uvtype UV; int main() { int i; union { - unsigned long l; - char c[sizeof(long)]; + UV l; + char c[$uvsize]; } u; - if (sizeof(long) > 4) - u.l = (0x08070605L << 32) | 0x04030201L; + if ($uvsize > 4) + u.l = (((UV)0x08070605) << 32) | (UV)0x04030201; else - u.l = 0x04030201L; - for (i = 0; i < sizeof(long); i++) + u.l = (UV)0x04030201; + for (i = 0; i < $uvsize; i++) printf("%c", u.c[i]+'0'); printf("\n"); exit(0); @@ -13572,7 +16157,7 @@ EOM fi case "$xxx_prompt" in y) - rp="What is the order of bytes in a long?" + rp="What is the order of bytes in $uvtype?" . ./myread byteorder="$ans" ;; @@ -15127,47 +17712,6 @@ EOCP ;; esac -: define a fucntion to check prototypes -$cat > protochk <> protochk <<'EOSH' - -$rm -f try.c -foo="$1" -shift -while test $# -ge 2; do - case "$1" in - $define) echo "#include <$2>" >> try.c ;; - literal) echo "$2" >> try.c ;; - esac - shift 2 -done -test "$prototype" = "$define" && echo '#define CAN_PROTOTYPE' >> try.c -cat >> try.c <<'EOCP' -#ifdef CAN_PROTOTYPE -#define _(args) args -#else -#define _(args) () -#endif -EOCP -echo "$foo" >> try.c -echo 'int no_real_function_has_this_name _((void)) { return 0; }' >> try.c -$cc $optimize $ccflags -c try.c > /dev/null 2>&1 -status=$? -$rm -f try.[co] -exit $status -EOSH -chmod +x protochk -$eunicefix protochk - : see what type is used for size_t rp="What is the type used for the length parameter for string functions?" set size_t sizetype 'unsigned int' stdio.h sys/types.h @@ -15334,10 +17878,7 @@ set pid_t pidtype int stdio.h sys/types.h eval $typedef_ask : Find earliest binary compatible site_perl subdirectory perl can use. -case "$bincompat5005" in -"$define") xs_apiversion='5.005' ;; -*) xs_apiversion=$version ;; # The current site_perl version. -esac +xs_apiversion=$version # The current site_perl version. : Find earliest pure perl site_perl subdirectory perl can use. : The versioned directories started at 5.005. pm_apiversion='5.005' @@ -15956,24 +18497,6 @@ $rm -f stdioh -: see if time exists -echo " " -if test "X$d_time" = X -o X"$timetype" = X; then - if set time val -f d_time; eval $csym; $val; then - echo 'time() found.' >&4 - val="$define" - rp="What is the type returned by time() on this system?" - set time_t timetype long stdio.h sys/types.h - eval $typedef_ask - else - echo 'time() not found, hope that will do.' >&4 - val="$undef" - timetype='int'; - fi - set d_time - eval $setvar -fi - : see what type uids are declared as in the kernel echo " " echo "Looking for the type for user ids returned by getuid()." @@ -16154,10 +18677,6 @@ esac set libutil.h i_libutil eval $inhdr -: see if locale.h is available -set locale.h i_locale -eval $inhdr - : see if mach cthreads are available if test "X$usethreads" = "X$define"; then set mach/cthreads.h i_machcthr @@ -16387,7 +18906,7 @@ for i in \`$cc -v -c tmp.c 2>&1 $postprocess_cc_v\` do case "\$i" in -D*) echo "\$i" | $sed 's/^-D//';; - -A*) $test "$gccversion" && echo "\$i" | $sed 's/^-A\(.*\)(\(.*\))/\1=\2/';; + -A*) $test "$gccversion" && echo "\$i" | $sed 's/^-A//' | $sed 's/\(.*\)(\(.*\))/\1=\2/';; esac done $rm -f try.c @@ -16504,10 +19023,6 @@ set i_termio; eval $setvar val=$val2; set i_sgtty; eval $setvar val=$val3; set i_termios; eval $setvar -: see if this is a shadow.h system -set shadow.h i_shadow -eval $inhdr - : see if stddef is available set stddef.h i_stddef eval $inhdr @@ -16681,9 +19196,7 @@ eval $find_extensions # Special case: Add in threads/shared since it is not picked up by the # recursive find above (and adding in general recursive finding breaks # SDBM_File/sdbm). A.D. 10/25/2001. -# Encode::JP needs an explicit mention for the same reason -# --jhi 2002-02-23 -known_extensions="$known_extensions threads/shared Encode/JP" +known_extensions="$known_extensions threads/shared" set X $nonxs_extensions shift nonxs_extensions="$*" @@ -16774,12 +19287,18 @@ for xxx in $known_extensions ; do esac ;; threads|threads/shared) - case "$usethreads" in - true|$define|y) - case "$useithreads" in - $define|true|[yY]*) avail_ext="$avail_ext $xxx" ;; - esac - esac + # 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" ;; IPC/SysV|ipc/sysv) : XXX Do we need a useipcsysv variable here @@ -16917,6 +19436,20 @@ EOM esac ;; esac +# +# Encode is a special case. If we are building Encode as a static +# extension, we need to explicitly list its subextensions as well. +# For other nested extensions, this is handled automatically by +# the appropriate Makefile.PL. +case " $static_ext " in + *" Encode "*) # Add the subextensions of Encode + cd "$rsrc/ext" + for xxx in `ls Encode/*/Makefile.PL|awk -F/ '{print $2}'`; do + static_ext="$static_ext Encode/$xxx" + done + cd "$tdir" + ;; +esac set X $dynamic_ext $static_ext $nonxs_ext shift @@ -17043,11 +19576,11 @@ archlibexp='$archlibexp' archname64='$archname64' archname='$archname' archobjs='$archobjs' +asctime_r_proto='$asctime_r_proto' awk='$awk' baserev='$baserev' bash='$bash' bin='$bin' -bincompat5005='$bincompat5005' binexp='$binexp' bison='$bison' byacc='$byacc' @@ -17085,8 +19618,11 @@ 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' @@ -17106,12 +19642,12 @@ d_access='$d_access' d_accessx='$d_accessx' d_alarm='$d_alarm' d_archlib='$d_archlib' +d_asctime_r='$d_asctime_r' d_atolf='$d_atolf' d_atoll='$d_atoll' d_attribut='$d_attribut' d_bcmp='$d_bcmp' d_bcopy='$d_bcopy' -d_bincompat5005='$d_bincompat5005' d_bsd='$d_bsd' d_bsdgetpgrp='$d_bsdgetpgrp' d_bsdsetpgrp='$d_bsdsetpgrp' @@ -17127,7 +19663,10 @@ d_closedir='$d_closedir' d_cmsghdr_s='$d_cmsghdr_s' d_const='$d_const' d_crypt='$d_crypt' +d_crypt_r='$d_crypt_r' d_csh='$d_csh' +d_ctermid_r='$d_ctermid_r' +d_ctime_r='$d_ctime_r' d_cuserid='$d_cuserid' d_dbl_dig='$d_dbl_dig' d_dbminitproto='$d_dbminitproto' @@ -17138,15 +19677,22 @@ 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_fchdir='$d_fchdir' @@ -17183,19 +19729,29 @@ 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_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' @@ -17206,15 +19762,26 @@ 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_gmtime_r='$d_gmtime_r' d_gnulibc='$d_gnulibc' d_grpasswd='$d_grpasswd' d_hasmntopt='$d_hasmntopt' @@ -17231,6 +19798,7 @@ d_killpg='$d_killpg' d_lchown='$d_lchown' d_ldbl_dig='$d_ldbl_dig' d_link='$d_link' +d_localtime_r='$d_localtime_r' d_locconv='$d_locconv' d_lockf='$d_lockf' d_longdbl='$d_longdbl' @@ -17273,7 +19841,6 @@ d_mymalloc='$d_mymalloc' d_nice='$d_nice' d_nl_langinfo='$d_nl_langinfo' d_nv_preserves_uv='$d_nv_preserves_uv' -d_nv_preserves_uv_bits='$d_nv_preserves_uv_bits' d_off64_t='$d_off64_t' d_old_pthread_create_joinable='$d_old_pthread_create_joinable' d_oldpthreads='$d_oldpthreads' @@ -17299,7 +19866,10 @@ 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' @@ -17324,19 +19894,25 @@ 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' @@ -17344,6 +19920,7 @@ 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' @@ -17363,6 +19940,8 @@ d_socklen_t='$d_socklen_t' d_sockpair='$d_sockpair' d_socks5_init='$d_socks5_init' 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' @@ -17381,6 +19960,7 @@ 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_strtod='$d_strtod' d_strtol='$d_strtol' @@ -17405,7 +19985,11 @@ d_telldir='$d_telldir' d_telldirproto='$d_telldirproto' d_time='$d_time' 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' @@ -17443,12 +20027,19 @@ dlext='$dlext' dlsrc='$dlsrc' doublesize='$doublesize' drand01='$drand01' +drand48_r_proto='$drand48_r_proto' 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' @@ -17468,12 +20059,33 @@ full_csh='$full_csh' full_sed='$full_sed' 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' grep='$grep' groupcat='$groupcat' groupstype='$groupstype' @@ -17492,6 +20104,7 @@ i8size='$i8size' i8type='$i8type' i_arpainet='$i_arpainet' i_bsdioctl='$i_bsdioctl' +i_crypt='$i_crypt' i_db='$i_db' i_dbm='$i_dbm' i_dirent='$i_dirent' @@ -17621,6 +20234,7 @@ lint='$lint' lkflags='$lkflags' ln='$ln' lns='$lns' +localtime_r_proto='$localtime_r_proto' locincpth='$locincpth' loclibpth='$loclibpth' longdblsize='$longdblsize' @@ -17669,6 +20283,7 @@ nroff='$nroff' nvEUformat='$nvEUformat' nvFUformat='$nvFUformat' nvGUformat='$nvGUformat' +nv_preserves_uv_bits='$nv_preserves_uv_bits' nveformat='$nveformat' nvfformat='$nvfformat' nvgformat='$nvgformat' @@ -17711,9 +20326,12 @@ 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' rmail='$rmail' @@ -17740,6 +20358,13 @@ 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' @@ -17774,6 +20399,8 @@ socksizetype='$socksizetype' sort='$sort' spackage='$spackage' spitshell='$spitshell' +srand48_r_proto='$srand48_r_proto' +srandom_r_proto='$srandom_r_proto' src='$src' ssizetype='$ssizetype' startperl='$startperl' @@ -17786,6 +20413,7 @@ 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' @@ -17798,11 +20426,13 @@ 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'