#! /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.)
#
# $RCSfile: Configure,v $$Revision: 4.0.1.2 $$Date: 91/06/07 10:09:34 $
#
# 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.)

cat >/tmp/c1$$ <<EOF
ARGGGHHHH!!!!!

SCO csh still thinks true is false.  Write to SCO today and tell them that next
year Configure ought to "rm /bin/csh" unless they fix their blasted shell. :-)

(Actually, Configure ought to just patch csh in place.  Hmm.  Hmmmmm.  All
we'd have to do is go in and swap the && and || tokens, wherever they are.)

[End of diatribe.  We now return you to your regularly scheduled programming...]

EOF
cat >/tmp/c2$$ <<EOF
OOPS!  You naughty creature!  You didn't run Configure with sh!
I will attempt to remedy the situation by running sh for you...

EOF

true || cat /tmp/c1$$ /tmp/c2$$
true || exec sh $0

export PATH || cat /tmp/c2$$
export PATH || exec sh $0
rm -f /tmp/c1$$ /tmp/c2$$

PATH=".:$PATH:/bin:/usr/bin:/usr/local/bin:/usr/ucb:/usr/local:/usr/lbin:/etc:/usr/new:/usr/new/bin:/usr/nbin"

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=''
bash=''
ksh=''
lex=''
flex=''
bison=''
Log=''
Header=''
Id=''
lastuname=''
alignbytes=''
bin=''
installbin=''
byteorder=''
contains=''
cppstdin=''
cppminus=''
d_bcmp=''
d_bcopy=''
d_bzero=''
d_castneg=''
castflags=''
d_charsprf=''
d_chsize=''
d_crypt=''
cryptlib=''
d_csh=''
d_dosuid=''
d_dup2=''
d_fchmod=''
d_fchown=''
d_fcntl=''
d_flexfnam=''
d_flock=''
d_getgrps=''
d_gethent=''
d_getpgrp=''
d_getpgrp2=''
d_getprior=''
d_htonl=''
d_index=''
d_killpg=''
d_lstat=''
d_memcmp=''
d_memcpy=''
d_mkdir=''
d_msg=''
d_msgctl=''
d_msgget=''
d_msgrcv=''
d_msgsnd=''
d_ndbm=''
d_odbm=''
d_open3=''
d_readdir=''
d_rename=''
d_rmdir=''
d_select=''
d_sem=''
d_semctl=''
d_semget=''
d_semop=''
d_setegid=''
d_seteuid=''
d_setpgrp=''
d_setpgrp2=''
d_setprior=''
d_setregid=''
d_setresgid=''
d_setreuid=''
d_setresuid=''
d_setrgid=''
d_setruid=''
d_shm=''
d_shmat=''
d_voidshmat=''
d_shmctl=''
d_shmdt=''
d_shmget=''
d_socket=''
d_sockpair=''
d_oldsock=''
socketlib=''
d_statblks=''
d_stdstdio=''
d_strctcpy=''
d_strerror=''
d_symlink=''
d_syscall=''
d_truncate=''
d_vfork=''
d_voidsig=''
d_tosignal=''
d_volatile=''
d_vprintf=''
d_charvspr=''
d_wait4=''
d_waitpid=''
gidtype=''
groupstype=''
i_fcntl=''
i_gdbm=''
i_grp=''
i_niin=''
i_sysin=''
i_pwd=''
d_pwquota=''
d_pwage=''
d_pwchange=''
d_pwclass=''
d_pwexpire=''
d_pwcomment=''
i_sys_file=''
i_sysioctl=''
i_time=''
i_sys_time=''
i_sys_select=''
d_systimekernel=''
i_utime=''
i_varargs=''
i_vfork=''
intsize=''
libc=''
nm_opts=''
libndir=''
i_my_dir=''
i_ndir=''
i_sys_ndir=''
i_dirent=''
i_sys_dir=''
d_dirnamlen=''
ndirc=''
ndiro=''
mallocsrc=''
mallocobj=''
usemymalloc=''
mallocptrtype=''
mansrc=''
manext=''
models=''
split=''
small=''
medium=''
large=''
huge=''
optimize=''
ccflags=''
cppflags=''
ldflags=''
cc=''
nativegcc=''
libs=''
n=''
c=''
package=''
randbits=''
scriptdir=''
installscr=''
sig_name=''
spitshell=''
shsharp=''
sharpbang=''
startsh=''
stdchar=''
uidtype=''
usrinclude=''
inclPath=''
void=''
voidhave=''
voidwant=''
w_localtim=''
w_s_timevl=''
w_s_tm=''
yacc=''
lib=''
privlib=''
installprivlib=''
CONFIG=''
: get the name of the package
package=perl
: Here we go...
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/ccs/lib /usr/lib /usr/ucblib /usr/local/lib /usr/lib/large /lib '$xlibpth' /lib/large /usr/lib/small /lib/small'
smallmach='pdp11 i8086 z8000 i80286 iAPX286'
trap 'echo " "; 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

attrlist="DGUX M_I186 M_I286 M_I386 M_I8086 M_XENIX UTS __DGUX__"
attrlist="$attrlist __STDC__ __m88k__ ansi bsd4_2 gcos gimpel"
attrlist="$attrlist hp9000s300 hp9000s500 hp9000s800 hpux"
attrlist="$attrlist i186 i386 i8086 iAPX286 ibm interdata"
attrlist="$attrlist m68k m88k mc300 mc500 mc68000 mc68k mc700 mert"
attrlist="$attrlist ns16000 ns32000 nsc32000 os pdp11 posix pyr sinix"
attrlist="$attrlist sparc sun tower tower32 tower32_600 tower32_800 tss"
attrlist="$attrlist u3b2 u3b20 u3b200 u3b5 ultrix unix vax venix xenix"
attrlist="$attrlist z8000"
boPATH=""
eoPATH="/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 /bsd43/usr/bin"
d_newshome="/usr/NeWS"
errnolist=errnolist
h_fcntl=false
h_sys_file=false
serve_shm=""
serve_msg="$undef"
serve_inet_udp=""
serve_inet_tcp=""
serve_unix_udp=""
serve_unix_tcp=""
d_ndir=ndir
voidwant=1
voidwant=7
libswanted="c_s net_s net nsl_s nsl socket nm ndir ndbm dbm malloc sun m bsd BSD x posix ucb"
inclwanted='/usr/include /usr/netinclude /usr/include/sun /usr/include/bsd /usr/include/lan /usr/ucbinclude'

: Now test for existence of everything in MANIFEST

echo "First let's make sure your kit is complete.  Checking..."
awk '$1 !~ /PACKINGLIST/ {print $1}' ../MANIFEST | split -200
rm -f missing
for filelist in x??; do
    (cd ..; ls `cat UU/$filelist` >/dev/null 2>>UU/missing)
done
if test -s missing; then
    cat missing
    kill $$
fi
echo "Looks good..."

: some greps do not return status, grrr.
echo "grimblepritz" >contains.txt
if grep blurfldyick contains.txt >/dev/null 2>&1 ; then
    contains=contains
elif grep grimblepritz contains.txt >/dev/null 2>&1 ; then
    contains=grep
else
    contains=contains
fi
: 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..."
    if test -f /bsd43/bin/echo; then
	echo "#!/bsd43/bin/echo hi" > spit.sh
    else
	echo "#!/bin/echo hi" > spit.sh
    fi
    $eunicefix spit.sh
    chmod +x spit.sh
    ./spit.sh > today
    if $contains hi today >/dev/null 2>&1; then
	echo "It does."
	sharpbang='#!'
    else
	echo "#! /bin/echo hi" > spit.sh
	$eunicefix spit.sh
	chmod +x spit.sh
	./spit.sh > today
	if test -s today; then
	    echo "It does."
	    sharpbang='#! '
	else
	    echo "It doesn't."
	    sharpbang=': use '
	fi
    fi
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 >start.sh <<EOSS
$startsh
set abc
test "$?abc" != 1
EOSS

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

: 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

: 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@netlabs.com)
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

: 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
bison
cpp
csh
egrep
nroff
test
uname
yacc
"
pth=`echo :$boPATH:$PATH:$eoPATH: | sed -e 's/:/ /g'`
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" >Loc1.txt
    echo $n "hi there$c" >Loc2.txt
    if cmp Loc1.txt Loc2.txt >/dev/null 2>&1; then
	echo "They are compatible.  In fact, they may be identical."
    else
	case "$n" in
	'-n') n='' c='\c' ans='\c' ;;
	*) n='-n' c='' ans='-n' ;;
	esac
	cat <<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
    ;;
*)
    : cross your fingers
    echo=echo
    ;;
esac

: 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

: get old answers, if there is a config file out there
hint=default
if test -f ../config.sh; then
    echo " "
    eval "`grep lastuname ../config.sh`"
    tmp=`(uname -a) 2>&1`
    if test "X$tmp" = "X$lastuname"; then
	dflt=y
    else
	dflt=n
    fi
    lastuname="$tmp"
    rp="I see a config.sh file.  Did Configure make it on THIS system? [$dflt]"
    echo $n "$rp $c"
    . myread
    case "$ans" in
    n*) echo "OK, I'll ignore it."; mv ../config.sh ../config.sh.old;;
    *)  echo "Fetching default answers from your old config.sh file..."
	tmp="$n"
	ans="$c"
        . ../config.sh
	n="$tmp"
	c="$ans"
	hint=previous
	;;
    esac
fi
if test -d ../hints && test ! -f ../config.sh; then
    echo ' '
    echo "First time through, eh?  I have some defaults handy for the following systems:"
    (cd ../hints; ls -C *.sh | sed 's/\.sh/   /g')
    dflt=''
    : Half the following guesses are probably wrong...
    test -f /irix && dflt="$dflt sgi"
    test -f /xenix && dflt="$dflt sco_xenix"
    test -f /dynix && dflt="$dflt dynix"
    test -f /dnix && dflt="$dflt dnix"
    test -f /bin/mips && /bin/mips && dflt="$dflt mips"
    test -d /NextApps && test -f /usr/adm/software_version && dflt="$dflt next"
    if test -f /bin/uname || test -f /usr/bin/uname; then
	set `uname -a | tr '[A-Z]' '[a-z]'`

	test -f "../hints/$5.sh" && dflt="$dflt $5"

	case "$5" in
	3b2) dflt="$dflt 3b2";;
	fps*) dflt="$dflt fps";;
	mips*) dflt="$dflt mips";;
	[23]100) dflt="$dflt mips";;
	next*) dflt="$dflt next" ;;
	esac

	case "$1" in
	aix) dflt="$dflt aix_rs" ;;
	sunos) case "$3" in
	    3.4) dflt="$dflt sunos_3_4" ;;
	    3.5) dflt="$dflt sunos_3_5" ;;
	    4.0.1) dflt="$dflt sunos_4_0_1" ;;
	    4.0.2) dflt="$dflt sunos_4_0_2" ;;
	    esac
	    ;;
	dnix) dflt="$dflt dnix" ;;
	genix) dflt="$dflt genix" ;;
	hp*ux) dflt="$dflt hpux" ;;
	next) dflt="$dflt next" ;;
	irix) dflt="$dflt sgi" ;;
	ultrix) case "$3" in
	    3*) dflt="$dflt ultrix_3" ;;
	    4*) dflt="$dflt ultrix_4" ;;
	    esac
	    ;;
	uts) dflt="$dflt uts" ;;
	$2) if test -f /etc/systemid; then
		set `echo $3 | sed 's/\./ /` $4
		if test -f ../hints/sco_$1_$2_$3.sh; then
		    dflt="$dflt sco_$1_$2_$3"
		elif test -f ../hints/sco_$1_$2.sh; then
		    dflt="$dflt sco_$1_$2"
		elif test -f ../hints/sco_$1.sh; then
		    dflt="$dflt sco_$1"
		fi
	    fi
	    ;;
	esac
    fi
    set X `echo $dflt | tr ' ' '\012' | sort | uniq`
    shift
    dflt=${1+"$@"}
    case "$dflt" in
    '') dflt=none;;
    esac
    echo '(You may give one or more space-separated answers, or "none" if appropriate.'
    echo 'If your OS version has no hints, do not give a wrong version--say "none".)'
    rp="Which of these apply, if any? [$dflt]"
    echo $n "$rp $c"
    . myread
    for file in $ans; do
	if test -f ../hints/$file.sh; then
	    . ../hints/$file.sh
	    cat ../hints/$file.sh >>../config.sh
	    hint=recommended
	fi
    done
fi

cat >whoa <<'EOF'
eval "was=\$$2"
dflt=y
echo ' '
echo "*** WHOA THERE!!! ***"
echo "    The $hint value for \$$2 on this machine was \"$was\"!"
rp="    Keep the $hint value? [y]"
echo $n "$rp $c"
. myread
case "$ans" in
y) td=$was; tu=$was;;
esac
EOF

setvar='td=$define; tu=$undef; set X $1; eval "was=\$$2";
case "$val$was" in
defineundef) . whoa; eval "$2=\$td";;
undefdefine) . whoa; eval "$2=\$tu";;
*) eval "$2=$val";;
esac'

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

: Sigh.  Well, at least the box is fast...
echo " "
$echo $n "Hmm...  $c"
case "$usrinclude" in
'') dflt='/usr/include';;
*) dflt=$usrinclude;;
esac
inclPath=''
if $test -f /bin/mips && /bin/mips; then
    echo "Looks like a MIPS system..."
    $cat >usrinclude.c <<'EOCP'
#ifdef SYSTYPE_BSD43
/bsd43
#endif
EOCP
    if cc -E usrinclude.c > usrinclude.out && $contains / usrinclude.out >/dev/null 2>&1 ; then
	echo "and you're compiling with the BSD43 compiler and libraries."
	dflt='/bsd43/usr/include'
	inclPath='/bsd43'
    else
	echo "and you're compiling with the SysV compiler and libraries."
    fi
else
    echo "Doesn't look like a MIPS system."
    echo "exit 1" >mips
    chmod +x mips
    $eunicefix mips
fi

cont=true
while $test "$cont" ; do
    echo " "
    rp="Where are the include files you want to use? [$dflt]"
    $echo $n "$rp $c"
    . myread
    usrinclude="$ans"
    if $test -d $ans; then
	cont=''
    else
	if $test "$fastread" = yes; then
	    dflt=y
	else
	    dflt=n
	fi
	rp="Directory $ans doesn't exist.  Use that name anyway? [$dflt]"
	$echo $n "$rp $c"
	. myread
	dflt=''
	case "$ans" in
	y*) cont='';;
	esac
    fi
done

: make some quick guesses about what we are up against
echo " "
cat $usrinclude/signal.h $usrinclude/sys/signal.h >guess.txt 2>/dev/null
if test "$usrinclude" = "/bsd43/usr/include" ; then
    echo "Looks kind of like a SysV MIPS running BSD, but we'll see..."
    echo exit 0 >bsd
    echo exit 1 >usg
    echo exit 1 >v7
elif test `echo abc | tr a-z A-Z` = Abc ; then
    echo "Looks kind of like a USG system, but we'll see..."
    echo exit 1 >bsd
    echo exit 0 >usg
    echo exit 1 >v7
elif $contains SIGTSTP guess.txt >/dev/null 2>&1 ; then
    echo "Looks kind of like a BSD system, but we'll see..."
    echo exit 0 >bsd
    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

: 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`
    case "$nativegcc" in
    '') case "$ccflags" in
	*-fpcc-struct-return*) dflt=n;;
	*) dflt=y;;
	esac
	;;
    undef) dflt=n;;
    *) dflt=y;;
    esac
    echo " "
    rp="Are your system (especially dbm) libraries compiled with gcc? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
    n*) nativegcc="$undef"; gccflags='-fpcc-struct-return';;
    *) nativegcc="$define"; gccflags='';;
    esac
    ;;
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="$gccflags";;
    *) dflt='';;
    esac
    ;;
*-fpcc-struct-return*) dflt="$ccflags";;
*) case "$cc" in
    *gcc*) dflt="$ccflags $gccflags";;
    *) dflt="$ccflags";;
    esac
    ;;
esac
for thisincl in $inclwanted; do
    if test -d $thisincl; then
	if test "x$thisincl" != "x$usrinclude"; then
	    case "$dflt" in
	    *$thisincl*);;
	    *) dflt="$dflt -I$thisincl";;
	    esac
	fi
    fi
done
case "$optimize" in
-g*)
    case "$dflt" in
    *DEBUGGING*);;
    *) dflt="$dflt -DDEBUGGING";;
    esac
    ;;
esac
if $contains 'LANGUAGE_C' $usrinclude/signal.h >/dev/null 2>&1; then
    case "$dflt" in
    *LANGUAGE_C*);;
    *) dflt="$dflt -DLANGUAGE_C";;
    esac
fi
if $contains '_NO_PROTO' $usrinclude/signal.h >/dev/null 2>&1; then
    case "$dflt" in
    *_NO_PROTO*);;
    *) dflt="$dflt -D_NO_PROTO";;
    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*|-U*|-I*|-traditional|-ansi|-nostdinc) 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"

echo " "
echo "Checking for optional libraries..."
case "$libs" in
'') dflt=' ';;
*) dflt="$libs ";;
esac
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/ccs/lib /usr/lib /usr/ucblib /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
		xxx=`./loc lib$thislib.so X /usr/ccs/lib /usr/lib /usr/ucblib /usr/local/lib /lib`
		if test -f $xxx; then
		    echo "Found -l$thislib as a shared object only."
		    case "$dflt" in
		    *"-l$thislib "*|*"-l$thatlib "*);;
		    *) dflt="$dflt -l$thislib ";;
		    esac
		else
		    echo "No -l$thislib."
		fi
	    fi
	fi
    fi
done
set X $dflt
shift
dflt="$*"
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 size of random number generator
echo " "
case "$alignbytes" in
'')
    echo "Checking alignment constraints..."
    $cat >try.c <<'EOCP'
struct foobar {
    char foo;
    double bar;
} try;
main()
{
    printf("%d\n", (char*)&try.bar - (char*)&try.foo);
}
EOCP
    if $cc $ccflags try.c -o try >/dev/null 2>&1 ; then
	dflt=`./try`
    else
	dflt='?'
	echo "(I can't seem to compile the test program...)"
    fi
    ;;
*)
    dflt="$alignbytes"
    ;;
esac
rp="Doubles must be aligned on a how-many-byte boundary? [$dflt]"
$echo $n "$rp $c"
. myread
alignbytes="$ans"
$rm -f try.c try

: determine where public executables go
cat <<EOF
 
The following questions distinguish the directory in which executables
reside from the directory in which they are installed (and from which they
are presumably copied to the former directory by occult means).  This
distinction is often necessary under afs.  On most other systems, however,
the two directories are the same.
 
EOF
case "$bin" in
'')
    dflt=`./loc . /usr/local/bin /usr/local/bin /usr/lbin /usr/local /usr/bin /bin`
    ;;
*)  dflt="$bin"
    ;;
esac
cont=true
while $test "$cont" ; do
    rp="In which directory will public executables reside (~name ok)? [$dflt]"
    $echo "In which directory will public executables reside (~name ok)?"
    $echo $n "[$dflt] $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

case "$installbin" in
'')
    dflt=`echo $bin | sed 's#^/afs/#/afs/.#'`
    test -d $dflt || dflt="$bin"
    ;;
*)  dflt="$installbin"
    ;;
esac
cont=true
while $test "$cont" ; do
    rp="In which directory will public executables be installed (~name ok)? [$dflt]"
    $echo "In which directory will public executables be installed (~name ok)?"
    $echo $n "[$dflt] $c"
    . myread
    installbin="$ans"
    installbin=`./filexp $installbin`
    if test -d $installbin; then
	cont=''
    else
	case "$fastread" in
	yes) dflt=y;;
	*) dflt=n;;
	esac
	rp="Directory $installbin doesn't exist.  Use that name anyway? [$dflt]"
	$echo $n "$rp $c"
	. myread
	dflt=''
	case "$ans" in
	y*) cont='';;
	esac
    fi
done

: 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 >byteorder.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 byteorder.c -o byteorder >/dev/null 2>&1 ; then
	dflt=`./byteorder`
	case "$dflt" in
	????|????????) echo "(The test program ran ok.)";;
	*) echo "(The test program didn't run right for some reason.)";;
	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"

: check for ability to cast negative floats to unsigned
echo " "
echo 'Checking to see if your C compiler can cast weird floats to unsigned'
$cat >try.c <<'EOCP'
#include <signal.h>

blech() { exit(3); }

main()
{
	double f = -123;
	unsigned long along;
	unsigned int aint;
	unsigned short ashort;
	int result = 0;

	signal(SIGFPE, blech);
	along = (unsigned long)f;
	aint = (unsigned int)f;
	ashort = (unsigned short)f;
	if (along != (unsigned long)-123)
	    result |= 1;
	if (aint != (unsigned int)-123)
	    result |= 1;
	if (ashort != (unsigned short)-123)
	    result |= 1;
	f = (double)0x40000000;
	f = f + f;
	along = 0;
	along = (unsigned long)f;
	if (along != 0x80000000)
	    result |= 2;
	f -= 1;
	along = 0;
	along = (unsigned long)f;
	if (along != 0x7fffffff)
	    result |= 1;
	f += 2;
	along = 0;
	along = (unsigned long)f;
	if (along != 0x80000001)
	    result |= 2;
	exit(result);
}
EOCP
if $cc -o try $ccflags try.c >/dev/null 2>&1; then
    ./try
    castflags=$?
else
    castflags=3
fi
case "$castflags" in
0)  val="$define"
    echo "Yup, it does."
    ;;
*)  val="$undef"
    echo "Nope, it doesn't."
    ;;
esac
set d_castneg
eval $setvar
$rm -f 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

cd ..
echo 'cat >.$$.c; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' >cppstdin
chmod 755 cppstdin
wrapper=`pwd`/cppstdin
cd UU

if test "X$cppstdin" != "X" && \
  $cppstdin $cppminus <testcpp.c >testcpp.out 2>&1 && \
  $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
    echo "You used to use $cppstdin $cppminus so we'll use that again."
elif test "$cc" = gcc && \
  (echo "Using gcc, eh?  We'll try to force gcc -E using a wrapper..."; \
  $wrapper <testcpp.c >testcpp.out 2>&1; \
  $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1) ; then
    echo "Yup, we can."
    cppstdin="$wrapper"
    cppminus='';
elif echo 'Maybe "'"$cc"' -E" will work...'; \
  $cc -E <testcpp.c >testcpp.out 2>&1; \
  $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
    echo "Yup, it does."
    cppstdin="$cc -E"
    cppminus='';
elif echo 'Nope...maybe "'"$cc"' -E -" will work...'; \
  $cc -E - <testcpp.c >testcpp.out 2>&1; \
  $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
    echo "Yup, it does."
    cppstdin="$cc -E"
    cppminus='-';
elif echo 'Uh-uh.  Time to get fancy.  Trying a wrapper...'; \
  $wrapper <testcpp.c >testcpp.out 2>&1; \
  $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
    cppstdin="$wrapper"
    cppminus=''
    echo "Eureka!."
elif echo 'No such luck, maybe "'$cpp'" will work...'; \
  $cpp <testcpp.c >testcpp.out 2>&1; \
  $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
    echo "It works!"
    cppstdin="$cpp"
    cppminus='';
elif echo 'Nixed again...maybe "'$cpp' -" will work...'; \
  $cpp - <testcpp.c >testcpp.out 2>&1; \
  $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
    echo "Hooray, it works!  I was beginning to wonder."
    cppstdin="$cpp"
    cppminus='-';
elif echo 'Nope...maybe "'"$cc"' -P" will work...'; \
  $cc -P <testcpp.c >testcpp.out 2>&1; \
  $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
    echo "Yipee, that works!"
    cppstdin="$cc -P"
    cppminus='';
elif echo 'Nope...maybe "'"$cc"' -P -" will work...'; \
  $cc -P - <testcpp.c >testcpp.out 2>&1; \
  $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
    echo "At long last!"
    cppstdin="$cc -P"
    cppminus='-';
else
    dflt=blurfl
    $echo $n "No dice.  I can't find a C preprocessor.  Name one: $c"
    rp='Name a C preprocessor:'
    . myread
    cppstdin="$ans"
    $cppstdin <testcpp.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 and rerun Configure."
	exit 1
    fi
fi

: get list of predefined functions in a handy place
echo " "
case "$libc" in
'') libc=unknown;;
esac
case "$nm_opts" in
'') if test -f /mach_boot; then
	nm_opts=''
    elif test -d /usr/ccs/lib; then
	nm_opts='-p'
    else
	nm_opts=''
    fi
    ;;
esac
: on mips, we DO NOT want /lib, and we want inclPath/usr/lib
case "$libpth" in
'') if mips; then
	libpth='$inclPath/usr/lib /usr/local/lib'
	nm_opts="-B"
    else
	libpth='/usr/ccs/lib /lib /usr/lib /usr/ucblib /usr/local/lib'
    fi
    ;;
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/ccs/lib/libc.so
test -f $1 || set /usr/lib/libc.so
test -f $1 || set /usr/lib/libc.so.[0-9]*
test -f $1 || set /lib/libsys_s.a
eval set \$$#
if test -f "$1"; then
    echo "Your (shared) C library seems to be in $1."
    libc="$1"
elif test -f "$libc"; then
    echo "Your C library seems to be in $libc."
elif test -f /lib/libc.a; then
    echo "Your C library seems to be in /lib/libc.a.  You're normal."
    libc=/lib/libc.a
else
    if   ans=`./loc libc.a  blurfl/dyick $libpth`; test -f "$ans"; then
	:
    elif ans=`./loc libc    blurfl/dyick $libpth`; test -f "$ans"; then
	    libnames="$libnames "`./loc clib blurfl/dyick $libpth`
    elif ans=`./loc clib    blurfl/dyick $libpth`; test -f "$ans"; then
	:
    elif ans=`./loc Slibc.a blurfl/dyick $xlibpth`; test -f "$ans"; then
	:
    elif ans=`./loc Mlibc.a blurfl/dyick $xlibpth`; test -f "$ans"; then
	:
    elif ans=`./loc Llibc.a blurfl/dyick $xlibpth`; test -f "$ans"; then
	:
    fi
    if test -f "$ans"; then
	echo "Your C library seems to be 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 " "
if test $libc = "/lib/libc"; then
    libc="$libc /lib/clib"
fi
cat <<END
 
If the guess above is wrong (which it might be if you're using a strange
compiler, or your machine supports multiple models), you can override it here.
END
dflt="$libc";
rp="Your C library is where? [$dflt]"
$echo $n "$rp $c"
. myread
libc="$ans"
echo " "
echo $libc $libnames | tr ' ' '\012' | sort | uniq >libnames
$echo "Extracting names from the following files for later perusal:"
sed 's/^/	/' libnames
echo $n "This may take a while...$c"
set X `cat libnames`
shift
nm $nm_opts $* 2>/dev/null >libc.tmp
$sed -n -e 's/^.* [ATDS]  *[_.]*//p' -e 's/^.* [ATDS] //p' <libc.tmp >libc.list
if $contains '^printf$' libc.list >/dev/null 2>&1; then
    echo done
elif $sed -n -e 's/^__*//' -e 's/^\([a-zA-Z_0-9$]*\).*xtern.*/\1/p' \
	<libc.tmp >libc.list; \
  $contains '^printf$' libc.list >/dev/null 2>&1; then
    echo done
elif $sed -n -e '/|UNDEF/d' -e '/FUNC..GL/s/^.*|__*//p' <libc.tmp >libc.list; \
  $contains '^printf$' libc.list >/dev/null 2>&1; then
    echo done
elif $sed -n -e 's/^.* D __*//p' -e 's/^.* D //p' <libc.tmp >libc.list; \
  $contains '^printf$' libc.list >/dev/null 2>&1; then
    echo done
elif $sed -n -e 's/^_//' -e 's/^\([a-zA-Z_0-9]*\).*xtern.*text.*/\1/p' \
		<libc.tmp >libc.list; \
  $contains '^printf$' libc.list >/dev/null 2>&1; then
    echo done
elif $grep '|' <libc.tmp | $sed -n -e '/|COMMON/d' -e '/|DATA/d' -e '/ file/d' \
                                   -e 's/^\([^     ]*\).*/\1/p' >libc.list
  $contains '^printf$' libc.list >/dev/null 2>&1; then
    echo done
elif $sed -n -e 's/^.*|FUNC |GLOB .*|//p' -e 's/^.*|FUNC |WEAK .*|//p' \
	   <libc.tmp >libc.list; \
  $contains '^printf$' libc.list >/dev/null 2>&1; then
    echo done
else
    nm -p $* 2>/dev/null >libc.tmp
    $sed -n -e 's/^.* [AT]  *_[_.]*//p' -e 's/^.* [AT] //p' <libc.tmp >libc.list
    if $contains '^printf$' libc.list >/dev/null 2>&1; then
	nm_opts='-p'
	echo "done"
    else
	echo " "
	echo "nm didn't seem to work right."
	echo "Trying ar instead..."
	if ar t $libc > libc.tmp; then
	    for thisname in $libnames; do
		ar t $thisname >>libc.tmp
	    done
	    $sed -e 's/\.o$//' < libc.tmp > libc.list
	    echo "Ok."
	else
	    echo "ar didn't seem to work right."
	    echo "Maybe this is a Cray...trying bld instead..."
	    if bld t $libc | $sed -e 's/.*\///' -e 's/\.o:.*$//' > libc.list; then
		for thisname in $libnames; do
		    bld t $libnames | \
			$sed -e 's/.*\///' -e 's/\.o:.*$//' >>libc.list
		    ar t $thisname >>libc.tmp
		done
		echo "Ok."
	    else
		echo "That didn't work either.  Giving up."
		exit 1
	    fi
	fi
    fi
fi
if test -f /lib/syscalls.exp; then
    echo "Also extracting names from /lib/syscalls.exp for good ole AIX..."
    sed -n 's/^\([^ 	]*\)[ 	]*syscall$/\1/p' /lib/syscalls.exp >>libc.list
fi

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

: 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'
#include <stdio.h>
main()
{
    int sprintf();
    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)."
    val="$undef"
else
    echo "Your sprintf() returns (char*)."
    val="$define"
fi
set d_charsprf
eval $setvar

: see if vprintf exists
echo " "
if $contains '^vprintf$' libc.list >/dev/null 2>&1; then
    echo 'vprintf() found.'
    val="$define"
    cat >vprintf.c <<'EOF'
#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 vprintf.c -o vprintf >/dev/null 2>&1 && ./vprintf; then
	echo "Your vsprintf() returns (int)."
	val2="$undef"
    else
	echo "Your vsprintf() returns (char*)."
	val2="$define"
    fi
else
    echo 'vprintf() not found.'
    val="$undef"
    val2="$undef"
fi
set d_vprintf
eval $setvar
val=$val2
set d_charvspr
eval $setvar

: see if chsize exists
set chsize d_chsize
eval $inlibc

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

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

: see if readdir exists
set readdir d_readdir
eval $inlibc

: see if there are directory access routines out there
echo " "
xxx=`./loc ndir.h x $usrinclude /usr/local/include $inclwanted`
case "$xxx" in
x)
    xxx=`./loc sys/ndir.h x $usrinclude /usr/local/include $inclwanted`
    ;;
esac
D_dirnamlen="$undef"
I_dirent="$undef"
I_sys_dir="$undef"
I_my_dir="$undef"
I_ndir="$undef"
I_sys_ndir="$undef"
libndir=''
ndirc=''
ndiro=''
if $test -r $usrinclude/dirent.h; then
    echo "dirent.h found."
    if $contains 'd_namlen' $usrinclude/dirent.h >/dev/null 2>&1; then
	D_dirnamlen="$define"
    fi
    I_dirent="$define"
elif $test -r $xxx; then
    echo "You seem to use <$xxx>,"
    if $test "$d_readdir" = "$define"; then
	echo "and I can get readdir() from your C library."
    elif $test -r /usr/lib/libndir.a || $test -r /usr/local/lib/libndir.a; then
	echo "and I'll get the routines using -lndir ."
	libndir='-lndir'
    else
	ans=`./loc libndir.a x $libpth`
	case "$ans" in
	x)
	    echo "but I can't find the ndir library!"
	    ;;
	*)
	    echo "and I found the directory library in $ans."
	    libndir="$ans"
	    ;;
	esac
    fi
    if $contains 'd_namlen' $xxx >/dev/null 2>&1; then
	D_dirnamlen="$define"
    fi
    case "$xxx" in
    sys/)
	I_sys_ndir="$define"
	;;
    *)
	I_ndir="$define"
	;;
    esac
else
    : The next line used to require this to be a bsd system.
    if $contains '^readdir$' libc.list >/dev/null 2>&1 ; then
	echo "No ndir library found, but you have readdir() so we'll use that."
	if $contains 'd_namlen' $usrinclude/sys/dir.h >/dev/null 2>&1; then
	    D_dirnamlen="$define"
	fi
	I_sys_dir="$define"
    else
	echo "No ndir library found--using ./$d_ndir.c."
: This will lose since $d_ndir.h is in another directory.
: I doubt we can rely on it being in ../$d_ndir.h . 
: At least it will fail in a conservative manner.
	if $contains 'd_namlen' $d_ndir.h >/dev/null 2>&1; then
	    D_dirnamlen="$define"
	fi
	I_my_dir="$define"
	ndirc="$d_ndir.c"
	ndiro="$d_ndir.o"
    fi
fi
val=$D_dirnamlen;	set d_dirnamlen;	eval $setvar
val=$I_dirent;		set i_dirent;		eval $setvar
val=$I_sys_dir;		set i_sys_dir;		eval $setvar
val=$I_my_dir;		set i_my_dir;		eval $setvar
val=$I_ndir;		set i_ndir;		eval $setvar
val=$I_sys_ndir;	set i_sys_ndir;		eval $setvar

: 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
set fcntl d_fcntl
eval $inlibc

: see if we can have long filenames
echo " "
rm -f 123456789abcde
if (echo hi >123456789abcdef) 2>/dev/null; then
    : not version 8
    if test -f 123456789abcde; then
	echo 'You cannot have filenames longer than 14 characters.  Sigh.'
	val="$undef"
    else
	echo 'You can have filenames longer than 14 characters.'
	val="$define"
    fi
else
    : version 8 probably
    echo "You can't have filenames longer than 14 chars.  You can't even think about them!"
    val="$undef"
fi 
set d_flexfnam
eval $setvar

: 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;;
*)  if $test -f /unix; then
	dflt=n
    else
	dflt=y
    fi
    ;;
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 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 msgctl exists
set msgctl d_msgctl
eval $inlibc

: see if msgget exists
set msgget d_msgget
eval $inlibc

: see if msgsnd exists
set msgsnd d_msgsnd
eval $inlibc

: see if msgrcv exists
set msgrcv d_msgrcv
eval $inlibc

: see how much of the 'msg*(2)' library is present.
h_msg=true
echo " "
case "$d_msgctl$d_msgget$d_msgsnd$d_msgrcv" in
*undef*) h_msg=false;;
esac
: we could also check for sys/ipc.h ...
if $h_msg && $test -r $usrinclude/sys/msg.h; then
    echo "You have the full msg*(2) library."
    val="$define"
else
    echo "You don't have the full msg*(2) library."
    val="$undef"
fi
set d_msg
eval $setvar

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

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

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

if $contains socketpair libc.list >/dev/null 2>&1; then
    val="$define"
else
    val="$undef"
fi
set d_sockpair
eval $setvar
val=$val2
set d_oldsock
eval $setvar

: Locate the flags for 'open()'
echo " "
$cat >open3.c <<'EOCP'
#include <sys/types.h>
#ifdef I_FCNTL
#include <fcntl.h>
#endif
#ifdef I_SYS_FILE
#include <sys/file.h>
#endif
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 -r $usrinclude/sys/file.h && \
   $cc $cppflags "-DI_SYS_FILE" open3.c -o open3 >/dev/null 2>&1 ; then
    h_sys_file=true;
    echo "sys/file.h defines the O_* constants..."
    if ./open3; then
	echo "and you have the 3 argument form of open()."
	val="$define"
    else
	echo "but not the 3 argument form of open().  Oh, well."
	val="$undef"
    fi
elif $test -r $usrinclude/fcntl.h && \
   $cc "-DI_FCNTL" open3.c -o open3 >/dev/null 2>&1 ; then
    h_fcntl=true;
    echo "fcntl.h defines the O_* constants..."
    if ./open3; then
	echo "and you have the 3 argument form of open()."
	val="$define"
    else
	echo "but not the 3 argument form of open().  Oh, well."
	val="$undef"
    fi
else
    val="$undef"
    echo "I can't find the O_* constant definitions!  You got problems."
fi
set d_open3
eval $setvar

: see if how pwd stuff is defined
echo " "
if $test -r $usrinclude/pwd.h ; then
    i_pwd="$define"
    echo "pwd.h found."
    $cppstdin $cppflags $cppminus <$usrinclude/pwd.h >pwd.txt
    if $contains 'pw_quota' pwd.txt >/dev/null 2>&1; then
	d_pwquota="$define"
    else
	d_pwquota="$undef"
    fi
    if $contains 'pw_age' pwd.txt >/dev/null 2>&1; then
	d_pwage="$define"
    else
	d_pwage="$undef"
    fi
    if $contains 'pw_change' pwd.txt >/dev/null 2>&1; then
	d_pwchange="$define"
    else
	d_pwchange="$undef"
    fi
    if $contains 'pw_class' pwd.txt >/dev/null 2>&1; then
	d_pwclass="$define"
    else
	d_pwclass="$undef"
    fi
    if $contains 'pw_expire' pwd.txt >/dev/null 2>&1; then
	d_pwexpire="$define"
    else
	d_pwexpire="$undef"
    fi
    if $contains 'pw_comment' pwd.txt >/dev/null 2>&1; then
	d_pwcomment="$define"
    else
	d_pwcomment="$undef"
    fi
else
    i_pwd="$undef"
    d_pwquota="$undef"
    d_pwage="$undef"
    d_pwchange="$undef"
    d_pwclass="$undef"
    d_pwexpire="$undef"
    d_pwcomment="$undef"
    echo "No pwd.h found."
fi

: see if rename exists
set rename d_rename
eval $inlibc

: see if rmdir exists
set rmdir d_rmdir
eval $inlibc

: see if select exists
set select d_select
eval $inlibc

: see if semctl exists
set semctl d_semctl
eval $inlibc

: see if semget exists
set semget d_semget
eval $inlibc

: see if semop exists
set semop d_semop
eval $inlibc

: see how much of the 'sem*(2)' library is present.
h_sem=true
echo " "
case "$d_semctl$d_semget$d_semop" in
*undef*) h_sem=false;;
esac
: we could also check for sys/ipc.h ...
if $h_sem && $test -r $usrinclude/sys/sem.h; then
    echo "You have the full sem*(2) library."
    val="$define"
else
    echo "You don't have the full sem*(2) library."
    val="$undef"
fi
set d_sem
eval $setvar

: 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

: see if shmctl exists
set shmctl d_shmctl
eval $inlibc

: see if shmget exists
set shmget d_shmget
eval $inlibc

: see if shmat exists
set shmat d_shmat
eval $inlibc

d_voidshmat="$undef"
case "$d_shmat" in
define)
    $cppstdin $cppflags $cppminus < $usrinclude/sys/shm.h >voidshmat.txt 2>/dev/null
    if $contains "void.*shmat" voidshmat.txt >/dev/null 2>&1; then
	echo "and shmat returns (void*)"
	d_voidshmat="$define"
    else
	echo "and shmat returns (char*)"
    fi
    ;;
esac

: see if shmdt exists
set shmdt d_shmdt
eval $inlibc

: see how much of the 'shm*(2)' library is present.
h_shm=true
echo " "
case "$d_shmctl$d_shmget$d_shmat$d_shmdt" in
*undef*) h_shm=false;;
esac
: we could also check for sys/ipc.h ...
if $h_shm && $test -r $usrinclude/sys/shm.h; then
    echo "You have the full shm*(2) library."
    val="$define"
else
    echo "You don't have the full shm*(2) library."
    val="$undef"
fi
set d_shm
eval $setvar

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

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

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

	foo = bar;
}
EOCP
if $cc -c strctcpy.c >/dev/null 2>&1 ; then
    val="$define"
    echo "Yup, it can."
else
    val="$undef"
    echo "Nope, it can't."
fi
set d_strctcpy
eval $setvar

: 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

: set if package uses struct tm
w_s_tm=1

: set if package uses struct timeval
case "$d_select" in
define) w_s_timevl=1 ;;
esac

: set if package uses localtime function
w_localtim=1

: see which of time.h, sys/time.h, and sys/select should be included.
idefs=''
cat <<'EOM'
  
Testing to see which of <time.h>, <sys/time.h>, and <sys/select.h>
should be included, because this application wants:

EOM
case "$w_s_itimer" in
1)
    echo "	struct itimerval"
    idefs="-DS_ITIMERVAL $idefs"
    ;;
esac
case "$w_s_timevl" in
1)
    echo "	struct timeval"
    idefs="-DS_TIMEVAL $idefs"
    ;;
esac
case "$w_s_tm" in
1)
    echo "	struct tm"
    idefs="-DS_TM $idefs"
    ;;
esac
case "$w_localtim" in
1)
    echo "	ctime(3) declarations"
    idefs="-DD_CTIME $idefs"
    ;;
esac
case "$idefs" in
'')
    echo "	(something I don't know about)"
    ;;
esac
echo " "
echo "I'm now running the test program..."
$cat >i_time.c <<'EOCP'
#include <sys/types.h>
#ifdef I_TIME
#include <time.h>
#endif
#ifdef I_SYS_TIME
#ifdef SYSTIMEKERNEL
#define KERNEL
#endif
#include <sys/time.h>
#endif
#ifdef I_SYS_SELECT
#include <sys/select.h>
#endif
main()
{
    struct tm foo;
    struct tm *tmp;
#ifdef S_TIMEVAL
    struct timeval bar;
#endif
#ifdef S_ITIMERVAL
    struct itimerval baz;
#endif

    if (foo.tm_sec == foo.tm_sec)
	exit(0);
#ifdef S_TIMEVAL
    if (bar.tv_sec == bar.tv_sec)
	exit(0);
#endif
#ifdef S_ITIMERVAL
    if (baz.it_interval == baz.it_interval)
	exit(0);
#endif
#ifdef S_TIMEVAL
    if (bar.tv_sec == bar.tv_sec)
	exit(0);
#endif
#ifdef D_CTIME
    /* this might not do anything for us... */
    tmp = localtime((time_t *)0);
#endif
    exit(1);
}
EOCP
flags=''
for i_sys_select in '' '-DI_SYS_SELECT'; do
    for d_systimekernel in '' '-DSYSTIMEKERNEL'; do
	for i_time in '' '-DI_TIME'; do
	    for i_systime in '-DI_SYS_TIME' ''; do
		case "$flags" in
		'') echo Trying $i_time $i_systime $d_systimekernel $i_sys_select
		    if $cc $ccflags $idefs \
			    $i_time $i_systime $d_systimekernel $i_sys_select \
			    i_time.c -o i_time >/dev/null 2>&1 ; then
			set X $i_time $i_systime $d_systimekernel $i_sys_select
			shift
			flags="$*"
			echo Succeeded with $flags
		    fi
		    ;;
		esac
	    done
	done
    done
done
case "$flags" in
*SYSTIMEKERNEL*) val="$define";;
*) val="$undef";;
esac
set d_systimekernel
eval $setvar
case "$flags" in
*I_TIME*) val="$define";;
*) val="$undef";;
esac
set i_time
eval $setvar
case "$flags" in
*I_SYS_SELECT*) val="$define";;
*) val="$undef";;
esac
set i_sys_select
eval $setvar
case "$flags" in
*I_SYS_TIME*) val="$define";;
*) val="$undef";;
esac
set i_sys_time
eval $setvar
case "$flags$i_sys_time$i_time" in
undefundef) i_sys_time="$define"; i_time="$define";
    echo "ICK, NOTHING WORKED!!!  You may have to diddle the includes.";;
esac

: see if signal is declared as pointer to function returning int or void
echo " "
$cppstdin $cppflags $cppminus < $usrinclude/signal.h >d_voidsig.txt
if $contains 'int[^A-Za-z]*signal' d_voidsig.txt >/dev/null 2>&1 ; then
    echo "You have int (*signal())() instead of void."
    val="$undef"
else
    echo "You have void (*signal())() instead of int."
    val="$define"
fi
set d_voidsig
eval $setvar
case $voidsig in
define) d_tosignal=void;;
*) d_tosignal=int;;
esac

: see if truncate exists
set truncate d_truncate
eval $inlibc

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

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

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

: see if there is a waitpid
set waitpid d_waitpid
eval $inlibc

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

: see what type gids are returned by getgroups
echo " "
case "$groupstype" in
'')
    if $contains 'getgroups.*short' /usr/lib/lint/llib-lc >/dev/null 2>&1; then
	dflt='short'
    elif $contains 'getgroups.*int' /usr/lib/lint/llib-lc >/dev/null 2>&1; then
	dflt='int'
    elif $contains 'getgroups.*short' /usr/include/libc.h >/dev/null 2>&1; then
	dflt='short'
    elif $contains 'getgroups.*int' /usr/include/libc.h >/dev/null 2>&1; then
	dflt='int'
    elif $contains 'getgroups.*short' /usr/lib/lint/llib-lbsd >/dev/null 2>&1; then
	dflt='short'
    elif $contains 'getgroups.*int' /usr/lib/lint/llib-lbsd >/dev/null 2>&1; then
	dflt='int'
    elif $contains 'int.*gidset' /usr/man/man2/getgroups.2 >/dev/null 2>&1; then
	dflt='int'
    elif $contains 'gid_t;' $usrinclude/sys/types.h >/dev/null 2>&1 ; then
	dflt='gid_t'
    else
	set `grep 'groups\[NGROUPS\];' $usrinclude/sys/user.h 2>/dev/null` unsigned short
	case $1 in
	unsigned) dflt="$1 $2" ;;
	*) dflt="$1" ;;
	esac
    fi
    ;;
*)  dflt="$groupstype"
    ;;
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
groupstype="$ans"

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

: 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'
    libs=`echo $libs | sed 's/-lmalloc//'`
    case "$mallocptrtype" in
    '')
	cat >usemymalloc.c <<'END'
#ifdef __STDC__
#include <stdlib.h>
#else
#include <malloc.h>
#endif
void *malloc();
END
	if $cc $ccflags -c usemymalloc.c >/dev/null 2>&1; then
	    mallocptrtype=void
	else
	    mallocptrtype=char
	fi
	;;
    esac
    echo " "
    echo "Your system wants malloc to return $mallocptrtype*, it would seem."
    ;;
*) mallocsrc=''; mallocobj=''; mallocptrtype=void;;
esac

: 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 reside in a library
that is accessible by everyone.  Where should these "private" but accessible
EOM
$echo $n "files reside? (~name ok) [$dflt] $c"
rp="Private files will reside where? [$dflt]"
. myread
privlib=`./filexp "$ans"`

case "$installprivlib" in
'')
    dflt=`echo $privlib | sed 's#^/afs/#/afs/.#'`
    test -d $dflt || dflt="$privlib"
    ;;
*)  dflt="$installprivlib"
    ;;
esac
$cat <<EOM

On some systems (such as afs) you have to install the library files in a
different directory to get them to go to the right place.  Where should the
EOM
$echo $n "library files be installed? (~name ok) [$dflt] $c"
rp="Install private files where? [$dflt]"
. myread
installprivlib=`./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 >randbits.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 randbits.c -o randbits >/dev/null 2>&1 ; then
	dflt=`./randbits`
    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"

: determine where publicly executable scripts go
case "$scriptdir" in
'')
    dflt="$bin"
    : guess some guesses
    test -d /usr/share/scripts && dflt=/usr/share/scripts
    test -d /usr/share/bin && dflt=/usr/share/bin
    ;;
*)  dflt="$scriptdir"
    ;;
esac
cont=true
$cat <<EOM
 
Some installations have a separate directory just for executable scripts so
that they can mount it across multiple architectures but keep the scripts in
one spot.  You might, for example, have a subdirectory of /usr/share for this.
Or you might just lump your scripts in with all your other executables.
 
EOM
while $test "$cont" ; do
    rp="Where will publicly executable scripts reside (~name ok)? [$dflt]"
    $echo $n "$rp $c"
    . myread
    scriptdir="$ans"
    scriptdir=`./filexp "$scriptdir"`
    if test -d $scriptdir; then
	cont=''
    else
	case "$fastread" in
	yes) dflt=y;;
	*) dflt=n;;
	esac
	rp="Directory $scriptdir doesn't exist.  Use that name anyway? [$dflt]"
	$echo $n "$rp $c"
	. myread
	dflt=''
	case "$ans" in
	y*) cont='';;
	esac
    fi
done

case "$installscr" in
'')
    dflt=`echo $scriptdir | sed 's#^/afs/#/afs/.#'`
    test -d $dflt || dflt="$scriptdir"
    ;;
*)  dflt="$scriptdir"
    ;;
esac
cont=true
$cat <<EOM
 
Some installations must install scripts in a different directory than where
they will eventually reside.  On most systems they're the same directory.
EOM
while $test "$cont" ; do
    rp="Where do you install publicly executable scripts (~name ok)? [$dflt]"
    $echo $n "$rp $c"
    . myread
    installscr="$ans"
    installscr=`./filexp "$installscr"`
    if test -d $installscr; then
	cont=''
    else
	case "$fastread" in
	yes) dflt=y;;
	*) dflt=n;;
	esac
	rp="Directory $installscr doesn't exist.  Use that name anyway? [$dflt]"
	$echo $n "$rp $c"
	. myread
	dflt=''
	case "$ans" in
	y*) cont='';;
	esac
    fi
done

: generate list of signal names
echo " "
case "$sig_name" in
'')
    echo "Generating a list of signal names..."
    set X `cat $usrinclude/signal.h $usrinclude/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.*;' $usrinclude/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;' $usrinclude/sys/types.h >/dev/null 2>&1 ; then
	dflt='uid_t';
    else
	set `grep '_ruid;' $usrinclude/sys/user.h 2>/dev/null` unsigned short
	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"

: 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 "$voidhave" in
'')
    $cat >void.c <<'EOCP'
#if TRY & 1
void main() {
#else
main() {
#endif
	extern void moo();	/* function returning void */
	void (*goo)();		/* ptr to func returning void */
#if TRY & 2
	void (*foo[10])();
#endif

#if TRY & 4
	if(goo == moo) {
		exit(0);
	}
#endif
	exit(0);
}
EOCP
    if $cc -c -DTRY=$voidwant void.c >void.out 2>&1 ; then
	voidhave=$voidwant
	echo "It appears to support void to the level $package wants ($voidwant)."
	if $contains warning void.out >/dev/null 2>&1; then
	    echo "However, you might get some warnings that look like this:"
	    $cat void.out
	fi
    else
	echo "Hmm, your compiler has some difficulty with void.  Checking further..."
	if $cc -c -DTRY=1 void.c >/dev/null 2>&1 ; then
	    echo "It supports 1..."
	    if $cc -c -DTRY=3 void.c >/dev/null 2>&1 ; then
		voidhave=3
		echo "And it supports 2 but not 4."
	    else
		echo "It doesn't support 2..."
		if $cc -c -DTRY=5 void.c >/dev/null 2>&1 ; then
		    voidhave=5
		    echo "But it supports 4."
		else
		    voidhave=1
		    echo "And it doesn't support 4."
		fi
	    fi
	else
	    echo "There is no support at all for void."
	    voidhave=0
	fi
    fi
esac
dflt="$voidhave";
rp="Your void support flags add up to what? [$dflt]"
$echo $n "$rp $c"
. myread
voidhave="$ans"

: preserve RCS keywords in files with variable substitution, grrr
Log='$Log'
Header='$Header'
Id='$Id'
Author='$Author'
Date='$Date'
Locker='$Locker'
RCSfile='$RCSfile'
Revision='$Revision'
Source='$Source'
State='$State'


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

: see if we can include fcntl.h
echo " "
if $h_fcntl; then
    val="$define"
    echo "We'll be including <fcntl.h>."
else
    val="$undef"
    if $h_sys_file; then
	echo "We don't need to <fcntl.h> if we include <sys/file.h>."
    else
	echo "We won't be including <fcntl.h>."
    fi
fi
set i_fcntl
eval $setvar

: see if gdbm is available
echo " "
xxx=`./loc gdbm.h x $usrinclude /usr/local/include $inclwanted`
if test -f $xxx; then
    val="$define"
    echo "gdbm.h found."
else
    val="$undef"
    echo "gdbm.h not found."
fi
set i_gdbm
eval $setvar

: see if this is an grp system
echo " "
if $test -r $usrinclude/grp.h ; then
    val="$define"
    echo "grp.h found."
else
    val="$undef"
    echo "No grp.h found."
fi
set i_grp
eval $setvar

: see if this is a netinet/in.h or sys/in.h system
echo " "
xxx=`./loc netinet/in.h x $usrinclude /usr/local/include $inclwanted`
if test -f $xxx; then
    val="$define"
    val2="$undef"
    echo "netinet/in.h found."
else
    val="$undef"
    echo "No netinet/in.h found, ..."
    xxx=`./loc sys/in.h x $usrinclude /usr/local/include $inclwanted`
    if test -f $xxx; then
	val2="$define"
	echo "but I found sys/in.h instead."
    else
	val2="$undef"
	echo "and I didn't find sys/in.h either."
    fi
fi
set i_niin
eval $setvar
val=$val2
set i_sysin
eval $setvar

: Do we need to #include <sys/file.h> ?
echo " "
if $h_sys_file; then
    val="$define"
    echo "We'll be including <sys/file.h>."
else
    val="$undef"
    echo "We won't be including <sys/file.h>."
fi
set i_sys_file
eval $setvar

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

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

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

: see if this is a vfork system
echo " "
if $test -r $usrinclude/vfork.h ; then
    val="$define"
    echo "vfork.h found."
else
    val="$undef"
    echo "No vfork.h found."
fi
set i_vfork
eval $setvar

: end of configuration questions
echo " "
echo "End of configuration questions."
echo " "

: create config.sh file
echo " "
if test -d ../UU; then
    cd ..
fi
echo "Creating config.sh..."
test -f config.sh && cp config.sh UU/oldconfig.sh
$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'
bash='$bash'
ksh='$ksh'
lex='$lex'
flex='$flex'
bison='$bison'
Log='$Log'
Header='$Header'
Id='$Id'
lastuname='$lastuname'
alignbytes='$alignbytes'
bin='$bin'
installbin='$installbin'
byteorder='$byteorder'
contains='$contains'
cppstdin='$cppstdin'
cppminus='$cppminus'
d_bcmp='$d_bcmp'
d_bcopy='$d_bcopy'
d_bzero='$d_bzero'
d_castneg='$d_castneg'
castflags='$castflags'
d_charsprf='$d_charsprf'
d_chsize='$d_chsize'
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_flexfnam='$d_flexfnam'
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_killpg='$d_killpg'
d_lstat='$d_lstat'
d_memcmp='$d_memcmp'
d_memcpy='$d_memcpy'
d_mkdir='$d_mkdir'
d_msg='$d_msg'
d_msgctl='$d_msgctl'
d_msgget='$d_msgget'
d_msgrcv='$d_msgrcv'
d_msgsnd='$d_msgsnd'
d_ndbm='$d_ndbm'
d_odbm='$d_odbm'
d_open3='$d_open3'
d_readdir='$d_readdir'
d_rename='$d_rename'
d_rmdir='$d_rmdir'
d_select='$d_select'
d_sem='$d_sem'
d_semctl='$d_semctl'
d_semget='$d_semget'
d_semop='$d_semop'
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_shm='$d_shm'
d_shmat='$d_shmat'
d_voidshmat='$d_voidshmat'
d_shmctl='$d_shmctl'
d_shmdt='$d_shmdt'
d_shmget='$d_shmget'
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_truncate='$d_truncate'
d_vfork='$d_vfork'
d_voidsig='$d_voidsig'
d_tosignal='$d_tosignal'
d_volatile='$d_volatile'
d_vprintf='$d_vprintf'
d_charvspr='$d_charvspr'
d_wait4='$d_wait4'
d_waitpid='$d_waitpid'
gidtype='$gidtype'
groupstype='$groupstype'
i_fcntl='$i_fcntl'
i_gdbm='$i_gdbm'
i_grp='$i_grp'
i_niin='$i_niin'
i_sysin='$i_sysin'
i_pwd='$i_pwd'
d_pwquota='$d_pwquota'
d_pwage='$d_pwage'
d_pwchange='$d_pwchange'
d_pwclass='$d_pwclass'
d_pwexpire='$d_pwexpire'
d_pwcomment='$d_pwcomment'
i_sys_file='$i_sys_file'
i_sysioctl='$i_sysioctl'
i_time='$i_time'
i_sys_time='$i_sys_time'
i_sys_select='$i_sys_select'
d_systimekernel='$d_systimekernel'
i_utime='$i_utime'
i_varargs='$i_varargs'
i_vfork='$i_vfork'
intsize='$intsize'
libc='$libc'
nm_opts='$nm_opts'
libndir='$libndir'
i_my_dir='$i_my_dir'
i_ndir='$i_ndir'
i_sys_ndir='$i_sys_ndir'
i_dirent='$i_dirent'
i_sys_dir='$i_sys_dir'
d_dirnamlen='$d_dirnamlen'
ndirc='$ndirc'
ndiro='$ndiro'
mallocsrc='$mallocsrc'
mallocobj='$mallocobj'
usemymalloc='$usemymalloc'
mallocptrtype='$mallocptrtype'
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'
nativegcc='$nativegcc'
libs='$libs'
n='$n'
c='$c'
package='$package'
randbits='$randbits'
scriptdir='$scriptdir'
installscr='$installscr'
sig_name='$sig_name'
spitshell='$spitshell'
shsharp='$shsharp'
sharpbang='$sharpbang'
startsh='$startsh'
stdchar='$stdchar'
uidtype='$uidtype'
usrinclude='$usrinclude'
inclPath='$inclPath'
void='$void'
voidhave='$voidhave'
voidwant='$voidwant'
w_localtim='$w_localtim'
w_s_timevl='$w_s_timevl'
w_s_tm='$w_s_tm'
yacc='$yacc'
lib='$lib'
privlib='$privlib'
installprivlib='$installprivlib'
EOT

test -f patchlevel.h && awk '{printf "%s=%s\n",$2,$3}' patchlevel.h >>config.sh
echo "CONFIG=true" >>config.sh

if test -f UU/oldconfig.sh; then
    sed -n 's/^\([a-zA-Z_0-9]*\)=.*/\1/p' config.sh config.sh UU/oldconfig.sh |\
      sort | uniq -u >UU/oldsyms
    set X `cat UU/oldsyms`
    shift
    case $# in
    0) ;;
    *)  echo "Hmm...You had some extra variables I don't know about...I'll try to keep 'em..."
	for sym in `cat UU/oldsyms`; do
	    echo "    Propagating $hint variable "'$'"$sym..."
	    eval 'tmp="$'"${sym}"'"'
	    echo "$tmp" | \
	      sed -e "s/'/'\"'\"'/g" -e "s/^/$sym='/" -e "s/$/'/" >>config.sh
	done
	;;
    esac
fi

: Finish up
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
chmod +x doSH
./doSH

if $contains '^depend:' [Mm]akefile >/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 [Mm]akefile; then
    echo " "
    echo "Now you must run a make."
else
    echo "Done."
fi

$rm -f kit*isdone
$rm -rf UU
: end of Configure