[p5sagit/p5-mst-13.2.git] / Configure

#! /bin/sh
#
# If these # comments don't work, trim them.  Don't worry about any other
# shell scripts, Configure will trim # comments from them for you.
#
# (If you are trying to port this package to a machine without sh, I would
# suggest you cut out the prototypical config.h from the end of Configure
# and edit it to reflect your system.  Some packages may include samples
# of config.h for certain machines, so you might look for one of those.)
#
# $Header: Configure,v 3.0.1.6 90/03/12 16:10:23 lwall Locked $
#
# Yes, you may rip this off to use in other distribution packages.
# (Note: this Configure script was generated automatically.  Rather than
# working with this copy of Configure, you may wish to get metaconfig.)

: sanity checks
PATH=".:/bin:/usr/bin:/usr/local/bin:/usr/ucb:/usr/local:/usr/lbin:/etc:/usr/new:/usr/new/bin:/usr/nbin:$PATH"
export PATH || (echo "OOPS, this isn't sh.  Desperation time.  I will feed myself to sh."; sh $0; kill $$)

if test ! -t 0; then
    echo "Say 'sh Configure', not 'sh <Configure'"
    exit 1
fi

(alias) >/dev/null 2>&1 && \
    echo "(I see you are using the Korn shell.  Some ksh's blow up on Configure," && \
    echo "especially on exotic machines.  If yours does, try the Bourne shell instead.)"

if test ! -d ../UU; then
    if test ! -d UU; then
	mkdir UU
    fi
    cd UU
fi

case "$1" in
-d) shift; fastread='yes';;
esac

d_eunice=''
define=''
eunicefix=''
loclist=''
expr=''
sed=''
echo=''
cat=''
rm=''
mv=''
cp=''
tail=''
tr=''
mkdir=''
sort=''
uniq=''
grep=''
trylist=''
test=''
inews=''
egrep=''
more=''
pg=''
Mcc=''
vi=''
mailx=''
mail=''
cpp=''
perl=''
emacs=''
ls=''
rmail=''
sendmail=''
shar=''
smail=''
tbl=''
troff=''
nroff=''
uname=''
uuname=''
line=''
chgrp=''
chmod=''
lint=''
sleep=''
pr=''
tar=''
ln=''
lpr=''
lp=''
touch=''
make=''
date=''
csh=''
Log=''
Header=''
bin=''
byteorder=''
contains=''
cppstdin=''
cppminus=''
d_bcmp=''
d_bcopy=''
d_bzero=''
d_charsprf=''
d_crypt=''
cryptlib=''
d_csh=''
d_dosuid=''
d_dup2=''
d_fchmod=''
d_fchown=''
d_fcntl=''
d_flock=''
d_getgrps=''
d_gethent=''
d_getpgrp=''
d_getpgrp2=''
d_getprior=''
d_htonl=''
d_index=''
d_ioctl=''
d_killpg=''
d_lstat=''
d_memcmp=''
d_memcpy=''
d_mkdir=''
d_ndbm=''
d_odbm=''
d_readdir=''
d_rename=''
d_rmdir=''
d_setegid=''
d_seteuid=''
d_setpgrp=''
d_setpgrp2=''
d_setprior=''
d_setregid=''
d_setresgid=''
d_setreuid=''
d_setresuid=''
d_setrgid=''
d_setruid=''
d_socket=''
d_sockpair=''
d_oldsock=''
socketlib=''
d_statblks=''
d_stdstdio=''
d_strctcpy=''
d_strerror=''
d_symlink=''
d_syscall=''
d_varargs=''
d_vfork=''
d_voidsig=''
d_volatile=''
d_vprintf=''
d_charvspr=''
d_wait4=''
gidtype=''
i_dirent=''
d_dirnamlen=''
i_fcntl=''
i_grp=''
i_niin=''
i_pwd=''
d_pwquota=''
d_pwage=''
d_pwchange=''
d_pwclass=''
d_pwexpire=''
i_sysdir=''
i_sysioctl=''
i_sysndir=''
i_time=''
i_systime=''
d_systimekernel=''
i_utime=''
i_varargs=''
i_vfork=''
intsize=''
libc=''
mallocsrc=''
mallocobj=''
usemymalloc=''
mansrc=''
manext=''
models=''
split=''
small=''
medium=''
large=''
huge=''
optimize=''
ccflags=''
cppflags=''
ldflags=''
cc=''
libs=''
n=''
c=''
package=''
randbits=''
sig_name=''
spitshell=''
shsharp=''
sharpbang=''
startsh=''
stdchar=''
uidtype=''
voidflags=''
defvoidused=''
yacc=''
privlib=''
lib=''
CONFIG=''
: set package name
package=perl

echo " "
echo "Beginning of configuration questions for $package kit."
: Eunice requires " " instead of "", can you believe it
echo " "

define='define'
undef='undef'
: change the next line if compiling for Xenix/286 on Xenix/386
xlibpth='/usr/lib/386 /lib/386'
libpth='/usr/lib /usr/local/lib /usr/lib/large /lib '$xlibpth' /lib/large /usr/lib/small /lib/small'
smallmach='pdp11 i8086 z8000 i80286 iAPX286'
rmlist='kit[1-9]isdone kit[1-9][0-9]isdone'
trap 'echo " "; rm -f $rmlist; exit 1' 1 2 3

: We must find out about Eunice early
eunicefix=':'
if test -f /etc/unixtovms; then
    eunicefix=/etc/unixtovms
fi
if test -f /etc/unixtovms.exe; then
    eunicefix=/etc/unixtovms.exe
fi

: Now test for existence of everything in MANIFEST

echo "First let's make sure your kit is complete.  Checking..."
(cd ..; awk '' `awk '$1 !~ /PACKINGLIST/ {print $1}' MANIFEST` >/dev/null || kill $$)
echo "Looks good..."

attrlist="mc68000 sun gcos unix ibm gimpel interdata tss os mert pyr"
attrlist="$attrlist vax pdp11 i8086 z8000 u3b2 u3b5 u3b20 u3b200"
attrlist="$attrlist hpux hp9000s300 hp9000s500 hp9000s800"
attrlist="$attrlist ns32000 ns16000 iAPX286 mc300 mc500 mc700 sparc"
attrlist="$attrlist nsc32000 sinix xenix venix posix ansi M_XENIX"
attrlist="$attrlist $mc68k __STDC__ UTS M_I8086 M_I186 M_I286 M_I386"
attrlist="$attrlist i186 __m88k__ m88k DGUX __DGUX__"
pth="/usr/ucb /bin /usr/bin /usr/local /usr/local/bin /usr/lbin /usr/plx /usr/5bin /vol/local/bin /etc /usr/lib /lib /usr/local/lib /sys5.3/bin /sys5.3/usr/bin /bsd4.3/bin /bsd4.3/usr/bin /bsd4.3/usr/ucb"
d_newshome="/usr/NeWS"
defvoidused=7
libswanted="net_s net nsl_s nsl socket nm ndir ndbm dbm sun bsd BSD x c_s"
inclwanted='/usr/netinclude /usr/include/sun /usr/include/bsd /usr/include/lan'
: some greps do not return status, grrr.
echo "grimblepritz" >grimble
if grep blurfldyick grimble >/dev/null 2>&1 ; then
    contains=contains
elif grep grimblepritz grimble >/dev/null 2>&1 ; then
    contains=grep
else
    contains=contains
fi
rm -f grimble
: the following should work in any shell
case "$contains" in
contains*)
    echo " "
    echo "AGH!  Grep doesn't return a status.  Attempting remedial action."
    cat >contains <<'EOSS'
grep "$1" "$2" >.greptmp && cat .greptmp && test -s .greptmp
EOSS
chmod +x contains
esac

: see if sh knows # comments
echo " "
echo "Checking your sh to see if it knows about # comments..."
if sh -c '#' >/dev/null 2>&1 ; then
    echo "Your sh handles # comments correctly."
    shsharp=true
    spitshell=cat
    echo " "
    echo "Okay, let's see if #! works on this system..."
    echo "#!/bin/echo hi" > try
    $eunicefix try
    chmod +x try
    ./try > today
    if $contains hi today >/dev/null 2>&1; then
	echo "It does."
	sharpbang='#!'
    else
	echo "#! /bin/echo hi" > try
	$eunicefix try
	chmod +x try
	./try > today
	if test -s today; then
	    echo "It does."
	    sharpbang='#! '
	else
	    echo "It doesn't."
	    sharpbang=': use '
	fi
    fi
else
    echo "Your sh doesn't grok # comments--I will strip them later on."
    shsharp=false
    echo "exec grep -v '^#'" >spitshell
    chmod +x spitshell
    $eunicefix spitshell
    spitshell=`pwd`/spitshell
    echo "I presume that if # doesn't work, #! won't work either!"
    sharpbang=': use '
fi

: figure out how to guarantee sh startup
echo " "
echo "Checking out how to guarantee sh startup..."
startsh=$sharpbang'/bin/sh'
echo "Let's see if '$startsh' works..."
cat >try <<EOSS
$startsh
set abc
test "$?abc" != 1
EOSS

chmod +x try
$eunicefix try
if ./try; then
    echo "Yup, it does."
else
    echo "Nope.  You may have to fix up the shell scripts to make sure sh runs them."
fi
rm -f try today

: first determine how to suppress newline on echo command
echo "Checking echo to see how to suppress newlines..."
(echo "hi there\c" ; echo " ") >.echotmp
if $contains c .echotmp >/dev/null 2>&1 ; then
    echo "...using -n."
    n='-n'
    c=''
else
    cat <<'EOM'
...using \c
EOM
    n=''
    c='\c'
fi
echo $n "Type carriage return to continue.  Your cursor should be here-->$c"
read ans
rm -f .echotmp

: now set up to do reads with possible shell escape and default assignment
cat <<EOSC >myread
case "\$fastread" in
yes) ans=''; echo " " ;;
*) ans='!';;
esac
while expr "X\$ans" : "X!" >/dev/null; do
    read ans
    case "\$ans" in
    !)
	sh
	echo " "
	echo $n "\$rp $c"
	;;
    !*)
	set \`expr "X\$ans" : "X!\(.*\)\$"\`
	sh -c "\$*"
	echo " "
	echo $n "\$rp $c"
	;;
    esac
done
rp='Your answer:'
case "\$ans" in
'') ans="\$dflt";;
esac
EOSC

: general instructions
cat <<EOH
 
This installation shell script will examine your system and ask you questions
to determine how the $package package should be installed.  If you get stuck
on a question, you may use a ! shell escape to start a subshell or execute
a command.  Many of the questions will have default answers in square
brackets--typing carriage return will give you the default.

On some of the questions which ask for file or directory names you are
allowed to use the ~name construct to specify the login directory belonging
to "name", even if you don't have a shell which knows about that.  Questions
where this is allowed will be marked "(~name ok)".

EOH
rp="[Type carriage return to continue]"
echo $n "$rp $c"
. myread
cat <<EOH

Much effort has been expended to ensure that this shell script will run
on any Unix system.  If despite that it blows up on you, your best bet is
to edit Configure and run it again. Also, let me (lwall@jpl-devvax.jpl.nasa.gov)
know how I blew it.  If you can't run Configure for some reason, you'll have
to generate a config.sh file by hand.

This installation script affects things in two ways: 1) it may do direct
variable substitutions on some of the files included in this kit, and
2) it builds a config.h file for inclusion in C programs.  You may edit
any of these files as the need arises after running this script.

If you make a mistake on a question, there is no easy way to back up to it
currently.  The easiest thing to do is to edit config.sh and rerun all the
SH files.  Configure will offer to let you do this before it runs the SH files.

EOH
rp="[Type carriage return to continue]"
echo $n "$rp $c"
. myread

: get old answers, if there is a config file out there
if test -f ../config.sh; then
    echo " "
    dflt=y
    rp="I see a config.sh file.  Did Configure make it on THIS system? [$dflt]"
    echo $n "$rp $c"
    . myread
    case "$ans" in
    n*) echo "OK, I'll ignore it.";;
    *)  echo "Fetching default answers from your old config.sh file..."
	tmp="$n"
	ans="$c"
        . ../config.sh
	n="$tmp"
	c="$ans"
	;;
    esac
fi

: find out where common programs are
echo " "
echo "Locating common programs..."
cat <<EOSC >loc
$startsh
case \$# in
0) exit 1;;
esac
thing=\$1
shift
dflt=\$1
shift
for dir in \$*; do
    case "\$thing" in
    .)
	if test -d \$dir/\$thing; then
	    echo \$dir
	    exit 0
	fi
	;;
    *)
	if test -f \$dir/\$thing; then
	    echo \$dir/\$thing
	    exit 0
	elif test -f \$dir/\$thing.exe; then
	    : on Eunice apparently
	    echo \$dir/\$thing
	    exit 0
	fi
	;;
    esac
done
echo \$dflt
exit 1
EOSC
chmod +x loc
$eunicefix loc
loclist="
cat
cp
echo
expr
grep
mkdir
mv
rm
sed
sort
tr
uniq
"
trylist="
Mcc
cpp
csh
egrep
test
"
for file in $loclist; do
    xxx=`loc $file $file $pth`
    eval $file=$xxx
    eval _$file=$xxx
    case "$xxx" in
    /*)
	echo $file is in $xxx.
	;;
    *)
	echo "I don't know where $file is.  I hope it's in everyone's PATH."
	;;
    esac
done
echo " "
echo "Don't worry if any of the following aren't found..."
ans=offhand
for file in $trylist; do
    xxx=`loc $file $file $pth`
    eval $file=$xxx
    eval _$file=$xxx
    case "$xxx" in
    /*)
	echo $file is in $xxx.
	;;
    *)
	echo "I don't see $file out there, $ans."
	ans=either
	;;
    esac
done
case "$egrep" in
egrep)
    echo "Substituting grep for egrep."
    egrep=$grep
    ;;
esac
case "$test" in
test)
    echo "Hopefully test is built into your sh."
    ;;
/bin/test)
    if sh -c "PATH= test true" >/dev/null 2>&1; then
	echo "Using the test built into your sh."
	test=test
    fi
    ;;
*)
    test=test
    ;;
esac
case "$echo" in
echo)
    echo "Hopefully echo is built into your sh."
    ;;
/bin/echo)
    echo " "
    echo "Checking compatibility between /bin/echo and builtin echo (if any)..."
    $echo $n "hi there$c" >foo1
    echo $n "hi there$c" >foo2
    if cmp foo1 foo2 >/dev/null 2>&1; then
	echo "They are compatible.  In fact, they may be identical."
    else
	case "$n" in
	'-n') n='' c='\c' ans='\c' ;;
	*) n='-n' c='' ans='-n' ;;
	esac
	cat <<FOO
They are not compatible!  You are probably running ksh on a non-USG system.
I'll have to use /bin/echo instead of the builtin, since Bourne shell doesn't
have echo built in and we may have to run some Bourne shell scripts.  That
means I'll have to use $ans to suppress newlines now.  Life is ridiculous.

FOO
	rp="Your cursor should be here-->"
	$echo $n "$rp$c"
	. myread
    fi
    $rm -f foo1 foo2
    ;;
*)
    : cross your fingers
    echo=echo
    ;;
esac
rmlist="$rmlist loc"

: set up shell script to do ~ expansion
cat >filexp <<EOSS
$startsh
: expand filename
case "\$1" in
 ~/*|~)
    echo \$1 | $sed "s|~|\${HOME-\$LOGDIR}|"
    ;;
 ~*)
    if $test -f /bin/csh; then
	/bin/csh -f -c "glob \$1"
	echo ""
    else
	name=\`$expr x\$1 : '..\([^/]*\)'\`
	dir=\`$sed -n -e "/^\${name}:/{s/^[^:]*:[^:]*:[^:]*:[^:]*:[^:]*:\([^:]*\).*"'\$'"/\1/" -e p -e q -e '}' </etc/passwd\`
	if $test ! -d "\$dir"; then
	    me=\`basename \$0\`
	    echo "\$me: can't locate home directory for: \$name" >&2
	    exit 1
	fi
	case "\$1" in
	*/*)
	    echo \$dir/\`$expr x\$1 : '..[^/]*/\(.*\)'\`
	    ;;
	*)
	    echo \$dir
	    ;;
	esac
    fi
    ;;
*)
    echo \$1
    ;;
esac
EOSS
chmod +x filexp
$eunicefix filexp

: determine where public executables go
case "$bin" in
'')
    dflt=`loc . /bin /usr/local/bin /usr/lbin /usr/local /usr/bin`
    ;;
*)  dflt="$bin"
    ;;
esac
cont=true
while $test "$cont" ; do
    echo " "
    rp="Where do you want to put the public executables? (~name ok) [$dflt]"
    $echo $n "$rp $c"
    . myread
    bin="$ans"
    bin=`./filexp "$bin"`
    if test -d $bin; then
	cont=''
    else
	case "$fastread" in
	yes) dflt=y;;
	*) dflt=n;;
	esac
	rp="Directory $bin doesn't exist.  Use that name anyway? [$dflt]"
	$echo $n "$rp $c"
	. myread
	dflt=''
	case "$ans" in
	y*) cont='';;
	esac
    fi
done

: determine where manual pages go
$cat <<EOM
  
$package has manual pages that need to be installed in source form.
EOM
case "$mansrc" in
'')
    dflt=`loc . /usr/man/man1 /usr/man/mann /usr/man/manl /usr/man/local/man1 /usr/man/u_man/man1 /usr/man/man1 /usr/man/man.L`
    ;;
*)  dflt="$mansrc"
    ;;
esac
cont=true
while $test "$cont" ; do
    echo " "
    rp="Where do the manual pages (source) go? (~name ok) [$dflt]"
    $echo $n "$rp $c"
    . myread
    mansrc=`./filexp "$ans"`
    if $test -d "$mansrc"; then
	cont=''
    else
	if $test "$fastread" = yes; then
	    dflt=y
	else
	    dflt=n
	fi
	rp="Directory $mansrc doesn't exist.  Use that name anyway? [$dflt]"
	$echo $n "$rp $c"
	. myread
	dflt=''
	case "$ans" in
	y*) cont='';;
	esac
    fi
done
case "$mansrc" in
*l)
    manext=l
    ;;
*n)
    manext=n
    ;;
*o)
    manext=l
    ;;
*p)
    manext=p
    ;;
*C)
    manext=C
    ;;
*L)
    manext=L
    ;;
*)
    manext=1
    ;;
esac

: make some quick guesses about what we are up against
echo " "
$echo $n "Hmm...  $c"
cat /usr/include/signal.h /usr/include/sys/signal.h >foo
if test `echo abc | tr a-z A-Z` = Abc ; then
    echo "Looks kind of like a USG system, but we'll see..."
    echo exit 1 >bsd
    echo exit 0 >usg
    echo exit 1 >v7
elif $contains SIGTSTP foo >/dev/null 2>&1 ; then
    echo "Looks kind of like a BSD system, but we'll see..."
    echo exit 0 >bsd
    echo exit 1 >usg
    echo exit 1 >v7
else
    echo "Looks kind of like a version 7 system, but we'll see..."
    echo exit 1 >bsd
    echo exit 1 >usg
    echo exit 0 >v7
fi
case "$eunicefix" in
*unixtovms*)
    cat <<'EOI'
There is, however, a strange, musty smell in the air that reminds me of
something...hmm...yes...I've got it...there's a VMS nearby, or I'm a Blit.
EOI
    echo "exit 0" >eunice
    d_eunice="$define"
    ;;
*)
    echo " "
    echo "Congratulations.  You aren't running Eunice."
    d_eunice="$undef"
    echo "exit 1" >eunice
    ;;
esac
if test -f /xenix; then
    echo "Actually, this looks more like a XENIX system..."
    echo "exit 0" >xenix
else
    echo " "
    echo "It's not Xenix..."
    echo "exit 1" >xenix
fi
chmod +x xenix
$eunicefix xenix
if test -f /venix; then
    echo "Actually, this looks more like a VENIX system..."
    echo "exit 0" >venix
else
    echo " "
    if xenix; then
	: null
    else
	echo "Nor is it Venix..."
    fi
    echo "exit 1" >venix
fi
chmod +x bsd usg v7 eunice venix
$eunicefix bsd usg v7 eunice venix
rm -rf foo
rmlist="$rmlist bsd usg v7 eunice venix xenix"

: see what memory models we can support
case "$models" in
'')
    : We may not use Cppsym or we get a circular dependency through cc.
    : But this should work regardless of which cc we eventually use.
    cat >pdp11.c <<'EOP'
main() {
#ifdef pdp11
    exit(0);
#else
    exit(1);
#endif
}
EOP
    cc -o pdp11 pdp11.c >/dev/null 2>&1
    if pdp11 2>/dev/null; then
	dflt='unsplit split'
    else
	ans=`loc . X /lib/small /lib/large /usr/lib/small /usr/lib/large /lib/medium /usr/lib/medium /lib/huge`
	case "$ans" in
	X) dflt='none';;
	*)  if $test -d /lib/small || $test -d /usr/lib/small; then
		dflt='small'
	    else
		dflt=''
	    fi
	    if $test -d /lib/medium || $test -d /usr/lib/medium; then
		dflt="$dflt medium"
	    fi
	    if $test -d /lib/large || $test -d /usr/lib/large; then
		dflt="$dflt large"
	    fi
	    if $test -d /lib/huge || $test -d /usr/lib/huge; then
		dflt="$dflt huge"
	    fi
	esac
    fi
    ;;
*)  dflt="$models" ;;
esac
$cat <<EOM
 
Some systems have different model sizes.  On most systems they are called
small, medium, large, and huge.  On the PDP11 they are called unsplit and
split.  If your system doesn't support different memory models, say "none".
If you wish to force everything to one memory model, say "none" here and
put the appropriate flags later when it asks you for other cc and ld flags.
Venix systems may wish to put "none" and let the compiler figure things out.
(In the following question multiple model names should be space separated.)

EOM
rp="Which models are supported? [$dflt]"
$echo $n "$rp $c"
. myread
models="$ans"

case "$models" in
none)
    small=''
    medium=''
    large=''
    huge=''
    unsplit=''
    split=''
    ;;
*split)
    case "$split" in
    '') 
	if $contains '\-i' $mansrc/man1/ld.1 >/dev/null 2>&1 || \
	   $contains '\-i' $mansrc/man1/cc.1 >/dev/null 2>&1; then
	    dflt='-i'
	else
	    dflt='none'
	fi
	;;
    *) dflt="$split";;
    esac
    rp="What flag indicates separate I and D space? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
    none) ans='';;
    esac
    split="$ans"
    unsplit=''
    ;;
*large*|*small*|*medium*|*huge*)
    case "$models" in
    *large*)
	case "$large" in
	'') dflt='-Ml';;
	*) dflt="$large";;
	esac
	rp="What flag indicates large model? [$dflt]"
	$echo $n "$rp $c"
	. myread
	case "$ans" in
	none) ans='';
	esac
	large="$ans"
	;;
    *) large='';;
    esac
    case "$models" in
    *huge*)
	case "$huge" in
	'') dflt='-Mh';;
	*) dflt="$huge";;
	esac
	rp="What flag indicates huge model? [$dflt]"
	$echo $n "$rp $c"
	. myread
	case "$ans" in
	none) ans='';
	esac
	huge="$ans"
	;;
    *) huge="$large";;
    esac
    case "$models" in
    *medium*)
	case "$medium" in
	'') dflt='-Mm';;
	*) dflt="$medium";;
	esac
	rp="What flag indicates medium model? [$dflt]"
	$echo $n "$rp $c"
	. myread
	case "$ans" in
	none) ans='';
	esac
	medium="$ans"
	;;
    *) medium="$large";;
    esac
    case "$models" in
    *small*)
	case "$small" in
	'') dflt='none';;
	*) dflt="$small";;
	esac
	rp="What flag indicates small model? [$dflt]"
	$echo $n "$rp $c"
	. myread
	case "$ans" in
	none) ans='';
	esac
	small="$ans"
	;;
    *) small='';;
    esac
    ;;
*)
    echo "Unrecognized memory models--you may have to edit Makefile.SH"
    ;;
esac

: see if we need a special compiler
echo " "
if usg; then
    case "$cc" in
    '')
	case "$Mcc" in
	/*) dflt='Mcc'
	    ;;
	*)
	    case "$large" in
	    -M*)
		dflt='cc'
		;;
	    *)
		if $contains '\-M' $mansrc/cc.1 >/dev/null 2>&1 ; then
		    dflt='cc -M'
		else
		    dflt='cc'
		fi
		;;
	    esac
	    ;;
	esac
	;;
    *)  dflt="$cc";;
    esac
    $cat <<'EOM'
  
On some systems the default C compiler will not resolve multiple global
references that happen to have the same name.  On some such systems the
"Mcc" command may be used to force these to be resolved.  On other systems
a "cc -M" command is required.  (Note that the -M flag on other systems
indicates a memory model to use!)  If you have the Gnu C compiler, you
might wish to use that instead.  What command will force resolution on
EOM
    $echo $n "this system? [$dflt] $c"
    rp="Command to resolve multiple refs? [$dflt]"
    . myread
    cc="$ans"
else
    case "$cc" in
    '') dflt=cc;;
    *) dflt="$cc";;
    esac
    rp="Use which C compiler? [$dflt]"
    $echo $n "$rp $c"
    . myread
    cc="$ans"
fi
case "$cc" in
gcc*) cpp=`loc gcc-cpp $cpp $pth`;;
esac

: determine optimize, if desired, or use for debug flag also
case "$optimize" in
' ') dflt="none"
     ;;
'') dflt="-O";
    ;;
*)  dflt="$optimize"
    ;;
esac
cat <<EOH

Some C compilers have problems with their optimizers, by default, $package
compiles with the -O flag to use the optimizer.  Alternately, you might
want to use the symbolic debugger, which uses the -g flag (on traditional
Unix systems).  Either flag can be specified here.  To use neither flag,
specify the word "none".
  
EOH
rp="What optimizer/debugger flag should be used? [$dflt]"
$echo $n "$rp $c"
. myread
optimize="$ans"
case "$optimize" in
'none') optimize=" "
     ;;
esac

case "$ccflags" in
'') case "$cc" in
    *gcc*) dflt='-fpcc-struct-return';;
    *) dflt='';;
    esac
    ;;
*) dflt="$ccflags";;
esac
for thisincl in $inclwanted; do
    if test -d $thisincl; then
	case "$dflt" in
	*$thisincl*);;
	*) dflt="$dflt -I$thisincl";;
	esac
    fi
done
case "$optimize" in
-g*)
    case "$dflt" in
    *DEBUGGING*);;
    *) dflt="$dflt -DDEBUGGING";;
    esac
    ;;
esac
if $contains 'LANGUAGE_C' /usr/include/signal.h >/dev/null 2>&1; then
    case "$dflt" in
    *LANGUAGE_C*);;
    *) dflt="$dflt -DLANGUAGE_C";;
    esac
fi
case "$dflt" in
'') dflt=none;;
esac
cat <<EOH

Your C compiler may want other flags.  For this question you should
include -I/whatever and -DWHATEVER flags and any other flags used by
the C compiler, but you should NOT include libraries or ld flags like
-lwhatever.  To use no flags, specify the word "none".
  
EOH
rp="Any additional cc flags? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
none) ans='';
esac
ccflags="$ans"

: the following weeds options from ccflags that are of no interest to cpp
cppflags="$ccflags"
case "$cc" in
*gcc*) cppflags="$cppflags -D__GNUC__";;
esac
case "$cppflags" in
'');;
*)  set X $cppflags
    cppflags=''
    for flag do
	case $flag in
	-D*|-I*) cppflags="$cppflags $flag";;
	esac
    done
    case "$cppflags" in
    *-*)  echo "(C preprocessor flags: $cppflags)";;
    esac
    ;;
esac

case "$ldflags" in
'') if venix; then
	dflt='-i -z'
    else
	dflt='none'
    fi
    ;;
*) dflt="$ldflags";;
esac
echo " "
rp="Any additional ld flags (NOT including libraries)? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
none) ans='';
esac
ldflags="$ans"
rmlist="$rmlist pdp11"

echo " "
echo "Checking for optional libraries..."
case "$libswanted" in
'') libswanted='c_s';;
esac
for thislib in $libswanted; do
    case "$thislib" in
    dbm) thatlib=ndbm;;
    *_s) thatlib=NONE;;
    *) thatlib="${thislib}_s";;
    *) thatlib=NONE;;
    esac
    xxx=`loc lib$thislib.a X /usr/lib /usr/local/lib /lib`
    if test -f $xxx; then
	echo "Found -l$thislib."
	case "$dflt" in
	*-l$thislib*|*-l$thatlib*);;
	*) dflt="$dflt -l$thislib";;
	esac
    else
	xxx=`loc lib$thislib.a X $libpth`
	if test -f $xxx; then
	    echo "Found $xxx."
	    case "$dflt" in
	    *$xxx*);;
	    *) dflt="$dflt $xxx";;
	    esac
	else
	    xxx=`loc Slib$thislib.a X $xlibpth`
	    if test -f $xxx; then
		echo "Found -l$thislib."
		case "$dflt" in
		*-l$thislib*|*-l$thatlib*);;
		*) dflt="$dflt -l$thislib";;
		esac
	    else
		echo "No -l$thislib."
	    fi
	fi
    fi
done
set X $dflt
shift
dflt="$*"
case "$libs" in
*) dflt="$libs";;
esac
case "$dflt" in
'') dflt='none';;
esac

$cat <<EOM
 
Some versions of Unix support shared libraries, which make
executables smaller but make load time slightly longer.

On some systems, mostly newer Unix System V's, the shared library
is included by putting the option "-lc_s" as the last thing on the
cc command line when linking.  Other systems use shared libraries
by default.  There may be other libraries needed to compile $package
on your machine as well.  If your system needs the "-lc_s" option,
include it here.  Include any other special libraries here as well.
Say "none" for none.
EOM

echo " "
rp="Any additional libraries? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
none) ans='';
esac
libs="$ans"

: check for ordering of bytes in a long
case "$byteorder" in
'')
cat <<'EOM'
  
In the following, larger digits indicate more significance.  A big-endian
machine like a Pyramid or a Motorola 680?0 chip will come out to 4321.  A
little-endian machine like a Vax or an Intel 80?86 chip would be 1234.  Other
machines may have weird orders like 3412.  A Cray will report 87654321.  If
the test program works the default is probably right.
I'm now running the test program...
EOM
    $cat >try.c <<'EOCP'
#include <stdio.h>
main()
{
    int i;
    union {
	unsigned long l;
	char c[sizeof(long)];
    } u;

    if (sizeof(long) > 4)
	u.l = (0x08070605<<32) | 0x04030201;
    else
	u.l = 0x04030201;
    for (i=0; i < sizeof(long); i++)
	printf("%c",u.c[i]+'0');
    printf("\n");
}
EOCP
    if $cc $ccflags try.c -o try >/dev/null 2>&1 ; then
	dflt=`./try`
	case "$dflt" in
	????|????????) echo "(The test program ran ok.)";;
	*) echo "(The test program didn't run right for some reason.)";;
	esac
    else
	dflt='4321'
	echo "(I can't seem to compile the test program.  Guessing big-endian...)"
    fi
    ;;
*)
    echo " "
    dflt="$byteorder"
    ;;
esac
rp="What is the order of bytes in a long? [$dflt]"
$echo $n "$rp $c"
. myread
byteorder="$ans"
$rm -f try.c try

: see how we invoke the C preprocessor
echo " "
echo "Now, how can we feed standard input to your C preprocessor..."
cat <<'EOT' >testcpp.c
#define ABC abc
#define XYZ xyz
ABC.XYZ
EOT
echo 'Maybe "'"$cc"' -E" will work...'
$cc -E <testcpp.c >testcpp.out 2>&1
: try to force gcc preprocessor if that is the compiler they are using
case $? in
0) cppstdin="$cc -E";;
*) case "$cc" in
    *gcc*)
	cd ..
	echo 'Trying (cat >/tmp/$$.c; '"$cc"' -E /tmp/$$.c; rm /tmp/$$.c)'
	echo 'cat >/tmp/$$.c; '"$cc"' -E /tmp/$$.c; rm /tmp/$$.c' >cppstdin
	chmod 755 cppstdin
	cppstdin=`pwd`/cppstdin
	cppminus='';
	cd UU
	$cppstdin <testcpp.c >testcpp.out 2>&1
	;;
    esac
    ;;
esac
if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
    echo "Yup, it does."
    cppstdin="$cc -E"
    cppminus='';
else
    echo 'Nope, maybe "'$cpp'" will work...'
    $cpp <testcpp.c >testcpp.out 2>&1
    if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Yup, it does."
	cppstdin="$cpp"
	cppminus='';
    else
	echo 'No such luck...maybe "'$cpp' -" will work...'
	$cpp - <testcpp.c >testcpp.out 2>&1
	if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	    echo "It works!"
	    cppstdin="$cpp"
	    cppminus='-';
	else
	    echo 'Nixed again...maybe "'"$cc"' -E -" will work...'
	    $cc -E - <testcpp.c >testcpp.out 2>&1
	    if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
		echo "Hooray, it works!  I was beginning to wonder."
		cppstdin="$cc -E"
		cppminus='-';
	    else
		echo 'Nope...maybe "'"$cc"' -P" will work...'
		$cc -P <testcpp.c >testcpp.out 2>&1
		if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
		    echo "Yup, that does."
		    cppstdin="$cc -P"
		    cppminus='';
		else
		    echo 'Nope...maybe "'"$cc"' -P -" will work...'
		    $cc -P - <testcpp.c >testcpp.out 2>&1
		    if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
			echo "Yup, that does."
			cppstdin="$cc -P"
			cppminus='-';
		    else
			echo 'Hmm...perhaps you already told me...'
			case "$cppstdin" in
			'') ;;
			*) $cppstdin $cppminus <testcpp.c >testcpp.out 2>&1;;
			esac
			if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
			    echo "Hooray, you did!  I was beginning to wonder."
			else
			    echo 'Uh-uh.  Time to get fancy...'
			    cd ..
			    echo 'Trying (cat >/tmp/$$.c; '"$cc"' -E /tmp/$$.c; rm /tmp/$$.c)'
			    echo 'cat >/tmp/$$.c; '"$cc"' -E /tmp/$$.c; rm /tmp/$$.c' >cppstdin
			    chmod 755 cppstdin
			    cppstdin=`pwd`/cppstdin
			    cppminus='';
			    cd UU
			    $cppstdin <testcpp.c >testcpp.out 2>&1
			    if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
				echo "Eureka!."
			    else
				dflt=blurfl
				$echo $n "No dice.  I can't find a C preprocessor.  Name one: $c"
				rp='Name a C preprocessor:'
				. myread
				cppstdin="$ans"
				$cppstdin <testcpp.c >testcpp.out 2>&1
				if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
				    echo "OK, that will do."
				else
				    echo "Sorry, I can't get that to work.  Go find one."
				    exit 1
				fi
			    fi
			fi
		    fi
		fi
	    fi
	fi
    fi
fi
rm -f testcpp.c testcpp.out

: get list of predefined functions in a handy place
echo " "
case "$libc" in
'') libc=unknown;;
esac
case "$libpth" in
'') libpth='/lib /usr/lib /usr/local/lib';;
esac
case "$libs" in
*-lc_s*) libc=`loc libc_s.a $libc $libpth`
esac
libnames='';
case "$libs" in
'') ;;
*)  for thislib in $libs; do
	case "$thislib" in
	-l*) thislib=`expr X$thislib : 'X-l\(.*\)'`
	    try=`loc lib$thislib.a blurfl/dyick $libpth`
	    if test ! -f $try; then
		try=`loc lib$thislib blurfl/dyick $libpth`
		if test ! -f $try; then
		    try=`loc $thislib blurfl/dyick $libpth`
		    if test ! -f $try; then
			try=`loc Slib$thislib.a blurfl/dyick $xlibpth`
			if test ! -f $try; then
			    try=''
			fi
		    fi
		fi
	    fi
	    libnames="$libnames $try"
	    ;;
	*) libnames="$libnames $thislib" ;;
	esac
    done
    ;;
esac
set /usr/lib/libc.so.[0-9]*
eval set \$$#
if test -f "$1"; then
    echo "Your shared C library is in $1."
    libc="$1"
elif test -f $libc; then
    echo "Your C library is in $libc, like you said before."
elif test -f /lib/libc.a; then
    echo "Your C library is in /lib/libc.a.  You're normal."
    libc=/lib/libc.a
else
    ans=`loc libc.a blurfl/dyick $libpth`
    if test ! -f "$ans"; then
	ans=`loc libc blurfl/dyick $libpth`
    fi
    if test ! -f "$ans"; then
	ans=`loc clib blurfl/dyick $libpth`
    fi
    if test ! -f "$ans"; then
	ans=`loc Slibc.a blurfl/dyick $xlibpth`
    fi
    if test ! -f "$ans"; then
	ans=`loc Mlibc.a blurfl/dyick $xlibpth`
    fi
    if test ! -f "$ans"; then
	ans=`loc Llibc.a blurfl/dyick $xlibpth`
    fi
    if test -f "$ans"; then
	echo "Your C library is in $ans, of all places."
	libc=$ans
    else
	cat <<EOM
 
I can't seem to find your C library.  I've looked in the following places:

	$libpth

None of these seems to contain your C library.  What is the full name
EOM
	dflt=None
	$echo $n "of your C library? $c"
	rp='C library full name?'
	. myread
	libc="$ans"
    fi
fi
echo " "
set `echo $libc $libnames | tr ' ' '\012' | sort | uniq`
$echo $n "Extracting names from $* for later perusal...$c"
nm $* 2>/dev/null >libc.tmp
$sed -n -e 's/^.* [AT]  *_[_.]*//p' -e 's/^.* [AT] //p' <libc.tmp >libc.list
if $contains '^printf$' libc.list >/dev/null 2>&1; then
    echo "done"
else
    $sed -n -e 's/^__*//' -e 's/^\([a-zA-Z_0-9$]*\).*xtern.*/\1/p' <libc.tmp >libc.list
    $contains '^printf$' libc.list >/dev/null 2>&1 || \
	$sed -n -e 's/^.* D __*//p' -e 's/^.* D //p' <libc.tmp >libc.list
    $contains '^printf$' libc.list >/dev/null 2>&1 || \
       $sed -n -e 's/^_//' \
	      -e 's/^\([a-zA-Z_0-9]*\).*xtern.*text.*/\1/p' <libc.tmp >libc.list
    $contains '^printf$' libc.list >/dev/null 2>&1 || \
	$sed -n -e 's/^.*|FUNC |GLOB .*|//p' <libc.tmp >libc.list
    if $contains '^printf$' libc.list >/dev/null 2>&1; then
	echo "done"
    else
	echo " "
	echo "nm didn't seem to work right."
	echo "Trying ar instead..."
	if ar t $libc > libc.tmp; then
	    for thisname in $libnames; do
		ar t $thisname >>libc.tmp
	    done
	    $sed -e 's/\.o$//' < libc.tmp > libc.list
	    echo "Ok."
	else
	    echo "ar didn't seem to work right."
	    echo "Maybe this is a Cray...trying bld instead..."
	    if bld t $libc | $sed -e 's/.*\///' -e 's/\.o:.*$//' > libc.list; then
		for thisname in $libnames; do
		    bld t $libnames | \
			$sed -e 's/.*\///' -e 's/\.o:.*$//' >>libc.list
		    ar t $thisname >>libc.tmp
		done
		echo "Ok."
	    else
	    	echo "That didn't work either.  Giving up."
	    	exit 1
	    fi
	fi
    fi
fi

inlibc='echo " ";
if $contains "^$1\$" libc.list >/dev/null 2>&1;
then echo "$1() found"; eval "$2=$define";
else echo "$1() not found"; eval "$2=$undef"; fi'

rmlist="$rmlist libc.tmp libc.list"

: see if bcmp exists
set bcmp d_bcmp
eval $inlibc

: see if bcopy exists
set bcopy d_bcopy
eval $inlibc

: see if bzero exists
set bzero d_bzero
eval $inlibc

: see if sprintf is declared as int or pointer to char
echo " "
cat >.ucbsprf.c <<'EOF'
main() { char buf[10]; exit((unsigned long)sprintf(buf,"%s","foo") > 10L); }
EOF
if $cc $ccflags .ucbsprf.c -o .ucbsprf >/dev/null 2>&1 && .ucbsprf; then
    echo "Your sprintf() returns (int)."
    d_charsprf="$undef"
else
    echo "Your sprintf() returns (char*)."
    d_charsprf="$define"
fi
/bin/rm -f .ucbsprf.c .ucbsprf

: see if vprintf exists
echo " "
if $contains '^vprintf$' libc.list >/dev/null 2>&1; then
    echo 'vprintf() found.'
    d_vprintf="$define"
    cat >.ucbsprf.c <<'EOF'
#include <stdio.h>
#include <varargs.h>

main() { xxx("foo"); }

xxx(va_alist)
va_dcl
{
    va_list args;
    char buf[10];

    va_start(args);
    exit((unsigned long)vsprintf(buf,"%s",args) > 10L);
}
EOF
    if $cc $ccflags .ucbsprf.c -o .ucbsprf >/dev/null 2>&1 && .ucbsprf; then
	echo "Your vsprintf() returns (int)."
	d_charvspr="$undef"
    else
	echo "Your vsprintf() returns (char*)."
	d_charvspr="$define"
    fi
    /bin/rm -f .ucbsprf.c .ucbsprf
else
    echo 'vprintf() not found.'
    d_vprintf="$undef"
    d_charvspr="$undef"
fi

: see if crypt exists
echo " "
if $contains '^crypt$' libc.list >/dev/null 2>&1; then
    echo 'crypt() found.'
    d_crypt="$define"
    cryptlib=''
else
    cryptlib=`loc Slibcrypt.a "" $xlibpth`
    if $test -z "$cryptlib"; then
	cryptlib=`loc Mlibcrypt.a "" $xlibpth`
    else
	cryptlib=-lcrypt
    fi
    if $test -z "$cryptlib"; then
	cryptlib=`loc Llibcrypt.a "" $xlibpth`
    else
	cryptlib=-lcrypt
    fi
    if $test -z "$cryptlib"; then
	cryptlib=`loc libcrypt.a "" $libpth`
    else
	cryptlib=-lcrypt
    fi
    if $test -z "$cryptlib"; then
	echo 'crypt() not found.'
	d_crypt="$undef"
    else
	d_crypt="$define"
    fi
fi

: get csh whereabouts
case "$csh" in
'csh') d_csh="$undef" ;;
*)     d_csh="$define" ;;
esac

: see if this is a dirent system
echo " "
if $test -r /usr/include/dirent.h ; then
    i_dirent="$define"
    echo "dirent.h found."
    if $contains 'd_namlen' /usr/include/sys/dirent.h >/dev/null 2>&1; then
	d_dirnamlen="$define"
    else
	d_dirnamlen="$undef"
    fi
else
    i_dirent="$undef"
    if $contains 'd_namlen' /usr/include/sys/dir.h >/dev/null 2>&1; then
	d_dirnamlen="$define"
    else
	d_dirnamlen="$undef"
    fi
    echo "No dirent.h found."
fi

: now see if they want to do setuid emulation
case "$d_dosuid" in
'') dflt=n;;
*undef*) dflt=n;;
*) dflt=y;;
esac
cat <<EOM
 
Some sites have disabled setuid #! scripts because of a bug in the kernel
that prevents them from being secure.  If you are on such a system, the
setuid/setgid bits on scripts are currently useless.  It is possible for
$package to detect those bits and emulate setuid/setgid in a secure fashion
until a better solution is devised for the kernel problem.

EOM
rp="Do you want to do setuid/setgid emulation? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
'') $ans="$dflt";;
esac
case "$ans" in
y*)  d_dosuid="$define";;
*) d_dosuid="$undef";;
esac

: see if dup2 exists
set dup2 d_dup2
eval $inlibc

: see if fchmod exists
set fchmod d_fchmod
eval $inlibc

: see if fchown exists
set fchown d_fchown
eval $inlibc

: see if this is an fcntl system
echo " "
if $test -r /usr/include/fcntl.h ; then
    d_fcntl="$define"
    echo "fcntl.h found."
else
    d_fcntl="$undef"
    echo "No fcntl.h found, but that's ok."
fi

: see if flock exists
set flock d_flock
eval $inlibc

: see if getgroups exists
set getgroups d_getgrps
eval $inlibc

: see if gethostent exists
set gethostent d_gethent
eval $inlibc

: see if getpgrp exists
set getpgrp d_getpgrp
eval $inlibc

: see if getpgrp2 exists
set getpgrp2 d_getpgrp2
eval $inlibc

: see if getpriority exists
set getpriority d_getprior
eval $inlibc

: see if htonl exists
set htonl d_htonl
eval $inlibc

: index or strcpy
echo " "
case "$d_index" in
n) dflt=n;;
*) dflt=y;;
esac
if $contains '^index$' libc.list >/dev/null 2>&1 ; then
    if $contains '^strchr$' libc.list >/dev/null 2>&1 ; then
	echo "Your system has both index() and strchr().  Shall I use"
	rp="index() rather than strchr()? [$dflt]"
	$echo $n "$rp $c"
	. myread
	case "$ans" in
	    n*) d_index="$define" ;;
	    *)  d_index="$undef" ;;
	esac
    else
	d_index="$undef"
	echo "index() found."
    fi
else
    if $contains '^strchr$' libc.list >/dev/null 2>&1 ; then
	d_index="$define"
	echo "strchr() found."
    else
	echo "No index() or strchr() found!"
	d_index="$undef"
    fi
fi

: see if ioctl defs are in sgtty/termio or sys/ioctl
echo " "
if $test -r /usr/include/sys/ioctl.h ; then
    d_ioctl="$define"
    echo "sys/ioctl.h found."
else
    d_ioctl="$undef"
    echo "sys/ioctl.h not found, assuming ioctl args are defined in sgtty.h."
fi

: see if killpg exists
set killpg d_killpg
eval $inlibc

: see if lstat exists
set lstat d_lstat
eval $inlibc

: see if memcmp exists
set memcmp d_memcmp
eval $inlibc

: see if memcpy exists
set memcpy d_memcpy
eval $inlibc

: see if mkdir exists
set mkdir d_mkdir
eval $inlibc

: see if ndbm is available
echo " "
xxx=`loc ndbm.h x /usr/include /usr/local/include $inclwanted`
if test -f $xxx; then
    d_ndbm="$define"
    echo "ndbm.h found."
else
    d_ndbm="$undef"
    echo "ndbm.h not found."
fi

: see if we have the old dbm
echo " "
xxx=`loc dbm.h x /usr/include /usr/local/include $inclwanted`
if test -f $xxx; then
    d_odbm="$define"
    echo "dbm.h found."
else
    d_odbm="$undef"
    echo "dbm.h not found."
fi

: see if this is a pwd system
echo " "
if $test -r /usr/include/pwd.h ; then
    i_pwd="$define"
    echo "pwd.h found."
    $cppstdin $cppflags </usr/include/pwd.h >$$.h
    if $contains 'pw_quota' $$.h >/dev/null 2>&1; then
	d_pwquota="$define"
    else
	d_pwquota="$undef"
    fi
    if $contains 'pw_age' $$.h >/dev/null 2>&1; then
	d_pwage="$define"
    else
	d_pwage="$undef"
    fi
    if $contains 'pw_change' $$.h >/dev/null 2>&1; then
	d_pwchange="$define"
    else
	d_pwchange="$undef"
    fi
    if $contains 'pw_class' $$.h >/dev/null 2>&1; then
	d_pwclass="$define"
    else
	d_pwclass="$undef"
    fi
    if $contains 'pw_expire' $$.h >/dev/null 2>&1; then
	d_pwexpire="$define"
    else
	d_pwexpire="$undef"
    fi
    rm -f $$.h
else
    i_pwd="$undef"
    d_pwquota="$undef"
    d_pwage="$undef"
    d_pwchange="$undef"
    d_pwclass="$undef"
    d_pwexpire="$undef"
    echo "No pwd.h found."
fi

: see if readdir exists
set readdir d_readdir
eval $inlibc

: see if rename exists
set rename d_rename
eval $inlibc

: see if rmdir exists
set rmdir d_rmdir
eval $inlibc

: see if setegid exists
set setegid d_setegid
eval $inlibc

: see if seteuid exists
set seteuid d_seteuid
eval $inlibc

: see if setpgrp exists
set setpgrp d_setpgrp
eval $inlibc

: see if setpgrp2 exists
set setpgrp2 d_setpgrp2
eval $inlibc

: see if setpriority exists
set setpriority d_setprior
eval $inlibc

: see if setregid exists
set setregid d_setregid
eval $inlibc
set setresgid d_setresgid
eval $inlibc

: see if setreuid exists
set setreuid d_setreuid
eval $inlibc
set setresuid d_setresuid
eval $inlibc

: see if setrgid exists
set setrgid d_setrgid
eval $inlibc

: see if setruid exists
set setruid d_setruid
eval $inlibc

socketlib=''
: see whether socket exists
echo " "
if $contains socket libc.list >/dev/null 2>&1; then
    echo "Looks like you have Berkeley networking support."
    d_socket="$define"
    : now check for advanced features
    if $contains setsockopt libc.list >/dev/null 2>&1; then
	d_oldsock="$undef"
    else
	echo "...but it uses the old 4.1c interface, rather than 4.2"
	d_oldsock="$define"
    fi
else
    : hpux, for one, puts all the socket stuff in socklib.o
    if $contains socklib libc.list >/dev/null 2>&1; then
	echo "Looks like you have Berkeley networking support."
	d_socket="$define"
	: we will have to assume that it supports the 4.2 BSD interface
	d_oldsock="$undef"
    else
	echo "Hmmm...you don't have Berkeley networking in libc.a..."
	: look for an optional networking library
	if test -f /usr/lib/libnet.a; then
	    (ar t /usr/lib/libnet.a ||
		nm -g /usr/lib/libnet.a) 2>/dev/null >> libc.list
	    if $contains socket libc.list >/dev/null 2>&1; then
		echo "but the Wollongong group seems to have hacked it in."
		socketlib="-lnet"
		d_socket="$define"
		: now check for advanced features
		if $contains setsockopt libc.list >/dev/null 2>&1; then
		    d_oldsock="$undef"
		else
		    echo "...using the old 4.1c interface, rather than 4.2"
		    d_oldsock="$define"
		fi
	    else
		echo "or even in libnet.a, which is peculiar."
		d_socket="$undef"
		d_oldsock="$undef"
	    fi
	else
	    echo "or anywhere else I see."
	    d_socket="$undef"
	    d_oldsock="$undef"
	fi
    fi
fi
if $contains socketpair libc.list >/dev/null 2>&1; then
    d_sockpair="$define"
else
    d_sockpair="$undef"
fi

: see if stat knows about block sizes
echo " "
if $contains 'st_blocks;' /usr/include/sys/stat.h >/dev/null 2>&1 ; then
    if $contains 'st_blksize;' /usr/include/sys/stat.h >/dev/null 2>&1 ; then
	echo "Your stat knows about block sizes."
	d_statblks="$define"
    else
	echo "Your stat doesn't know about block sizes."
	d_statblks="$undef"
    fi
else
    echo "Your stat doesn't know about block sizes."
    d_statblks="$undef"
fi

: see if stdio is really std
echo " "
if $contains 'char.*_ptr.*;' /usr/include/stdio.h >/dev/null 2>&1 ; then
    if $contains '_cnt;' /usr/include/stdio.h >/dev/null 2>&1 ; then
	echo "Your stdio is pretty std."
	d_stdstdio="$define"
    else
	echo "Your stdio isn't very std."
	d_stdstdio="$undef"
    fi
else
    echo "Your stdio isn't very std."
    d_stdstdio="$undef"
fi

: check for structure copying
echo " "
echo "Checking to see if your C compiler can copy structs..."
$cat >try.c <<'EOCP'
main()
{
	struct blurfl {
	    int dyick;
	} foo, bar;

	foo = bar;
}
EOCP
if $cc -c $ccflags try.c >/dev/null 2>&1 ; then
    d_strctcpy="$define"
    echo "Yup, it can."
else
    d_strctcpy="$undef"
    echo "Nope, it can't."
fi
$rm -f try.*

: see if strerror exists
set strerror d_strerror
eval $inlibc

: see if symlink exists
set symlink d_symlink
eval $inlibc

: see if syscall exists
set syscall d_syscall
eval $inlibc

: see if we should include time.h, sys/time.h, or both
cat <<'EOM'
  
Testing to see if we should include <time.h>, <sys/time.h> or both.
I'm now running the test program...
EOM
$cat >try.c <<'EOCP'
#ifdef I_TIME
#include <time.h>
#endif
#ifdef I_SYSTIME
#ifdef SYSTIMEKERNEL
#define KERNEL
#endif
#include <sys/time.h>
#endif
main()
{
    struct tm foo;
#ifdef S_TIMEVAL
    struct timeval bar;
#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_timeval in '-DS_TIMEVAL' ''; do
    for d_systimekernel in '' '-DSYSTIMEKERNEL'; do
	for i_time in '' '-DI_TIME'; do
	    for i_systime in '-DI_SYSTIME' ''; do
		case "$flags" in
		'') echo Trying $i_time $i_systime $d_systimekernel $s_timeval
		    if $cc $ccflags \
			    $i_time $i_systime $d_systimekernel $s_timeval \
			    try.c -o try >/dev/null 2>&1 ; then
			set X $i_time $i_systime $d_systimekernel $s_timeval
			shift
			flags="$*"
			echo Succeeded with $flags
		    fi
		    ;;
		esac
	    done
	done
    done
done
case "$flags" in
*SYSTIMEKERNEL*) d_systimekernel="$define";;
*) d_systimekernel="$undef";;
esac
case "$flags" in
*I_TIME*) i_time="$define";;
*) i_time="$undef";;
esac
case "$flags" in
*I_SYSTIME*) i_systime="$define";;
*) i_systime="$undef";;
esac
$rm -f try.c try

: see if this is a varargs system
echo " "
if $test -r /usr/include/varargs.h ; then
    d_varargs="$define"
    echo "varargs.h found."
else
    d_varargs="$undef"
    echo "No varargs.h found, but that's ok (I hope)."
fi

: see if there is a vfork
set vfork d_vfork
eval $inlibc

: see if signal is declared as pointer to function returning int or void
echo " "
$cppstdin $cppflags < /usr/include/signal.h >$$.tmp
if $contains 'void.*signal' $$.tmp >/dev/null 2>&1 ; then
    echo "You have void (*signal())() instead of int."
    d_voidsig="$define"
else
    echo "You have int (*signal())() instead of void."
    d_voidsig="$undef"
fi
rm -f $$.tmp

: check for volatile keyword
echo " "
echo 'Checking to see if your C compiler knows about "volatile"...'
$cat >try.c <<'EOCP'
main()
{
	char *volatile foo;
	volatile int bar;
	foo = foo;
}
EOCP
if $cc -c $ccflags try.c >/dev/null 2>&1 ; then
    d_volatile="$define"
    echo "Yup, it does."
else
    d_volatile="$undef"
    echo "Nope, it doesn't."
fi
$rm -f try.*

: see if there is a wait4
set wait4 d_wait4
eval $inlibc

: check for void type
echo " "
$cat <<EOM
Checking to see how well your C compiler groks the void type...

  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.

EOM
case "$voidflags" in
'')
    $cat >try.c <<'EOCP'
#if TRY & 1
void main() {
#else
main() {
#endif
	extern void moo();	/* function returning void */
	void (*goo)();		/* ptr to func returning void */
#if TRY & 2
	void (*foo[10])();
#endif

#if TRY & 4
	if(goo == moo) {
		exit(0);
	}
#endif
	exit(0);
}
EOCP
    if $cc $ccflags -c -DTRY=$defvoidused try.c >.out 2>&1 ; then
	voidflags=$defvoidused
	echo "It appears to support void."
	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..."
	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
		voidflags=3
		echo "And it supports 2 but not 4."
	    else
		echo "It doesn't support 2..."
		if $cc $ccflags -c -DTRY=5 try.c >/dev/null 2>&1 ; then
		    voidflags=5
		    echo "But it supports 4."
		else
		    voidflags=1
		    echo "And it doesn't support 4."
		fi
	    fi
	else
	    echo "There is no support at all for void."
	    voidflags=0
	fi
    fi
esac
dflt="$voidflags";
rp="Your void support flags add up to what? [$dflt]"
$echo $n "$rp $c"
. myread
voidflags="$ans"
$rm -f try.* .out

: see what type gids are declared as in the kernel
echo " "
case "$gidtype" in
'')
    if $contains 'getgroups.*short' /usr/lib/lint/llib-lc >/dev/null 2>&1; then
	dflt='short'
    elif $contains 'getgroups.*int' /usr/lib/lint/llib-lc >/dev/null 2>&1; then
	dflt='int'
    elif $contains 'gid_t;' /usr/include/sys/types.h >/dev/null 2>&1 ; then
	dflt='gid_t'
    else
	set `grep 'groups\[NGROUPS\];' /usr/include/sys/user.h 2>/dev/null` unsigned short
	case $1 in
	unsigned) dflt="$1 $2" ;;
	*) dflt="$1" ;;
	esac
    fi
    ;;
*)  dflt="$gidtype"
    ;;
esac
cont=true
echo "(The following only matters if you have getgroups().)"
rp="What type are the group ids returned by getgroups()? [$dflt]"
$echo $n "$rp $c"
. myread
gidtype="$ans"

: see if this is an fcntl system
echo " "
if $test -r /usr/include/fcntl.h ; then
    i_fcntl="$define"
    echo "fcntl.h found."
else
    i_fcntl="$undef"
    echo "No fcntl.h found, but that's ok."
fi

: see if this is an grp system
echo " "
if $test -r /usr/include/grp.h ; then
    i_grp="$define"
    echo "grp.h found."
else
    i_grp="$undef"
    echo "No grp.h found."
fi

: see if this is a netinet/in.h system
echo " "
xxx=`loc netinet/in.h x /usr/include /usr/local/include $inclwanted`
if test -f $xxx; then
    i_niin="$define"
    echo "netinet/in.h found."
else
    i_niin="$undef"
    echo "No netinet/in.h found."
fi

: see if this is a sys/dir.h system
echo " "
if $test -r /usr/include/sys/dir.h ; then
    i_sysdir="$define"
    echo "sys/dir.h found."
else
    i_sysdir="$undef"
    echo "No sys/dir.h found."
fi

: see if ioctl defs are in sgtty/termio or sys/ioctl
echo " "
if $test -r /usr/include/sys/ioctl.h ; then
    i_sysioctl="$define"
    echo "sys/ioctl.h found."
else
    i_sysioctl="$undef"
    echo "sys/ioctl.h not found, assuming ioctl args are defined in sgtty.h."
fi

: see if this is a sys/ndir.h system
echo " "
xxx=`loc sys/ndir.h x /usr/include /usr/local/include $inclwanted`
if test -f $xxx; then
    i_sysndir="$define"
    echo "sys/ndir.h found."
else
    i_sysndir="$undef"
    echo "No sys/ndir.h found."
fi

: see if we should include utime.h
echo " "
if $test -r /usr/include/utime.h ; then
    i_utime="$define"
    echo "utime.h found."
else
    i_utime="$undef"
    echo "No utime.h found, but that's ok."
fi

: see if this is a varargs system
echo " "
if $test -r /usr/include/varargs.h ; then
    i_varargs="$define"
    echo "varargs.h found."
else
    i_varargs="$undef"
    echo "No varargs.h found, but that's ok (I hope)."
fi

: see if this is a vfork system
echo " "
if $test -r /usr/include/vfork.h ; then
    i_vfork="$define"
    echo "vfork.h found."
else
    i_vfork="$undef"
    echo "No vfork.h found."
fi

: check for length of integer
echo " "
case "$intsize" in
'')
    echo "Checking to see how big your integers are..."
    $cat >try.c <<'EOCP'
#include <stdio.h>
main()
{
    printf("%d\n", sizeof(int));
}
EOCP
    if $cc $ccflags try.c -o try >/dev/null 2>&1 ; then
	dflt=`./try`
    else
	dflt='4'
	echo "(I can't seem to compile the test program.  Guessing...)"
    fi
    ;;
*)
    dflt="$intsize"
    ;;
esac
rp="What is the size of an integer (in bytes)? [$dflt]"
$echo $n "$rp $c"
. myread
intsize="$ans"
$rm -f try.c try

: determine where private executables go
case "$privlib" in
'')
    dflt=/usr/lib/$package
    test -d /usr/local/lib && dflt=/usr/local/lib/$package
    ;;
*)  dflt="$privlib"
    ;;
esac
$cat <<EOM

The $package package has some auxiliary files that should be put in a library
that is accessible by everyone.  Where do you want to put these "private"
EOM
$echo $n "but accessible files? (~name ok) [$dflt] $c"
rp="Put private files where? [$dflt]"
. myread
privlib=`./filexp "$ans"`

: check for size of random number generator
echo " "
case "$randbits" in
'')
    echo "Checking to see how many bits your rand function produces..."
    $cat >try.c <<'EOCP'
#include <stdio.h>
main()
{
    register int i;
    register unsigned long tmp;
    register unsigned long max = 0L;

    for (i=1000; i; i--) {
	tmp = (unsigned long)rand();
	if (tmp > max) max = tmp;
    }
    for (i=0; max; i++)
	max /= 2;
    printf("%d\n",i);
}
EOCP
    if $cc $ccflags try.c -o try >/dev/null 2>&1 ; then
	dflt=`./try`
    else
	dflt='?'
	echo "(I can't seem to compile the test program...)"
    fi
    ;;
*)
    dflt="$randbits"
    ;;
esac
rp="How many bits does your rand() function produce? [$dflt]"
$echo $n "$rp $c"
. myread
randbits="$ans"
$rm -f try.c try

: generate list of signal names
echo " "
case "$sig_name" in
'')
    echo "Generating a list of signal names..."
    set X `cat /usr/include/signal.h /usr/include/sys/signal.h 2>&1 | awk '
$1 ~ /^#define$/ && $2 ~ /^SIG[A-Z0-9]*$/ && $3 ~ /^[1-9][0-9]*$/ {
    sig[$3] = substr($2,4,20)
    if (max < $3 && $3 < 60) {
	max = $3
    }
}

END {
    for (i=1; i<=max; i++) {
	if (sig[i] == "")
	    printf "%d", i
	else
	    printf "%s", sig[i]
	if (i < max)
	    printf " "
    }
    printf "\n"
}
'`
    shift
    case $# in
    0)  echo 'kill -l' >/tmp/foo$$
	set X `$csh -f </tmp/foo$$`
	shift
	case $# in
	0)set HUP INT QUIT ILL TRAP IOT EMT FPE KILL BUS SEGV SYS PIPE ALRM TERM
	    ;;
	esac
	;;
    esac
    sig_name="ZERO $*"
    ;;
esac
echo "Signals are: $sig_name"

: see what type of char stdio uses.
echo " "
if $contains 'unsigned.*char.*_ptr.*;' /usr/include/stdio.h >/dev/null 2>&1 ; then
    echo "Your stdio uses unsigned chars."
    stdchar="unsigned char"
else
    echo "Your stdio uses signed chars."
    stdchar="char"
fi

: see what type uids are declared as in the kernel
case "$uidtype" in
'')
    if $contains 'uid_t;' /usr/include/sys/types.h >/dev/null 2>&1 ; then
	dflt='uid_t';
    else
	set `grep '_ruid;' /usr/include/sys/user.h 2>/dev/null` unsigned short
	case $1 in
	unsigned) dflt="$1 $2" ;;
	*) dflt="$1" ;;
	esac
    fi
    ;;
*)  dflt="$uidtype"
    ;;
esac
cont=true
echo " "
rp="What type are user ids returned by getuid(), etc.? [$dflt]"
$echo $n "$rp $c"
. myread
uidtype="$ans"

: preserve RCS keywords in files with variable substitution, grrr
Log='$Log'
Header='$Header'


: determine which malloc to compile in
echo " "
case "$usemymalloc" in
'')
    if bsd || v7; then
	dflt='y'
    else
	dflt='n'
    fi
    ;;
*)  dflt="$usemymalloc"
    ;;
esac
rp="Do you wish to attempt to use the malloc that comes with $package? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
'') ans=$dflt;;
esac
usemymalloc="$ans"
case "$ans" in
y*) mallocsrc='malloc.c'; mallocobj='malloc.o';;
*) mallocsrc=''; mallocobj='';;
esac

: determine compiler compiler
case "$yacc" in
'') dflt=yacc;;
*)  dflt="$yacc";;
esac
cont=true
    echo " "
rp="Which compiler compiler (yacc or bison -y) will you use? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
'') ans="$dflt";;
esac
yacc="$ans"

echo " "
echo "End of configuration questions."
echo " "

: create config.sh file
echo " "
if test -d ../UU; then
    cd ..
fi
echo "Creating config.sh..."
$spitshell <<EOT >config.sh
$startsh
# config.sh
# This file was produced by running the Configure script.

d_eunice='$d_eunice'
define='$define'
eunicefix='$eunicefix'
loclist='$loclist'
expr='$expr'
sed='$sed'
echo='$echo'
cat='$cat'
rm='$rm'
mv='$mv'
cp='$cp'
tail='$tail'
tr='$tr'
mkdir='$mkdir'
sort='$sort'
uniq='$uniq'
grep='$grep'
trylist='$trylist'
test='$test'
inews='$inews'
egrep='$egrep'
more='$more'
pg='$pg'
Mcc='$Mcc'
vi='$vi'
mailx='$mailx'
mail='$mail'
cpp='$cpp'
perl='$perl'
emacs='$emacs'
ls='$ls'
rmail='$rmail'
sendmail='$sendmail'
shar='$shar'
smail='$smail'
tbl='$tbl'
troff='$troff'
nroff='$nroff'
uname='$uname'
uuname='$uuname'
line='$line'
chgrp='$chgrp'
chmod='$chmod'
lint='$lint'
sleep='$sleep'
pr='$pr'
tar='$tar'
ln='$ln'
lpr='$lpr'
lp='$lp'
touch='$touch'
make='$make'
date='$date'
csh='$csh'
Log='$Log'
Header='$Header'
bin='$bin'
byteorder='$byteorder'
contains='$contains'
cppstdin='$cppstdin'
cppminus='$cppminus'
d_bcmp='$d_bcmp'
d_bcopy='$d_bcopy'
d_bzero='$d_bzero'
d_charsprf='$d_charsprf'
d_crypt='$d_crypt'
cryptlib='$cryptlib'
d_csh='$d_csh'
d_dosuid='$d_dosuid'
d_dup2='$d_dup2'
d_fchmod='$d_fchmod'
d_fchown='$d_fchown'
d_fcntl='$d_fcntl'
d_flock='$d_flock'
d_getgrps='$d_getgrps'
d_gethent='$d_gethent'
d_getpgrp='$d_getpgrp'
d_getpgrp2='$d_getpgrp2'
d_getprior='$d_getprior'
d_htonl='$d_htonl'
d_index='$d_index'
d_ioctl='$d_ioctl'
d_killpg='$d_killpg'
d_lstat='$d_lstat'
d_memcmp='$d_memcmp'
d_memcpy='$d_memcpy'
d_mkdir='$d_mkdir'
d_ndbm='$d_ndbm'
d_odbm='$d_odbm'
d_readdir='$d_readdir'
d_rename='$d_rename'
d_rmdir='$d_rmdir'
d_setegid='$d_setegid'
d_seteuid='$d_seteuid'
d_setpgrp='$d_setpgrp'
d_setpgrp2='$d_setpgrp2'
d_setprior='$d_setprior'
d_setregid='$d_setregid'
d_setresgid='$d_setresgid'
d_setreuid='$d_setreuid'
d_setresuid='$d_setresuid'
d_setrgid='$d_setrgid'
d_setruid='$d_setruid'
d_socket='$d_socket'
d_sockpair='$d_sockpair'
d_oldsock='$d_oldsock'
socketlib='$socketlib'
d_statblks='$d_statblks'
d_stdstdio='$d_stdstdio'
d_strctcpy='$d_strctcpy'
d_strerror='$d_strerror'
d_symlink='$d_symlink'
d_syscall='$d_syscall'
d_varargs='$d_varargs'
d_vfork='$d_vfork'
d_voidsig='$d_voidsig'
d_volatile='$d_volatile'
d_vprintf='$d_vprintf'
d_charvspr='$d_charvspr'
d_wait4='$d_wait4'
gidtype='$gidtype'
i_dirent='$i_dirent'
d_dirnamlen='$d_dirnamlen'
i_fcntl='$i_fcntl'
i_grp='$i_grp'
i_niin='$i_niin'
i_pwd='$i_pwd'
d_pwquota='$d_pwquota'
d_pwage='$d_pwage'
d_pwchange='$d_pwchange'
d_pwclass='$d_pwclass'
d_pwexpire='$d_pwexpire'
i_sysdir='$i_sysdir'
i_sysioctl='$i_sysioctl'
i_sysndir='$i_sysndir'
i_time='$i_time'
i_systime='$i_systime'
d_systimekernel='$d_systimekernel'
i_utime='$i_utime'
i_varargs='$i_varargs'
i_vfork='$i_vfork'
intsize='$intsize'
libc='$libc'
mallocsrc='$mallocsrc'
mallocobj='$mallocobj'
usemymalloc='$usemymalloc'
mansrc='$mansrc'
manext='$manext'
models='$models'
split='$split'
small='$small'
medium='$medium'
large='$large'
huge='$huge'
optimize='$optimize'
ccflags='$ccflags'
cppflags='$cppflags'
ldflags='$ldflags'
cc='$cc'
libs='$libs'
n='$n'
c='$c'
package='$package'
randbits='$randbits'
sig_name='$sig_name'
spitshell='$spitshell'
shsharp='$shsharp'
sharpbang='$sharpbang'
startsh='$startsh'
stdchar='$stdchar'
uidtype='$uidtype'
voidflags='$voidflags'
defvoidused='$defvoidused'
yacc='$yacc'
privlib='$privlib'
lib='$lib'
CONFIG=true
EOT

CONFIG=true

echo " "
dflt=''
fastread=''
echo "If you didn't make any mistakes, then just type a carriage return here."
rp="If you need to edit config.sh, do it as a shell escape here:"
$echo $n "$rp $c"
. UU/myread
case "$ans" in
'') ;;
*) : in case they cannot read
    eval $ans;;
esac
: if this fails, just run all the .SH files by hand
. ./config.sh

echo " "
echo "Doing variable substitutions on .SH files..."
set x `awk '{print $1}' <MANIFEST | $grep '\.SH'`
shift
case $# in
0) set x *.SH; shift;;
esac
if test ! -f $1; then
    shift
fi
for file in $*; do
    case "$file" in
    */*)
	dir=`$expr X$file : 'X\(.*\)/'`
	file=`$expr X$file : 'X.*/\(.*\)'`
	(cd $dir && . $file)
	;;
    *)
	. $file
	;;
    esac
done
if test -f config.h.SH; then
    if test ! -f config.h; then
	: oops, they left it out of MANIFEST, probably, so do it anyway.
	. config.h.SH
    fi
fi

if $contains '^depend:' Makefile >/dev/null 2>&1; then
    dflt=n
    $cat <<EOM

Now you need to generate make dependencies by running "make depend".
You might prefer to run it in background: "make depend > makedepend.out &"
It can take a while, so you might not want to run it right now.

EOM
    rp="Run make depend now? [$dflt]"
    $echo $n "$rp $c"
    . UU/myread
    case "$ans" in
    y*) make depend && echo "Now you must run a make."
	;;
    *)  echo "You must run 'make depend' then 'make'."
	;;
    esac
elif test -f Makefile; then
    echo " "
    echo "Now you must run a make."
else
    echo "Done."
fi

$rm -f kit*isdone
: the following is currently useless
cd UU && $rm -f $rmlist
: since this removes it all anyway
cd .. && $rm -rf UU
: end of Configure