#! /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.
# Write to either:
#
#     harlan@mumps.pfcs.com (Harlan Stenn)
#     ram@eiffel.com (Raphael Manfredi)
#
# and we will send you -or point you to- the latest revision of the dist
# package, which includes metaconfig.)
#

# $Id: Configure,v 2.0 1993/02/21 00:01:26 jlf Exp jlf $
#
# Generated on Fri Feb 19 20:44:27 EST 1993 [metaconfig 2.9dev PL0]

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

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

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

[End of diatribe. We now return you to your regularly scheduled programming...]
EOF
cat >/tmp/c2$$ <<EOF
OOPS!  You naughty creature!  You didn't run Configure with sh!
I will attempt to remedy the situation by running sh for you...

EOF

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

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

: Sanity checks
PATH=".:$PATH:/bin:/usr/bin:/usr/local/bin:/usr/ucb:/usr/local:/usr/lbin"
PATH=$PATH:'/usr/5bin:/etc:/usr/gnu/bin:/usr/new:/usr/new/bin:/usr/nbin'
PATH=$PATH:'/sys5.3/bin:/sys5.3/usr/bin:/bsd4.3/bin:/bsd4.3/usr/ucb'
PATH=$PATH:'/bsd4.3/usr/bin:/usr/bsd:/bsd43/bin:/usr/ccs/bin'
PATH=$PATH:'/etc:/usr/lib:/lib:/usr/ccs/lib'
export PATH

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

: Warn them if they use ksh
(alias) >/dev/null 2>&1 && \
	cat <<'EOM'
(I see you are using the Korn shell.  Some ksh's blow up on Configure,
especially on exotic machines.  If yours does, try the Bourne shell instead.)
EOM

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

cf_by=''
cf_time=''
d_bsd=''
d_eunice=''
d_xenix=''
eunicefix=''
Mcc=''
awk=''
bison=''
cat=''
chgrp=''
chmod=''
chown=''
compress=''
cp=''
cpio=''
cpp=''
csh=''
date=''
echo=''
egrep=''
emacs=''
expr=''
flex=''
gcc=''
grep=''
inews=''
less=''
line=''
lint=''
ln=''
lp=''
lpr=''
ls=''
mail=''
mailx=''
make=''
mkdir=''
more=''
mv=''
nroff=''
perl=''
pg=''
pmake=''
pr=''
rm=''
rmail=''
sed=''
sendmail=''
shar=''
sleep=''
smail=''
sort=''
submit=''
tail=''
tar=''
tbl=''
test=''
touch=''
tr=''
troff=''
uname=''
uniq=''
uuname=''
vi=''
zcat=''
hint=''
myuname=''
Author=''
Date=''
Header=''
Id=''
Locker=''
Log=''
RCSfile=''
Revision=''
Source=''
State=''
d_cacheavail=''
cc=''
ccflags=''
cppflags=''
ldflags=''
lkflags=''
optimize=''
contains=''
cppminus=''
cppstdin=''
d_access=''
d_const=''
aphostname=''
d_gethname=''
d_phostname=''
d_uname=''
d_open3=''
d_portable=''
d_bournefunc=''
d_evalalias=''
h_fcntl=''
h_sysfile=''
libc=''
libpth=''
plibpth=''
xlibpath=''
libs=''
d_forcedpathname=''
d_forcepath=''
modules_bin=''
modules_files=''
modules_home=''
modules_init=''
mydomain=''
myhostname=''
phostname=''
c=''
n=''
package=''
sharpbang=''
shsharp=''
spitshell=''
startsh=''
static_linking=''
sysman=''
tcl_incdir=''
tcl_incdir_flags=''
tcl_lib=''
nm_opt=''
runnm=''
usenm=''
incpath=''
mips=''
mips_type=''
usrinc=''
d_x11libs=''
x11_incdir=''
x11_incdir_flags=''
x11_libdir=''
x11_libdir_flags=''
x11_libs=''
d_whoami=''
i_sysfile=''
i_sysselct=''
large=''
CONFIG=''

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

: process the command line options
set X `for arg in "$@"; do echo $arg; done | awk '
BEGIN {
	optstr = "deEf:hrsSV";	# 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 "?";
}
'`
eval "set $*"
shift
		
: set up default values
reuseval=false
config_sh=''
alldone=''
error=''
silent=''
extractsh=''

: 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 "Configure: cannot read config file $1." >&2
			error=true
		fi
		cd UU
		shift;;
	-h) shift; error=true;;
	-r) shift; reuseval=true;;
	-s) shift; silent=true;;
	-E) shift; alldone=exit;;
	-S) shift; extractsh=true;;
	-V) echo "Configure generated by metaconfig 2.9dev PL0." >&2
		exit 0;;
	--) break;;
	-*) echo "Configure: unknown option $1" >&2; shift; error=true;;
	*) break;;
	esac
done

case "$error" in
true)
	cat >&2 <<EOM
Usage: Configure [-dehrESV] [-f config.sh]
  -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.
  -E : stop at the end of questions, after having produced config.sh.
  -S : perform variable substitutions on all .SH files (can mix with -f)
  -V : print version number and exit (with a zero status).
EOM
	exit 1
	;;
esac

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

case "$extractsh" in
true)
	case "$config_sh" in
	'') config_sh='config.sh'; config='./config.sh';;
	/*) config="$config_sh";;
	*) config="./$config_sh";;
	esac
	echo " "
	echo "Fetching answers from $config_sh..."
	cd ..
	. $config
	echo " "
	. ./UU/extract
	rm -rf UU
	echo "Done."
	exit 0
	;;
esac

: set package name
package=Modules

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

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

trap 'echo " "; rm -rf $rmlist; exit 1' 1 2 3 15

: 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

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

: general looking path for locating libraries
libpth='/usr/lib/large /lib '$xlibpth' /lib/large'
libpth=$libpth' /usr/lib/small /lib/small'

: no include file wanted by default
inclwanted=''


: 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\" >&3;;
*) case \"\$rp\" in
	'') echo $n \"[\$xxxm] $c\";;
	*)
		if test \`echo \"\$rp [\$xxxm]  \" | wc -c\` -ge $COLUMNS; then
			echo \"\$rp\" >&3
			echo $n \"[\$xxxm] $c\" >&3
		else
			echo $n \"\$rp [\$xxxm] $c\" >&3
		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 " " >&3;;
		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
	"\$ans")
		case "\$ans" in
		!)
			sh
			echo " "
			$myecho
			;;
		!*)
			set x \`expr "X\$ans" : "X!\(.*\)\$"\`
			shift
			sh -c "\$*"
			echo " "
			$myecho
			;;
		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
done
case "\$ans" in
'') ans="\$xxxm";;
esac
EOSC

: general instructions
cat <<EOH
 
This installation shell script will examine your system and ask you questions
to determine how the Modules 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).

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.  Also, let me (John.Furlani@East.Sun.COM)
know how I blew it.  If you can't run Configure for some reason, you'll have to
generate a config.sh file by hand.

This installation script affects things in two ways:

1) it may do direct variable substitutions on some of the files included
   in this kit.
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

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

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

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

: find out where common programs are
echo " "
echo "Locating common programs..." >&3
cat <<EOSC >loc
$startsh
case \$# in
0) exit 1;;
esac
thing=\$1
shift
dflt=\$1
shift
for dir in \$*; do
	case "\$thing" in
	.)
	if test -d \$dir/\$thing; then
		echo \$dir
		exit 0
	fi
	;;
	*)
	if test -f \$dir/\$thing; then
		echo \$dir/\$thing
		exit 0
	elif test -f \$dir/\$thing.exe; then
		: on Eunice apparently
		echo \$dir/\$thing
		exit 0
	fi
	;;
	esac
done
echo \$dflt
exit 1
EOSC
chmod +x loc
$eunicefix loc
loclist="
awk
cat
chgrp
chmod
chown
echo
expr
grep
mv
rm
sed
sort
tr
uniq
"
trylist="
Mcc
cpp
date
test
uname
"
pth=`echo $PATH | sed -e 's/:/ /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 "I don't know where $file is.  I hope it's in everyone's PATH."
		;;
	esac
done
echo " "
echo "Don't worry if any of the following aren't found..."
ans=offhand
for file in $trylist; do
	xxx=`./loc $file $file $pth`
	eval $file=$xxx
	eval _$file=$xxx
	case "$xxx" in
	/*)
		echo $file is in $xxx.
		;;
	*)
		echo "I don't see $file out there, $ans."
		ans=either
		;;
	esac
done
case "$egrep" in
egrep)
	echo "Substituting grep for egrep."
	egrep=$grep
	;;
esac
case "$test" in
test)
	echo "Hopefully test is built into your sh."
	;;
/bin/test)
	if sh -c "PATH= test true" >/dev/null 2>&1; then
		echo "Using the test built into your sh."
		test=test
	fi
	;;
*)
	test=test
	;;
esac
case "$echo" in
echo)
	echo "Hopefully echo is built into your sh."
	;;
/bin/echo)
	echo " "
echo "Checking compatibility between /bin/echo and builtin echo (if any)..." >&3
	$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 /bin/echo instead of the builtin, since Bourne shell doesn't
have echo built in and we may have to run some Bourne shell scripts.  That
means I'll have to use $ans to suppress newlines now.  Life is ridiculous.

FOO
		$echo $n "The star should be here-->$c"
		$echo "*"
	fi
	$rm -f foo1 foo2
	;;
*)
	: cross your fingers
	echo=echo
	;;
esac

: Try to determine whether config.sh was made on this system
case "$config_sh" in
'')
: indentation wrong on purpose--RAM
myuname=`( ($uname -a) 2>/dev/null || hostname) 2>&1`
dflt=n
if test -f ../config.sh; then
	xxx=$myuname
	eval "`grep myuname= ../config.sh`"
	if test "X$xxx" = "X$myuname"; then
		dflt=y
	fi
fi

: Get old answers, if there is a config file out there
hint=default
if test -f ../config.sh; then
	echo " "
	rp="I see a config.sh file.  Did Configure make it on THIS system?"
	. myread
	case "$ans" in
	n*|N*) echo "OK, I'll ignore it.";;
	*)  echo "Fetching default answers from your old config.sh file..." >&3
		tmp="$n"
		ans="$c"
		. ../config.sh
		cp ../config.sh .
		n="$tmp"
		c="$ans"
		hint=previous
		;;
	esac
fi
: remember, indentation is wrong--RAM
;;
*)
	echo " "
	echo "Fetching default answers from $config_sh..." >&3
	tmp="$n"
	ans="$c"
	cd ..
	cp $config_sh config.sh 2>/dev/null
	. ./config.sh
	cd UU
	cp ../config.sh .
	n="$tmp"
	c="$ans"
	hint=previous
	;;
esac

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

: 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

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

: make some quick guesses about what we are up against
echo " "
$echo $n "Hmm...  $c" >&3
$cat /usr/include/signal.h /usr/include/sys/signal.h >foo 2>/dev/null
if 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..." >&3
		echo exit 0 >bsd
		echo exit 0 >usg
		echo exit 1 >v7
	else
		if $contains SIGTSTP foo >/dev/null 2>&1 ; then
		echo "Looks kind of like an extended USG system, but we'll see..." >&3
		else
			echo "Looks kind of like a USG system, but we'll see..." >&3
		fi
		echo exit 1 >bsd
		echo exit 0 >usg
		echo exit 1 >v7
	fi
	d_bsd="$undef"
elif $contains SIGTSTP foo >/dev/null 2>&1 ; then
	echo "Looks kind of like a BSD system, but we'll see..." >&3
	d_bsd="$define"
	echo exit 0 >bsd
	echo exit 1 >usg
	echo exit 1 >v7
else
	echo "Looks kind of like a Version 7 system, but we'll see..." >&3
	d_bsd="$undef"
	echo exit 1 >bsd
	echo exit 1 >usg
	echo exit 0 >v7
fi
case "$eunicefix" in
*unixtovms*)
	cat <<'EOI'
There is, however, a strange, musty smell in the air that reminds me of
something...hmm...yes...I've got it...there's a VMS nearby, or I'm a Blit.
EOI
	echo "exit 0" >eunice
	d_eunice="$define"
: 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"
	echo "exit 1" >eunice
	;;
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..."
	echo "exit 1" >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
	echo "exit 1" >venix
fi
chmod +x bsd usg v7 eunice venix
$eunicefix bsd usg v7 eunice venix
$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
case "$cc" in
gcc*) cpp=`loc gcc-cpp $cpp $pth`;;
esac

: 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"
	for file in $loclist; do
		eval $file=$file
	done
	;;
	*)  d_portable="$undef" ;;
esac

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

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
*f*) type='File';;
*d*) type='Directory';;
*l*) type='Locate'; fn=`expr $fn : '.*:\(.*\)'`;;
esac

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

while test "$type"; do
	redo=''
	rp="$orig_rp"
	dflt="$orig_dflt"
	case "$tilde" in
	true) rp="$rp (~name ok)";;
	esac
	. myread
	case "$ans" in
	none)
		value=''
		case "$none_ok" in
		true) type='';;
		esac
		;;
	*)
		case "$tilde" in
		'') value="$ans";;
		*)
			value=`./filexp $ans`
			case $? in
			0)
				if test "$ans" != "$value"; then
					echo "(That is $value on this particular system.)"
				fi
				;;
			*) value="$ans";;
			esac
			case "$d_portable" in
			"$define") value="$ans";;
			esac
			;;
		esac
		case "$fullpath" in
		true)
			case "$value" in
			/*) ;;
			*)
				redo=true
				case "$already" in
				true)
				echo "I shall only accept a full path name, as in /bin/ls." >&3
				echo "Use a ! shell escape if you wish to check pathnames." >&3
					;;
				*)
				echo "Please give a full path name, starting with slash." >&3
					case "$tilde" in
					true)
				echo "Note that using ~name is ok provided it expands well." >&3
						already=true
						;;
					esac
				esac
				;;
			esac
			;;
		esac
		case "$redo" in
		'')
			case "$type" in
			File)
				if test -f "$value"; then
					type=''
				elif test -r "$value" || (test -h "$value") >/dev/null 2>&1
				then
					echo "($value is not a plain file, but that's ok.)"
					type=''
				fi
				;;
			Directory)
				if test -d "$value"; then
					type=''
				fi
				;;
			Locate)
				if test -d "$value"; then
					echo "(Looking for $fn in directory $value.)"
					value="$value/$fn"
				fi
				if test -f "$value"; then
					type=''
				fi
				;;
			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?"
				. myread
				dflt=''
				case "$ans" in
				y*) type='';;
				*) echo " ";;
				esac
				;;
			esac
			;;
		esac
		;;
	esac
done
ans="$value"
rp="$orig_rp"
dflt="$orig_dflt"
EOSC

: What should the include directory be ?
echo " "
$echo $n "Hmm...  $c"
case "$usrinc" in
'') dflt='/usr/include';;
*) dflt=$usrinc;;
esac
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."
else
	echo "Doesn't look like a MIPS system."
	echo "exit 1" >mips
	chmod +x mips
	$eunicefix mips
fi
echo " "
fn=d/
rp='Where are the include files you want to use?'
. getfile
usrinc="$ans"

: 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

case "$ccflags" in
'') case "$cc" in
	*gcc*) dflt='-fpcc-struct-return';;
	*) dflt='';;
	esac
	;;
*) dflt="$ccflags"
	case "$cc" in
	*gcc*) case "$dflt" in
		*-fpcc-struct-return*) ;;
		*) dflt="$dflt -fpcc-struct-return";;
		esac;;
	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

case "$optimize" in
-g*)
	case "$dflt" in
	*DEBUG*);;
	*) dflt="$dflt -DDEBUG";;
	esac
	;;
esac

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

set signal.h LANGUAGE_C; eval $inctest
set signal.h NO_PROTOTYPE; eval $inctest
set signal.h _NO_PROTO; eval $inctest

case "$dflt" in
'') dflt=none;;
esac
$cat <<EOH

Your C compiler may want other flags.  For this question you should include
-I/whatever and -DWHATEVER flags and any other flags used by the C compiler,
but you should NOT include libraries or ld flags like -lwhatever.  To use no
flags, specify the word "none".

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

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

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

: 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"
	else
		plibpth="/usr/ccs/lib /usr/lib /usr/ucblib /usr/local/lib"
	fi;;
esac
libpth="$plibpth $libpth"

: Looking for optional libraries
echo " "
echo "Checking for optional libraries..." >&3
case "$libs" in
'') dflt='';;
*) dflt="$libs";;
esac
case "$libswanted" in
'') libswanted='c_s';;
esac
for thislib in $libswanted; do
	case "$thislib" in
	dbm) thatlib=ndbm;;
	*_s) thatlib=NONE;;
	*) thatlib="${thislib}_s";;
	*) thatlib=NONE;;
	esac
	yyy="$incpath/usr/ccs/lib $incpath/usr/lib $incpath/usr/ucblib"
	yyy="$yyy $incpath/usr/local/lib $incpath/lib"
	xxx=`loc lib$thislib.a X $yyy`
	if $test -f $xxx; then
		echo "Found -l$thislib."
		case "$dflt" in
		*-l$thislib*|*-l$thatlib*);;
		*) dflt="$dflt -l$thislib";;
		esac
	else
		xxx=`loc lib$thislib.a X $libpth`
		if $test -f $xxx; then
			echo "Found $xxx."
			case "$dflt" in
			*$xxx*);;
			*) dflt="$dflt $xxx";;
			esac
		else
			xxx=`loc Slib$thislib.a X $xlibpth`
			if $test -f $xxx; then
				echo "Found -l$thislib."
				case "$dflt" in
				*-l$thislib*|*-l$thatlib*);;
				*) dflt="$dflt -l$thislib";;
				esac
			else
				echo "No -l$thislib."
			fi
		fi
	fi
done
set X $dflt
shift
dflt="$*"
case "$libs" in
'') dflt="$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) ans='';
esac
libs="$ans"

: see if nm is to be used to determine whether a symbol is defined or not
case "$usenm" in
'')
	dflt=`egrep 'inlibc|csym' ../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)
: indentation is wrong on purpose--RAM
: 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
libpth="$plibpth $libpth"
libnames='';
case "$libs" in
'') ;;
*)  for thislib in $libs; do
	case "$thislib" in
	-l*)
		thislib=`expr X$thislib : 'X-l\(.*\)'`
		try=`loc lib$thislib.a blurfl/dyick $libpth`
		if test ! -f $try; then
			try=`loc lib$thislib blurfl/dyick $libpth`
			if test ! -f $try; then
				try=`loc $thislib blurfl/dyick $libpth`
				if test ! -f $try; then
					try=`loc Slib$thislib.a blurfl/dyick $xlibpth`
					if test ! -f $try; then
						try=''
					fi
				fi
			fi
		fi
		libnames="$libnames $try"
		;;
	*) libnames="$libnames $thislib" ;;
	esac
	done
	;;
esac
case "$libc" in
unknown)
	set /usr/ccs/lib/libc.so
	$test -r $1 || set /usr/lib/libc.so
	$test -r $1 || set /usr/lib/libc.so.[0-9]*
	$test -r $1 || set /lib/libsys_s.a
	eval set \$$#
	;;
*)
	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."
	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 ans=`./loc libc.a blurfl/dyick $libpth`; $test -r "$ans"; then
		:
	elif ans=`./loc libc blurfl/dyick $libpth`; $test -r "$ans"; then
		libnames="$libnames "`./loc clib blurfl/dyick $libpth`
	elif ans=`./loc clib blurfl/dyick $libpth`; $test -r "$ans"; then
		:
	elif ans=`./loc Slibc.a blurfl/dyick $xlibpth`; $test -r "$ans"; then
		:
	elif ans=`./loc Mlibc.a blurfl/dyick $xlibpth`; $test -r "$ans"; then
		:
	else
		ans=`./loc Llibc.a blurfl/dyick $xlibpth`
	fi
	if $test -r "$ans"; then
		echo "Your C library seems to be in $ans, of all places."
		libc=$ans
	else
		libc='blurfl'
	fi
fi
if $test -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 >&3 <<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:" >&3
echo " "
$sed 's/^/	/' libnames >&3
echo " "
$echo $n "This may take a while...$c" >&3

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" >&3'
xrun='eval "<libc.tmp $com >libc.list"; echo "done" >&3'
if com="$sed -n -e 's/^.* [ADTS]  *_[_.]*//p' -e 's/^.* [ADTS] //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
else
	nm -p $* 2>/dev/null >libc.tmp
	com="$sed -n -e 's/^.* [ADTS]  *_[_.]*//p' -e 's/^.* [ADTS] //p'";\
	eval "<libc.tmp $com >libc.list"
	if $contains '^fprintf$' libc.list >/dev/null 2>&1; then
		nm_opt='-p'
		echo "done" >&3
	else
		echo " "
		echo "nm didn't seem to work right. Trying ar instead..." >&3
		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." >&3
		else
			echo "ar didn't seem to work right." >&3
			echo "Maybe this is a Cray...trying bld instead..." >&3
			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." >&3
			else
				echo "That didn't work either.  Giving up." >&3
				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..." >&3
	$sed -n 's/^\([^ 	]*\)[ 	]*syscall$/\1/p' /lib/syscalls.exp >>libc.list
fi
: remember, indentation is wrong on purpose--RAM
;;
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 int $1$tdc; printf(\"%d\", $1$tc); }" > t.c;
		if $cc $ccflags -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!!! ***" >&3
echo "    The $hint value for \$$var on this machine was \"$was\"!" >&3
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." >&3;
		case "$was" in $undef) . whoa; esac; eval "$var=\$td";;
	*)
		echo "$sym() NOT found." >&3;
		case "$was" in $define) . whoa; esac; eval "$var=\$tu";;
	esac;;
*)
	case "$was" in
	$define) echo "$sym() found." >&3;;
	*) echo "$sym() NOT found." >&3;;
	esac;;
esac'

: see how we invoke the C preprocessor
echo " "
echo "Now, how can we feed standard input to your C preprocessor..." >&3
cat <<'EOT' >testcpp.c
#define ABC abc
#define XYZ xyz
ABC.XYZ
EOT
cd ..
echo 'cat >.$$.c; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' >cppstdin
chmod 755 cppstdin
wrapper=`pwd`/cppstdin
cd UU
if $test "X$cppstdin" != "X" && \
	$cppstdin $cppminus <testcpp.c >testcpp.out 2>&1 && \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "You used to use $cppstdin $cppminus so we'll use that again."
elif $test -f /usr/ccs/lib/cpp; \
        echo 'Maybe "/usr/lib/cpp" will work...'; \
	/usr/lib/cpp <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Yup, it does."
	cppstdin="/usr/lib/cpp"
	cppminus='';
elif $test -f /usr/ccs/lib/cpp; \
        echo 'Maybe "/usr/ccs/lib/cpp" will work...'; \
	/usr/ccs/lib/cpp <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Yup, it does."
	cppstdin="/usr/ccs/lib/cpp"
	cppminus='';
elif echo 'Maybe "'"$cc"' -E" will work...'; \
	$cc -E <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Yup, it does."
	cppstdin="$cc -E"
	cppminus='';
elif echo 'Nope...maybe "'"$cc"' -E -" will work...'; \
	$cc -E - <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Yup, it does."
	cppstdin="$cc -E"
	cppminus='-';
elif echo 'Uh-uh.  Time to get fancy.  Trying a wrapper...'; \
	$wrapper <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	cppstdin="$wrapper"
	cppminus=''
	echo "Eureka!"
elif echo 'No such luck, maybe "'$cpp'" will work...'; \
	$cpp <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "It works!"
	cppstdin="$cpp"
	cppminus='';
elif echo 'Nixed again...maybe "'$cpp' -" will work...'; \
	$cpp - <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Hooray, it works!  I was beginning to wonder."
	cppstdin="$cpp"
	cppminus='-';
elif echo 'Nope...maybe "'"$cc"' -P" will work...'; \
	$cc -P <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "Yipee, that works!"
	cppstdin="$cc -P"
	cppminus='';
elif echo 'Nope...maybe "'"$cc"' -P -" will work...'; \
	$cc -P - <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
	echo "At long last!"
	cppstdin="$cc -P"
	cppminus='-';
elif $test "$cc" = gcc && \
	(echo "Using gcc, eh?  We'll try to force gcc -E using a wrapper..."; \
	$wrapper <testcpp.c >testcpp.out 2>&1; \
	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1) ; then
	echo "Yup, we can."
	cppstdin="$wrapper"
	cppminus='';
else
	dflt=''
	rp="No dice.  I can't find a C preprocessor.  Name one:"
	. myread
	cppstdin="$ans"
	$cppstdin <testcpp.c >testcpp.out 2>&1
	if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
		echo "OK, that will do." >&3
	else
echo "Sorry, I can't get that to work.  Go find one and rerun Configure." >&3
		exit 1
	fi
fi
$rm -f testcpp.c testcpp.out

: determine filename position in cpp output
echo " "
echo "Computing filename position in cpp output for #include directives..." >&3
echo '#include <stdio.h>' > foo.c
$cat >fieldn <<EOF
$startsh
$cppstdin $cppminus $cppflags <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." >&3
	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." >&3
	else
		echo "I can't find the four *_OK access constants--I'll use mine." >&3
	fi
	;;
esac
$rm -f access*

: determine where the Tcl directories are
$cat << EOT

----------- Begining of The Modules Package specific questions -----------

Modules must be linked with libtcl.a which is the Tcl (Tool Command Language)
package developed by John Ousterhout.  It also requires the Tcl header files
from the source code directory.

EOT

dflt=y
rp='Do you have the Tcl library libtcl.a and the source include files?'
. myread
case "$ans" in
y*) ;;
*)  $cat << EOT

If you do not have Tcl yet, you can pick it up via anon ftp from
sprite.berkeley.edu or where you picked up Modules.

I'm going to exit the configuration script since you must have the Tcl library
and Tcl include files from the source in order to build Modules.

EOT

exit 1
;;
esac

case "$tcl_lib" in
    '')
	dflt=`loc libtcl.a . /usr/lib /usr/local/lib /lib`
	;;
    *)
	dflt="$tcl_lib"
	;;
    esac

fn=ln:libtcl.a
rp='Where is libtcl.a?'
. getfile
tcl_lib="$ans"

case "$tcl_incdir" in
    '')
	dflt=""
	;;
    *)
	dflt="$tcl_incdir"
	;;
    esac

$echo ""

fn=dn
rp='If the Tcl include files are not in /usr/include, where are they located?'
. getfile
tcl_incdir="$ans"
case "$tcl_incdir" in
  '') tcl_incdir_flags="" ;;
  *)  tcl_incdir_flags="-I$ans" ;;
esac

: determine the home of Modules
echo " "
case "$modules_home" in
'')
	dflt="/depot/Modules"
	;;
*)
	dflt="$modules_home"
	;;
esac
fn=d~/
rp='Where is home for Modules kit?'
. getfile
modules_home="$ans"

echo " "
case "$modules_bin" in
'')
	dflt="$modules_home/bin"
	;;
*)
	dflt="$modules_bin"
	;;
esac
fn=d~/
rp='Where do you want to put the Modules modulecmd executable?'
. getfile
modules_bin="$ans"

$cat << EOT

Users of Modules will need to source shell initialization files which will
enable them to use the Modules package.  These should be accessible for all
users and in the same place on every machine.

EOT

case "$modules_init" in
'')
	dflt="$modules_home/init"
	;;
*)
	dflt="$modules_init"
	;;
esac
fn=d~/
rp='Where do you want to put the Modules shell initialization files?'
. getfile
modules_init="$ans"

$cat << EOT

Modules users must access modulefiles in order to change their environment.
These files should be accessible for all users and preferrabley in the same
place on every machine.

EOT

case "$modules_files" in
'')
	dflt="$modules_home/modulefiles"
	;;
*)
	dflt="$modules_files"
	;;
esac
fn=d~/
rp='Where do you want to put the global modulefiles?'
. getfile
modules_files="$ans"

$cat << EOT

There is a FORCE_PATH variable which can be defined to ALWAYS keep
a given path at the very end of the PATH environment variable.  For example,
this is useful if you always want users to have /usr/local/bin in their
path as a catch-all.

EOT

dflt=y
rp='Do you want to force a path?'
. myread
case "$ans" in
y*)
    d_forcepath="$define"
    
    case "$d_forcedpathname" in
    '')
	dflt="/usr/local/bin:/usr/local/scripts"
	;;
    *)
	dflt="$d_forcedpathname"
	;;
    esac
    rp='What path do you want to force?'
    . myread
    d_forcedpathname="$ans"
    ;;

*)
    d_forcepath="$undef"
    d_forcepathname="$undef"
    ;;
esac


: do we evaluate aliases

$cat << EOT
    
By default, when aliases are set within Modules via the set-alias command, a
file will be created containing the aliases (or shell functions).  The calling
shell will be instructed to source this file and then remove it when
evaluating the environment changes.  The reason for this change is that many C
Shells don't handle complex (i.e. lots of arguments) aliases being interpreted
via eval.   In addition, most Bourne shells and their derelicts can't define
functions through the eval command.

The file creation and sourcing can be disabled.  In this case, the set-alias
information is sent to shell in the eval line with the environment changes.  I
would not recommend this unless you are certain that the shells you use handle
this properly.

EOT

dflt=n
rp='Should Modules define aliases and functions via the shell eval?'
. myread
case "$ans" in
n*) d_evalalias="$undef" ;;
*)  d_evalalias="$define" ;;
esac

$cat << EOT
    
Some Bourne shells can't define functions. 
EOT

dflt=y
rp='Does your /bin/sh handle functions?'
. myread
case "$ans" in
y*) d_bournefunc="$define" ;;
*)  d_bournefunc="$undef" ;;
esac

: do we cache the MODULEPATH directories

$cat << EOT
    
Modules has the ability to build caches to speed up the avail command.  Two
files are created in each directory in MODULEPATH that the user running
'module avail' can write into.  The list of modulefiles in each directory is
cached so that the next avail command will go much faster.

EOT

dflt=y
rp='Do you want to enable Modules avail cache?'
. myread
case "$ans" in
y*) d_cacheavail="$define" ;;
*)  d_cacheavail="$undef" ;;
esac

: 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'

: check for const keyword
echo " "
echo 'Checking to see if your C compiler knows about "const"...' >&3
$cat >const.c <<'EOCP'
main()
{
	const char *foo;
}
EOCP
if $cc -c $ccflags const.c >/dev/null 2>&1 ; then
	val="$define"
	echo "Yup, it does."
else
	val="$undef"
	echo "Nope, it doesn't."
fi
set d_const
eval $setvar

: now get the host name
echo " "
echo "Figuring out host name..." >&3
cont=true
echo 'Maybe "hostname" will work...'
if ans=`sh -c hostname 2>&1` ; then
	myhostname=$ans
	phostname=hostname
	cont=''
fi
if $test "$cont"; then
	if xenix; then
		echo 'Oh, dear.  Maybe "/etc/systemid" is the key...'
		if ans=`cat /etc/systemid 2>&1` ; then
			myhostname=$ans
			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 ans=`sh -c 'uuname -l' 2>&1` ; then
		myhostname=$ans
		phostname='uuname -l'
	else
		echo 'Strange.  Maybe "uname -n" will work...'
		if ans=`sh -c 'uname -n' 2>&1` ; then
			myhostname=$ans
			phostname='uname -n'
		else
			echo 'Oh well, maybe I can mine it out of whoami.h...'
			if ans=`sh -c $contains' sysname $usrinc/whoami.h' 2>&1` ; then
				myhostname=`echo "$ans" | $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...";;
				esac
			fi
		fi
	fi
fi
: you do not want to know about this
set $myhostname
myhostname=$1

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

: 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

: a little sanity check here
case "$phostname" in
'') ;;
*)
	case `$phostname` 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
	phostname=''
	;;
	esac
	;;
esac

: see how we will look up host name
echo " "
if false; then
	: dummy stub to allow use of elif
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 "$and" in
		n*) d_uname="$define"; ans=uname;;
		esac
	else
		echo 'uname() found.' >&3
		d_uname="$define"
		ans=uname
	fi
elif set gethostname val -f d_gethname; eval $csym; $val; then
	echo 'gethostname() found.' >&3
	d_gethname="$define"
	ans=gethostname
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 $ans() that lies about the hostname
but can't be fixed for political or economic reasons.  If you wish, I can
pretend $ans() isn't there and maybe compute hostname at run-time
thanks to the '$phostname' command.

EOM
	rp="Shall I ignore $ans() 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
	'')
		echo "There will be no way for $package to get your hostname." >&3;;
	*)
	echo "I'll use 'popen("'"'$aphostname'", "r")'"' to get your hostname." >&3
		;;
	esac;;
esac
case "$d_phostname" in
'') d_phostname="$undef";;
esac

: 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..." >&3
	if ./open3; then
		echo "and you have the 3 argument form of open()." >&3
		val="$define"
	else
		echo "but not the 3 argument form of open().  Oh, well." >&3
		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..." >&3
	if ./open3; then
		echo "and you have the 3 argument form of open()." >&3
		val="$define"
	else
		echo "but not the 3 argument form of open().  Oh, well." >&3
		val="$undef"
	fi
else
	val="$undef"
	echo "I can't find the O_* constant definitions!  You got problems." >&3
fi
set d_open3
eval $setvar
$rm -f open3*

: see to what degree we can use X11 resources
echo " "

$cat << EOT

Modules can access the X resource database directly via an x-resource Tcl
command which can be used inside of the modulefiles.  In order to use them
directly, Modules must link with the X11 libraries and have access to the X11
include files.

EOT
 
dflt=y
rp='Do you have access to X11 libraries?'
. myread
case "$ans" in
y*) d_x11libs="$define"
    case "$x11_libdir" in
    '')
	dflt=""
	;;
    *)
	dflt="$x11_libdir"
	;;
    esac
    fn=dn
    rp='If the X11 libraries are not in /usr/lib, where are they?'
    . getfile
    x11_libdir="$ans"
    case "$x11_libdir" in
    '') x11_libdir_flags="" ;;
    *)  x11_libdir_flags="-L$ans" ;;
    esac
    
    case "$x11_incdir" in
    '')
	dflt=""
	;;
    *)
	dflt="$x11_incdir"
	;;
    esac
    fn=dn
    rp='If the X11 include files are not in /usr/include, where are they?'
    . getfile
    x11_incdir="$ans"
    case "$x11_incdir" in
    '') x11_incdir_flags="" ;;
    *)  x11_incdir_flags="-I$ans" ;;
    esac

    case "$x11_libs" in
    '')
	dflt="none"
	;;
    *)
	dflt="$addl_x11_libs"
	;;
    esac
    rp='Are there additional system libraries needed to use the X11 libraries?'
    . myread
    case "$ans" in
    ''|'none')
	ans=""
	;;
    esac
    x11_libs="-lXmu -lXt -lX11"
    addl_x11_libs="$ans"
    ;;
    
*)  d_x11libs="$undef"
    x11_libs=""
    addl_x11_libs=""
    x11_libdir=""
    x11_incdir=""
    ;;
esac

case "$d_x11libs" in
*define*) ;;
*)
$cat <<EOT

There are no X11 libraries for the X resource Tcl command.  The X resource Tcl
command will have a stub compiled in its place.
EOT
    ;;
esac

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

: determine whether static linking is desired

$cat << EOT

Since modulecmd is run for very short periods of time, the startup time
becomes a large part of the time required to run the command.  By statically
linking in libraries, the startup time and thus the response time of Modules
can be reduced.  In addition, linking in the X11 libraries statically will
improve the portability of modulecmd by eliminating any messages about old
library versions. 

EOT
 

echo " "
dflt=y
rp='Do you want to statically link the executable?'
. myread
case "$ans" in
y*)     
    echo " "
    case "$static_linking" in
    '')
    	dflt=-static
    	;;
    *)
    	dflt="$static_linking"
    	;;
    esac
    fn=d~
    rp='What flag turns on static linking with your compiler?'
    . myread
    static_linking="$ans"
    ;;
esac
: end of configuration questions
echo " "
echo "End of configuration questions."
echo " "

: create config.sh file
echo " "
if test -d ../UU; then
	cd ..
fi
echo "Creating config.sh..." >&3
cf_time=`$date 2>&1`
cf_by=`( (logname) 2>/dev/null || whoami) 2>&1`
$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".
#

# Configuration time: $cf_time
# Configured by: $cf_by
# Target system: $myuname

cf_by='$cf_by'
cf_time='$cf_time'
d_bsd='$d_bsd'
d_eunice='$d_eunice'
d_xenix='$d_xenix'
eunicefix='$eunicefix'
Mcc='$Mcc'
awk='$awk'
bison='$bison'
cat='$cat'
chgrp='$chgrp'
chmod='$chmod'
chown='$chown'
compress='$compress'
cp='$cp'
cpio='$cpio'
cpp='$cpp'
csh='$csh'
date='$date'
echo='$echo'
egrep='$egrep'
emacs='$emacs'
expr='$expr'
flex='$flex'
gcc='$gcc'
grep='$grep'
inews='$inews'
less='$less'
line='$line'
lint='$lint'
ln='$ln'
lp='$lp'
lpr='$lpr'
ls='$ls'
mail='$mail'
mailx='$mailx'
make='$make'
mkdir='$mkdir'
more='$more'
mv='$mv'
nroff='$nroff'
perl='$perl'
pg='$pg'
pmake='$pmake'
pr='$pr'
rm='$rm'
rmail='$rmail'
sed='$sed'
sendmail='$sendmail'
shar='$shar'
sleep='$sleep'
smail='$smail'
sort='$sort'
submit='$submit'
tail='$tail'
tar='$tar'
tbl='$tbl'
test='$test'
touch='$touch'
tr='$tr'
troff='$troff'
uname='$uname'
uniq='$uniq'
uuname='$uuname'
vi='$vi'
zcat='$zcat'
hint='$hint'
myuname='$myuname'
Author='$Author'
Date='$Date'
Header='$Header'
Id='$Id'
Locker='$Locker'
Log='$Log'
RCSfile='$RCSfile'
Revision='$Revision'
Source='$Source'
State='$State'
d_cacheavail='$d_cacheavail'
cc='$cc'
ccflags='$ccflags'
cppflags='$cppflags'
ldflags='$ldflags'
lkflags='$lkflags'
optimize='$optimize'
contains='$contains'
cppminus='$cppminus'
cppstdin='$cppstdin'
d_access='$d_access'
d_const='$d_const'
aphostname='$aphostname'
d_gethname='$d_gethname'
d_phostname='$d_phostname'
d_uname='$d_uname'
d_open3='$d_open3'
d_portable='$d_portable'
d_bournefunc='$d_bournefunc'
d_evalalias='$d_evalalias'
h_fcntl='$h_fcntl'
h_sysfile='$h_sysfile'
libc='$libc'
libpth='$libpth'
plibpth='$plibpth'
xlibpath='$xlibpath'
libs='$libs'
d_forcedpathname='$d_forcedpathname'
d_forcepath='$d_forcepath'
modules_bin='$modules_bin'
modules_files='$modules_files'
modules_home='$modules_home'
modules_init='$modules_init'
mydomain='$mydomain'
myhostname='$myhostname'
phostname='$phostname'
c='$c'
n='$n'
package='$package'
sharpbang='$sharpbang'
shsharp='$shsharp'
spitshell='$spitshell'
startsh='$startsh'
static_linking='$static_linking'
sysman='$sysman'
tcl_incdir='$tcl_incdir'
tcl_incdir_flags='$tcl_incdir_flags'
tcl_lib='$tcl_lib'
nm_opt='$nm_opt'
runnm='$runnm'
usenm='$usenm'
incpath='$incpath'
mips='$mips'
mips_type='$mips_type'
usrinc='$usrinc'
d_x11libs='$d_x11libs'
x11_incdir='$x11_incdir'
x11_incdir_flags='$x11_incdir_flags'
x11_libdir='$x11_libdir'
x11_libdir_flags='$x11_libdir_flags'
x11_libs='$x11_libs'
EOT

: add special variables
$test -f patchlevel.h && \
awk '/^#define/ {printf "%s=%s\n",$2,$3}' 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) ;;
	*)	echo "Hmm...You had some extra variables I don't know about...I'll try to keep 'em..."
	for sym in `cat UU/oldsyms`; do
		echo "    Propagating $hint variable "'$'"$sym..."
		eval 'tmp="$'"${sym}"'"'
		echo "$tmp" | \
		sed -e "s/'/'\"'\"'/g" -e "s/^/$sym='/" -e "s/$/'/" >>config.sh
	done
	;;
	esac
fi

: Finish up by extracting the .SH files
case "$alldone" in
exit)
	$rm -rf UU
	echo "Done."
	exit 0
	;;
cont)
	;;
'')
	echo " "
	dflt=''
echo "If you didn't make any mistakes, then just type a carriage return here."
	rp="If you need to edit config.sh, do it as a shell escape here:"
	. ./UU/myread
	case "$ans" in
	'') ;;
	*) : in case they cannot read
		eval $ans;;
	esac
	;;
esac

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

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

if $contains '^depend:' [Mm]akefile >/dev/null 2>&1; then
	dflt=n
	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
