#! /bin/sh
#
# If these # comments don't work, trim them. Don't worry about any other
# shell scripts, Configure will trim # comments from them for you.
#
# (If you are trying to port this package to a machine without sh,
# I would suggest you have a look at the prototypical config_h.SH file
# and edit it to reflect your system. Some packages may include samples
# of config.h for certain machines, so you might look for one of those.)
#
# Yes, you may rip this off to use in other distribution packages. This
# script belongs to the public domain and cannot be copyrighted.
#
# (Note: this Configure script was generated automatically. Rather than
# working with this copy of Configure, you may wish to get metaconfig.
# The dist-3.0 package (which contains metaconfig) was posted in
# comp.sources.misc so you may fetch it yourself from your nearest
# archive site. Check with Archie if you don't know where that can be.)
#

# $Id: Configure,v 3.0.1.13 1996/12/26 10:44:52 ram Exp $
#
# Generated on Thu Dec 26 09:12:15 MET 1996 [metaconfig 3.0 PL60]

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 $argv:q

(exit $?0) || cat /tmp/c2$$
(exit $?0) || exec sh $0 $argv:q
rm -f /tmp/c1$$ /tmp/c2$$

: compute my invocation name
me=$0
case "$0" in
*/*)
	me=`echo $0 | sed -e 's!.*/\(.*\)!\1!' 2>/dev/null`
	test "$me" || me=$0
	;;
esac

: Proper PATH separator
p_=:
: On OS/2 this directory should exist if this is not floppy only system :-]
if test -d c:/.; then
	p_=\;
	PATH=`cmd /c "echo %PATH%" | tr '\\\\' / `
	OS2_SHELL=`cmd /c "echo %OS2_SHELL%" | tr '\\\\' / | tr '[A-Z]' '[a-z]'`
fi

: Proper PATH setting
paths='/bin /usr/bin /usr/local/bin /usr/ucb /usr/local /usr/lbin'
paths="$paths /opt/bin /opt/local/bin /opt/local /opt/lbin"
paths="$paths /usr/5bin /etc /usr/gnu/bin /usr/new /usr/new/bin /usr/nbin"
paths="$paths /opt/gnu/bin /opt/new /opt/new/bin /opt/nbin"
paths="$paths /sys5.3/bin /sys5.3/usr/bin /bsd4.3/bin /bsd4.3/usr/ucb"
paths="$paths /bsd4.3/usr/bin /usr/bsd /bsd43/bin /usr/ccs/bin"
paths="$paths /etc /usr/lib /usr/ucblib /lib /usr/ccs/lib"
paths="$paths /sbin /usr/sbin /usr/libexec"

for p in $paths
do
	case "$p_$PATH$p_" in
	*$p_$p$p_*) ;;
	*) test -d $p && PATH=$PATH$p_$p ;;
	esac
done

PATH=.$p_$PATH
export PATH

: On HP-UX, large Configure scripts may exercise a bug in /bin/sh
if test -f /hp-ux -a -f /bin/ksh; then
	if (PATH=.; alias -x) >/dev/null 2>&1; then
		: already under /bin/ksh
	else
		cat <<'EOM'
(Feeding myself to ksh to avoid nasty sh bug in "here document" expansion.)
EOM
		unset ENV
		case "$0" in
		Configure|*/Configure) exec /bin/ksh $0 "$@";;
		*) exec /bin/ksh Configure "$@";;
		esac
	fi
else
	: Warn them if they use ksh on other systems
	(PATH=.; alias -x) >/dev/null 2>&1 && \
		cat <<EOM
(I see you are using the Korn shell.  Some ksh's blow up on $me,
especially on exotic machines.  If yours does, try the Bourne shell instead.)
EOM
fi

: Configure runs within the UU subdirectory
test -d UU || mkdir UU
unset CDPATH
cd UU && rm -f ./*

d_bsd=''
d_eunice=''
d_xenix=''
eunicefix=''
Mcc=''
awk=''
bash=''
bison=''
byacc=''
cat=''
chgrp=''
chmod=''
chown=''
comm=''
compress=''
cp=''
cpio=''
cpp=''
csh=''
date=''
echo=''
egrep=''
emacs=''
expr=''
find=''
flex=''
gcc=''
grep=''
inews=''
ksh=''
less=''
line=''
lint=''
ln=''
lp=''
lpr=''
ls=''
mail=''
mailx=''
make=''
mkdir=''
more=''
mv=''
nroff=''
perl=''
pg=''
pmake=''
pr=''
rm=''
rmail=''
sed=''
sendmail=''
sh=''
shar=''
sleep=''
smail=''
sort=''
submit=''
tail=''
tar=''
tbl=''
test=''
touch=''
tr=''
troff=''
uname=''
uniq=''
uuname=''
vi=''
zcat=''
mailpatches=''
notifypatches=''
usermail=''
hint=''
myuname=''
osname=''
osvers=''
Author=''
Date=''
Header=''
Id=''
Locker=''
Log=''
RCSfile=''
Revision=''
Source=''
State=''
afs=''
baserev=''
bin=''
binexp=''
installbin=''
cc=''
gccversion=''
ccflags=''
cppflags=''
ldflags=''
lkflags=''
optimize=''
cf_email=''
cf_by=''
cf_time=''
contains=''
cpp_stuff=''
cpplast=''
cppminus=''
cpprun=''
cppstdin=''
d_access=''
d_bcopy=''
d_flexfnam=''
d_flock=''
aphostname=''
d_gethname=''
d_phostname=''
d_uname=''
d_hidnet=''
hiddennet=''
d_open3=''
d_portable=''
d_rename=''
d_setpgid=''
d_bsdpgrp=''
d_setpgrp=''
d_setrgid=''
d_setruid=''
d_setsid=''
d_strccmp=''
d_index=''
d_strchr=''
d_strerrm=''
d_strerror=''
d_sysernlst=''
d_syserrlst=''
d_time=''
timetype=''
d_uwait3=''
d_uwait=''
d_vfork=''
usevfork=''
d_voidsig=''
signal_t=''
d_wifstat=''
defeditor=''
h_fcntl=''
h_sysfile=''
i_fcntl=''
i_string=''
strings=''
i_sysfile=''
d_voidtty=''
i_bsdioctl=''
i_sysfilio=''
i_sysioctl=''
i_syssockio=''
i_sysparam=''
i_systypes=''
i_syswait=''
i_sgtty=''
i_termio=''
i_termios=''
i_systime=''
i_systimek=''
i_time=''
timeincl=''
i_unistd=''
install=''
installdir=''
intsize=''
libc=''
glibpth=''
libpth=''
plibpth=''
xlibpth=''
libs=''
lns=''
maildir=''
maildirexp=''
mailer=''
mailfile=''
installmansrc=''
manext=''
mansrc=''
mansrcexp=''
d_flockonly=''
d_lockflock=''
flock_only=''
lock_by_flock=''
mkdep=''
huge=''
large=''
medium=''
models=''
small=''
split=''
mydomain=''
myhostname=''
phostname=''
c=''
n=''
d_berknames=''
d_passnames=''
d_usgnames=''
nametype=''
groupcat=''
hostcat=''
passcat=''
orgname=''
package=''
spackage=''
patchlevel=''
perlpath=''
pidtype=''
prefix=''
prefixexp=''
installprivlib=''
privlib=''
privlibexp=''
prototype=''
reg10=''
reg11=''
reg12=''
reg13=''
reg14=''
reg15=''
reg16=''
reg1=''
reg2=''
reg3=''
reg4=''
reg5=''
reg6=''
reg7=''
reg8=''
reg9=''
registers=''
rootid=''
installscript=''
scriptdir=''
scriptdirexp=''
so=''
sharpbang=''
shsharp=''
spitshell=''
src=''
startperl=''
startsh=''
sysman=''
uidtype=''
nm_opt=''
runnm=''
usenm=''
incpath=''
mips=''
mips_type=''
usrinc=''
utmp=''
defvoidused=''
voidflags=''
CONFIG=''

define='define'
undef='undef'
smallmach='pdp11 i8086 z8000 i80286 iAPX286'
rmlist=''

: 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

: list of known cpp symbols, sorted alphabetically
al="AMIX BIT_MSF BSD BSD4_3 BSD_NET2 CMU CRAY DGUX DOLPHIN DPX2"
al="$al GO32 GOULD_PN HP700 I386 I80960 I960 Lynx M68000 M68K MACH"
al="$al MIPSEB MIPSEL MSDOS MTXINU MULTIMAX MVS"
al="$al M_COFF M_I186 M_I286 M_I386 M_I8086 M_I86 M_I86SM"
al="$al M_SYS3 M_SYS5 M_SYSIII M_SYSV M_UNIX M_XENIX"
al="$al NeXT OCS88 OSF1 PARISC PC532 PORTAR POSIX"
al="$al PWB R3000 RES RISC6000 RT Sun386i SVR3 SVR4"
al="$al SYSTYPE_BSD SYSTYPE_SVR4 SYSTYPE_SYSV Tek4132 Tek4300"
al="$al UMAXV USGr4 USGr4_2 UTEK UTS UTek UnicomPBB UnicomPBD Utek"
al="$al VMS Xenix286"
al="$al _AIX _AIX32 _AIX370 _AM29000 _COFF _CRAY _CX_UX _EPI"
al="$al _IBMESA _IBMR2 _M88K _M88KBCS_TARGET"
al="$al _MIPSEB _MIPSEL _M_COFF _M_I86 _M_I86SM _M_SYS3"
al="$al _M_SYS5 _M_SYSIII _M_SYSV _M_UNIX _M_XENIX _NLS _PGC_ _R3000"
al="$al _SYSTYPE_BSD _SYSTYPE_BSD43 _SYSTYPE_SVR4"
al="$al _SYSTYPE_SYSV _SYSV3 _U370 _UNICOS"
al="$al __386BSD__ __BIG_ENDIAN __BIG_ENDIAN__ __BSD_4_4__"
al="$al __DGUX__ __DPX2__ __H3050R __H3050RX"
al="$al __LITTLE_ENDIAN __LITTLE_ENDIAN__ __MACH__"
al="$al __MIPSEB __MIPSEB__ __MIPSEL __MIPSEL__"
al="$al __Next__ __OSF1__ __PARAGON__ __PGC__ __PWB __STDC__"
al="$al __SVR4_2__ __UMAXV__"
al="$al ____386BSD____ __alpha __alpha__ __amiga"
al="$al __bsd4_2 __bsd4_2__ __bsdi__ __convex__"
al="$al __host_mips__"
al="$al __hp9000s200 __hp9000s300 __hp9000s400 __hp9000s500"
al="$al __hp9000s500 __hp9000s700 __hp9000s800"
al="$al __hppa __hpux __hp_osf __i286 __i286__ __i386 __i386__"
al="$al __i486 __i486__ __i860 __i860__ __ibmesa __ksr1__ __linux__"
al="$al __m68k __m68k__ __m88100__ __m88k __m88k__"
al="$al __mc68000 __mc68000__ __mc68020 __mc68020__"
al="$al __mc68030 __mc68030__ __mc68040 __mc68040__"
al="$al __mc88100 __mc88100__ __mips __mips__"
al="$al __motorola__ __osf__ __pa_risc __sparc__ __stdc__"
al="$al __sun __sun__ __svr3__ __svr4__ __ultrix __ultrix__"
al="$al __unix __unix__ __uxpm__ __uxps__ __vax __vax__"
al="$al _host_mips _mips _unix"
al="$al a29k aegis aix aixpc alliant alpha am29000 amiga ansi ardent"
al="$al apollo ardent att386 att3b"
al="$al bsd bsd43 bsd4_2 bsd4_3 bsd4_4 bsdi bull"
al="$al cadmus clipper concurrent convex cray ctix"
al="$al dmert encore gcos gcx gimpel gould"
al="$al hbullx20 hcx host_mips hp200 hp300 hp700 hp800"
al="$al hp9000 hp9000s300 hp9000s400 hp9000s500"
al="$al hp9000s700 hp9000s800 hp9k8 hppa hpux"
al="$al i186 i286 i386 i486 i8086"
al="$al i80960 i860 iAPX286 ibm ibm032 ibmrt interdata is68k"
al="$al ksr1 linux luna luna88k m68k m88100 m88k"
al="$al mc300 mc500 mc68000 mc68010 mc68020 mc68030"
al="$al mc68040 mc68060 mc68k mc68k32 mc700"
al="$al mc88000 mc88100 merlin mert mips mvs n16"
al="$al ncl_el ncl_mr"
al="$al news1500 news1700 news1800 news1900 news3700"
al="$al news700 news800 news900 ns16000 ns32000"
al="$al ns32016 ns32332 ns32k nsc32000 os osf"
al="$al parisc pc532 pdp11 plexus posix pyr"
al="$al riscix riscos scs sequent sgi sinix sony sony_news"
al="$al sonyrisc sparc sparclite spectrum stardent stratos"
al="$al sun sun3 sun386 svr4 sysV68 sysV88"
al="$al titan tower tower32 tower32_200 tower32_600 tower32_700"
al="$al tower32_800 tower32_850 tss u370 u3b u3b2 u3b20 u3b200"
al="$al u3b20d u3b5 ultrix unix unixpc unos vax venix vms"
al="$al xenix z8000"

gccversion=''
: no include file wanted by default
inclwanted=''

i_sysselct=''
i_whoami=''
: change the next line if compiling for Xenix/286 on Xenix/386
xlibpth='/usr/lib/386 /lib/386'

: general looking path for locating libraries
glibpth="/lib/pa1.1 /usr/lib/large /lib /usr/lib $xlibpth"
glibpth="$glibpth /lib/large /usr/lib/small /lib/small"
glibpth="$glibpth /usr/ccs/lib /usr/ucblib /usr/local/lib /usr/shlib"

: Private path used by Configure to find libraries.  Its value
: is prepended to libpth. This variable takes care of special
: machines, like the mips.  Usually, it should be empty.
plibpth=''

: default library list
libswanted=''
: full support for void wanted by default
defvoidused=15

libswanted=''

: produce awk script to parse command line options
cat >options.awk <<'EOF'
BEGIN {
	optstr = "dD:eEf:hKOrsSU:V";	# getopt-style specification

	len = length(optstr);
	for (i = 1; i <= len; i++) {
		c = substr(optstr, i, 1);
		if (i < len) a = substr(optstr, i + 1, 1); else a = "";
		if (a == ":") {
			arg[c] = 1;
			i++;
		}
		opt[c] = 1;
	}
}
{
	expect = 0;
	str = $0;
	if (substr(str, 1, 1) != "-") {
		printf("'%s'\n", str);
		next;
	}
	len = length($0);
	for (i = 2; i <= len; i++) {
		c = substr(str, i, 1);
		if (!opt[c]) {
			printf("-%s\n", substr(str, i));
			next;
		}
		printf("-%s\n", c);
		if (arg[c]) {
			if (i < len)
				printf("'%s'\n", substr(str, i + 1));
			else
				expect = 1;
			next;
		}
	}
}
END {
	if (expect)
		print "?";
}
EOF

: process the command line options
set X `for arg in "$@"; do echo "X$arg"; done |
	sed -e s/X// | awk -f options.awk`
eval "set $*"
shift
rm -f options.awk

: set up default values
fastread=''
reuseval=false
config_sh=''
alldone=''
error=''
silent=''
extractsh=''
override=''
knowitall=''
rm -f optdef.sh


: option parsing
while test $# -gt 0; do
	case "$1" in
	-d) shift; fastread=yes;;
	-e) shift; alldone=cont;;
	-f)
		shift
		cd ..
		if test -r "$1"; then
			config_sh="$1"
		else
			echo "$me: cannot read config file $1." >&2
			error=true
		fi
		cd UU
		shift;;
	-h) shift; error=true;;
	-r) shift; reuseval=true;;
	-s) shift; silent=true; realsilent=true;;
	-E) shift; alldone=exit;;
	-K) shift; knowitall=true;;
	-O) shift; override=true;;
	-S) shift; silent=true; extractsh=true;;
	-D)
		shift
		case "$1" in
		*=)
			echo "$me: use '-U symbol=', not '-D symbol='." >&2
			echo "$me: ignoring -D $1" >&2
			;;
		*=*) echo "$1" | \
				sed -e "s/'/'\"'\"'/g" -e "s/=\(.*\)/='\1'/" >> optdef.sh;;
		*) echo "$1='define'" >> optdef.sh;;
		esac
		shift
		;;
	-U)
		shift
		case "$1" in
		*=) echo "$1" >> optdef.sh;;
		*=*)
			echo "$me: use '-D symbol=val', not '-U symbol=val'." >&2
			echo "$me: ignoring -U $1" >&2
			;;
		*) echo "$1='undef'" >> optdef.sh;;
		esac
		shift
		;;
	-V) echo "$me generated by metaconfig 3.0 PL60." >&2
		exit 0;;
	--) break;;
	-*) echo "$me: unknown option $1" >&2; shift; error=true;;
	*) break;;
	esac
done

case "$error" in
true)
	cat >&2 <<EOM
Usage: $me [-dehrsEKOSV] [-f config.sh] [-D symbol] [-D symbol=value]
                 [-U symbol] [-U symbol=]
  -d : use defaults for all answers.
  -e : go on without questioning past the production of config.sh.
  -f : specify an alternate default configuration file.
  -h : print this help message and exit (with an error status).
  -r : reuse C symbols value if possible (skips costly nm extraction).
  -s : silent mode, only echoes questions and essential information.
  -D : define symbol to have some value:
         -D symbol         symbol gets the value 'define'
         -D symbol=value   symbol gets the value 'value'
  -E : stop at the end of questions, after having produced config.sh.
  -K : do not use unless you know what you are doing.
  -O : let -D and -U override definitions from loaded configuration file.
  -S : perform variable substitutions on all .SH files (can mix with -f)
  -U : undefine symbol:
         -U symbol    symbol gets the value 'undef'
         -U symbol=   symbol gets completely empty
  -V : print version number and exit (with a zero status).
EOM
	exit 1
	;;
esac

: Sanity checks
case "$fastread$alldone" in
yescont|yesexit) ;;
*)
	if test ! -t 0; then
		echo "Say 'sh Configure', not 'sh <Configure'"
		exit 1
	fi
	;;
esac

exec 4>&1
case "$silent" in
true) exec 1>/dev/null;;
esac

: run the defines and the undefines, if any, but leave the file out there...
touch optdef.sh
. ./optdef.sh

: set package name
package=mailagent
first=`echo $package | sed -e 's/^\(.\).*/\1/'`
last=`echo $package | sed -e 's/^.\(.*\)/\1/'`
case "`echo AbyZ | tr '[:lower:]' '[:upper:]' 2>/dev/null`" in
ABYZ) spackage=`echo $first | tr '[:lower:]' '[:upper:]'`$last;;
*) spackage=`echo $first | tr '[a-z]' '[A-Z]'`$last;;
esac

: Some greps do not return status, grrr.
echo "grimblepritz" >grimble
if grep blurfldyick grimble >/dev/null 2>&1 ; then
	contains=contains
elif grep grimblepritz grimble >/dev/null 2>&1 ; then
	contains=grep
else
	contains=contains
fi
rm -f grimble
: the following should work in any shell
case "$contains" in
contains*)
	echo " "
	echo "AGH!  Grep doesn't return a status.  Attempting remedial action."
	cat >contains <<'EOSS'
grep "$1" "$2" >.greptmp && cat .greptmp && test -s .greptmp
EOSS
chmod +x contains
esac

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

: compute the number of columns on the terminal for proper question formatting
case "$COLUMNS" in
'') COLUMNS='80';;
esac

: set up the echo used in my read
myecho="case \"\$xxxm\" in
'') echo $n \"\$rp $c\" >&4;;
*) case \"\$rp\" in
	'') echo $n \"[\$xxxm] $c\";;
	*)
		if test \`echo \"\$rp [\$xxxm]  \" | wc -c\` -ge $COLUMNS; then
			echo \"\$rp\" >&4
			echo $n \"[\$xxxm] $c\" >&4
		else
			echo $n \"\$rp [\$xxxm] $c\" >&4
		fi
		;;
	esac;;
esac"

: now set up to do reads with possible shell escape and default assignment
cat <<EOSC >myread
xxxm=\$dflt
$myecho
ans='!'
case "\$fastread" in
yes) case "\$dflt" in
	'') ;;
	*) ans='';
		case "\$silent-\$rp" in
		true-) ;;
		*) echo " " >&4;;
		esac;;
	esac;;
*) case "\$silent" in
	true) case "\$rp" in
		'') ans='';;
		esac;;
	esac;;
esac
while expr "X\$ans" : "X!" >/dev/null; do
	read answ
	set x \$xxxm
	shift
	aok=''; eval "ans=\"\$answ\"" && aok=y
	case  "\$answ" in
	"!")
		sh 1>&4
		echo " "
		$myecho
		;;
	!*)
		set x \`expr "X\$ans" : "X!\(.*\)\$"\`
		shift
		sh 1>&4 -c "\$*"
		echo " "
		$myecho
		;;
	"\$ans")
		case "\$ans" in
		\\&*)
			set x \`expr "X\$ans" : "X&\(.*\)\$"\`
			shift
			case "\$1" in
			-d)
				fastread=yes
				echo "(OK, I'll run with -d after this question.)" >&4
				;;
			-*)
				echo "*** Sorry, \$1 not supported yet." >&4
				;;
			esac
			$myecho
			ans=!
			;;
		esac;;
	*)
		case "\$aok" in
		y)
			echo "*** Substitution done -- please confirm."
			xxxm="\$ans"
			ans=\`echo $n "\$ans$c" | tr '\012' ' '\`
			xxxm="\$ans"
			ans=!
			;;
		*)
			echo "*** Error -- try again."
			ans=!
			;;
		esac
		$myecho
		;;
	esac
	case "\$ans\$xxxm\$nostick" in
	'')
		ans=!
		$myecho
		;;
	esac
done
case "\$ans" in
'') ans="\$xxxm";;
esac
EOSC

: Find the path to the source tree
echo " "
case "$src" in
'') src=`echo $0 | sed -e 's%/[^/][^/]*$%%'`;;
esac
case "$src" in
'')
	src=.
	rsrc=..
	;;
/*) rsrc="$src/..";;
*) rsrc="../$src";;
esac
if test -f $rsrc/Configure && \
	$contains "^package=$package" $rsrc/Configure >/dev/null 2>&1
then
   : found it, so we are ok.
else
	rsrc=''
	for src in . .. ../.. ../../.. ../../../..; do
		if test -f ../$src/Configure && \
			$contains "^package=$package" ../$src/Configure >/dev/null 2>&1
		then
			rsrc=../$src
			break
		fi
	done
fi
case "$rsrc" in
'')
	dflt=
	rp="Directory where sources for $package are located?"
	. ./myread
	src="$ans"
	rsrc="$src"
	if test -f $rsrc/Configure && \
		$contains "^package=$package" $rsrc/Configure >/dev/null 2>&1
	then
		echo "Ok, I've found them under $src"
	else
		echo "Sorry, I can't seem to be able to locate $package sources." >&4
		exit 1
	fi
	;;
*)
	echo "Sources for $package found in $src" >&4
	;;
esac

: script used to extract .SH files with variable substitutions
cat >extract <<'EOS'
CONFIG=true
echo "Doing variable substitutions on .SH files..."
if test -f $src/MANIFEST; then
	set x `awk '{print $1}' <$src/MANIFEST | grep '\.SH'`
else
	echo "(Looking for .SH files under the source directory.)"
	set x `(cd $src; find . -name "*.SH" -print)`
fi
shift
case $# in
0) set x `(cd $src; echo *.SH)`; shift;;
esac
if test ! -f $src/$1; then
	shift
fi
mkdir_p='
name=$1;
create="";
while test $name; do
	if test ! -d "$name"; then
		create="$name $create";
		name=`echo $name | sed -e "s|^[^/]*$||"`;
		name=`echo $name | sed -e "s|\(.*\)/.*|\1|"`;
	else
		name="";
	fi;
done;
for file in $create; do
	mkdir $file;
done
'
for file in $*; do
	case "$src" in
	".")
		case "$file" in
		*/*)
			dir=`expr X$file : 'X\(.*\)/'`
			file=`expr X$file : 'X.*/\(.*\)'`
			(cd $dir && . ./$file)
			;;
		*)
			. ./$file
			;;
		esac
		;;
	*)
		case "$file" in
		*/*)
			dir=`expr X$file : 'X\(.*\)/'`
			file=`expr X$file : 'X.*/\(.*\)'`
			(set x $dir; shift; eval $mkdir_p)
			sh <$src/$dir/$file
			;;
		*)
			sh <$src/$file
			;;
		esac
		;;
	esac
done
if test -f $src/config_h.SH; then
	if test ! -f config.h; then
	: oops, they left it out of MANIFEST, probably, so do it anyway.
	. $src/config_h.SH
	fi
fi
EOS

: extract files and exit if asked to do so
case "$extractsh" in
true)
	case "$realsilent" in
	true) ;;
	*) exec 1>&4;;
	esac
	case "$config_sh" in
	'') config_sh='config.sh'; config="$rsrc/config.sh";;
	/*) config="$config_sh";;
	*) config="$rsrc/$config_sh";;
	esac
	echo " "
	echo "Fetching answers from $config_sh..."
	. $config
	test "$override" && . ./optdef.sh
	echo " "
	cd ..
	. UU/extract
	rm -rf UU
	echo "Done."
	exit 0
	;;
esac

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

trap 'echo " "; test -d ../UU && rm -rf X $rmlist; exit 1' 1 2 3 15

: Now test for existence of everything in MANIFEST
echo " "
if test -f $rsrc/MANIFEST; then
	echo "First let's make sure your kit is complete.  Checking..." >&4
	awk '$1 !~ /PACK[A-Z]+/ {print $1}' $rsrc/MANIFEST | split -50
	rm -f missing
	tmppwd=`pwd`
	for filelist in x??; do
		(cd $rsrc; ls `cat $tmppwd/$filelist` >/dev/null 2>>$tmppwd/missing)
	done
	if test -s missing; then
		cat missing >&4
		cat >&4 <<'EOM'

THIS PACKAGE SEEMS TO BE INCOMPLETE.

You have the option of continuing the configuration process, despite the
distinct possibility that your kit is damaged, by typing 'y'es.  If you
do, don't blame me if something goes wrong.  I advise you to type 'n'o
and contact the author (Raphael_Manfredi@grenoble.hp.com).

EOM
		echo $n "Continue? [n] $c" >&4
		read ans
		case "$ans" in
		y*)
			echo "Continuing..." >&4
			rm -f missing
			;;
		*)
			echo "ABORTING..." >&4
			kill $$
			;;
		esac
	else
		echo "Looks good..." >&4
	fi
else
	echo "There is no MANIFEST file.  I hope your kit is complete !"
fi
rm -f missing x??

: create .config dir to save info across Configure sessions
test -d ../.config || mkdir ../.config
cat >../.config/README <<EOF
This directory created by Configure to save information that should
persist across sessions for $package.

You may safely delete it if you wish.
EOF

: general instructions
needman=true
firsttime=true
user=`( (logname) 2>/dev/null || whoami) 2>&1`
if $contains "^$user\$" ../.config/instruct >/dev/null 2>&1; then
	firsttime=false
	echo " "
	rp='Would you like to see the instructions?'
	dflt=n
	. ./myread
	case "$ans" in
	[yY]*) ;;
	*) needman=false;;
	esac
fi
if $needman; then
	cat <<EOH
 
This installation shell script will examine your system and ask you questions
to determine how the mailagent 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=''
	dflt='Type carriage return to continue'
	. ./myread
	cat <<'EOH'

The prompter used in this script allows you to use shell variables and
backticks in your answers.  You may use $1, $2, etc...  to refer to the words
in the default answer, as if the default line was a set of arguments given to a
script shell.  This means you may also use $* to repeat the whole default line,
so you do not have to re-type everything to add something to the default.

Everytime there is a substitution, you will have to confirm.  If there is an
error (e.g. an unmatched backtick), the default answer will remain unchanged
and you will be prompted again.

If you are in a hurry, you may run 'Configure -d'.  This will bypass nearly all
the questions and use the computed defaults (or the previous answers if there
was already a config.sh file). Type 'Configure -h' for a list of options.
You may also start interactively and then answer '& -d' at any prompt to turn
on the non-interactive behaviour for the remaining of the execution.

EOH
	. ./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 yours, your best bet is to edit
Configure and run it again.  If you can't run Configure for some reason,
you'll have to generate a config.sh file by hand.  Whatever problems you
have, let me (Raphael_Manfredi@grenoble.hp.com) know how I blew it.

This installation script affects things in two ways:

1) it may do direct variable substitutions on some of the files included
   in this kit.
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
	dflt='Type carriage return to continue'
	. ./myread
	case "$firsttime" in
	true) echo $user >>../.config/instruct;;
	esac
fi

: see if sh knows # comments
echo " "
echo "Checking your sh to see if it knows about # comments..." >&4
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..."
	xcat=/bin/cat
	test -f $xcat || xcat=/usr/bin/cat
	echo "#!$xcat" >try
	$eunicefix try
	chmod +x try
	./try > today
	if test -s today; then
		echo "It does."
		sharpbang='#!'
	else
		echo "#! $xcat" > try
		$eunicefix try
		chmod +x try
		./try > today
		if test -s today; then
			echo "It does."
			sharpbang='#! '
		else
			echo "It's just a comment."
			sharpbang=': use '
		fi
	fi
else
	echo "Your sh doesn't grok # comments--I will strip them later on."
	shsharp=false
	cd ..
	echo "exec grep -v '^[ 	]*#'" >spitshell
	chmod +x spitshell
	$eunicefix spitshell
	spitshell=`pwd`/spitshell
	cd UU
	echo "I presume that if # doesn't work, #! won't work either!"
	sharpbang=': use '
fi
rm -f try today

: figure out how to guarantee sh startup
echo " "
echo "Checking out how to guarantee sh startup..." >&4
case "$SYSTYPE" in
*bsd*|sys5*) startsh=$sharpbang"/$SYSTYPE/bin/sh";;
*) startsh=$sharpbang'/bin/sh';;
esac
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

: find out where common programs are
echo " "
echo "Locating common programs..." >&4
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
	;;
	*)
	for thisthing in \$dir/\$thing; do
		: just loop through to pick last item
	done
	if test -f \$thisthing; then
		echo \$thisthing
		exit 0
	elif test -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="
awk
cat
chgrp
chmod
chown
comm
echo
expr
grep
ln
mkdir
mv
rm
sed
sleep
sort
touch
tr
uniq
"
trylist="
Mcc
cpp
date
inews
line
mail
nroff
perl
rmail
sendmail
smail
test
uname
vi
zcat
"
pth=`echo $PATH | sed -e "s/$p_/ /g"`
pth="$pth /lib /usr/lib"
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 $file is in $xxx.
		;;
	*)
		echo "I don't know where '$file' is, and my life depends on it."
		echo "Go find a public domain implementation or fix your PATH setting!"
		exit 1
		;;
	esac
done
echo " "
echo "Don't worry if any of the following aren't found..."
say=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 $file is in $xxx.
		;;
	*)
		echo "I don't see $file out there, $say."
		say=either
		;;
	esac
done
case "$egrep" in
egrep)
	echo "Substituting grep for egrep."
	egrep=$grep
	;;
esac
case "$test" in
test)
	echo "Hopefully test is built into your sh."
	;;
*)
	if `sh -c "PATH= test true" >/dev/null 2>&1`; then
		echo "Using the test built into your sh."
		test=test
		_test=test
	fi
	;;
esac
case "$echo" in
echo)
	echo "Hopefully echo is built into your sh."
	;;
'') ;;
*)
	echo " "
echo "Checking compatibility between $echo and builtin echo (if any)..." >&4
	$echo $n "hi there$c" >foo1
	echo $n "hi there$c" >foo2
	if cmp foo1 foo2 >/dev/null 2>&1; then
		echo "They are compatible.  In fact, they may be identical."
	else
		case "$n" in
		'-n') n='' c='\c';;
		*) n='-n' c='';;
		esac
		cat <<FOO
They are not compatible!  You are probably running ksh on a non-USG system.
I'll have to use $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 '$n$c' to suppress newlines now.  Life is ridiculous.

FOO
		$echo $n "The star should be here-->$c"
		$echo "*"
	fi
	$rm -f foo1 foo2
	;;
esac

: determine whether symbolic links are supported
echo " "
$touch blurfl
if $ln -s blurfl sym > /dev/null 2>&1 ; then
	echo "Symbolic links are supported." >&4
	lns="$ln -s"
else
	echo "Symbolic links are NOT supported." >&4
	lns="$ln"
fi
$rm -f blurfl sym

: see whether [:lower:] and [:upper:] are supported character classes
echo " "
up='[A-Z]'
low='[a-z]'
case "`echo AbyZ | $tr '[:lower:]' '[:upper:]' 2>/dev/null`" in
ABYZ)
	echo "Good, your tr supports [:lower:] and [:upper:] to convert case." >&4
	up='[:upper:]'
	low='[:lower:]'
	;;
*)
	echo "Your tr only supports [a-z] and [A-Z] to convert case." >&4
	;;
esac
: set up the translation script tr, must be called with ./tr of course
cat >tr <<EOSC
$startsh
case "\$1\$2" in
'[A-Z][a-z]') exec $tr '$up' '$low';;
'[a-z][A-Z]') exec $tr '$low' '$up';;
esac
exec $tr "\$@"
EOSC
chmod +x tr
$eunicefix tr

: Try to determine whether config.sh was made on this system
case "$config_sh" in
'')
myuname=`( ($uname -a) 2>/dev/null || hostname) 2>&1`
myuname=`echo $myuname | $sed -e 's/^[^=]*=//' -e 's/\///g' | \
	./tr '[A-Z]' '[a-z]' | tr '\012' ' '`
newmyuname="$myuname"
dflt=n
case "$knowitall" in
'')
	if test -f ../config.sh; then
		if $contains myuname= ../config.sh >/dev/null 2>&1; then
			eval "`grep myuname= ../config.sh`"
		fi
		if test "X$myuname" = "X$newmyuname"; then
			dflt=y
		fi
	fi
	;;
*) dflt=y;;
esac

: Get old answers, if there is a config file out there
hint=default
hintfile=''
if test -f ../config.sh; then
	echo " "
	rp="I see a config.sh file.  Shall I use it to set the defaults?"
	. ./myread
	case "$ans" in
	n*|N*) echo "OK, I'll ignore it.";;
	*)  echo "Fetching default answers from your old config.sh file..." >&4
		tmp_n="$n"
		tmp_c="$c"
		. ../config.sh
		cp ../config.sh .
		n="$tmp_n"
		c="$tmp_c"
		hint=previous
		;;
	esac
fi
;;
*)
	echo " "
	echo "Fetching default answers from $config_sh..." >&4
	tmp_n="$n"
	tmp_c="$c"
	cd ..
	cp $config_sh config.sh 2>/dev/null
	. ./config.sh
	cd UU
	cp ../config.sh .
	n="$tmp_n"
	c="$tmp_c"
	hint=previous
	;;
esac
test "$override" && . ./optdef.sh
myuname="$newmyuname"

: Restore computed paths
for file in $loclist $trylist; do
	eval $file="\$_$file"
done

: who configured the system
cf_time=`$date 2>&1`
(logname > .temp) >/dev/null 2>&1
$test -s .temp || (whoami > .temp) >/dev/null 2>&1
$test -s .temp || echo unknown > .temp
cf_by=`$cat .temp`
$rm -f .temp

: decide how portable to be
case "$d_portable" in
"$define") dflt=y;;
*)	dflt=n;;
esac
$cat <<'EOH'
 
I can set things up so that your shell scripts and binaries are more portable,
at what may be a noticable cost in performance.  In particular, if you
ask to be portable, the following happens:

     1) Shell scripts will rely on the PATH variable rather than using
	the paths derived above.
     2) ~username interpretations will be done at run time rather than
	by Configure.
     3) The system name will be determined at run time, if at all possible.

EOH
rp="Do you expect to run these scripts and binaries on multiple machines?"
. ./myread
case "$ans" in
	y*) d_portable="$define"
	;;
	*)  d_portable="$undef" ;;
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"
		failed=\$?
		echo ""
		exit \$failed
	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

: now set up to get a file name
cat <<'EOSC' >getfile
tilde=''
fullpath=''
already=''
skip=''
none_ok=''
exp_file=''
nopath_ok=''
orig_rp="$rp"
orig_dflt="$dflt"

case "$fn" in
*\(*)
	expr $fn : '.*(\(.*\)).*' | tr ',' '\012' >getfile.ok
	fn=`echo $fn | sed 's/(.*)//'`
	;;
esac

case "$fn" in
*:*)
	loc_file=`expr $fn : '.*:\(.*\)'`
	fn=`expr $fn : '\(.*\):.*'`
	;;
esac

case "$fn" in
*~*) tilde=true;;
esac
case "$fn" in
*/*) fullpath=true;;
esac
case "$fn" in
*+*) skip=true;;
esac
case "$fn" in
*n*) none_ok=true;;
esac
case "$fn" in
*e*) exp_file=true;;
esac
case "$fn" in
*p*) nopath_ok=true;;
esac

case "$fn" in
*f*) type='File';;
*d*) type='Directory';;
*l*) type='Locate';;
esac

what="$type"
case "$what" in
Locate) what='File';;
esac

case "$exp_file" in
'')
	case "$d_portable" in
	"$define") ;;
	*) exp_file=true;;
	esac
	;;
esac

cd ..
while test "$type"; do
	redo=''
	rp="$orig_rp"
	dflt="$orig_dflt"
	case "$tilde" in
	true) rp="$rp (~name ok)";;
	esac
	. UU/myread
	if test -f UU/getfile.ok && \
		$contains "^$ans\$" UU/getfile.ok >/dev/null 2>&1
	then
		value="$ans"
		ansexp="$ans"
		break
	fi
	case "$ans" in
	none)
		value=''
		ansexp=''
		case "$none_ok" in
		true) type='';;
		esac
		;;
	*)
		case "$tilde" in
		'') value="$ans"
			ansexp="$ans";;
		*)
			value=`UU/filexp $ans`
			case $? in
			0)
				if test "$ans" != "$value"; then
					echo "(That expands to $value on this system.)"
				fi
				;;
			*) value="$ans";;
			esac
			ansexp="$value"
			case "$exp_file" in
			'') value="$ans";;
			esac
			;;
		esac
		case "$fullpath" in
		true)
			case "$ansexp" in
			/*) value="$ansexp" ;;
			*)
				redo=true
				case "$already" in
				true)
				echo "I shall only accept a full path name, as in /bin/ls." >&4
				echo "Use a ! shell escape if you wish to check pathnames." >&4
					;;
				*)
				echo "Please give a full path name, starting with slash." >&4
					case "$tilde" in
					true)
				echo "Note that using ~name is ok provided it expands well." >&4
						already=true
						;;
					esac
				esac
				;;
			esac
			;;
		esac
		case "$redo" in
		'')
			case "$type" in
			File)
				if test -f "$ansexp"; then
					type=''
				elif test -r "$ansexp" || (test -h "$ansexp") >/dev/null 2>&1
				then
					echo "($value is not a plain file, but that's ok.)"
					type=''
				fi
				;;
			Directory)
				if test -d "$ansexp"; then
					type=''
				fi
				;;
			Locate)
				if test -d "$ansexp"; then
					echo "(Looking for $loc_file in directory $value.)"
					value="$value/$loc_file"
					ansexp="$ansexp/$loc_file"
				fi
				if test -f "$ansexp"; then
					type=''
				fi
				case "$nopath_ok" in
				true)	case "$value" in
					*/*) ;;
					*)	echo "Assuming $value will be in people's path."
						type=''
						;;
					esac
					;;
				esac
				;;
			esac

			case "$skip" in
			true) type='';
			esac

			case "$type" in
			'') ;;
			*)
				if test "$fastread" = yes; then
					dflt=y
				else
					dflt=n
				fi
				rp="$what $value doesn't exist.  Use that name anyway?"
				. UU/myread
				dflt=''
				case "$ans" in
				y*) type='';;
				*) echo " ";;
				esac
				;;
			esac
			;;
		esac
		;;
	esac
done
cd UU
ans="$value"
rp="$orig_rp"
dflt="$orig_dflt"
rm -f getfile.ok
EOSC

: determine root of directory hierarchy where package will be installed.
case "$prefix" in
'')
	dflt=`./loc . /usr/local /usr/local /local /opt /usr`
	;;
*)
	dflt="$prefix"
	;;
esac
$cat <<EOM

By default, $package will be installed in $dflt/bin, manual
pages under $dflt/man, etc..., i.e. with $dflt as prefix for
all installation directories. Typically set to /usr/local, but you
may choose /usr if you wish to install $package among your system
binaries. If you wish to have binaries under /bin but manual pages
under /usr/local/man, that's ok: you will be prompted separately
for each of the installation directories, the prefix being only used
to set the defaults.

EOM
fn=d~
rp='Installation prefix to use?'
. ./getfile
oldprefix=''
case "$prefix" in
'') ;;
*)
	case "$ans" in
	"$prefix") ;;
	*) oldprefix="$prefix";;
	esac
	;;
esac
prefix="$ans"
prefixexp="$ansexp"

: set the prefixit variable, to compute a suitable default value
prefixit='case "$3" in
""|none)
	case "$oldprefix" in
	"") eval "$1=\"\$$2\"";;
	*)
		case "$3" in
		"") eval "$1=";;
		none)
			eval "tp=\"\$$2\"";
			case "$tp" in
			""|" ") eval "$1=\"\$$2\"";;
			*) eval "$1=";;
			esac;;
		esac;;
	esac;;
*)
	eval "tp=\"$oldprefix-\$$2-\""; eval "tp=\"$tp\"";
	case "$tp" in
	--|/*--|\~*--) eval "$1=\"$prefix/$3\"";;
	/*-$oldprefix/*|\~*-$oldprefix/*)
		eval "$1=\`echo \$$2 | sed \"s,^$oldprefix,$prefix,\"\`";;
	*) eval "$1=\"\$$2\"";;
	esac;;
esac'

: is AFS running?
echo " "
if test -d /afs; then
	echo "AFS may be running... I'll be extra cautious then..." >&4
	afs=true
else
	echo "AFS does not seem to be running..." >&4
	afs=false
fi

: determine where public executables go
echo " "
set dflt bin bin
eval $prefixit
fn=d~
rp='Pathname where the public executables will reside?'
. ./getfile
if $test "X$ansexp" != "X$binexp"; then
	installbin=''
fi
bin="$ans"
binexp="$ansexp"
if $afs; then
	$cat <<EOM

Since you are running AFS, I need to 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).

EOM
	case "$installbin" in
	'') dflt=`echo $binexp | sed 's#^/afs/#/afs/.#'`;;
	*) dflt="$installbin";;
	esac
	fn=de~
	rp='Where will public executables be installed?'
	. ./getfile
	installbin="$ans"
else
	installbin="$binexp"
fi

: determine where manual pages are on this system
echo " "
case "$sysman" in
'') 
	syspath='/usr/man/man1 /usr/man/mann /usr/man/manl /usr/man/local/man1'
	syspath="$syspath /usr/man/u_man/man1 /usr/share/man/man1"
	syspath="$syspath /usr/catman/u_man/man1 /usr/man/l_man/man1"
	syspath="$syspath /usr/local/man/u_man/man1 /usr/local/man/l_man/man1"
	syspath="$syspath /usr/man/man.L /local/man/man1 /usr/local/man/man1"
	sysman=`./loc . /usr/man/man1 $syspath`
	;;
esac
if $test -d "$sysman"; then
	echo "System manual is in $sysman." >&4
else
	echo "Could not find manual pages in source form." >&4
fi

: set the prefixup variable, to restore leading tilda escape
prefixup='case "$prefixexp" in
"$prefix") ;;
*) eval "$1=\`echo \$$1 | sed \"s,^$prefixexp,$prefix,\"\`";;
esac'

: determine where manual pages go
set mansrc mansrc none
eval $prefixit
$cat <<EOM

$spackage has manual pages available in source form.
EOM
case "$nroff" in
nroff)
	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
'')
	lookpath="$prefixexp/man/man1 $prefixexp/man/u_man/man1"
	lookpath="$lookpath $prefixexp/man/l_man/man1"
	lookpath="$lookpath /usr/local/man/man1 /opt/man/man1 /usr/man/manl"
	lookpath="$lookpath /usr/man/local/man1 /usr/man/l_man/man1"
	lookpath="$lookpath /usr/local/man/u_man/man1 /usr/local/man/l_man/man1"
	lookpath="$lookpath /usr/man/man.L"
	mansrc=`./loc . $prefixexp/man/man1 $lookpath`
	if $test -d "$mansrc"; then
		dflt="$mansrc"
	else
		dflt="$sysman"
	fi
	set dflt
	eval $prefixup
	;;
' ') dflt=none;;
*)  dflt="$mansrc"
	;;
esac
echo " "
fn=dn~
rp='Where do the manual pages (source) go?'
. ./getfile
if test "X$mansrcexp" != "X$ansexp"; then
	installmansrc=''
fi
mansrc="$ans"
mansrcexp="$ansexp"
case "$mansrc" in
'') mansrc=' '
	installmansrc='';;
esac
if $afs && $test "$mansrc"; then
	$cat <<EOM

Since you are running AFS, I need to distinguish the directory in which
manual pages reside from the directory in which they are installed (and from
which they are presumably copied to the former directory by occult means).

EOM
	case "$installmansrc" in
	'') dflt=`echo $mansrcexp | sed 's#^/afs/#/afs/.#'`;;
	*) dflt="$installmansrc";;
	esac
	fn=de~
	rp='Where will man pages be installed?'
	. ./getfile
	installmansrc="$ans"
else
	installmansrc="$mansrcexp"
fi

case "$mansrc" in
' ') manext='0';;
*l) manext=l;;
*n) manext=n;;
*o) manext=l;;
*p) manext=n;;
*C) manext=C;;
*L) manext=L;;
*L1) manext=L1;;
*) manext=1;;
esac

: determine where private executables go
set dflt privlib lib/$package
eval $prefixit
$cat <<EOM

There are some auxiliary files for $package that need to be put into a
private library directory that is accessible by everyone.

EOM
fn=d~+
rp='Pathname where the private library files will reside?'
. ./getfile
if $test "X$privlibexp" != "X$ansexp"; then
	installprivlib=''
fi
privlib="$ans"
privlibexp="$ansexp"
if $afs; then
	$cat <<EOM

Since you are running AFS, I need to distinguish the directory in which
private files reside from the directory in which they are installed (and from
which they are presumably copied to the former directory by occult means).

EOM
	case "$installprivlib" in
	'') dflt=`echo $privlibexp | sed 's#^/afs/#/afs/.#'`;;
	*) dflt="$installprivlib";;
	esac
	fn=de~
	rp='Where will private files be installed?'
	. ./getfile
	installprivlib="$ans"
else
	installprivlib="$privlibexp"
fi

: determine where public executable scripts go
set scriptdir scriptdir
eval $prefixit
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
	$test -d /usr/local/script && dflt=/usr/local/script
	$test -d $prefixexp/script && dflt=$prefixexp/script
	set dflt
	eval $prefixup
	;;
*)  dflt="$scriptdir"
	;;
esac
$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
fn=d~
rp='Where do you keep publicly executable scripts?'
. ./getfile
if $test "X$ansexp" != "X$scriptdirexp"; then
	installscript=''
fi
scriptdir="$ans"
scriptdirexp="$ansexp"
if $afs; then
	$cat <<EOM

Since you are running AFS, I need to distinguish the directory in which
scripts reside from the directory in which they are installed (and from
which they are presumably copied to the former directory by occult means).

EOM
	case "$installscript" in
	'') dflt=`echo $scriptdirexp | sed 's#^/afs/#/afs/.#'`;;
	*) dflt="$installscript";;
	esac
	fn=de~
	rp='Where will public scripts be installed?'
	. ./getfile
	installscript="$ans"
else
	installscript="$scriptdirexp"
fi

: determine perl absolute location
case "$perlpath" in
'')
	if test -f /usr/bin/perl; then
		dflt=/usr/bin/perl
	else
		case "$perl" in
		*/*) dflt="$perl";;
		*) dflt=/usr/bin/perl;;
		esac
	fi
	;;
*)  dflt="$perlpath"
	;;
esac
echo " "
fn=f~/
rp="Where is perl located on your system?"
. ./getfile
perlpath="$ans"

: see what memory models we can support
case "$models" in
'')
	$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
		tans=`./loc . X /lib/small /lib/large /usr/lib/small /usr/lib/large /lib/medium /usr/lib/medium /lib/huge`
		case "$tans" 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 memory models are supported?"
. ./myread
models="$ans"

case "$models" in
none)
	small=''
	medium=''
	large=''
	huge=''
	unsplit=''
	split=''
	;;
*split)
	case "$split" in
	'') if $contains '\-i' $sysman/ld.1 >/dev/null 2>&1 || \
			 $contains '\-i' $sysman/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?"
	. ./myread
	tans="$ans"
	case "$tans" in
	none) tans='';;
	esac
	split="$tans"
	unsplit='';;
*large*|*small*|*medium*|*huge*)
	case "$models" in
	*large*)
		case "$large" in
		'') dflt='-Ml';;
		*) dflt="$large";;
		esac
	rp="What flag indicates large model?"
	. ./myread
	tans="$ans"
	case "$tans" in
	none) tans='';
	esac
	large="$tans";;
	*) large='';;
	esac
	case "$models" in
	*huge*) case "$huge" in
		'') dflt='-Mh';;
		*) dflt="$huge";;
		esac
		rp="What flag indicates huge model?"
		. ./myread
		tans="$ans"
		case "$tans" in
		none) tans='';
		esac
		huge="$tans";;
	*) huge="$large";;
	esac
	case "$models" in
	*medium*) case "$medium" in
		'') dflt='-Mm';;
		*) dflt="$medium";;
		esac
		rp="What flag indicates medium model?"
		. ./myread
		tans="$ans"
		case "$tans" in
		none) tans='';
		esac
		medium="$tans";;
	*) medium="$large";;
	esac
	case "$models" in
	*small*) case "$small" in
		'') dflt='none';;
		*) dflt="$small";;
		esac
		rp="What flag indicates small model?"
		. ./myread
		tans="$ans"
		case "$tans" in
		none) tans='';
		esac
		small="$tans";;
	*) small='';;
	esac
	;;
*)
	echo "Unrecognized memory models--you may have to edit Makefile.SH" >&4
	;;
esac

: make some quick guesses about what we are up against
echo " "
$echo $n "Hmm...  $c"
echo exit 1 >bsd
echo exit 1 >usg
echo exit 1 >v7
echo exit 1 >osf1
echo exit 1 >eunice
echo exit 1 >xenix
echo exit 1 >venix
echo exit 1 >os2
d_bsd="$undef"
$cat /usr/include/signal.h /usr/include/sys/signal.h >foo 2>/dev/null
if test -f /osf_boot || $contains 'OSF/1' /usr/include/ctype.h >/dev/null 2>&1
then
	echo "Looks kind of like an OSF/1 system, but we'll see..."
	echo exit 0 >osf1
elif test `echo abc | tr a-z A-Z` = Abc ; then
	xxx=`./loc addbib blurfl $pth`
	if $test -f $xxx; then
	echo "Looks kind of like a USG system with BSD features, but we'll see..."
		echo exit 0 >bsd
		echo exit 0 >usg
	else
		if $contains SIGTSTP foo >/dev/null 2>&1 ; then
			echo "Looks kind of like an extended USG system, but we'll see..."
		else
			echo "Looks kind of like a USG system, but we'll see..."
		fi
		echo exit 0 >usg
	fi
elif $contains SIGTSTP foo >/dev/null 2>&1 ; then
	echo "Looks kind of like a BSD system, but we'll see..."
	d_bsd="$define"
	echo exit 0 >bsd
else
	echo "Looks kind of like a Version 7 system, but we'll see..."
	echo exit 0 >v7
fi
case "$eunicefix" in
*unixtovms*)
	$cat <<'EOI'
There is, however, a strange, musty smell in the air that reminds me of
something...hmm...yes...I've got it...there's a VMS nearby, or I'm a Blit.
EOI
	echo exit 0 >eunice
	d_eunice="$define"
: it so happens the Eunice I know will not run shell scripts in Unix format
	;;
*)
	echo " "
	echo "Congratulations.  You aren't running Eunice."
	d_eunice="$undef"
	;;
esac
case "$p_" in
:) ;;
*)
	$cat <<'EOI'
I have the feeling something is not exactly right, however...don't tell me...
lemme think...does HAL ring a bell?...no, of course, you're only running OS/2!
EOI
	echo exit 0 >os2
	;;
esac
if test -f /xenix; then
	echo "Actually, this looks more like a XENIX system..."
	echo exit 0 >xenix
	d_xenix="$define"
else
	echo " "
	echo "It's not Xenix..."
	d_xenix="$undef"
fi
chmod +x xenix
$eunicefix xenix
if test -f /venix; then
	echo "Actually, this looks more like a VENIX system..."
	echo exit 0 >venix
else
	echo " "
	if ./xenix; then
		: null
	else
		echo "Nor is it Venix..."
	fi
fi
chmod +x bsd usg v7 osf1 eunice xenix venix os2
$eunicefix bsd usg v7 osf1 eunice xenix venix os2
$rm -f foo

: 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' $sysman/cc.1 >/dev/null 2>&1 ; then
					if $contains '\-M' $sysman/cpp.1 >/dev/null 2>&1; then
						dflt='cc'
					else
						dflt='cc -M'
					fi
				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.

EOM
	rp="What command will force resolution on this system?"
	. ./myread
	cc="$ans"
else
	case "$cc" in
	'') dflt=cc;;
	*) dflt="$cc";;
	esac
	rp="Use which C compiler?"
	. ./myread
	cc="$ans"
fi
echo " "
echo "Checking for GNU cc in disguise and/or its version number..." >&4
$cat >gccvers.c <<EOM
#include <stdio.h>
int main() {
#ifdef __GNUC__
#ifdef __VERSION__
	printf("%s\n", __VERSION__);
#else
	printf("%s\n", "1");
#endif
#endif
	exit(0);
}
EOM
if $cc -o gccvers gccvers.c >/dev/null 2>&1; then
	gccversion=`./gccvers`
	case "$gccversion" in
	'') echo "You are not using GNU cc." ;;
	*)  echo "You are using GNU cc $gccversion." ;;
	esac
else
	echo " "
	echo "*** WHOA THERE!!! ***" >&4
	echo "    Your C compiler \"$cc\" doesn't seem to be working!" >&4
	case "$knowitall" in
	'')
	echo "    You'd better start hunting for one and let me know about it." >&4
		exit 1
		;;
	esac
fi
$rm -f gccvers*
case "$gccversion" in
1*) cpp=`./loc gcc-cpp $cpp $pth` ;;
esac

: What should the include directory be ?
echo " "
$echo $n "Hmm...  $c"
dflt='/usr/include'
incpath=''
mips_type=''
if $test -f /bin/mips && /bin/mips; then
	echo "Looks like a MIPS system..."
	$cat >usr.c <<'EOCP'
#ifdef SYSTYPE_BSD43
/bsd43
#endif
EOCP
	if $cc -E usr.c > usr.out && $contains / usr.out >/dev/null 2>&1; then
		dflt='/bsd43/usr/include'
		incpath='/bsd43'
		mips_type='BSD 4.3'
	else
		mips_type='System V'
	fi
	$rm -f usr.c usr.out
	echo "and you're compiling with the $mips_type compiler and libraries."
	echo "exit 0" >mips
else
	echo "Doesn't look like a MIPS system."
	echo "exit 1" >mips
fi
chmod +x mips
$eunicefix mips
echo " "
case "$usrinc" in
'') ;;
*) dflt="$usrinc";;
esac
fn=d/
rp='Where are the include files you want to use?'
. ./getfile
usrinc="$ans"

: see how we invoke the C preprocessor
echo " "
echo "Now, how can we feed standard input to your C preprocessor..." >&4
cat <<'EOT' >testcpp.c
#define ABC abc
#define XYZ xyz
ABC.XYZ
EOT
cd ..
echo 'cat >.$$.c; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' >cppstdin
chmod 755 cppstdin
wrapper=`pwd`/cppstdin
ok='false'
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."
	case "$cpprun" in
	'') echo "But let's see if we can live without a wrapper..." ;;
	*)
		if $cpprun $cpplast <testcpp.c >testcpp.out 2>&1 && \
			$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1
		then
			echo "(And we'll use $cpprun $cpplast to preprocess directly.)"
			ok='true'
		else
			echo "(However, $cpprun $cpplast does not work, let's see...)"
		fi
		;;
	esac
else
	case "$cppstdin" in
	'') ;;
	*)
		echo "Good old $cppstdin $cppminus does not seem to be of any help..."
		;;
	esac
fi

if $ok; then
	: nothing
elif echo 'Maybe "'"$cc"' -E" will work...'; \
	$cc -E <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Yup, it does."
	x_cpp="$cc -E"
	x_minus='';
elif echo 'Nope...maybe "'"$cc"' -E -" will work...'; \
	$cc -E - <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Yup, it does."
	x_cpp="$cc -E"
	x_minus='-';
elif echo 'Nope...maybe "'"$cc"' -P" will work...'; \
	$cc -P <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Yipee, that works!"
	x_cpp="$cc -P"
	x_minus='';
elif echo 'Nope...maybe "'"$cc"' -P -" will work...'; \
	$cc -P - <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "At long last!"
	x_cpp="$cc -P"
	x_minus='-';
elif echo 'No such luck, maybe "'$cpp'" will work...'; \
	$cpp <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "It works!"
	x_cpp="$cpp"
	x_minus='';
elif echo 'Nixed again...maybe "'$cpp' -" will work...'; \
	$cpp - <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Hooray, it works!  I was beginning to wonder."
	x_cpp="$cpp"
	x_minus='-';
elif echo 'Uh-uh.  Time to get fancy.  Trying a wrapper...'; \
	$wrapper <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	x_cpp="$wrapper"
	x_minus=''
	echo "Eureka!"
else
	dflt=''
	rp="No dice.  I can't find a C preprocessor.  Name one:"
	. ./myread
	x_cpp="$ans"
	x_minus=''
	$x_cpp <testcpp.c >testcpp.out 2>&1
	if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
		echo "OK, that will do." >&4
	else
echo "Sorry, I can't get that to work.  Go find one and rerun Configure." >&4
		exit 1
	fi
fi

case "$ok" in
false)
	cppstdin="$x_cpp"
	cppminus="$x_minus"
	cpprun="$x_cpp"
	cpplast="$x_minus"
	set X $x_cpp
	shift
	case "$1" in
	"$cpp")
		echo "Perhaps can we force $cc -E using a wrapper..."
		if $wrapper <testcpp.c >testcpp.out 2>&1; \
			$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1
		then
			echo "Yup, we can."
			cppstdin="$wrapper"
			cppminus='';
		else
			echo "Nope, we'll have to live without it..."
		fi
		;;
	esac
	case "$cpprun" in
	"$wrapper")
		cpprun=''
		cpplast=''
		;;
	esac
	;;
esac

case "$cppstdin" in
"$wrapper") ;;
*) $rm -f $wrapper;;
esac
$rm -f testcpp.c testcpp.out

: 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?"
. ./myread
optimize="$ans"
case "$optimize" in
'none') optimize=" ";;
esac

dflt=''
case "$ccflags" in
'')	
	case "$gccversion" in
	1*) dflt='-fpcc-struct-return' ;;
	esac
	case "$optimize" in
	*-g*) dflt="$dflt -DDEBUGGING";;
	esac
	case "$gccversion" in
	2*) if test -d /etc/conf/kconfig.d &&
			$contains _POSIX_VERSION $usrinc/sys/unistd.h >/dev/null 2>&1
		then
			dflt="$dflt -posix"
		fi
		;;
	esac
	;;
esac

case "$mips_type" in
*BSD*) ;;
'') ;;
*) inclwanted="$inclwanted $usrinc/bsd";;
esac
for thisincl in $inclwanted; do
	if $test -d $thisincl; then
		if $test x$thisincl != x$usrinc; then
			case "$dflt" in
			*$thisincl*);;
			*) dflt="$dflt -I$thisincl";;
			esac
		fi
	fi
done

inctest='if $contains $2 $usrinc/$1 >/dev/null 2>&1; then
	xxx=true;
elif $contains $2 $usrinc/sys/$1 >/dev/null 2>&1; then
	xxx=true;
else
	xxx=false;
fi;
if $xxx; then
	case "$dflt" in
	*$2*);;
	*) dflt="$dflt -D$2";;
	esac;
fi'

if ./osf1; then
	set signal.h __LANGUAGE_C__; eval $inctest
else
	set signal.h LANGUAGE_C; eval $inctest
fi
set signal.h NO_PROTOTYPE; eval $inctest
set signal.h _NO_PROTO; eval $inctest

case "$dflt" in
'') dflt=none;;
esac
case "$ccflags" in
'') ;;
*) dflt="$ccflags";;
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.  If you
want $package to honor its debug switch, you should include -DDEBUG here.
To use no flags, specify the word "none".

EOH
set X $dflt
shift
dflt=${1+"$@"}
rp="Any additional cc flags?"
. ./myread
case "$ans" in
none) ccflags='';;
*) ccflags="$ans";;
esac

: the following weeds options from ccflags that are of no interest to cpp
cppflags="$ccflags"
case "$gccversion" in
1*) cppflags="$cppflags -D__GNUC__"
esac
case "$mips_type" in
'');;
*BSD*) cppflags="$cppflags -DSYSTYPE_BSD43";;
esac
case "$cppflags" in
'');;
*)
	echo " "
	echo "Let me guess what the preprocessor flags are..." >&4
	set X $cppflags
	shift
	cppflags=''
	$cat >cpp.c <<'EOM'
#define BLURFL foo

BLURFL xx LFRULB
EOM
	previous=''
	for flag in $*
	do
		case "$flag" in
		-*) ftry="$flag";;
		*) ftry="$previous $flag";;
		esac
		if $cppstdin -DLFRULB=bar $ftry $cppminus <cpp.c \
			>cpp1.out 2>/dev/null && \
			$cpprun -DLFRULB=bar $ftry $cpplast <cpp.c \
			>cpp2.out 2>/dev/null && \
			$contains 'foo.*xx.*bar' cpp1.out >/dev/null 2>&1 && \
			$contains 'foo.*xx.*bar' cpp2.out >/dev/null 2>&1
		then
			cppflags="$cppflags $ftry"
			previous=''
		else
			previous="$flag"
		fi
	done
	set X $cppflags
	shift
	cppflags=${1+"$@"}
	case "$cppflags" in
	*-*)  echo "They appear to be: $cppflags";;
	esac
	$rm -f cpp.c cpp?.out
	;;
esac

: flags used in final linking phase
case "$ldflags" in
'') if ./venix; then
		dflt='-i -z'
	else
		dflt=''
	fi
	case "$ccflags" in
	*-posix*) dflt="$dflt -posix" ;;
	esac
	case "$dflt" in
	'') dflt='none' ;;
	esac
	;;
*) dflt="$ldflags";;
esac
echo " "
rp="Any additional ld flags (NOT including libraries)?"
. ./myread
case "$ans" in
none) ldflags='';;
*) ldflags="$ans";;
esac
rmlist="$rmlist pdp11"

: coherency check
echo " "
echo "Checking your choice of C compiler and flags for coherency..." >&4
set X $cc $optimize $ccflags $ldflags try.c -o try
shift
$cat >try.msg <<EOM
I've tried to compile and run a simple program with:

	$*
	./try

and I got the following output:

EOM
$cat > try.c <<'EOF'
#include <stdio.h>
main() { exit(0); }
EOF
dflt=y
if sh -c "$cc $optimize $ccflags $ldflags try.c -o try" >>try.msg 2>&1; then
	if sh -c './try' >>try.msg 2>&1; then
		dflt=n
	else
		echo "The program compiled OK, but exited with status $?." >>try.msg
		rp="You have a problem.  Shall I abort Configure"
		dflt=y
	fi
else
	echo "I can't compile the test program." >>try.msg
	rp="You have a BIG problem.  Shall I abort Configure"
	dflt=y
fi
case "$dflt" in
y)
	$cat try.msg
	case "$knowitall" in
	'')
		echo "(The supplied flags might be incorrect with this C compiler.)"
		;;
	*) dflt=n;;
	esac
	echo " "
	. ./myread
	case "$ans" in
	n*|N*) ;;
	*)	echo "Ok.  Stopping Configure." >&4
		exit 1
		;;
	esac
	;;
n) echo "OK, that should do.";;
esac
$rm -f try try.* core

: Initialize h_fcntl
h_fcntl=false

: Initialize h_sysfile
h_sysfile=false

: Set private lib path
case "$plibpth" in
'') if ./mips; then
		plibpth="$incpath/usr/lib /usr/local/lib /usr/ccs/lib"
	fi;;
esac
case "$libpth" in
' ') dlist='';;
'') dlist="$plibpth $glibpth";;
*) dlist="$libpth";;
esac

: Now check and see which directories actually exist, avoiding duplicates
libpth=''
for xxx in $dlist
do
    if $test -d $xxx; then
		case " $libpth " in
		*" $xxx "*) ;;
		*) libpth="$libpth $xxx";;
		esac
    fi
done
$cat <<'EOM'

Some systems have incompatible or broken versions of libraries.  Among
the directories listed in the question below, please remove any you
know not to be holding relevant libraries, and add any that are needed.
Say "none" for none.

EOM
case "$libpth" in
'') dflt='none';;
*)
	set X $libpth
	shift
	dflt=${1+"$@"}
	;;
esac
rp="Directories to use for library searches?"
. ./myread
case "$ans" in
none) libpth=' ';;
*) libpth="$ans";;
esac

: compute shared library extension
case "$so" in
'')
	if xxx=`./loc libc.sl X $libpth`; $test -f "$xxx"; then
		dflt='sl'
	else
		dflt='so'
	fi
	;;
*) dflt="$so";;
esac
$cat <<EOM

On some systems, shared libraries may be available.  Answer 'none' if
you want to suppress searching of shared libraries for the remaining
of this configuration.

EOM
rp='What is the file extension used for shared libraries?'
. ./myread
so="$ans"

: Looking for optional libraries
echo " "
echo "Checking for optional libraries..." >&4
case "$libs" in
' '|'') dflt='';;
*) dflt="$libs";;
esac
case "$libswanted" in
'') libswanted='c_s';;
esac
for thislib in $libswanted; do
	
	if xxx=`./loc lib$thislib.$so.[0-9]'*' X $libpth`; $test -f "$xxx"; then
		echo "Found -l$thislib (shared)."
		case " $dflt " in
		*"-l$thislib "*);;
		*) dflt="$dflt -l$thislib";;
		esac
	elif xxx=`./loc lib$thislib.$so X $libpth` ; $test -f "$xxx"; then
		echo "Found -l$thislib (shared)."
		case " $dflt " in
		*"-l$thislib "*);;
		*) dflt="$dflt -l$thislib";;
		esac
	elif xxx=`./loc lib$thislib.a X $libpth`; $test -f "$xxx"; then
		echo "Found -l$thislib."
		case " $dflt " in
		*"-l$thislib "*);;
		*) dflt="$dflt -l$thislib";;
		esac
	elif xxx=`./loc $thislib.a X $libpth`; $test -f "$xxx"; then
		echo "Found -l$thislib."
		case " $dflt " in
		*"-l$thislib "*);;
		*) dflt="$dflt -l$thislib";;
		esac
	elif xxx=`./loc lib${thislib}_s.a X $libpth`; $test -f "$xxx"; then
		echo "Found -l${thislib}_s."
		case " $dflt " in
		*"-l$thislib "*);;
		*) dflt="$dflt -l${thislib}_s";;
		esac
	elif xxx=`./loc Slib$thislib.a X $xlibpth`; $test -f "$xxx"; then
		echo "Found -l$thislib."
		case " $dflt " in
		*"-l$thislib "*);;
		*) dflt="$dflt -l$thislib";;
		esac
	else
		echo "No -l$thislib."
	fi
done
set X $dflt
shift
dflt="$*"
case "$libs" in
'') dflt="$dflt";;
*) dflt="$libs";;
esac
case "$dflt" in
' '|'') dflt='none';;
esac

$cat <<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?"
. ./myread
case "$ans" in
none) libs=' ';;
*) libs="$ans";;
esac

: see if nm is to be used to determine whether a symbol is defined or not
case "$usenm" in
'')
	dflt=`egrep 'inlibc|csym' $rsrc/Configure | wc -l 2>/dev/null`
	if $test $dflt -gt 20; then
		dflt=y
	else
		dflt=n
	fi
	;;
*)
	case "$usenm" in
	true) dflt=y;;
	*) dflt=n;;
	esac
	;;
esac
$cat <<EOM

I can use 'nm' to extract the symbols from your C libraries. This is a time
consuming task which may generate huge output on the disk (up to 3 megabytes)
but that should make the symbols extraction faster. The alternative is to skip
the 'nm' extraction part and to compile a small test program instead to
determine whether each symbol is present. If you have a fast C compiler and/or
if your 'nm' output cannot be parsed, this may be the best solution.

EOM
rp='Shall I use nm to extract C symbols from the libraries?'
. ./myread
case "$ans" in
n|N) usenm=false;;
*) usenm=true;;
esac

runnm=$usenm
case "$reuseval" in
true) runnm=false;;
esac

: nm options which may be necessary
case "$nm_opt" in
'') if $test -f /mach_boot; then
		nm_opt=''
	elif $test -d /usr/ccs/lib; then
		nm_opt='-p'
	elif $test -f /dgux; then
		nm_opt='-p'
	else
		nm_opt=''
	fi;;
esac

case "$runnm" in
true)
: get list of predefined functions in a handy place
echo " "
case "$libc" in
'') libc=unknown
	case "$libs" in
	*-lc_s*) libc=`./loc libc_s.a $libc $libpth`
	esac
	;;
esac
libnames='';
case "$libs" in
'') ;;
*)  for thislib in $libs; do
	case "$thislib" in
	-lc|-lc_s)
		: Handle C library specially below.
		;;
	-l*)
		thislib=`echo $thislib | $sed -e 's/^-l//'`
		if try=`./loc lib$thislib.$so.'*' X $libpth`; $test -f "$try"; then
			:
		elif try=`./loc lib$thislib.$so X $libpth`; $test -f "$try"; then
			:
		elif try=`./loc lib$thislib.a X $libpth`; $test -f "$try"; then
			:
		elif try=`./loc lib$thislib X $libpth`; $test -f "$try"; then
			:
		elif try=`./loc $thislib X $libpth`; $test -f "$try"; then
			:
		elif try=`./loc Slib$thislib.a X $xlibpth`; $test -f "$try"; then
			:
		else
			try=''
		fi
		libnames="$libnames $try"
		;;
	*) libnames="$libnames $thislib" ;;
	esac
	done
	;;
esac
xxx=normal
case "$libc" in
unknown)
	set /usr/ccs/lib/libc.$so
	$test -r $1 || set /usr/lib/libc.$so
	$test -r $1 || set /usr/shlib/libc.$so
	$test -r $1 || \
		set `echo blurfl; echo /usr/lib/libc.$so.[0-9]* | \
		tr ' ' '\012' | egrep -v '\.[A-Za-z]*$' | $sed -e '
			h
			s/[0-9][0-9]*/0000&/g
			s/0*\([0-9][0-9][0-9][0-9][0-9]\)/\1/g
			G
			s/\n/ /' | \
		 sort | $sed -e 's/^.* //'`
	eval set \$$#
	$test -r $1 || set /lib/libc.$so
	$test -r $1 || set /lib/libsys_s.a
	;;
*)
	set blurfl
	;;
esac
if $test -r "$1"; then
	echo "Your (shared) C library seems to be in $1."
	libc="$1"
elif $test -r /lib/libc && $test -r /lib/clib; then
	echo "Your C library seems to be in both /lib/clib and /lib/libc."
	xxx=apollo
	libc='/lib/clib /lib/libc'
	if $test -r /lib/syslib; then
		echo "(Your math library is in /lib/syslib.)"
		libc="$libc /lib/syslib"
	fi
elif $test -r "$libc" || (test -h "$libc") >/dev/null 2>&1; then
	echo "Your C library seems to be in $libc, as you said before."
elif $test -r $incpath/usr/lib/libc.a; then
	libc=$incpath/usr/lib/libc.a;
	echo "Your C library seems to be in $libc.  That's fine."
elif $test -r /lib/libc.a; then
	libc=/lib/libc.a;
	echo "Your C library seems to be in $libc.  You're normal."
else
	if tans=`./loc libc.a blurfl/dyick $libpth`; $test -r "$tans"; then
		:
	elif tans=`./loc libc blurfl/dyick $libpth`; $test -r "$tans"; then
		libnames="$libnames "`./loc clib blurfl/dyick $libpth`
	elif tans=`./loc clib blurfl/dyick $libpth`; $test -r "$tans"; then
		:
	elif tans=`./loc Slibc.a blurfl/dyick $xlibpth`; $test -r "$tans"; then
		:
	elif tans=`./loc Mlibc.a blurfl/dyick $xlibpth`; $test -r "$tans"; then
		:
	else
		tans=`./loc Llibc.a blurfl/dyick $xlibpth`
	fi
	if $test -r "$tans"; then
		echo "Your C library seems to be in $tans, of all places."
		libc=$tans
	else
		libc='blurfl'
	fi
fi
if $test $xxx = apollo -o -r "$libc" || (test -h "$libc") >/dev/null 2>&1; then
	dflt="$libc"
	cat <<EOM

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.

EOM
else
	dflt=''
	echo $libpth | tr ' ' '\012' | sort | uniq > libpath
	cat >&4 <<EOM
I can't seem to find your C library.  I've looked in the following places:

EOM
	$sed 's/^/	/' libpath
	cat <<EOM

None of these seems to contain your C library. I need to get its name...

EOM
fi
fn=f
rp='Where is your C library?'
. ./getfile
libc="$ans"

echo " "
echo $libc $libnames | tr ' ' '\012' | sort | uniq > libnames
set X `cat libnames`
shift
xxx=files
case $# in 1) xxx=file; esac
echo "Extracting names from the following $xxx for later perusal:" >&4
echo " "
$sed 's/^/	/' libnames >&4
echo " "
$echo $n "This may take a while...$c" >&4

nm $nm_opt $* 2>/dev/null >libc.tmp
$echo $n ".$c"
$grep fprintf libc.tmp > libc.ptf
xscan='eval "<libc.ptf $com >libc.list"; $echo $n ".$c" >&4'
xrun='eval "<libc.tmp $com >libc.list"; echo "done" >&4'
xxx='[ADTSIW]'
if com="$sed -n -e 's/__IO//' -e 's/^.* $xxx  *_[_.]*//p' -e 's/^.* $xxx //p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
elif com="$sed -n -e 's/^__*//' -e 's/^\([a-zA-Z_0-9$]*\).*xtern.*/\1/p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
elif com="$sed -n -e '/|UNDEF/d' -e '/FUNC..GL/s/^.*|__*//p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
elif com="$sed -n -e 's/^.* D __*//p' -e 's/^.* D //p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
elif com="$sed -n -e 's/^_//' -e 's/^\([a-zA-Z_0-9]*\).*xtern.*text.*/\1/p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
elif com="$sed -n -e 's/^.*|FUNC |GLOB .*|//p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
elif com="$grep '|' | $sed -n -e '/|COMMON/d' -e '/|DATA/d' \
				-e '/ file/d' -e 's/^\([^ 	]*\).*/\1/p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
elif com="$sed -n -e 's/^.*|FUNC |GLOB .*|//p' -e 's/^.*|FUNC |WEAK .*|//p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
elif com="$sed -n -e 's/^__//' -e '/|Undef/d' -e '/|Proc/s/ .*//p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
elif com="$sed -n -e '/Def. Text/s/.* \([^ ]*\)\$/\1/p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
elif com="$sed -n -e 's/^[-0-9a-f ]*_\(.*\)=.*/\1/p'";\
	eval $xscan;\
	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
		eval $xrun
else
	nm -p $* 2>/dev/null >libc.tmp
	$grep fprintf libc.tmp > libc.ptf
	if com="$sed -n -e 's/^.* [ADTSIW]  *_[_.]*//p' -e 's/^.* [ADTSIW] //p'";\
		eval $xscan; $contains '^fprintf$' libc.list >/dev/null 2>&1
	then
		nm_opt='-p'
		eval $xrun
	else
		echo " "
		echo "nm didn't seem to work right. Trying ar instead..." >&4
		com=''
		if ar t $libc > libc.tmp; then
			for thisname in $libnames; do
				ar t $thisname >>libc.tmp
			done
			$sed -e 's/\.o$//' < libc.tmp > libc.list
			echo "Ok." >&4
		else
			echo "ar didn't seem to work right." >&4
			echo "Maybe this is a Cray...trying bld instead..." >&4
			if bld t $libc | $sed -e 's/.*\///' -e 's/\.o:.*$//' > libc.list
			then
				for thisname in $libnames; do
					bld t $libnames | \
					$sed -e 's/.*\///' -e 's/\.o:.*$//' >>libc.list
					ar t $thisname >>libc.tmp
				done
				echo "Ok." >&4
			else
				echo "That didn't work either.  Giving up." >&4
				exit 1
			fi
		fi
	fi
fi
nm_extract="$com"
if $test -f /lib/syscalls.exp; then
	echo " "
	echo "Also extracting names from /lib/syscalls.exp for good ole AIX..." >&4
	$sed -n 's/^\([^ 	]*\)[ 	]*syscall$/\1/p' /lib/syscalls.exp >>libc.list
fi
;;
esac
$rm -f libnames libpath

: is a C symbol defined?
csym='tlook=$1;
case "$3" in
-v) tf=libc.tmp; tc=""; tdc="";;
-a) tf=libc.tmp; tc="[0]"; tdc="[]";;
*) tlook="^$1\$"; tf=libc.list; tc="()"; tdc="()";;
esac;
tx=yes;
case "$reuseval-$4" in
true-) ;;
true-*) tx=no; eval "tval=\$$4"; case "$tval" in "") tx=yes;; esac;;
esac;
case "$tx" in
yes)
	case "$runnm" in
	true)
		if $contains $tlook $tf >/dev/null 2>&1;
		then tval=true;
		else tval=false;
		fi;;
	*)
		echo "main() { extern short $1$tdc; printf(\"%hd\", $1$tc); }" > t.c;
		if $cc $ccflags $ldflags -o t t.c $libs >/dev/null 2>&1;
		then tval=true;
		else tval=false;
		fi;
		$rm -f t t.c;;
	esac;;
*)
	case "$tval" in
	$define) tval=true;;
	*) tval=false;;
	esac;;
esac;
eval "$2=$tval"'

: set up the script used to warn in case of inconsistency
cat <<'EOSC' >whoa
dflt=y
echo " "
echo "*** WHOA THERE!!! ***" >&4
echo "    The $hint value for \$$var on this machine was \"$was\"!" >&4
rp="    Keep the $hint value?"
. ./myread
case "$ans" in
y) td=$was; tu=$was;;
esac
EOSC

: define an is-in-libc? function
inlibc='echo " "; td=$define; tu=$undef;
sym=$1; var=$2; eval "was=\$$2";
tx=yes;
case "$reuseval$was" in
true) ;;
true*) tx=no;;
esac;
case "$tx" in
yes)
	set $sym tres -f;
	eval $csym;
	case "$tres" in
	true)
		echo "$sym() found." >&4;
		case "$was" in $undef) . ./whoa; esac; eval "$var=\$td";;
	*)
		echo "$sym() NOT found." >&4;
		case "$was" in $define) . ./whoa; esac; eval "$var=\$tu";;
	esac;;
*)
	case "$was" in
	$define) echo "$sym() found." >&4;;
	*) echo "$sym() NOT found." >&4;;
	esac;;
esac'

: determine filename position in cpp output
echo " "
echo "Computing filename position in cpp output for #include directives..." >&4
echo '#include <stdio.h>' > foo.c
$cat >fieldn <<EOF
$startsh
$cppstdin $cppflags $cppminus <foo.c 2>/dev/null | \
$grep '^[ 	]*#.*stdio\.h' | \
while read cline; do
	pos=1
	set \$cline
	while $test \$# -gt 0; do
		if $test -r \`echo \$1 | $tr -d '"'\`; then
			echo "\$pos"
			exit 0
		fi
		shift
		pos=\`expr \$pos + 1\`
	done
done
EOF
chmod +x fieldn
fieldn=`./fieldn`
$rm -f foo.c fieldn
case $fieldn in
'') pos='???';;
1) pos=first;;
2) pos=second;;
3) pos=third;;
*) pos="${fieldn}th";;
esac
echo "Your cpp writes the filename in the $pos field of the line."

: locate header file
$cat >findhdr <<EOF
$startsh
wanted=\$1
name=''
if test -f $usrinc/\$wanted; then
	echo "$usrinc/\$wanted"
	exit 0
fi
awkprg='{ print \$$fieldn }'
echo "#include <\$wanted>" > foo\$\$.c
$cppstdin $cppminus $cppflags < foo\$\$.c 2>/dev/null | \
$grep "^[ 	]*#.*\$wanted" | \
while read cline; do
	name=\`echo \$cline | $awk "\$awkprg" | $tr -d '"'\`
	case "\$name" in
	*/\$wanted) echo "\$name"; exit 0;;
	*) name='';;
	esac;
done;
$rm -f foo\$\$.c;
case "\$name" in
'') exit 1;;
esac
EOF
chmod +x findhdr

: access call always available on UNIX
set access d_access
eval $inlibc

: locate the flags for 'access()'
case "$d_access" in
"$define")
	echo " "
	$cat >access.c <<'EOCP'
#include <sys/types.h>
#ifdef I_FCNTL
#include <fcntl.h>
#endif
#ifdef I_SYS_FILE
#include <sys/file.h>
#endif
#ifdef I_UNISTD
#include <unistd.h>
#endif
main() {
	exit(R_OK);
}
EOCP
	: check sys/file.h first, no particular reason here
	if $test `./findhdr sys/file.h` && \
		$cc $cppflags -DI_SYS_FILE access.c -o access >/dev/null 2>&1 ; then
		h_sysfile=true;
		echo "<sys/file.h> defines the *_OK access constants." >&4
	elif $test `./findhdr fcntl.h` && \
		$cc $cppflags -DI_FCNTL access.c -o access >/dev/null 2>&1 ; then
		h_fcntl=true;
		echo "<fcntl.h> defines the *_OK access constants." >&4
	elif $test `./findhdr unistd.h` && \
		$cc $cppflags -DI_UNISTD access.c -o access >/dev/null 2>&1 ; then
		echo "<unistd.h> defines the *_OK access constants." >&4
	else
		echo "I can't find the four *_OK access constants--I'll use mine." >&4
	fi
	;;
esac
$rm -f access*

: see if bcopy exists
set bcopy d_bcopy
eval $inlibc

: function used to set $1 to $val
setvar='var=$1; eval "was=\$$1"; td=$define; tu=$undef;
case "$val$was" in
$define$undef) . ./whoa; eval "$var=\$td";;
$undef$define) . ./whoa; eval "$var=\$tu";;
*) eval "$var=$val";;
esac'

: see if setpgrp exists
set setpgrp d_setpgrp
eval $inlibc

: see which flavor of setpgrp is in use
case "$d_setpgrp" in
"$define")
	echo " "
	$cat >set.c <<EOP
main()
{
	if (getuid() == 0) {
		printf("(I see you are running Configure as super-user...)\n");
		setuid(1);
	}
	if (-1 == setpgrp(1, 1))
		exit(1);
	exit(0);
}
EOP
	if $cc $ccflags $ldflags -o set set.c $libs >/dev/null 2>&1; then
		./set 2>/dev/null
		case $? in
		0) echo "You have to use setpgrp() instead of setpgrp(pid, pgrp)." >&4
			val="$undef";;
		*) echo "You have to use setpgrp(pid, pgrp) instead of setpgrp()." >&4
			val="$define";;
		esac
	else
		if ./usg; then
			xxx="USG one, i.e. you use setpgrp()."
			val="$undef"
		else
			xxx="BSD one, i.e. you use setpgrp(pid, pgrp)."
			val="$define"
		fi
		echo "Assuming your setpgrp is a $xxx" >&4
	fi
	;;
*) val="$undef";;
esac
set d_bsdpgrp
eval $setvar
$rm -f set set.c

: see if we can have long filenames
echo " "
rmlist="$rmlist /tmp/cf$$"
$test -d /tmp/cf$$ || mkdir /tmp/cf$$
first=123456789abcdef
second=/tmp/cf$$/$first
$rm -f $first $second
if (echo hi >$first) 2>/dev/null; then
	if $test -f 123456789abcde; then
		echo 'You cannot have filenames longer than 14 characters.  Sigh.' >&4
		val="$undef"
	else
		if (echo hi >$second) 2>/dev/null; then
			if $test -f /tmp/cf$$/123456789abcde; then
				$cat <<'EOM'
That's peculiar... You can have filenames longer than 14 characters, but only
on some of the filesystems.  Maybe you are using NFS.  Anyway, to avoid problems
I shall consider your system cannot support long filenames at all.
EOM
				val="$undef"
			else
				echo 'You can have filenames longer than 14 characters.' >&4
				val="$define"
			fi
		else
			$cat <<'EOM'
How confusing! Some of your filesystems are sane enough to allow filenames
longer than 14 characters but some others like /tmp can't even think about them.
So, for now on, I shall assume your kernel does not allow them at all.
EOM
			val="$undef"
		fi
	fi
else
	$cat <<'EOM'
You can't have filenames longer than 14 chars.  You can't even think about them!
EOM
	val="$undef"
fi 
set d_flexfnam
eval $setvar
$rm -rf /tmp/cf$$ 123456789abcde*

: see if we have to deal with yellow pages, now NIS.
if $test -d /usr/etc/yp || $test -d /etc/yp; then
	if $test -f /usr/etc/nibindd; then
		echo " "
		echo "I'm fairly confident you're on a NeXT."
		echo " "
		rp='Do you get the passwd file via NetInfo?'
		dflt=y
		case "$passcat" in
		nidump*) ;;
		'') ;;
		*) dflt=n;;
		esac
		. ./myread
		case "$ans" in
		y*) passcat='nidump passwd .'
			;;
		*)	echo "You told me, so don't blame me."
			case "$passcat" in
			nidump*) passcat=''
			esac
			;;
		esac
		echo " "
		rp='Do you get the hosts file via NetInfo?'
		dflt=y
		case "$hostcat" in
		nidump*) ;;
		'') ;;
		*) dflt=n;;
		esac
		. ./myread
		case "$ans" in
		y*) hostcat='nidump hosts .';;
		*)	case "$hostcat" in
			nidump*) hostcat='';;
			esac
			;;
		esac
	fi
	case "$passcat" in
	nidump*) ;;
	*)
		case "$passcat" in
		*ypcat*) dflt=y;;
		'') if $contains '^\+' /etc/passwd >/dev/null 2>&1; then
				dflt=y
			else
				dflt=n
			fi;;
		*) dflt=n;;
		esac
		echo " "
		rp='Are you getting the passwd file via yellow pages?'
		. ./myread
		case "$ans" in
		y*) passcat='ypcat passwd'
			;;
		*)	passcat='cat /etc/passwd'
			;;
		esac
		;;
	esac
	case "$hostcat" in
	nidump*) ;;
	*)
		case "$hostcat" in
		*ypcat*) dflt=y;;
		'') if $contains '^\+' /etc/passwd >/dev/null 2>&1; then
				dflt=y
			else
				dflt=n
			fi;;
		*) dflt=n;;
		esac
		echo " "
		rp='Are you getting the hosts file via yellow pages?'
		. ./myread
		case "$ans" in
		y*) hostcat='ypcat hosts';;
		*) hostcat='cat /etc/hosts';;
		esac
		;;
	esac
fi
case "$hostcat" in
'') hostcat='cat /etc/hosts';;
esac
case "$groupcat" in
'') groupcat='cat /etc/group';;
esac
case "$passcat" in
'') passcat='cat /etc/passwd';;
esac

: now get the host name
echo " "
echo "Figuring out host name..." >&4
case "$myhostname" in
'') cont=true
	echo 'Maybe "hostname" will work...'
	if tans=`sh -c hostname 2>&1` ; then
		myhostname=$tans
		phostname=hostname
		cont=''
	fi
	;;
*) cont='';;
esac
if $test "$cont"; then
	if ./xenix; then
		echo 'Oh, dear.  Maybe "/etc/systemid" is the key...'
		if tans=`cat /etc/systemid 2>&1` ; then
			myhostname=$tans
			phostname='cat /etc/systemid'
			echo "Whadyaknow.  Xenix always was a bit strange..."
			cont=''
		fi
	elif $test -r /etc/systemid; then
		echo "(What is a non-Xenix system doing with /etc/systemid?)"
	fi
fi
if $test "$cont"; then
	echo 'No, maybe "uuname -l" will work...'
	if tans=`sh -c 'uuname -l' 2>&1` ; then
		myhostname=$tans
		phostname='uuname -l'
	else
		echo 'Strange.  Maybe "uname -n" will work...'
		if tans=`sh -c 'uname -n' 2>&1` ; then
			myhostname=$tans
			phostname='uname -n'
		else
			echo 'Oh well, maybe I can mine it out of whoami.h...'
			if tans=`sh -c $contains' sysname $usrinc/whoami.h' 2>&1` ; then
				myhostname=`echo "$tans" | $sed 's/^.*"\(.*\)"/\1/'`
				phostname="sed -n -e '"'/sysname/s/^.*\"\\(.*\\)\"/\1/{'"' -e p -e q -e '}' <$usrinc/whoami.h"
			else
				case "$myhostname" in
				'') echo "Does this machine have an identity crisis or something?"
					phostname='';;
				*)
					echo "Well, you said $myhostname before..."
					phostname='echo $myhostname';;
				esac
			fi
		fi
	fi
fi
: you do not want to know about this
set $myhostname
myhostname=$1

: verify guess
if $test "$myhostname" ; then
	dflt=y
	rp='Your host name appears to be "'$myhostname'".'" Right?"
	. ./myread
	case "$ans" in
	y*) ;;
	*) myhostname='';;
	esac
fi

: bad guess or no guess
while $test "X$myhostname" = X ; do
	dflt=''
	rp="Please type the (one word) name of your host:"
	. ./myread
	myhostname="$ans"
done

: translate upper to lower if necessary
case "$myhostname" in
*[A-Z]*)
	echo "(Normalizing case in your host name)"
	myhostname=`echo $myhostname | ./tr '[A-Z]' '[a-z]'`
	;;
esac

case "$myhostname" in
*.*)
	dflt=`expr "X$myhostname" : "X[^.]*\(\..*\)"`
	myhostname=`expr "X$myhostname" : "X\([^.]*\)\."`
	echo "(Trimming domain name from host name--host name is now $myhostname)"
	;;
*) case "$mydomain" in
	'')
		$hostcat >hosts
		dflt=.`$awk "/[0-9].*$myhostname/ {for(i=2; i<=NF;i++) print \\\$i}" \
			hosts | $sort | $uniq | \
			$sed -n -e "s/$myhostname\.\([a-zA-Z_.]\)/\1/p"`
		case "$dflt" in
		.) echo "(You do not have fully-qualified names in /etc/hosts)"
			tans=`./loc resolv.conf X /etc /usr/etc`
			if $test -f "$tans"; then
				echo "(Attempting domain name extraction from $tans)"
				dflt=.`egrep '^domain' $tans | $sed 's/domain[ 	]*\(.*\)/\1/' \
					| ./tr '[A-Z]' '[a-z]' 2>/dev/null`
			fi
			;;
		esac
		case "$dflt" in
		.) echo "(No help from resolv.conf either -- attempting clever guess)"
			dflt=.`sh -c domainname 2>/dev/null`
			case "$dflt" in
			'') dflt='.';;
			.nis.*|.yp.*|.main.*) dflt=`echo $dflt | $sed -e 's/^\.[^.]*//'`;;
			esac
			;;
		esac
		case "$dflt" in
		.) echo "(Lost all hope -- silly guess then)"
			dflt='.uucp'
			;;
		esac
		$rm -f hosts
		;;
	*) dflt="$mydomain";;
	esac;;
esac
echo " "
rp="What is your domain name?"
. ./myread
tans="$ans"
case "$ans" in
'') ;;
.*) ;;
*) tans=".$tans";;
esac
mydomain="$tans"

: translate upper to lower if necessary
case "$mydomain" in
*[A-Z]*)
	echo "(Normalizing case in your domain name)"
	mydomain=`echo $mydomain | ./tr '[A-Z]' '[a-z]'`
	;;
esac

: a little sanity check here
case "$phostname" in
'') ;;
*)
	case `$phostname | ./tr '[A-Z]' '[a-z]'` in
	$myhostname$mydomain|$myhostname) ;;
	*)
		case "$phostname" in
		sed*)
			echo "(That doesn't agree with your whoami.h file, by the way.)"
			;;
		*)
			echo "(That doesn't agree with your $phostname command, by the way.)"
			;;
		esac
	;;
	esac
	;;
esac

: see how we will look up host name
echo " "
if false; then
	: dummy stub to allow use of elif
elif set gethostname val -f d_gethname; eval $csym; $val; then
	echo 'gethostname() found.' >&4
	d_gethname="$define"
	call=gethostname
elif set uname val -f d_uname; eval $csym; $val; then
	if ./xenix; then
		$cat <<'EOM'
uname() was found, but you're running xenix, and older versions of xenix
have a broken uname(). If you don't really know whether your xenix is old
enough to have a broken system call, use the default answer.

EOM
		dflt=y
		case "$d_uname" in
		"$define") dflt=n;;
		esac
		rp='Is your uname() broken?'
		. ./myread
		case "$ans" in
		n*) d_uname="$define"; call=uname;;
		esac
	else
		echo 'uname() found.' >&4
		d_uname="$define"
		call=uname
	fi
fi
case "$d_gethname" in
'') d_gethname="$undef";;
esac
case "$d_uname" in
'') d_uname="$undef";;
esac
case "$d_uname$d_gethname" in
*define*)
	dflt=n
	cat <<EOM
 
Every now and then someone has a $call() that lies about the hostname
but can't be fixed for political or economic reasons.  If you wish, I can
pretend $call() isn't there and maybe compile in the hostname or
compute it from the '$phostname' command at run-time.

EOM
	rp="Shall I ignore $call() from now on?"
	. ./myread
	case "$ans" in
	y*) d_uname="$undef" d_gethname="$undef"; $echo $n "Okay...$c";;
	esac;;
esac
case "$phostname" in
'') aphostname='';;
*) case "$aphostname" in
	/*) ;;
	*) set X $phostname
		shift
		file=$1
		shift
		file=`./loc $file $file $pth`
		aphostname=`echo $file $*`
		;;
	esac
	;;
esac
case "$d_uname$d_gethname" in
*define*) ;;
*)
	case "$phostname" in
	'') ;;
	*)
		$cat <<EOT

There is no gethostname() or uname() on this system.  You have two
possibilities at this point:

1)  You can have your host name ($myhostname) compiled into $package, which
    lets $package start up faster, but makes your binaries non-portable, or
2)  you can have $package use a
	
	popen("$aphostname","r")

    which will start slower but be more portable.

If you want option 2 but with a different command, you can edit config.sh at
the end of this shell script.

EOT
		case "$d_phostname" in
		"$define") dflt=n;;
		"$undef")  dflt=y;;
		'')
			case "$d_portable" in
			"$define") dflt=n ;;
			*) dflt=y ;;
			esac;;
		esac
		rp="Do you want your host name compiled in?"
		. ./myread
		case "$ans" in
		n*) d_phostname="$define" ;;
		*) aphostname=''; d_phostname="$undef";;
		esac;;
	esac
	case "$aphostname" in
	'')
		echo 'No hostname function -- hardwiring "'$myhostname'".' >&4;;
	esac;;
esac
case "$d_phostname" in
'') d_phostname="$undef";;
esac

: see which of string.h or strings.h is needed
echo " "
strings=`./findhdr string.h`
if $test "$strings" && $test -r "$strings"; then
	echo "Using <string.h> instead of <strings.h>." >&4
	val="$define"
else
	val="$undef"
	strings=`./findhdr strings.h`
	if $test "$strings" && $test -r "$strings"; then
		echo "Using <strings.h> instead of <string.h>." >&4
	else
		echo "No string header found -- You'll surely have problems." >&4
	fi
fi
set i_string
eval $setvar
case "$i_string" in
"$undef") strings=`./findhdr strings.h`;;
*)	  strings=`./findhdr string.h`;;
esac

: index or strchr
echo " "
if set index val -f; eval $csym; $val; then
	if set strchr val -f d_strchr; eval $csym; $val; then
		if $contains strchr "$strings" >/dev/null 2>&1 ; then
			val="$define"
			vali="$undef"
			echo "strchr() found." >&4
		else
			val="$undef"
			vali="$define"
			echo "index() found." >&4
		fi
	else
		val="$undef"
		vali="$define"
		echo "index() found." >&4
	fi
else
	if set strchr val -f d_strchr; eval $csym; $val; then
		val="$define"
		vali="$undef"
		echo "strchr() found." >&4
	else
		echo "No index() or strchr() found!" >&4
		val="$undef"
		vali="$undef"
	fi
fi
set d_strchr; eval $setvar
val="$vali"
set d_index; eval $setvar

: 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 `./findhdr sys/file.h` && \
		$cc $cppflags "-DI_SYS_FILE" open3.c -o open3 >/dev/null 2>&1 ; then
	h_sysfile=true;
	echo "<sys/file.h> defines the O_* constants..." >&4
	if ./open3; then
		echo "and you have the 3 argument form of open()." >&4
		val="$define"
	else
		echo "but not the 3 argument form of open().  Oh, well." >&4
		val="$undef"
	fi
elif $test `./findhdr fcntl.h` && \
		$cc "-DI_FCNTL" open3.c -o open3 >/dev/null 2>&1 ; then
	h_fcntl=true;
	echo "<fcntl.h> defines the O_* constants..." >&4
	if ./open3; then
		echo "and you have the 3 argument form of open()." >&4
		val="$define"
	else
		echo "but not the 3 argument form of open().  Oh, well." >&4
		val="$undef"
	fi
else
	val="$undef"
	echo "I can't find the O_* constant definitions!  You got problems." >&4
fi
set d_open3
eval $setvar
$rm -f open3*

: see if rename exists
set rename d_rename
eval $inlibc

: see if setpgid exists
set setpgid d_setpgid
eval $inlibc

: see if setrgid exists
set setrgid d_setrgid
eval $inlibc

: see if setruid exists
set setruid d_setruid
eval $inlibc

: see if setsid exists
set setsid d_setsid
eval $inlibc

: see if strcasecmp exists
set strcasecmp d_strccmp
eval $inlibc

: see if strerror and/or sys_errlist[] exist
echo " "
if set strerror val -f d_strerror; eval $csym; $val; then
	echo 'strerror() found.' >&4
	d_strerror="$define"
	d_strerrm='strerror(e)'
	if set sys_errlist val -a d_syserrlst; eval $csym; $val; then	
		echo "(You also have sys_errlist[], so we could roll our own strerror.)" 
		d_syserrlst="$define"
	else
	echo "(Since you don't have sys_errlist[], sterror() is welcome.)"
		d_syserrlst="$undef"
	fi
elif xxx=`./findhdr string.h`; test "$xxx" || xxx=`./findhdr strings.h`; \
	$contains '#[ 	]*define.*strerror' "$xxx" >/dev/null 2>&1; then
	echo 'strerror() found in string header.' >&4
	d_strerror="$define"
	d_strerrm='strerror(e)'
	if set sys_errlist val -a d_syserrlst; eval $csym; $val; then	
		echo "(Most probably, strerror() uses sys_errlist[] for descriptions.)"
		d_syserrlst="$define"
	else
		echo "(You don't appear to have any sys_errlist[], how can this be?)"
		d_syserrlst="$undef"
	fi
elif set sys_errlist val -a d_syserrlst; eval $csym; $val; then
echo "strerror() not found, but you have sys_errlist[] so we'll use that." >&4
	d_strerror="$undef"
	d_syserrlst="$define"
	d_strerrm='((e)<0||(e)>=sys_nerr?"unknown":sys_errlist[e])'
else
	echo 'strerror() and sys_errlist[] NOT found.' >&4
	d_strerror="$undef"
	d_syserrlst="$undef"
	d_strerrm='"unknown"'
fi
if set sys_errnolist val -a d_sysernlst; eval $csym; $val; then
	echo "(Symbolic error codes can be fetched via the sys_errnolist[] array.)"
	d_sysernlst="$define"
else
	echo "(However, I can't extract the symbolic error code out of errno.)"
	d_sysernlst="$undef"
fi

: see if union wait is available
echo " "
set X $cppflags
shift
flags=''
also=''
for f in $*; do
	case "$f" in
	*NO_PROTO*) ;;
	*) flags="$flags $f";;
	esac
done
$cat `./findhdr sys/wait.h` /dev/null | \
	$cppstdin $flags $cppminus >wait.out 2>/dev/null
if $contains 'union.*wait.*{' wait.out >/dev/null 2>&1 ; then
	echo "Looks like your <sys/wait.h> knows about 'union wait'..." >&4
	val="$define"
	also='also '
	if $contains 'extern.*wait[ 	]*([ 	]*int' wait.out >/dev/null 2>&1
	then
		echo "But wait() seems to expect an 'int' pointer (POSIX way)." >&4
		val="$undef"
		also=''
	elif $contains 'extern.*wait[ 	]*([ 	]*union' wait.out >/dev/null 2>&1
	then
		echo "And indeed wait() expects an 'union wait' pointer (BSD way)." >&4
	else
		echo "So we'll use that for wait()." >&4
	fi
else
	echo "No trace of 'union wait' in <sys/wait.h>..." >&4
	val="$undef"
	echo "Your wait() should be happy with a plain 'int' pointer." >&4
fi
set d_uwait
eval $setvar
$rm -f wait.out

: backward compatibility for d_hvfork
if test X$d_hvfork != X; then
	d_vfork="$d_hvfork"
	d_hvfork=''
fi
: see if there is a vfork
val=''
set vfork val
eval $inlibc

: Ok, but do we want to use it. vfork is reportedly unreliable in 
: perl on Solaris 2.x, and probably elsewhere.
case "$val" in
$define)
	echo " "
	case "$usevfork" in
	false) dflt='n';;
	*) dflt='y';;
	esac
	rp="Some systems have problems with vfork().  Do you want to use it?"
	. ./myread
	case "$ans" in
	y|Y) ;;
	*)
		echo "Ok, we won't use vfork()."
		val="$undef"
		;;
	esac
	;;
esac
set d_vfork
eval $setvar
case "$d_vfork" in
$define) usevfork='true';;
*) usevfork='false';;
esac

: get C preprocessor symbols handy
echo " "
$echo $n "Hmm... $c"
echo $al | $tr ' ' '\012' >Cppsym.know
$cat <<EOSS >Cppsym
$startsh
case "\$1" in
-l) list=true
	shift
	;;
esac
unknown=''
case "\$list\$#" in
1|2)
	for sym do
		if $contains "^\$1$" Cppsym.true >/dev/null 2>&1; then
			exit 0
		elif $contains "^\$1$" Cppsym.know >/dev/null 2>&1; then
			:
		else
			unknown="\$unknown \$sym"
		fi
	done
	set X \$unknown
	shift
	;;
esac
case \$# in
0) exit 1;;
esac
echo \$* | $tr ' ' '\012' | $sed -e 's/\(.*\)/\\
#ifdef \1\\
exit 0; _ _ _ _\1\\	 \1\\
#endif\\
/' >Cppsym\$\$
echo "exit 1; _ _ _" >>Cppsym\$\$
$cppstdin $cppminus <Cppsym\$\$ | $grep '^exit [01]; _ _'  >Cppsym2\$\$
case "\$list" in
true) $awk 'NF > 5 {print substr(\$6,2,100)}' <Cppsym2\$\$ ;;
*)
	sh Cppsym2\$\$
	status=\$?
	;;
esac
$rm -f Cppsym\$\$ Cppsym2\$\$
exit \$status
EOSS
chmod +x Cppsym
$eunicefix Cppsym
./Cppsym -l $al | $sort | $grep -v '^$' >Cppsym.true

: now check the C compiler for additional symbols
$cat >ccsym <<EOS
$startsh
$cat >tmp.c <<EOF
extern int foo;
EOF
for i in \`$cc -v -c tmp.c 2>&1\`
do
	case "\$i" in
	-D*) echo "\$i" | $sed 's/^-D//';;
	-A*) $test "$gccversion" && echo "\$i" | $sed 's/^-A\(.*\)(\(.*\))/\1=\2/';;
	esac
done
$rm -f try.c
EOS
chmod +x ccsym
$eunicefix ccsym
./ccsym | $sort | $uniq >ccsym.raw
$awk '/\=/ { print $0; next }
	{ print $0"=1" }' ccsym.raw >ccsym.list
$awk '{ print $0"=1" }' Cppsym.true >ccsym.true
$comm -13 ccsym.true ccsym.list >ccsym.own
$comm -12 ccsym.true ccsym.list >ccsym.com
$comm -23 ccsym.true ccsym.list >ccsym.cpp
also=''
symbols='symbols'
if $test -z ccsym.raw; then
	echo "Your C compiler doesn't seem to define any symbol!" >&4
	echo " "
	echo "However, your C preprocessor defines the following ones:"
	$cat Cppsym.true
else
	if $test -s ccsym.com; then
		echo "Your C compiler and pre-processor define these symbols:"
		$sed -e 's/\(.*\)=.*/\1/' ccsym.com
		also='also '
		symbols='ones'
		$test "$silent" || sleep 1
	fi
	if $test -s ccsym.cpp; then
		$test "$also" && echo " "
		echo "Your C pre-processor ${also}defines the following $symbols:"
		$sed -e 's/\(.*\)=.*/\1/' ccsym.cpp
		also='further '
		$test "$silent" || sleep 1
	fi
	if $test -s ccsym.own; then
		$test "$also" && echo " "
		echo "Your C compiler ${also}defines the following cpp variables:"
		$sed -e 's/\(.*\)=1/\1/' ccsym.own
		$sed -e 's/\(.*\)=.*/\1/' ccsym.own | $uniq >>Cppsym.true
		$test "$silent" || sleep 1
	fi
fi
$rm -f ccsym*

: see if this is a termio system
val="$undef"
val2="$undef"
val3="$undef"
if $test `./findhdr termios.h`; then
	set tcsetattr i_termios
	eval $inlibc
	val3="$i_termios"
fi
echo " "
case "$val3" in
"$define") echo "You have POSIX termios.h... good!" >&4;;
*) if ./Cppsym pyr; then
		case "`/bin/universe`" in
		ucb) if $test `./findhdr sgtty.h`; then
				val2="$define"
				echo "<sgtty.h> found." >&4
			else
				echo "System is pyramid with BSD universe."
				echo "<sgtty.h> not found--you could have problems." >&4
			fi;;
		*) if $test `./findhdr termio.h`; then
				val="$define"
				echo "<termio.h> found." >&4
			else
				echo "System is pyramid with USG universe."
				echo "<termio.h> not found--you could have problems." >&4
			fi;;
		esac
	elif ./usg; then
		if $test `./findhdr termio.h`; then
			echo "<termio.h> found." >&4
			val="$define"
		elif $test `./findhdr sgtty.h`; then
			echo "<sgtty.h> found." >&4
			val2="$define"
		else
echo "Neither <termio.h> nor <sgtty.h> found--you could have problems." >&4
		fi
	else
		if $test `./findhdr sgtty.h`; then
			echo "<sgtty.h> found." >&4
			val2="$define"
		elif $test `./findhdr termio.h`; then
			echo "<termio.h> found." >&4
			val="$define"
		else
echo "Neither <sgtty.h> nor <termio.h> found--you could have problems." >&4
		fi
	fi;;
esac
set i_termio; eval $setvar
val=$val2; set i_sgtty; eval $setvar
val=$val3; set i_termios; eval $setvar

: define an alternate in-header-list? function
inhdr='echo " "; td=$define; tu=$undef; yyy=$@;
cont=true; xxf="echo \"<\$1> found.\" >&4";
case $# in 2) xxnf="echo \"<\$1> NOT found.\" >&4";;
*) xxnf="echo \"<\$1> NOT found, ...\" >&4";;
esac;
case $# in 4) instead=instead;; *) instead="at last";; esac;
while $test "$cont"; do
	xxx=`./findhdr $1`
	var=$2; eval "was=\$$2";
	if $test "$xxx" && $test -r "$xxx";
	then eval $xxf;
	eval "case \"\$$var\" in $undef) . ./whoa; esac"; eval "$var=\$td";
		cont="";
	else eval $xxnf;
	eval "case \"\$$var\" in $define) . ./whoa; esac"; eval "$var=\$tu"; fi;
	set $yyy; shift; shift; yyy=$@;
	case $# in 0) cont="";;
	2) xxf="echo \"but I found <\$1> $instead.\" >&4";
		xxnf="echo \"and I did not find <\$1> either.\" >&4";;
	*) xxf="echo \"but I found <\$1\> instead.\" >&4";
		xxnf="echo \"there is no <\$1>, ...\" >&4";;
	esac;
done;
while $test "$yyy";
do set $yyy; var=$2; eval "was=\$$2";
	eval "case \"\$$var\" in $define) . ./whoa; esac"; eval "$var=\$tu";
	set $yyy; shift; shift; yyy=$@;
done'

: see if ioctl defs are in sgtty, termio, sys/filio or sys/ioctl
set sys/filio.h i_sysfilio
eval $inhdr
echo " "
if $test `./findhdr sys/ioctl.h`; then
	val="$define"
	echo '<sys/ioctl.h> found.' >&4
else
	val="$undef"
	if $test $i_sysfilio = "$define"; then
	    echo '<sys/ioctl.h> NOT found.' >&4
	else
		$test $i_sgtty = "$define" && xxx="sgtty.h"
		$test $i_termio = "$define" && xxx="termio.h"
		$test $i_termios = "$define" && xxx="termios.h"
echo "No <sys/ioctl.h> found, assuming ioctl args are defined in <$xxx>." >&4
	fi
fi
set i_sysioctl
eval $setvar

: check how to void tty association
echo " "
case "$i_sysioctl" in
"$define") xxx='sys/ioctl.h';;
esac
$cat > tcio.c <<EOM
#include <sys/types.h>	/* Just in case */
#include <$xxx>

main()
{
#ifdef TIOCNOTTY
	exit(0);
#else
	exit(1);
#endif
}
EOM
if ($cc -o tcio tcio.c && ./tcio) >/dev/null 2>&1; then
	val="$define"
	echo "TIOCNOTTY found in <$xxx>." >&4
	echo "Using ioctl() call on /dev/tty to void tty association." >&4
else
	val="$undef"
	echo "Closing standard file descriptors should void tty association." >&4
fi
set d_voidtty
eval $setvar
$rm -f tcio tcio.? core

: see if we can use WIFxxx macros
echo " "
case "$d_wifstat" in
"$define") echo "As before, you can safely use WIFEXITED and friends!" >&4;;
"$undef") echo "You still can't use WIFEXITED and friends!" >&4;;
*)
	echo "Let's see whether you can use the WIFEXITED(status) macro and its"
	case "$d_uwait" in
	"$define") type='union wait';;
	*) type='int';;
	esac
	echo "friends with status declared as '$type status'..."
	$cat >foo.c <<EOCP
#include <sys/types.h>
#include <sys/wait.h>

main()
{
	$type status;
	int e = 0;

#ifdef WIFEXITED
	if (WIFEXITED(status))
		printf("\n");
	exit(0);
#else
	exit(2);
#endif
}
EOCP
	d_wifstat="$undef"
	if $cc $ccflags $ldflags foo.c -o foo $libs >/dev/null 2>&1; then
		if ./foo >/dev/null; then
			echo "Great! Looks like we can use the WIFxxx macros." >&4
			d_wifstat="$define"
		else
			echo "You don't seem to have WIFxxx macros, but that's ok." >&4
		fi
	else
		echo "Apparently you can't use WIFxxx macros properly." >&4
	fi
	$rm -f foo.* foo core
	;;
esac

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

: how do we catenate cpp tokens here?
echo " "
echo "Checking to see how your cpp does stuff like catenate tokens..." >&4
$cat >cpp_stuff.c <<'EOCP'
#define RCAT(a,b)a/**/b
#define ACAT(a,b)a ## b
RCAT(Rei,ser)
ACAT(Cir,cus)
EOCP
$cppstdin $cppflags $cppminus <cpp_stuff.c >cpp_stuff.out 2>&1
if $contains 'Circus' cpp_stuff.out >/dev/null 2>&1; then
	echo "Oh!  Smells like ANSI's been here."
	echo "We can catify or stringify, separately or together!"
	cpp_stuff=42
elif $contains 'Reiser' cpp_stuff.out >/dev/null 2>&1; then
	$cat <<EOM
Ah, yes!  The good old days!
However, in the good old days we don't know how to stringify and
catify at the same time...
Unless we have a cute trick...  which I have!
EOM
	cpp_stuff=1
else
	$cat >&4 <<EOM
Hmm, I don't seem to be able to catenate tokens with your cpp.  You're going
to have to edit the values of CAT[2-5] and SCAT[2-5] in config.h...
EOM
	cpp_stuff="/* Help! How do we handle cpp_stuff? */*/"
fi
$rm -f cpp_stuff.*

: determine default editor
echo " "
case "$defeditor" in
'')
	case "$vi" in
	*/*) dflt="$vi";;
	*) dflt=/usr/ucb/vi;;
	esac
	;;
*)  dflt="$defeditor"
	;;
esac
fn=f/
rp="What is the default editor on your system?"
. ./getfile
defeditor="$ans"

: see if flock exists
set flock d_flock
eval $inlibc

: see which mailbox locking should be used
echo " "
lock_by_flock=''
flock_only=''
case "$d_flock" in
"$define")
	if $contains EWOULDBLOCK $usrinc/errno.h > /dev/null 2>&1; then
		echo 'EWOULDBLOCK found, will use flock type mailbox locking.'
		val="$define"
	elif $contains EWOULDBLOCK $usrinc/sys/errno.h > /dev/null 2>&1; then
		echo 'EWOULDBLOCK found, will use flock type mailbox locking.'
		val="$define"
	else
		echo 'Will use .lock type mailbox locking.'
		val="$undef"
	fi
	;;
*)
	echo 'Will use .lock type mailbox locking.'
	val="$undef"
	;;
esac
set d_lockflock; eval $setvar

case "$d_lockflock" in
"$define")
	lock_by_flock='true'
	case "$d_flockonly" in
	"$define") dflt=y;;
	*) dflt=n;;
	esac
	$cat <<EOM
 
Some sites wish to use flock style locking only. This allows $package to be
installed without the setgid bit being set on some systems that would otherwise
require it.

Note: Be sure no other mail utility that needs to lock the mail spool file
uses .lock type locking before using only flock style locking.

EOM
	rp="Would you like to use flock style mail spool locking only?"
	. myread
	case "$ans" in
	y*|Y*) val="$define";;
	*) val="$undef";;
	esac
	;;
*) val="$undef";;
esac
set d_flockonly; eval $setvar

case "$d_flockonly" in
"$define") flock_only='true';;
esac

: now get the host name to advertise as our mailing address
case "$hiddennet" in
'') dflt=n;;
*) dflt=y;;
esac
$cat <<EOM
 
Some sites are on "hidden" networks, in the sense that the network appears
to the outside world as a single machine.  The advertised name of any host
on this hidden network is the name of one machine on the local network which
knows how to forward mail to any other host on the hidden network.

Do you wish to advertise a different hostname to the world than the one your
own host ($myhostname$mydomain) has?

EOM
rp='Use "hidden" network?'
. ./myread
case "$ans" in
n*) d_hidnet="$undef" hiddennet='';;
*)
	d_hidnet="$define"
	echo " "
	case "$hiddennet" in
	'') dflt=`echo $mydomain | $sed -e 's/^\.//'`;;
	*) dflt="$hiddennet";;
	esac
	rp='What hostname do you wish to advertise?'
	. ./myread
	hiddennet="$ans"
	;;
esac

: locate a BSD compatible install program
echo " "
echo "Looking for a BSD-compatible install program..." >&4
creatdir=''
case "$install" in
'')
	tryit=''
	for dir in $pth; do
		for file in ginstall installbsd scoinst install; do
			if $test -f $dir/$file; then
				tryit="$tryit $dir/$file"
			fi
		done
	done
	$cat >try.c <<EOC
main()
{
	printf("OK\n");
	exit(0);
}
EOC
	if $cc try.c -o try >/dev/null 2>&1; then
		cp try try.ns
		strip try >/dev/null 2>&1
	else
		echo "(I can't seem to compile a trivial C program -- bypassing.)"
		echo "try" >try
		cp try try.ns
	fi
	$cat >tryinst <<EOS
$startsh
$rm -rf foo d
\$1 -d foo/bar
$mkdir d
\$1 -c -m 764 try.ns d
\$1 -c -s -m 642 try.ns d/try
EOS
	chmod +x tryinst
	$eunicefix tryinst
	dflt=''
	either=''
	for prog in $tryit; do
		$echo $n "Checking $prog... $c"
		./tryinst $prog >/dev/null 2>&1
		if $test -d foo/bar; then
			creatdir="$prog -d"
		fi
		(ls -l d/try >try.ls; ls -l d/try.ns >tryno.ls) 2>/dev/null
		if (cmp -s d/try try && cmp -s d/try.ns try.ns && \
			$contains 'rwxrw-r--' tryno.ls && \
			$contains 'rw-r---w-' try.ls) >/dev/null 2>&1
		then
			dflt="$prog"
			echo "ok, that will do."
			break
		fi
		echo "not good$either."
		either=' either'
		$rm -f try*.ls
	done
	$rm -rf foo d tryinst try try*.ls try.*
	case "$dflt" in
	'')
		echo "Hopefully, $package comes with its own install script!"
		dflt='./install'
		;;
	esac
	;;
*) dflt="$install";;
esac
$cat <<EOM

I will be requiring a BSD-compatible install program (one that allows
options like -s to strip executables or -m to specify a file mode) to
install $package.

If the question below contains a fully qualified default path, then it
is probably ok. If it is an unqualified name such as 'install', then it
means I was unable to find out a good install program I could use. If
you know of one, please tell me about it. If the default is './install',
then I shall be using the install script supplied with $package.

EOM
fn='/fe~(install,./install)'
rp='Which install program shall I use?'
. ./getfile
install="$ans"

: how can we create nested directories?
echo " "
echo "Ok, let's see how we can create nested directories..." >&4
case "$installdir" in
'')
	case "$creatdir" in
	'')
		$mkdir -p foo/bar >/dev/null 2>&1
		if $test -d foo/bar; then
			echo "Great, we can build them using 'mkdir -p'."
			creatdir='mkdir -p'
		elif eval "$install -d foo/bar"; $test -d foo/bar; then
			creatdir="install -d"
			echo "It looks like '$creatdir' will do it for us."
		fi
		;;
	*)
		eval "$creatdir foo/bar" >/dev/null 2>&1
		if $test -d foo/bar; then
			echo "Ah! We can use '$creatdir' to do just that."
		fi
		;;
	esac
	$rm -rf foo
	case "$creatdir" in
	'')
		echo "Heck! Another ancient system lacking the comfort of modern ones!"
		echo "You can thank $package for bringing you its own install script!"
		installdir='./install -d'
		;;
	*) installdir="$creatdir";;
	esac
	;;
*) echo "As you already told me, '$installdir' should work.";;
esac

: check for length of integer
echo " "
case "$intsize" in
'')
	echo "Checking to see how big your integers are..." >&4
	$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)?"
. ./myread
intsize="$ans"
$rm -f try.c try

: determine where mail is spooled
case "$maildir" in
'') dflt=`./loc . /usr/spool/mail /usr/spool/mail /usr/mail /var/mail`;;
*) dflt="$maildir";;
esac
echo " "
fn=d~
rp='Where is yet-to-be-read mail spooled?'
. ./getfile
maildir="$ans"
maildirexp="$ansexp"

: determine the name of a reasonable mailer
case "$mailer" in
'')
	if $test -f "$sendmail"; then
		dflt="$sendmail"
	elif $test -f "$smail"; then
		dflt="$smail"
	elif $test -f "$rmail"; then
		dflt="$rmail"
	elif $test -f /bin/mail; then
		dflt=/bin/mail
	else
		dflt=$mail
	fi
	;;
*)  dflt="$mailer";;
esac
$cat <<EOM

I need the full pathname of the program used to deliver mail on your system.
A typical answer would be /usr/lib/sendmail or /bin/rmail, but you may choose
any other program, as long as it can be fed from standard input and will
honour any user-supplied headers.

EOM
fn=f
rp='Mail transport agent to be used?'
. ./getfile
mailer="$ans"

: determine where mail is spooled
case "$mailfile" in
'')
	dflt=`./loc . XXX /usr/spool/mail /usr/mail /var/mail`
	case "$dflt" in
	XXX) dflt='%~/mailbox';;
	*) dflt="$dflt/%L";;
	esac
	;;
*)  dflt="$mailfile"
	;;
esac
cat <<'EOM'

In the following question, you may use %~ to represent the user's home
directory, and %L to represent a users name.

EOM
rp='In which file is yet-to-be-read mail spooled? (~name ok)'
. ./myread
mailfile=`./filexp "$ans"`

: find out how to generate dependencies
echo " "
echo "Checking how to generate makefile dependencies on your machine..." >&4
toplev=`cd ..;pwd`
$cat >dep.c <<'EOCP'
#include "dep.h"
EOCP
$cat >dep.h <<'EOCP'

EOCP
takeflags='flags=""
case "$@" in
*--*)
	for arg
	do
		shift
		case "$arg" in
		--) break;;
		*) flags="$flags $arg";;
		esac
	done;;
esac'
case "$mkdep" in
'')
	;;
*)
	if test -x "$mkdep" &&
		$mkdep dep.c >dep.out 2>/dev/null &&
		$contains 'dep\.o:.*dep\.h' dep.out >/dev/null 2>&1
	then
		echo "$mkdep works."
	else
		mkdep=
	fi
esac

case "$mkdep" in
'')
	$spitshell > ../mkdep <<EOM
$startsh
$takeflags
for srcfile
do
	$cpp -M -I. $cppflags \$flags \$srcfile 2>/dev/null
done
exit 0
EOM
	mkdep=$toplev/mkdep
	chmod +x $mkdep
	$eunicefix $mkdep
	if $mkdep dep.c >dep.out 2>/dev/null &&
		$contains 'dep\.o:.*dep\.h' dep.out >/dev/null 2>&1
	then
		echo "Looks like we can use $cpp -M."
	else
		mkdep=
	fi
	;;
esac

case "$mkdep" in
'')
	$spitshell > ../mkdep <<EOM
$startsh
$takeflags
for srcfile
do
	$cc -MM -I. $cppflags \$flags \$srcfile 2>/dev/null
done
exit 0
EOM
	mkdep=$toplev/mkdep
	chmod +x $mkdep
	$eunicefix $mkdep
	if $mkdep dep.c >dep.out 2>/dev/null &&
		$contains 'dep.o: dep.h' dep.out >/dev/null 2>&1
	then
		echo "Looks like we can use $cc -MM."
	else
		mkdep=
	fi
	;;
esac

case "$mkdep" in
'')
	$spitshell >../mkdep <<EOS
$startsh
$takeflags
for srcfile
do
	case "\$srcfile" in
	*.c) c='.c';;
	*.y) c='.y';;
	*.l) c='.l';;
	esac
	filebase=\`basename \$srcfile \$c\`
	<\$srcfile $cpp $cppminus $cppflags -I. \$flags 2>/dev/null | \\
	$sed -e '/^# *[0-9]/!d' \\
		-e 's/^.*"\(.*\)".*\$/'\$filebase'.o: \1/' \\
		-e 's|: \./|: |' \\
		-e 's|: *$|: '\$srcfile'|' | \\
	$grep -v '^#' | $sort | $uniq
done
exit 0
EOS
	mkdep=$toplev/mkdep
	chmod +x $mkdep
	$eunicefix $mkdep
	if $mkdep dep.c >dep.out 2>/dev/null &&
		$contains 'dep\.o:.*dep\.h' dep.out >/dev/null 2>&1
	then
		echo "A shell script using $cpp does the trick."
	else
		echo "$cpp doesn't seem to be any use at all."
		$spitshell >../mkdep <<EOS
$startsh
$takeflags
files="\$@"
set X \$flags
shift
inc='.'
while test \$# -gt 0
do
	case "\$1" in
	-I) 
		shift
		inc="\$inc:\$1"
		;;
	-I*)
		dir=\`echo \$1 | sed -e 's/^-I//'\`
		inc="\$inc:\$dir"
		;;
	esac
	shift
done
set X \$files
shift
trap "$rm -f /tmp/mkdep\$\$; exit 1" 1 2 3 15
for srcfile
do
	case "\$srcfile" in
	*.c) c='.c';;
	*.y) c='.y';;
	*.l) c='.l';;
	esac
	filebase=\`basename \$srcfile \$c\`
	echo \$filebase.o: \$srcfile
	$grep '^#[  ]*include' \$srcfile /dev/null | \
	$sed -n -e 's/#[   ]*include[  ]*//' \\
		-e '/<\(.*\)>/ d' \\
		-e 's/:[^"]*"\([^"]*\)".*/: \1/' \\
		-e 's/\.c:/\.o:/p' > /tmp/mkdep\$\$
	IFS=': '
	while read file dep; do
		for dir in \$inc; do
			if $test -f "\$dir/\$dep"; then
				dep="\$dir/\$dep"
				break
			fi
		done
		echo "\$file: \$dep" | $sed -e 's,: \./,: ,'
	done </tmp/mkdep\$\$
	IFS=' '
	$rm -f /tmp/mkdep\$\$
done
exit 0
EOS
		mkdep=$toplev/mkdep
		chmod +x $mkdep
		$eunicefix $mkdep
		if $mkdep dep.c >dep.out 2>/dev/null &&
			$contains 'dep\.o:.*dep\.h' dep.out >/dev/null 2>&1
		then
			cat << EOM

I can use a script with grep instead, but it will make some incorrect
dependencies, since it doesn't understand about conditional compilation.
Moreover, some dependencies may be missing, because scanning won't be
a recursive process.
If you have a program which generates makefile dependencies, you may want
to use it.  If not, you can use the script and edit the Makefile by hand
if you need to.
EOM
		else
			mkdep=
			cat << EOM

I can't seem to generate makefile dependencies at all!  Perhaps you have a
program that does?  If you don't, you might look at the mkdep script to
see if you can create one which works.
EOM
		fi
	fi
esac
dflt="$mkdep"
fn=f~/
rp="Name of program to make makefile dependencies?"
. ./getfile
mkdep="$ans"
$rm -f dep.c dep.h dep.o dep.out

: get organization name
longshots='/local/src /usr/src/new /usr/src/local /usr/local/src'
case "$orgname" in
'') if xxx=`./loc news/src/defs.h x $longshots`; then
		dflt=`$sed -n 's/^.*MYORG[ 	]*"\(.*\)".*$/\1/p' $xxx`
	else
		dflt=''
	fi
	;;
*)  dflt="$orgname";;
esac
$cat << 'EOH'
 
Please type the name of your organization as you want it to appear on the
Organization line of outgoing articles.  (It's nice if this also specifies
your location.  Your city name is probably sufficient if well known.)
For example:

    University of Southern North Dakota, Hoople

You may also put the name of a file, as long as it begins with a slash.
For example:

    /etc/organization

EOH
orgname=""
while test "X$orgname" = "X"; do
	rp='Organization:'
	. ./myread
	orgname="$ans"
done

: set the base revision
baserev=3.0

: get the patchlevel
echo " "
echo "Getting the current patchlevel..." >&4
if $test -r $rsrc/patchlevel.h;then
	patchlevel=`awk '/PATCHLEVEL/ {print $3}' < $rsrc/patchlevel.h`
else
	patchlevel=0
fi
echo "(You have $package $baserev PL$patchlevel.)"

: define an is-a-typedef? function
typedef='type=$1; var=$2; def=$3; shift; shift; shift; inclist=$@;
case "$inclist" in
"") inclist="sys/types.h";;
esac;
eval "varval=\$$var";
case "$varval" in
"")
	$rm -f temp.c;
	for inc in $inclist; do
		echo "#include <$inc>" >>temp.c;
	done;
	$cppstdin $cppflags $cppminus < temp.c >temp.E 2>/dev/null;
	if $contains $type temp.E >/dev/null 2>&1; then
		eval "$var=\$type";
	else
		eval "$var=\$def";
	fi;
	$rm -f temp.?;;
*) eval "$var=\$varval";;
esac'

: see what type pids are declared as in the kernel
set pid_t pidtype int stdio.h sys/types.h
eval $typedef
dflt="$pidtype"
echo " "
rp="What type are process ids on this system declared as?"
. ./myread
pidtype="$ans"

: Cruising for prototypes
echo " "
echo "Checking out function prototypes..." >&4
$cat >prototype.c <<'EOCP'
main(int argc, char *argv[]) {
	exit(0);}
EOCP
if $cc $ccflags -c prototype.c >prototype.out 2>&1 ; then
	echo "Your C compiler appears to support function prototypes."
	val="$define"
else
	echo "Your C compiler doesn't seem to understand function prototypes."
	val="$undef"
fi
set prototype
eval $setvar
$rm -f prototype*

: see how many register declarations we want to use
case "$registers" in
'')
	if ./Cppsym vax; then
		dflt=6
	elif ./Cppsym sun mc68000 mips; then
		dflt=10
	elif ./Cppsym pyr; then
		dflt=14
	elif ./Cppsym ns32000 ns16000; then
		dflt=5
	elif ./Cppsym $smallmach; then
		dflt=3
	else
		: if you have any other numbers for me, please send them in
		dflt=6
	fi;;
*) dflt=$registers ;;
esac
cat <<EOM
 
Different C compilers on different machines pay attention to different numbers
of register declarations.  About how many register declarations in each routine
does your C compiler pay attention to?  (OK to guess)

EOM
rp="Maximum register declarations?"
. ./myread
registers=$ans
reg1=''
$awk "BEGIN { for (i=1; i<=16; i++) printf \"reg%d=''\n\", i}" \
	</dev/null >.foo
. ./.foo
$awk "BEGIN { for (i=1; i<=$registers; i++) printf \"reg%d=register\n\", i}" \
	</dev/null >.foo
. ./.foo
$rm -f .foo

: determine root id
rootid=`$sed -e "/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*"'$'"/\1/" -e "q" -e "}" -e "d" </etc/passwd`
case "$rootid" in
'') rootid=0 ;;
*) echo " "; echo "Root uid = $rootid" >&4 ;;
esac

: see if signal is declared as pointer to function returning int or void
echo " "
xxx=`./findhdr signal.h`
$test "$xxx" && $cppstdin $cppminus $cppflags < $xxx >$$.tmp 2>/dev/null
if $contains 'int.*\*[ 	]*signal' $$.tmp >/dev/null 2>&1 ; then
	echo "You have int (*signal())() instead of void." >&4
	val="$undef"
elif $contains 'void.*\*[ 	]*signal' $$.tmp >/dev/null 2>&1 ; then
	echo "You have void (*signal())() instead of int." >&4
	val="$define"
elif $contains 'extern[ 	]*[(\*]*signal' $$.tmp >/dev/null 2>&1 ; then
	echo "You have int (*signal())() instead of void." >&4
	val="$undef"
else
	case "$d_voidsig" in
	'')
	echo "I can't determine whether signal handler returns void or int..." >&4
		dflt=void
		rp="What type does your signal handler return?"
		. ./myread
		case "$ans" in
		v*) val="$define";;
		*) val="$undef";;
		esac;;
	"$define")
		echo "As you already told me, signal handler returns void." >&4;;
	*)
		echo "As you already told me, signal handler returns int." >&4;;
	esac
fi
set d_voidsig
eval $setvar
case "$d_voidsig" in
"$define") signal_t="void";;
*) signal_t="int";;
esac
$rm -f $$.tmp

: figure out how to guarantee perl startup
case "$sharpbang" in
*!)
	$cat >xtry <<EOP
#!$perlpath
system("exit 0");
EOP
	chmod a+x xtry
	if ./xtry >/dev/null 2>&1; then
		$cat <<EOH

I can use the #! construct to start perl on your system. This will make
startup of perl scripts faster, but may cause problems if you want to share
those scripts and perl is not in a standard place (/usr/bin/perl) on all your
platforms. The alternative is to force a shell by starting the script with a
single ':' character.

EOH
		pdflt=y
	else
		$cat <<EOH

I could use the #! construct to start perl on your system, but using
    #!$perlpath
would be too long for your kernel to grok. Indeed, most systems do
limit the size of the leading #! string to 32 characters.

EOH
		pdflt=n
	fi
	$rm -f xtry
	case "$startperl" in
	*!*) dflt=y;;
	'') case "$d_portable" in
		"$define") dflt=n;;
		*) dflt=$pdflt;;
		esac;;
	esac
	rp='Shall I use #! to start up perl?'
	. ./myread
	case "$ans" in
	y*|Y*) startperl="#!$perlpath";;
	*) startperl=": # use perl";;
	esac;;
*) startperl=": # use perl";;
esac

: see if time exists
echo " "
if set time val -f d_time; eval $csym; $val; then
	echo 'time() found.' >&4
	val="$define"
	set time_t timetype long stdio.h sys/types.h
	eval $typedef
	dflt="$timetype"
	echo " "
	rp="What type is returned by time() on this system?"
	. ./myread
	timetype="$ans"
else
	echo 'time() not found, hope that will do.' >&4
	val="$undef"
	timetype='int';
fi
set d_time
eval $setvar

: see what type uids are declared as in the kernel
set uid_t uidtype xxx stdio.h sys/types.h
eval $typedef
case "$uidtype" in
xxx)
	xxx=`./findhdr sys/user.h`
	set `grep '_ruid;' "$xxx" 2>/dev/null` unsigned short
	case $1 in
	unsigned) dflt="$1 $2" ;;
	*) dflt="$1" ;;
	esac
	;;
*) dflt="$uidtype";;
esac
echo " "
rp="What is the type for user ids returned by getuid()?"
. ./myread
uidtype="$ans"

: determines where the utmp file lies
echo " "
case "$utmp" in
'') dflt=`./loc utmp /etc/utmp /etc /var/adm /usr/etc`;;
*) dflt="$utmp";;
esac
fn='l/:utmp'
rp="Where is the utmp file recording logins?"
. ./getfile
utmp="$ans"

: check for void type
echo " "
echo "Checking to see how well your C compiler groks the void type..." >&4
echo " "
$cat >&4 <<EOM
  Support flag bits are:
    1: basic void declarations.
    2: arrays of pointers to functions returning void.
    4: operations between pointers to and addresses of void functions.
    8: generic void pointers.
EOM
echo " "
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 & 8
	void *hue;		/* generic ptr */
#endif
#if TRY & 2
	void (*foo[10])();
#endif

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

: see if this is a sys/file.h system
val=''
set sys/file.h val
eval $inhdr

: do we need to include sys/file.h ?
case "$val" in
"$define")
	echo " "
	if $h_sysfile; then
		val="$define"
		echo "We'll be including <sys/file.h>." >&4
	else
		val="$undef"
		echo "We won't be including <sys/file.h>." >&4
	fi
	;;
*)
	h_sysfile=false
	;;
esac
set i_sysfile
eval $setvar

: see if fcntl.h is there
val=''
set fcntl.h val
eval $inhdr

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

: see if this is a sys/param system
set sys/param.h i_sysparam
eval $inhdr

: see if we should include time.h, sys/time.h, or both
echo " "
echo "Testing to see if we should include <time.h>, <sys/time.h> or both." >&4
$echo $n "I'm now running the test program...$c"
$cat >try.c <<'EOCP'
#include <sys/types.h>
#ifdef I_TIME
#include <time.h>
#endif
#ifdef I_SYSTIME
#ifdef SYSTIMEKERNEL
#define KERNEL
#endif
#include <sys/time.h>
#endif
#ifdef I_SYSSELECT
#include <sys/select.h>
#endif
main()
{
	struct tm foo;
#ifdef S_TIMEVAL
	struct timeval bar;
#endif
#ifdef S_TIMEZONE
	struct timezone tzp;
#endif
	if (foo.tm_sec == foo.tm_sec)
		exit(0);
#ifdef S_TIMEVAL
	if (bar.tv_sec == bar.tv_sec)
		exit(0);
#endif
	exit(1);
}
EOCP
flags=''
for s_timezone in '-DS_TIMEZONE' ''; do
sysselect=''
for s_timeval in '-DS_TIMEVAL' ''; do
for i_systimek in '' '-DSYSTIMEKERNEL'; do
for i_time in '' '-DI_TIME'; do
for i_systime in '-DI_SYSTIME' ''; do
	case "$flags" in
	'') $echo $n ".$c"
		if $cc $ccflags \
		$i_time $i_systime $i_systimek $sysselect $s_timeval $s_timezone \
		try.c -o try >/dev/null 2>&1 ; then
			set X $i_time $i_systime $i_systimek $sysselect $s_timeval
			shift
			flags="$*"
			echo " "
			$echo $n "Succeeded with $flags$c"
		fi
		;;
	esac
done
done
done
done
done
timeincl=''
echo " "
case "$flags" in
*SYSTIMEKERNEL*) i_systimek="$define"
	timeincl=`./findhdr sys/time.h`
	echo "We'll include <sys/time.h> with KERNEL defined." >&4;;
*) i_systimek="$undef";;
esac
case "$flags" in
*I_TIME*) i_time="$define"
	timeincl=`./findhdr time.h`" $timeincl"
	echo "We'll include <time.h>." >&4;;
*) i_time="$undef";;
esac
case "$flags" in
*I_SYSTIME*) i_systime="$define"
	timeincl=`./findhdr sys/time.h`" $timeincl"
	echo "We'll include <sys/time.h>." >&4;;
*) i_systime="$undef";;
esac
$rm -f try.c try

: see if sys/types.h has to be included
set sys/types.h i_systypes
eval $inhdr

: see if this is a syswait system
set sys/wait.h i_syswait
eval $inhdr

: see if this is a unistd.h system
set unistd.h i_unistd
eval $inhdr

: notify author that his package is used
if $test -f ../.config/mailauthor &&
	cmp $rsrc/patchlevel.h ../.config/mailauthor >/dev/null 2>&1
then
	status="say that you're using $package";
	case "$mailpatches" in
	true) status='have patches mailed to you as they are issued';;
	esac
	case "$notifypatches" in
	true) status='be notified when new patches are issued';;
	esac
	$cat <<EOM

You have already sent the author of $package (Raphael_Manfredi@grenoble.hp.com) mail to
$status. If you wish, you may modify
your previous request by sending a new mail with different options.

EOM
	rp='Should I send a status update to Raphael_Manfredi@grenoble.hp.com?'
	dflt=n
else
	$cat <<EOM

If you are able to send mail to the Internet, the author of $package would
really appreciate you letting me send off a quick note, just to say that you've
tried it. The author is more likely to spend time maintaining $package if it's
known that many people are using it, and you can even ask to get sent new
patches automagically this way if you wish. To protect your privacy, all I'll
say in the mail is the version of $package that you're using.

EOM
	rp='Should I send mail to Raphael_Manfredi@grenoble.hp.com?'
	dflt=y
	$test -f ../.config/nomail && dflt=n
fi
. ./myread
case "$ans" in
[yY]*)
	echo " "
	echo "Great! Your cooperation is really appreciated."
	$cat <<EOM

Some braindead sites do not set a proper return address in the From: header of
their outgoing mail, making it impossible to reply to mail they generate.
If your site is broken in this way, write to your system administrator and get
it fixed!!! In the mean time, you can manually specify the Internet e-mail
address by which the author can get back to you, should there be a need to do
so. If manually specified, it should be something like "user@domain.top".
If your mail system generates addresses correctly, specify "none".

EOM
	case "$usermail" in
	'-'|'') dflt=none;;
	*) dflt="$usermail";;
	esac
	rp='Manually specify a return address to use:'
	. ./myread
	case "$ans" in
	none|*@*.*)
		case "$ans" in
		none) usermail='-';;
		*) usermail="$ans";;
		esac
		;;
	*)
		echo "(Address does not look like an Internet one -- ignoring it.)"
		usermail='-'
		mailpatches=false
		notifypatches=false
		;;
	esac
	echo " "
	opt=''
	rp='Would you like to have new patches automatically mailed to you?'
	case "$mailpatches" in
	true) dflt=y;;
	*) dflt=n;;
	esac
	. ./myread
	case "$ans" in
	[yY]*) opt=' mailpatches'; mailpatches=true;;
	*)
		mailpatches=false
		echo " "
		rp='Ok, would you like to simply be notified of new patches?'
		case "$notifypatches" in
		false) dflt=n;;
		*) dflt=y;;
		esac
		. ./myread
		echo " "
		case "$ans" in
		[yY]*) opt=' notifypatches'; notifypatches=true;;
		*)
			echo "Fine, I'll simply say that you've tried it then."
			notifypatches=false
			;;
		esac
		;;
	esac
	echo "Sending mail to Raphael_Manfredi@grenoble.hp.com..." >&4
	atsh='@SH'
	$mailer Raphael_Manfredi@grenoble.hp.com <<EOM >/dev/null 2>&1
Subject: Command
Precedence: junk
To: Raphael_Manfredi@grenoble.hp.com

$atsh package $usermail $package $baserev $patchlevel$opt
EOM
	$rm -f ../.config/mailauthor ../.config/nomail
	cp $rsrc/patchlevel.h ../.config/mailauthor
	;;
*)
	case "$dflt" in
	"y")
		echo "Oh well, maybe next time."
		cp /dev/null ../.config/nomail
		;;
	esac
	;;
esac

: find out how to find out full name
case "$d_berknames" in
"$define")
	dflt=y;;
"$undef")
	dflt=n;;
*)
	if ./bsd; then
		dflt=y
	elif ./xenix; then
		dflt=y
	else
		dflt=n
	fi
	;;
esac
$cat <<'EOM'

Does your /etc/passwd file keep full names in Berkeley/V7 format (name first
thing after ':' in GCOS field)?  In that case, a typical entry in the password
file looks like this:

    guest:**paswword**:10:100:Mister Guest User:/usr/users:/bin/sh
                              ^^^^^^^^^^^^^^^^^
EOM
rp="Berkeley/V7 format for full name in /etc/passwd?"
. ./myread
case "$ans" in
y*) d_passnames="$define"
	d_berknames="$define"
	d_usgnames="$undef"
	nametype=bsd
	;;
*)
	case "$d_usgnames" in
	"$define") dflt=y;;
	"$undef") dflt=n;;
	*)
		if ./usg; then
			dflt=y
		else
			dflt=n
		fi
		;;
	esac
$cat <<'EOM'

Does your passwd file keep full names in USG format (name sandwiched between a
'-' and a '(')?  In that case, a typical entry in the password file looks like
this:

    guest:**paswword**:10:100:000-Mister Guest User(000):/usr/users:/bin/sh
                                  ^^^^^^^^^^^^^^^^^
EOM
	rp="USG format for full name in /etc/passwd?"
	. ./myread
	case "$ans" in
	n*) echo "Full name will be taken from ~/.fullname"
		d_passnames="$undef"
		d_berknames="$undef"
		d_usgnames="$undef"
		nametype=other
		;;
	*)
		d_passnames="$define"
		d_berknames="$undef"
		d_usgnames="$define"
		nametype=usg
		;;
	esac;;
esac

: figure out their full name
case "$NAME" in
'') case "$nametype" in
	other)
		fn=`./filexp ~/.fullname`
		xxx=usg
		$test -f $fn && xxx=other
		;;
	*)
		xxx="$nametype"
		;;
	esac

	case "$xxx" in
	bsd)
		cf_name=`$passcat | grep "^$cf_by:" | \
			sed -e 's/^[^:]*:[^:]*:[^:]*:[^:]*:\([^:]*\):.*/\1/' \
			-e 's/,.*//'`
		;;
    usg)
		cf_name=`$passcat | grep "^$cf_by:" | \
			sed -e 's/^[^:]*:[^:]*:[^:]*:[^:]*:\([^:]*\):.*/\1/' \
			-e 's/[^-]*-\(.*\)(.*)/\1/'`
		;;
	*)
		cf_name=`$cat $fn`
		;;
	esac
	;;
*)
	cf_name="$NAME"
	;;
esac
echo " "
echo "Pleased to meet you, $cf_name."

$cat <<EOM

I need to get your e-mail address in Internet format if possible, i.e.
something like user@host.domain. Please answer accurately since I have
no easy means to double check it. The default value provided below
is most probably close to the reality but may not be valid from outside
your organization...

EOM
cont=x
while test "$cont"; do
	case "$cf_email" in
	'') dflt="$cf_by@$myhostname$mydomain";;
	*) dflt="$cf_email";;
	esac
	rp='What is your e-mail address?'
	. ./myread
	cf_email="$ans"
	case "$cf_email" in
	*@*.*) cont='' ;;
	*)
		rp='Address does not look like an Internet one.  Use it anyway?'
		case "$fastread" in
		yes) dflt=y ;;
		*) dflt=n ;;
		esac
		. ./myread
		case "$ans" in
		y*) cont='' ;;
		*) echo " " ;;
		esac
		;;
	esac
done

: offer to join the mailing list
list_request='majordomo@foretune.co.jp'
list_sub="subscribe agent-users $cf_email"
list_unsub="unsubscribe agent-users $cf_email"
list_name="agent-users"
$cat <<EOM

There is a mailing list for discussion about $package and related issues.
This is the preferred place to ask questions about the program and discuss
modifications and additions with the author and other users.  If you are able
to send mail to the Internet, you are encouraged to subscribe.  You need only
ever subscribe once, and you can unsubscribe automatically at any time in the
future.  If you have already subscribed and you wish to unsubscribe now, you
may do so by answering "unsubscribe".  Answer "subscribe" to subscribe to the
list.

EOM
rp="Subscribe to or unsubscribe from the $list_name mailing list?"
dflt=neither
. ./myread
case "$ans" in
[sS]*)	$cat <<EOM

You will be sent a message from the list server to let you know when your
subscription has been successful and telling you how to submit articles and
how to unsubscribe again when necessary. You may also unsubscribe by running
this script again and asking it to do so for you.

EOM
	echo "Sending mail to subscribe you to the $list_name list..." >&4
	$mailer $list_request <<EOM >/dev/null 2>&1
Precedence: junk
To: $list_request

$list_sub
EOM
	;;
[uU]*)	echo "Sending mail to unsubscribe you from the $list_name list..." >&4
	$mailer $list_request <<EOM >/dev/null 2>&1
Precedence: junk
To: $list_request

$list_unsub
EOM
	;;
esac

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

: back to where it started
if test -d ../UU; then
	cd ..
fi

: configuration may be patched via a 'config.over' file
if $test -f config.over; then
	echo " "
	dflt=y
	rp='I see a config.over file.  Do you wish to load it?'
	. UU/myread
	case "$ans" in
	n*) echo "OK, I'll ignore it.";;
	*)	. ./config.over
		echo "Configuration override changes have been loaded."
		;;
	esac
fi

: in case they want portability, strip down executable paths
case "$d_portable" in
"$define")
	echo " "
	echo "Stripping down executable paths..." >&4
	for file in $loclist $trylist; do
		eval $file="\$file"
	done
	;;
esac

: create config.sh file
echo " "
echo "Creating config.sh..." >&4
$spitshell <<EOT >config.sh
$startsh
#
# This file was produced by running the Configure script. It holds all the
# definitions figured out by Configure. Should you modify one of these values,
# do not forget to propagate your changes by running "Configure -der". You may
# instead choose to run each of the .SH files by yourself, or "Configure -S".
#

# Package name      : $package
# Source directory  : $src
# Configuration time: $cf_time
# Configured by     : $cf_by
# Target system     : $myuname

Author='$Author'
Date='$Date'
Header='$Header'
Id='$Id'
Locker='$Locker'
Log='$Log'
Mcc='$Mcc'
RCSfile='$RCSfile'
Revision='$Revision'
Source='$Source'
State='$State'
afs='$afs'
aphostname='$aphostname'
awk='$awk'
baserev='$baserev'
bash='$bash'
bin='$bin'
binexp='$binexp'
bison='$bison'
byacc='$byacc'
c='$c'
cat='$cat'
cc='$cc'
ccflags='$ccflags'
cf_by='$cf_by'
cf_email='$cf_email'
cf_time='$cf_time'
chgrp='$chgrp'
chmod='$chmod'
chown='$chown'
comm='$comm'
compress='$compress'
contains='$contains'
cp='$cp'
cpio='$cpio'
cpp='$cpp'
cpp_stuff='$cpp_stuff'
cppflags='$cppflags'
cpplast='$cpplast'
cppminus='$cppminus'
cpprun='$cpprun'
cppstdin='$cppstdin'
csh='$csh'
d_access='$d_access'
d_bcopy='$d_bcopy'
d_berknames='$d_berknames'
d_bsd='$d_bsd'
d_bsdpgrp='$d_bsdpgrp'
d_eunice='$d_eunice'
d_flexfnam='$d_flexfnam'
d_flock='$d_flock'
d_flockonly='$d_flockonly'
d_gethname='$d_gethname'
d_hidnet='$d_hidnet'
d_index='$d_index'
d_lockflock='$d_lockflock'
d_open3='$d_open3'
d_passnames='$d_passnames'
d_phostname='$d_phostname'
d_portable='$d_portable'
d_rename='$d_rename'
d_setpgid='$d_setpgid'
d_setpgrp='$d_setpgrp'
d_setrgid='$d_setrgid'
d_setruid='$d_setruid'
d_setsid='$d_setsid'
d_strccmp='$d_strccmp'
d_strchr='$d_strchr'
d_strerrm='$d_strerrm'
d_strerror='$d_strerror'
d_sysernlst='$d_sysernlst'
d_syserrlst='$d_syserrlst'
d_time='$d_time'
d_uname='$d_uname'
d_usgnames='$d_usgnames'
d_uwait3='$d_uwait3'
d_uwait='$d_uwait'
d_vfork='$d_vfork'
d_voidsig='$d_voidsig'
d_voidtty='$d_voidtty'
d_wifstat='$d_wifstat'
d_xenix='$d_xenix'
date='$date'
defeditor='$defeditor'
defvoidused='$defvoidused'
echo='$echo'
egrep='$egrep'
emacs='$emacs'
eunicefix='$eunicefix'
expr='$expr'
find='$find'
flex='$flex'
flock_only='$flock_only'
gcc='$gcc'
gccversion='$gccversion'
glibpth='$glibpth'
grep='$grep'
groupcat='$groupcat'
h_fcntl='$h_fcntl'
h_sysfile='$h_sysfile'
hiddennet='$hiddennet'
hint='$hint'
hostcat='$hostcat'
huge='$huge'
i_bsdioctl='$i_bsdioctl'
i_fcntl='$i_fcntl'
i_sgtty='$i_sgtty'
i_string='$i_string'
i_sysfile='$i_sysfile'
i_sysfilio='$i_sysfilio'
i_sysioctl='$i_sysioctl'
i_sysparam='$i_sysparam'
i_syssockio='$i_syssockio'
i_systime='$i_systime'
i_systimek='$i_systimek'
i_systypes='$i_systypes'
i_syswait='$i_syswait'
i_termio='$i_termio'
i_termios='$i_termios'
i_time='$i_time'
i_unistd='$i_unistd'
incpath='$incpath'
inews='$inews'
install='$install'
installbin='$installbin'
installdir='$installdir'
installmansrc='$installmansrc'
installprivlib='$installprivlib'
installscript='$installscript'
intsize='$intsize'
ksh='$ksh'
large='$large'
ldflags='$ldflags'
less='$less'
libc='$libc'
libpth='$libpth'
libs='$libs'
line='$line'
lint='$lint'
lkflags='$lkflags'
ln='$ln'
lns='$lns'
lock_by_flock='$lock_by_flock'
lp='$lp'
lpr='$lpr'
ls='$ls'
mail='$mail'
maildir='$maildir'
maildirexp='$maildirexp'
mailer='$mailer'
mailfile='$mailfile'
mailpatches='$mailpatches'
mailx='$mailx'
make='$make'
manext='$manext'
mansrc='$mansrc'
mansrcexp='$mansrcexp'
medium='$medium'
mips='$mips'
mips_type='$mips_type'
mkdep='$mkdep'
mkdir='$mkdir'
models='$models'
more='$more'
mv='$mv'
mydomain='$mydomain'
myhostname='$myhostname'
myuname='$myuname'
n='$n'
nametype='$nametype'
nm_opt='$nm_opt'
notifypatches='$notifypatches'
nroff='$nroff'
optimize='$optimize'
orgname='$orgname'
osname='$osname'
osvers='$osvers'
package='$package'
passcat='$passcat'
patchlevel='$patchlevel'
perl='$perl'
perlpath='$perlpath'
pg='$pg'
phostname='$phostname'
pidtype='$pidtype'
plibpth='$plibpth'
pmake='$pmake'
pr='$pr'
prefix='$prefix'
prefixexp='$prefixexp'
privlib='$privlib'
privlibexp='$privlibexp'
prototype='$prototype'
reg10='$reg10'
reg11='$reg11'
reg12='$reg12'
reg13='$reg13'
reg14='$reg14'
reg15='$reg15'
reg16='$reg16'
reg1='$reg1'
reg2='$reg2'
reg3='$reg3'
reg4='$reg4'
reg5='$reg5'
reg6='$reg6'
reg7='$reg7'
reg8='$reg8'
reg9='$reg9'
registers='$registers'
rm='$rm'
rmail='$rmail'
rootid='$rootid'
runnm='$runnm'
scriptdir='$scriptdir'
scriptdirexp='$scriptdirexp'
sed='$sed'
sendmail='$sendmail'
sh='$sh'
shar='$shar'
sharpbang='$sharpbang'
shsharp='$shsharp'
signal_t='$signal_t'
sleep='$sleep'
smail='$smail'
small='$small'
so='$so'
sort='$sort'
spackage='$spackage'
spitshell='$spitshell'
split='$split'
src='$src'
startperl='$startperl'
startsh='$startsh'
strings='$strings'
submit='$submit'
sysman='$sysman'
tail='$tail'
tar='$tar'
tbl='$tbl'
test='$test'
timeincl='$timeincl'
timetype='$timetype'
touch='$touch'
tr='$tr'
troff='$troff'
uidtype='$uidtype'
uname='$uname'
uniq='$uniq'
usenm='$usenm'
usermail='$usermail'
usevfork='$usevfork'
usrinc='$usrinc'
utmp='$utmp'
uuname='$uuname'
vi='$vi'
voidflags='$voidflags'
xlibpth='$xlibpth'
zcat='$zcat'
EOT

: add special variables
$test -f $src/patchlevel.h && \
awk '/^#define/ {printf "%s=%s\n",$2,$3}' $src/patchlevel.h >>config.sh
echo "CONFIG=true" >>config.sh

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

: Finish up by extracting the .SH files
case "$alldone" in
exit)
	$rm -rf UU
	echo "Done."
	exit 0
	;;
cont)
	;;
'')
	dflt=''
	nostick=true
	$cat <<EOM

If you'd like to make any changes to the config.sh file before I begin
to configure things, do it as a shell escape now (e.g. !vi config.sh).

EOM
	rp="Press return or use a shell escape to edit config.sh:"
	. UU/myread
	nostick=''
	case "$ans" in
	'') ;;
	*) : in case they cannot read
		sh 1>&4 -c "$ans";;
	esac
	;;
esac

: if this fails, just run all the .SH files by hand
. ./config.sh

echo " "
exec 1>&4
. ./UU/extract

if $contains '^depend:' [Mm]akefile >/dev/null 2>&1; then
	dflt=y
	case "$silent" in
	true) ;;
	*)
		$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
		;;
	esac
	rp="Run make depend now?"
	. 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 ark*isdone
$rm -rf UU

: End of Configure

