OS/2 Professional/OS2PRO194.ISO/os2/com/utils/elm/sources/configur

Text File | 1991-01-18 | 92.7 KB | 4,101 lines

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

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

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

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

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

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

define=''
eunicefix=''
Log=''
Header=''
bin=''
byteorder=''
contains=''
cppstdin=''
cppminus=''
d_crypt=''
cryptlib=''
d_getopt=''
d_havetlib=''
termlib=''
d_mkdir=''
d_rename=''
d_sigvec=''
d_sigvectr=''
d_symlink=''
d_vfork=''
d_whoami=''
defeditor=''
hostname=''
phostname=''
mydomain=''
i_time=''
i_systime=''
d_systimekernel=''
maildir=''
n=''
c=''
package=''
pager=''
prefshell=''
spitshell=''
shsharp=''
sharpbang=''
startsh=''
d_eunice=''
loclist=''
expr=''
sed=''
echo=''
cat=''
rm=''
mv=''
cp=''
tail=''
tr=''
mkdir=''
sort=''
uniq=''
grep=''
trylist=''
test=''
inews=''
egrep=''
more=''
pg=''
Mcc=''
vi=''
mailx=''
mail=''
cpp=''
perl=''
emacs=''
ls=''
rmail=''
sendmail=''
shar=''
smail=''
submit=''
tbl=''
troff=''
nroff=''
uname=''
uuname=''
line=''
chgrp=''
chmod=''
lint=''
sleep=''
pr=''
tar=''
ln=''
lpr=''
lp=''
touch=''
make=''
date=''
csh=''
pmake=''
c_date=''
d_ascii=''
d_calendar=''
calendar=''
d_cuserid=''
d_flock=''
d_flockonly=''
lock_dir=''
d_gethname=''
d_douname=''
d_phostname=''
d_host_comp=''
ign_hname=''
d_havedbm=''
dbm=''
d_index=''
d_internet=''
d_mboxedit=''
d_mmdf=''
d_newauto=''
d_nfs=''
d_networkorder=''
d_noxheader=''
d_optreturn=''
d_pafirst=''
d_notouchadd=''
d_noaddfrom=''
d_usedomain=''
d_nocheckvalid=''
d_pidcheck=''
d_portable=''
d_ptem=''
d_remlock=''
maxattempts=''
d_setgid=''
mailermode=''
d_strcspn=''
d_strspn=''
d_strings=''
d_pwdinsys=''
strings=''
includepath=''
d_subshell=''
d_tempnam=''
tempnamo=''
tempnamc=''
d_termio=''
d_termios=''
d_tz_min=''
d_useembed=''
d_utimbuf=''
d_voidsig=''
defbatsub=''
elmalias=''
maxsysalias=''
maxuseralias=''
lib=''
libc=''
linepr=''
mailer=''
mailgrp=''
mansrc=''
manext=''
models=''
split=''
small=''
medium=''
large=''
huge=''
optimize=''
ccflags=''
cppflags=''
ldflags=''
cc=''
libs=''
nametype=''
d_passnames=''
d_berknames=''
d_usgnames=''
passcat=''
pathalias=''
domains=''
rmttape=''
roff=''
tmpdir=''
use_pmake=''
xencf=''
xenlf=''
d_xenix=''
d_bsd=''
CONFIG=''
: set package name
package=elm2

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

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

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

: Now test for existence of everything in MANIFEST

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

attrlist="mc68000 sun gcos unix ibm gimpel interdata tss os mert pyr"
attrlist="$attrlist vax pdp11 i8086 z8000 u3b2 u3b5 u3b20 u3b200"
attrlist="$attrlist hpux hp9000s300 hp9000s500 hp9000s800"
attrlist="$attrlist ns32000 ns16000 iAPX286 mc300 mc500 mc700 sparc"
attrlist="$attrlist nsc32000 sinix xenix venix posix ansi M_XENIX"
attrlist="$attrlist $mc68k __STDC__ UTS M_I8086 M_I186 M_I286 M_I386"
attrlist="$attrlist i186 __m88k__ m88k DGUX __DGUX__"
d_newshome="/usr/NeWS"
defvoidused=7
pth="/usr/ucb /bin /usr/bin /usr/local /usr/local/bin /usr/lbin /usr/5bin /vol/local/bin /etc"
pth="$pth /usr/lib /lib /usr/local/lib /sys5.3/bin /sys5.3/usr/bin /bsd4.3/bin /bsd4.3/usr/bin /bsd4.3/usr/ucb"
pth="$pth /usr/convex /usr/mmdf/bin /usr/mmdf/lib ${BSDBASE-/bsd}/usr/ucb ${BSDBASE-/bsd}/bin ${BSDBASE-/bsd}/usr/bin"

: check for out bin directory
if test ! -d ../bin; then
    echo "Making bin directory"
    mkdir ../bin
else
    echo "Found bin directory"
fi

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

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

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

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

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

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

: general instructions
cat <<EOH

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

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

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

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

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

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

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

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

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

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

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

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

: see if date exists, if so, init c_date
if $test ! "x$date" = "x" ; then
    c_date=`LANGUAGE= $date`
else
    c_date='date was unavailable at configuration'
fi

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

: determine text processor to use, default to troff if found.
case "$roff" in
'')
    if $test -n "$troff"; then
    dflt="$troff"
    else
    dflt=$nroff
    fi
    ;;
*)  dflt="$roff";;
esac
$cat <<EOM

The Elm manuals are set up for troff.  If you only have nroff, it can
be used, but the manuals will not be as readable.  If you use an alternate
processor for troff/nroff documents it can be specified here.  Elm expects
the text processor to write to standard out.   Some old troff programs require
the -t flag to send the output to standard out.  If yours does, use the -t flag
as part of the executable name and ignore the not found error message,
as in: troff -t

EOM
cont=true
while $test "$cont" ; do
    echo " "
    echo "Give the name of the program used to process manual pages on your"
    $echo $n "system: [$dflt] $c"
    rp="Preferred troff/nroff program: [$dflt]"
    . myread
    roff=$ans;
    if $test -f "$ans"; then
    cont=''
    else
    lookup=`loc "$ans" "" . $pth`
    if $test -f "$lookup"; then
        cont=''
        roff=$lookup
    else
        if $test "$fastread" = yes; then
        dflt=y
        else
        dflt=n
        fi
        echo "Text processor $ans doesn't exist."
        rp="Use that name anyway? [$dflt]"
        $echo $n "$rp $c"
        . myread
        dflt=''
        case "$ans" in
        y*) cont='';;
        esac
    fi
    fi
done

: determine where manual pages go
$cat <<EOM

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

: default clear to no extra flags
xencf=
xenlf=
d_xenix="$undef"
d_bsd="$undef"
: see if we are xenix
if xenix; then
    d_xenix="$define"
:    now are we a 286
    case "`uname -p`" in
    i80286)
        xencf="-LARGE -Ml2et32"
        xenlf="-Ml2t32 -F 5600 -SEG 512"
      esac
fi
if bsd; then
    d_bsd="$define"
fi

: see what memory models we can support
case "$models" in
'')
    : We may not use Cppsym or we get a circular dependency through cc.
    : But this should work regardless of which cc we eventually use.
    cat >pdp11.c <<'EOP'
main() {
#ifdef pdp11
    exit(0);
#else
    exit(1);
#endif
}
EOP
    cc -o pdp11 pdp11.c >/dev/null 2>&1
    if pdp11 2>/dev/null; then
    dflt='unsplit split'
    else
    ans=`loc . X /lib/small /lib/large /usr/lib/small /usr/lib/large /lib/medium /usr/lib/medium /lib/huge`
    case "$ans" in
    X) dflt='none';;
    *)  if $test -d /lib/small || $test -d /usr/lib/small; then
        dflt='small'
        else
        dflt=''
        fi
        if $test -d /lib/medium || $test -d /usr/lib/medium; then
        dflt="$dflt medium"
        fi
        if $test -d /lib/large || $test -d /usr/lib/large; then
        dflt="$dflt large"
        fi
        if $test -d /lib/huge || $test -d /usr/lib/huge; then
        dflt="$dflt huge"
        fi
    esac
    fi
    ;;
*)  dflt="$models" ;;
esac
if $test -z "$xencf" ; then
$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.
Xenix and Venix systems may wish to put "none" and let the compiler figure
things out.
(In the following question multiple model names should be space separated.)

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

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

: see if we need a special compiler
echo " "
if usg; then
    case "$cc" in
    '')
    case "$Mcc" in
    /*) dflt='Mcc'
        ;;
    *)
        case "$large" in
        -M*)
        dflt='cc'
        ;;
        *)
        if $contains '\-M' $mansrc/cc.1 >/dev/null 2>&1 ; then
            dflt='cc -M'
        else
            dflt='cc'
        fi
        ;;
        esac
        ;;
    esac
    ;;
    *)  dflt="$cc";;
    esac
    $cat <<'EOM'

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

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

Some C compilers have problems with their optimizers, by default, $package
compiles with the -O flag to use the optimizer.  Alternately, you might
want to use the symbolic debugger, which uses the -g flag (on traditional
Unix systems).  Either flag can be specified here.  To use neither flag,
specify the word "none".

EOH
rp="What optimizer/debugger flag should be used? [$dflt]"
$echo $n "$rp $c"
. myread
optimize="$ans"
case "$optimize" in
'none') optimize=" "
     ;;
esac

case "$ccflags" in
'') case "$cc" in
    *gcc*) dflt='-fpcc-struct-return';;
    *) dflt='';;
    esac
    ;;
*) dflt="$ccflags";;
esac
for thisincl in $inclwanted; do
    if test -d $thisincl; then
    case "$dflt" in
    *$thisincl*);;
    *) dflt="$dflt -I$thisincl";;
    esac
    fi
done
case "$optimize" in
-g*)
    case "$dflt" in
    *DEBUG*);;
    *) dflt="$dflt -DDEBUG";;
    esac
    ;;
esac
case "$dflt" in
'') dflt=none;;
esac
if $test -n "$xencf" ; then
    $echo "Xenix 286 system, using compiler flags $xencf"
    $echo "do not respecify these flags below."
    $echo ""
fi
cat <<EOH

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

EOH
rp="Any additional cc flags? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
none) ans='';
esac
ccflags="$ans"

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

if $test -n "$xenlf" ; then
    $echo "Xenix 286 system, using linker flags $xenlf"
    $echo "do not respecify these flags below"
    $echo ""
fi
case "$ldflags" in
'') if venix; then
    dflt='-i -z'
    else
    dflt='none'
    fi
    ;;
*) dflt="$ldflags";;
esac
echo " "
rp="Any additional ld flags (NOT including libraries)? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
none) ans='';
esac
ldflags="$ans"
rmlist="$rmlist pdp11"

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

$cat <<EOM

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

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

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

: check for ordering of bytes in a long
case "$byteorder" in
'')
cat <<'EOM'

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

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

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

I can't seem to find your C library.  I've looked in the following places:

    $libpth

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

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

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

: see if nfs exists
echo " "
dflt=`loc exports xyz /etc /usr/etc`
if $test "$dflt" = xyz; then
    dflt=`loc nfsd xyz /etc /usr/etc $pth`
fi
if $test "$dflt" = xyz; then
    echo "System does not support NFS, internal byte order will be used"
    d_nfs="$undef"
else
    echo "System supports NFS, network byte order will be used"
    d_nfs="$define"
fi

if $test "$d_nfs" = "$define"; then
    case "$byteorder" in
    4321)
        d_networkorder="$undef";
        ;;
    *)
        d_networkorder="$define";
        if $contains ntohl libc.list >/dev/null 2>&1; then
        echo 'ntohl found in libc, no special libraries needed for network byte ordering'
        else
        echo 'ntohl not found in libc, be sure to specify the library for network support'
        echo 'as an optional library'
        fi
        ;;
    esac
else
    d_networkorder="$undef";
fi

: get calendar mode and default calendar file name
$cat <<EOM

There is a neat feature that enables scanning of the message body for
entries to add to the users ".calendar" (or whatever) file.  These
entries are then processed by the system program calendar.  To use
this feature it needs to be enabled.  The name of the per user calendar
file used by your systems calendar program is also required.
EOM

case "$d_calendar" in
"$define") dflt=y;;
"$undef")  dflt=n;;
*)       dflt=y;;
esac

rp="Enable calendar feature [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
y*) d_calendar="$define";;
*)  d_calendar="$undef";;
esac

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

if $test "$d_calendar" = "$define"; then
    echo " "
    rp="Default calendar file: [$dflt]"
    $echo $n "$rp $c"
    . myread
    calendar="$ans"
fi

: check to see if the macros are 8 bit clean, ask the user
:
$cat <<EOM


Not all environments are restricted to the ASCII 7 bit character set.
For example, the ISO 8859/1 (Latin alphabet no. 1) character set,
consisting of 8 bits and 191 printable characters, is becoming
more and more common, especially in non-English speaking countries.

Unfortunately, not all isprint() functions or macros, which ELM
uses to determine whether a character is printable or not, will
handle non-ASCII (8 bit) characters properly.  It is suggested that you
start with this value configured to handle 8 bit characters correctly
and if there are problems with Elm aborting while displaying messages
that use extended character sets to reconfigure Elm to only display
7 bit characters.

EOM

case "$d_ascii" in
    "$define")   dflt='n';;
    *)  dflt='y';;
esac

echo "  "
rp="Should Elm assume that isprint() won't break on non-ascii characters? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
    y*) d_ascii="$undef";;
    *) d_ascii="$define";;
esac

: find out how to find out full name
echo " "
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
echo "Does your /etc/passwd file keep full names in Berkeley/V7 format (name first"
$echo $n "thing after ':' in GCOS field)? [$dflt] $c"
rp="Berkeley/V7 format full name? [$dflt]"
. myread
case "$ans" in
  y*)
    d_passnames="$define"
    d_berknames="$define"
    d_usgnames="$undef"
    nametype=bsd
    ;;
  *)
    echo " "
    case "$d_usgnames" in
    "$define")
    dflt=y;;
    "$undef")
    dflt=n;;
    *)
    if usg; then
        dflt=y
    else
        dflt=n
    fi
    ;;
    esac
    echo "Does your passwd file keep full names in USG format (name sandwiched"
    $echo $n "between a '-' and a '(')? [$dflt] $c"
    rp="USG format full name? [$dflt]"
    . 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

: see if we have to deal with yellow pages
if $test -d /usr/etc/yp || $test -d /etc/yp; then
    if $test "$passcat" = "ypcat passwd"; then
    dflt=y
    elif $contains '^\+:' /etc/passwd; then
    dflt=y
    else
    dflt=n
    fi
    rp="Are you getting the passwd file via yellow pages? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
    y*) passcat='ypcat passwd';;
    *) passcat='cat /etc/passwd';;
    esac
else
    passcat='cat /etc/passwd'
fi

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

: check for cuserid function
echo " "
if $contains '^cuserid$' libc.list >/dev/null 2>&1 ; then
    echo "cuserid() found."
    d_cuserid="$undef"
else
    echo "No cuserid() found--will use mine."
    d_cuserid="$define"
fi

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

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

: verify guess
if $test "$hostname" ; then
    dflt=y
    echo 'Your host name appears to be "'$hostname'".'
    $echo $n "Is this correct? [$dflt] $c"
    rp="Sitename is $hostname? [$dflt]"
    . myread
    case "$ans" in
      y*)  ;;
      *)      hostname='' ;;
    esac
fi

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

echo " "
case "$hostname" in
*.*)
    dflt=`$expr "X$hostname" : "X[^.]*\(\..*\)"`
    hostname=`$expr "X$hostname" : "X\([^.]*\)\."`
    echo "(Trimming domain name from host name--host name is now $hostname)"
    ;;
*)  case "$mydomain" in
    '') dflt='.UUCP';;
    *) dflt="$mydomain";;
    esac
    ;;
esac
rp="What is your domain name? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
'') ;;
.*) ;;
*) ans=".$ans";;
esac
mydomain="$ans"

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

: decide how portable to be
case "$d_portable" in
"$define") dflt=y;;
"$undef")  dflt=n;;
*)       if $test "$d_nfs" = "$define" ; then
           dflt=y
       else
           dflt=n
       fi
       ;;
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? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
    y*) d_portable="$define"
    for file in $loclist; do
        eval $file=$file
    done
    ;;
    *)  d_portable="$undef" ;;
esac

: see if there is a whoami file
echo " "
if $test -r /usr/include/whoami.h ; then
    d_whoami="$define"
    echo "whoami.h found."
else
    d_whoami="$undef"
fi

: see how we will look up host name
echo " "
d_douname="$undef"
d_gethname="$undef"
if $test -z "$d_phostname"; then
    d_phostname="$undef"
fi

if $contains '^gethostname$' libc.list >/dev/null 2>&1 ; then
    echo "gethostname() found."
    d_gethname="$define"
    ans=gethostname
elif xenix; then
    if $test -n "$uname"; then
    u_name=`$uname -n`
    else
    u_name=
    fi
    if $test -n "$line"; then
    if $test -r /etc/systemid; then
        s_name=`$line < /etc/systemid`
    else
        s_name=
    fi
    else
    s_name=
    fi
    if $test -n "$u_name"; then
    if $test "$u_name" = "$s_name"; then
        cat <<EOM
On Xenix, UUCP uses the name found in /etc/systemid, while uname()
returns the name compiled into the operating system via configure.
Elm needs the UUCP name, and currently these two match.  However, they
need not match.  Be sure to always keep these two names in sync.
Since they match, Elm will not consider that the Xenix uname function
is broken.  However, if you are not always able to make them
match, answer the compile in hostname question Yes.
EOM
        if $contains '^uname$' libc.list >/dev/null 2>&1 ; then
        echo "uname() found."
        d_douname="$define"
        ans=uname
        fi
    else
        cat <<EOM
On Xenix, UUCP uses the name found in /etc/systemid, while uname()
returns the name compiled into the operating system via configure.
Your /etc/systemid file contains $s_name.
But uname returns $u_name.
Since Elm needs the UUCP name, and currently these two do not match,
Elm will assume Xenix uname() is broken.
EOM
    fi
    else
    cat <<EOM
On Xenix, UUCP uses the name found in /etc/systemid, while uname()
returns the name compiled into the operating system via configure.
Elm needs the UUCP name, and currently the compiled in name is undefined.
Since mail needs the UUCP name, and these two need not match, Elm will
assume Xenix uname() is broken.
EOM
    fi
elif $contains '^uname$' libc.list >/dev/null 2>&1 ; then
    echo "uname() found."
    d_douname="$define"
    ans=uname
fi

case "$d_douname$d_gethname" in
*define*)
    case "$ign_hname" in
    '')    case "$d_host_comp" in
    "$define") dflt=y;;
    *)  dflt=n;;
    esac;;
    y)  dflt=y;;
    *)  dflt=n;;
    esac
    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.  Would you like to
EOM
    rp="pretend $ans() isn't there and maybe compile in the hostname? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
    y*) ign_hname=y
    d_douname="$undef"
    d_gethname="$undef"
    d_host_comp="$define"
    $echo $n "Okay... $c"
    ;;
    *)    ign_hname=n
    d_host_comp="$undef"
    ;;
    esac
    ;;
esac

case "$d_douname$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 ($hostname) compiled into $package, which
    lets $package start up faster, but makes your binaries non-portable, or
2)  you can have $package use a

    popen("$phostname","r")

    which will start slower but be more portable.

Option 1 will give you the option of using whoami.h if you have one.  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? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
      n*) d_phostname="$define"
          d_host_comp="$undef"
          ;;
      *)  phostname=''
          d_host_comp="$define"
          d_phostname="$undef"
          ;;
    esac
    ;;
    esac
    case "$phostname" in
      '')
    case "$d_whoami" in
      "$define")
        dflt=y
        $cat <<EOM

No hostname function--you can either use the whoami.h file, which has this line:

    `grep sysname /usr/include/whoami.h`

or you can have the name we came up with earlier ($hostname) hardwired in.
EOM
        rp="Use whoami.h to get hostname? [$dflt]"
        $echo $n "$rp $c"
        . myread
        case "$ans" in
        n*) d_whoami="$undef";;
        esac
        ;;
      "$undef")
        echo 'No hostname function and no whoami.h--hardwiring "'$hostname'".'
        d_host_comp="$define"
        d_phostname="$undef"
        ;;
    esac
    ;;
    esac
    ;;
esac

: see if flock exists
echo " "
if $contains flock libc.list >/dev/null 2>&1; then
    echo 'flock() found.'
    if $contains EWOULDBLOCK /usr/include/errno.h > /dev/null 2>&1; then
    echo 'EWOULDBLOCK found, will use flock type mailbox locking'
        d_flock="$define"
    elif $contains EWOULDBLOCK /usr/include/sys/errno.h > /dev/null 2>&1; then
    echo 'EWOULDBLOCK found, will use flock type mailbox locking'
        d_flock="$define"
    else
    echo 'flock() not found--will use .lock type mailbox locking'
    d_flock="$undef"
    fi
else
    echo 'flock() not found--will use .lock type mailbox locking'
    d_flock="$undef"
    d_flockonly="$undef"
fi

if $test "$d_flock" = "$define"; then
    case "$d_flockonly" in
    "$define")    dflt=y;;
    "$undef")    dflt=n;;
    *)        dflt=n;;
    esac
    $cat <<EOM

Some sites wish to use flock style locking only.  This allows Elm
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? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
    y*) d_flockonly="$define";;
    *)  d_flockonly="$undef";;
    esac
fi

if $test -d /usr/spool/locks ; then
    lock_dir=/usr/spool/locks
elif $test -d /usr/spool/uucp ; then
    lock_dir=/usr/spool/uucp
elif $test -d /var/spool/locks ; then
    lock_dir=/var/spool/locks
elif $test -d /var/spool/uucp ; then
    lock_dir=/var/spool/uucp
else
    lock_dir=/tmp
fi
echo " "
echo "Non mailbox locks will use the $lock_dir directory"
echo " "

: see if getopt exists
set getopt d_getopt
eval $inlibc

: determine pathnames of the domains and pathalias
case "$pathalias" in
'') dflt=`loc paths blurfl/dyick $pth /usr/lib/uucp`
    if $test "$dflt" = blurfl/dyick; then
    dflt=`loc nmail.paths /usr/lib/nmail.paths $pth /usr/lib/uucp`
    fi
    ;;
*)  dflt="$pathalias";;
esac
cont=true
while $test "$cont" ; do
    echo " "
    echo "Give the full path name of the pathalias"
    rp="data file? [$dflt]"
    $echo $n "$rp $c"
    . myread
    pathalias="$ans"
    if $test -f "$ans"; then
    cont=''
    else
    if $test "$fastread" = yes; then
        dflt=y
    else
        dflt=n
    fi
    echo "Pathalias data file $ans doesn't exist."
    rp="Use that name anyway? [$dflt]"
    $echo $n "$rp $c"
    . myread
    dflt=''
    case "$ans" in
    y*) cont='';;
    esac
    fi
done

case "$domains" in
'') dflt=`loc domains /usr/lib/domains $pth /usr/lib/uucp`;;
*)  dflt="$domains";;
esac
cont=true
while $test "$cont" ; do
    echo " "
    echo "Where does the uumail-style 'domains'"
    rp="file live? [$dflt]"
    $echo $n "$rp $c"
    . myread
    domains="$ans"
    if $test -f "$ans"; then
    cont=''
    else
    if $test "$fastread" = yes; then
        dflt=y
    else
        dflt=n
    fi
    echo "Domains data file $ans doesn't exist."
    rp="Use that name anyway? [$dflt]"
    $echo $n "$rp $c"
    . myread
    dflt=''
    case "$ans" in
    y*) cont='';;
    esac
    fi
done
: is pathalias available as a dbm file
d_havedbm="$undef"
dbm=''

if $test -f "$pathalias.pag" -a -f "$pathalias.dir"; then
    ans=`loc libdbm.a x $libpth`
    if $test "$ans" = x; then
    ans=`loc Slibdbm.a x $libpth`
    fi
    if $test "$ans" = x; then
    dflt=y
    echo " "
    rp="You have pathalias as a DBM file, but I cannot find the
DBM library.  Do you have dbm? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
        y*|t*) d_havedbm="$define"
        echo " "
        echo "Then where are the dbm routines kept (specify either -llibname"
        $echo $n " or full pathname (~name ok))? $c"
        rp='Specify dbm library:'
        . myread
        dbm=`filexp $ans`
        ;;
        *)    d_havedbm="$undef"
        dbm=''
        echo "I will use the non dbm access methods then."
        ;;
    esac
    else
    echo " "
    echo "You have pathalias as a DBM file...I'll use that instead."
    dbm=-ldbm
    d_havedbm="$define"
    fi
fi

: see if strings.h is in /usr/include or /usr/include/sys
echo " "
strings=`loc string.h "" /usr/include $includepath`
if $test -z "$strings"; then
    strings=`loc strings.h "" /usr/include $includepath`
fi
while $test -z "$strings"; do
    echo " "
    dflt=''
    rp="What is the full path name of the include file directory? []"
    $echo $n "$rp $c"
    . myread
    includepath=`filexp $ans`
    if $test -d "$includepath"; then
        strings=`loc string.h "" /usr/include $includepath`
        if $test -z "$strings"; then
            strings=`loc strings.h "" /usr/include $includepath`
        fi
        if $test -z "$strings"; then
            $cat <<EOM

Include file string.h or strings.h not found in $includepath.
Elm requires string.h on USG type systems or strings.h on BSD type
systems.  Please specify the directory where one of these files can
be found.
EOM
        fi
    else
        echo "Directory $includepath not found"
    fi
done

strings_f=`$expr "$strings" : ".*/\(.*\)"`
if $test "$strings_f" = "string.h"; then
    d_strings="$undef"
    echo Using string.h instead of strings.h
else
    d_strings="$define"
    echo Using strings.h instead of string.h
fi
pwdinsys=`loc pwd.h "" /usr/include $includepath`
if $test -z "$pwdinsys"; then
    d_pwdinsys="$define"
else
    d_pwdinsys="$undef"
fi

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

case "$d_mmdf" in
"$define") dflt=y;;
"$undef")  dflt=n;;
*)    if $test -f "$submit"; then
        dflt=y
    else
        dflt=n
    fi
    ;;
esac
$cat <<EOM

Some systems run MMDF as their Mail Transport Agent.  MMDF uses
a different way of delimiting messages in the mailbox files.
Usually this is a series of four Control A's.  $package needs to know
if this system uses MMDF.

EOM
rp="Does this system use MMDF as its MTA? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
y*) d_mmdf="$define";;
*)  d_mmdf="$undef";;
esac

: determine mail delivery agent for Elm to use
case "$mailer" in
'')
    if $test "$d_mmdf" = "$define" -a -f "$submit"; then
    dflt="$submit"
    elif $test -f "$sendmail"; then
    dflt="$sendmail"
    elif $test -f "$rmail"; then
    dflt="$rmail"
    elif $test -f /bin/mail; then
    dflt=/bin/mail
    else
    dflt=$mail
    fi
    ;;
*)  dflt="$mailer";;
esac
cont=true
while $test "$cont" ; do
    echo " "
    echo "Give the full path name of the program used to deliver mail on your"
    $echo $n "system: [$dflt] $c"
    rp="Preferred mail delivery agent: [$dflt]"
    . myread
    mailer="$ans"
    if $test -f "$ans"; then
    cont=''
    else
    if $test "$fastread" = yes; then
        dflt=y
    else
        dflt=n
    fi
    echo "Mail delivery agent $ans doesn't exist."
    rp="Use that name anyway? [$dflt]"
    $echo $n "$rp $c"
    . myread
    dflt=''
    case "$ans" in
    y*) cont='';;
    esac
    fi
done
if $test "$mailer" != "$sendmail"; then
    sendmail=''
fi
if $test "$mailer" != "$submit"; then
    submit=''
fi

: check for internet mailer
case "$d_internet" in
"$define")    dflt=y;;
"$undef")    dflt=n;;
*)    if $test -f "$sendmail"; then
        dflt=y
    elif $test -f "$submit"; then
        dflt=y
    elif $test -f "$smail"; then
        dflt=y
    else
        dflt=n
    fi
    ;;
esac
$cat <<EOM

Some newer mailers can deliver mail to addresses of the INTERNET persuasion,
such as [e-mail].  Other older mailers require the complete path to
the destination to be specified in the address.  Does your mailer understand
EOM
$echo $n "INTERNET addresses? [$dflt] $c"
rp="Does your mailer understand INTERNET addresses? [$dflt]"
. myread
case "$ans" in
y*) d_internet="$define";;
*)  d_internet="$undef";;
esac

case "$d_mboxedit" in
"$define") dflt=y;;
"$undef")  dflt=n;;
*)    dflt=n;;
esac
$cat <<EOM

A lot of sites that install the Elm Mail System find that the function
E)dit mailbox from within Elm is dangerous and confusing.  If you choose,
you can instead disable that function, with the program being slightly
smaller and presenting an appropriate error message to the user if they
try to E)dit their mailbox.

EOM
rp="Would you like to enable the E)dit Mailbox function? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
y*) d_mboxedit="$define";;
*)  d_mboxedit="$undef";;
esac

: see if mkdir exists
set mkdir d_mkdir
eval $inlibc

: ask about newmail running in the background automatically
case "$d_newauto" in
"$define")    dflt=y;;
"$undef")    dflt=n;;
*)        dflt=y;;
esac
echo " "
rp="Should newmail automatically run in the background? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
y*) d_newauto="$define";;
*)  d_newauto="$undef";;
esac

case "$d_notouchadd" in
"$define") dflt=n;;
"$undef")  dflt=y;;
*)       if $test "$d_internet" = "$define" ; then
           dflt=n
       else
           dflt=y
       fi
       ;;
esac
$cat <<EOM

Some sites are configured so that the low level transport mechanism
is supposed to resolve and rewrite uucp paths, unreachable
domains/networks, and so on.  If your site running either "smail",
a "gateway" configuration of sendmail, or some similar software
then the low level transport mechanism will resolve the uucp
paths.  In this case it is not necessary to have Elm resolve
the paths on outbound mail addresses.

EOM
echo " "
rp="Should Elm resolve outbound addresses? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
y*) d_notouchadd="$undef";;
*)  d_notouchadd="$define";;
esac

case "$d_pafirst" in
"$define") dflt=y;;
"$undef")  dflt=n;;
*)       dflt=n;;
esac
if $test "$d_notouchadd" = "$undef"; then
    $cat <<EOM

When given a machine that you talk to directly, should the 'pathalias'
route to the machine be used instead?"
EOM
    echo " "
    rp="Would you like to use pathalias route instead? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
    y*) d_pafirst="$define";;
    *)  d_pafirst="$undef";;
    esac
else
    d_pafirst="$undef"
fi

if $test -f "$sendmail"; then
    echo "You're running sendmail.  Setting noaddfrom, nocheckvalid, usedomain"
    d_noaddfrom="$define"
    d_nocheckvalid="$define"
    d_usedomain="$undef"
elif $test -f "$submit"; then
    echo "You're running submit with MMDF.  Setting noaddfrom, nocheckvalid, usedomain"
    d_noaddfrom="$undef"
    d_nocheckvalid="$define"
    d_usedomain="$define"
else
    case "$d_nocheckvalid" in
    "$define") dflt=n;;
    "$undef")  dflt=y;;
    *)       dflt=y;;
    esac

    $cat << EOM

Since you're not running sendmail or submit, should I check local user entered
addresses against the valid mailboxes on this system?
EOM

    echo " "
    rp="Would you like to check local addresses? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
    y*) d_nocheckvalid="$undef";;
    *)  d_nocheckvalid="$define";;
    esac

    if $test "$d_internet" = "$define"; then
        case "$d_usedomain" in
        "$define") dflt=y;;
        "$undef")  dflt=n;;
        *)       dflt=y;;
        esac

        $cat <<EOM

Are you running a machine where you want to have a domain name appended
to the hostname on outbound mail?
EOM
        echo " "
        rp="Would you like the domain name appended? [$dflt]"
        $echo $n "$rp $c"
        . myread
        case "$ans" in
        y*) d_usedomain="$define";;
        *)  d_usedomain="$undef";;
        esac
    else
        d_usedomain="$undef"
        $cat <<EOM

Since your mailer does not understand internet addresses, undefining
usedomain, your domain name will not be appended to the hostname on
outbound mail.

EOM
    fi

    case "$d_noaddfrom" in
    "$define") dflt=y;;
    "$undef")  dflt=n;;
    *)       dflt=n;;
    esac
    echo " "
    rp="Does your mailer add the From: header for you? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
    y*) d_noaddfrom="$define";;
    *)  d_noaddfrom="$undef";;
    esac
fi

case "$d_noxheader" in
"$define") dflt=y;;
"$undef")  dflt=n;;
*)    dflt=n;;
esac
$cat <<EOM

Some sites do not like to see the mail header "X-mailer:" in outgoing
messages.  If you choose, you may disable these headers.  However, it
is strongly urged to leave these headers in the mail to assist in
tracking down problems.

EOM
rp="Would you like to disable the X-mailer: headers? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
y*) d_noxheader="$define";;
*)  d_noxheader="$undef";;
esac

: ask about optimizing return addresses
case "$d_optreturn" in
"$define")    dflt=y;;
"$undef")    dflt=n;;
*)        dflt=n;;
esac
echo " "
echo "Should I optimize the return address when you"
rp="'alias current message'? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
y*) d_optreturn="$define";;
*)  d_optreturn="$undef";;
esac

: check for "kill(pid, 0)"
echo " "
case "$d_pidcheck" in
"$define")    ;;
"$undef")    ;;
*)
        echo "Checking to see if kill(pid, 0) works..."
        $cat >try.c <<'EOCP'
main()
    {
    int    pid, status0, status9;

    if ((pid = fork()) == 0)
        {
        sleep(30);
        exit(1);
        }
    status0 = kill(pid, 0);
    status9 = kill(pid, 9);
    exit(status0 == status9);
    }
EOCP
        if $cc try.c -o try >/dev/null 2>&1 ; then
        if try >/dev/null 2>&1 ; then
            echo "Your system does not support kill(pid, 0)..."
            d_pidcheck="$undef"
        else
            d_pidcheck="$define"
            echo "Your system supports kill(pid, 0)..."
        fi
        else
        echo "Your system does not support kill(pid, 0)..."
        d_pidcheck="$undef"
        fi
        $rm -f try.c try.o try
    ;;
esac

: see if /usr/include/sys/ptem.h exists, making it a possible System V/386
d_ptem="$undef"
if usg ; then
    echo " "
    echo "Checking to see if your system has sys/ptem.h..."
    if $test -f /usr/include/sys/ptem.h ; then
        echo "Yep, it does..."
        if "$contains" "struct winsize" /usr/include/sys/ptem.h >/dev/null 2>&1 ; then
        d_ptem="$define"
        echo "  and it has the needed structure."
    fi
    fi
fi

: get remove at last flag and number of lock attempts
$cat <<EOM

The next pair of questions have to do with what to do when another
program has locked a mailbox...

First, how many times should the Elm check for the removal of the lock
file before giving up?
EOM

case "$maxattempts" in
    '') dflt=6;;
    *)  dflt=$maxattempts;;
esac
cont=true
while $test "$cont" ; do
    echo " "
    rp="Number of lock attempts: [$dflt]"
    $echo $n "$rp $c"
    . myread
    maxattempts="$ans"
    if $test "$maxattempts" -lt 3 -o "$maxattempts" -gt 10 ; then
    echo "The recommended range is 3-10"
    odflt=$dflt
    dflt=n
    rp="Should I use your answer of $maxattempts lock attempts anyway? [$dflt]"
    $echo $n "$rp $c"
    . myread
    dflt=$odflt
    case "$ans" in
    y*) cont='';;
    esac
    else
    cont=''
    fi
done

case "$d_remlock" in
"$define") dflt=y;;
"$undef")  dflt=n;;
*)       dflt=n;;
esac
echo " "
rp="Should it REMOVE the lockfile after $maxattempts checks? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
y*) d_remlock="$define";;
*)  d_remlock="$undef";;
esac

: see if rename exists
set rename d_rename
eval $inlibc

: see if sigvector exists -- since sigvec will match the substring
echo " "
if $contains sigvector libc.list >/dev/null 2>&1; then
    echo 'sigvector() found--you must be running HP-UX.'
    d_sigvectr="$define"
    d_sigvec="$define"
else
: try the original name
    d_sigvectr="$undef"
    if $contains sigvec libc.list >/dev/null 2>&1; then
    echo 'sigvec() found.'
    d_sigvec="$define"
    else
    echo 'sigvec() not found--race conditions with signals may occur.'
    d_sigvec="$undef"
    fi
fi

: see if strspn exists
echo " "
if $contains strspn libc.list >/dev/null 2>&1; then
    echo 'strspn() found.'
    d_strspn="$define"
else
    echo 'strspn() not found--will use our strspn instead.'
    d_strspn="$undef"
fi

: see if strcspn exists
echo " "
if $contains strcspn libc.list >/dev/null 2>&1; then
    echo 'strcspn() found.'
    d_strcspn="$define"
else
    echo 'strcspn() not found--will use our strcspn instead.'
    d_strcspn="$undef"
fi

case "$d_subshell" in
"$define") dflt=y;;
"$undef")  dflt=n;;
*)    dflt=y;;
esac
$cat <<EOM

Some sites wish to disable the usage of the shell escape from Elm.
If you choose, you can not allow subshells from withing Elm.

Note: This only controls Elms usage of the ! command.  Any pager or
editor could still allow subshells.

EOM
rp="Would you like to allow the ! command (subshells)? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
y*) d_subshell="$define";;
*)  d_subshell="$undef";;
esac

: see if tempnam exists
echo " "
if $contains tempnam libc.list >/dev/null 2>&1; then
    echo 'tempnam() found.'
    d_tempnam="$define"
else
    echo 'tempnam() not found--will use our tempnam instead.'
    d_tempnam="$undef"
fi

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

: get C preprocessor symbols handy
echo " "
echo $attrlist | $tr '[ - ]' '[\012-\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-\012]' | $sed -e 's/\(.*\)/\\
#ifdef \1\\
exit 0; _ _ _ _\1\\     \1\\
#endif\\
/' >/tmp/Cppsym\$\$
echo exit 1 >>/tmp/Cppsym\$\$
$cppstdin $cppminus </tmp/Cppsym\$\$ >/tmp/Cppsym2\$\$
case "\$list" in
true) awk 'NF > 5 {print substr(\$6,2,100)}' </tmp/Cppsym2\$\$ ;;
*)
    sh /tmp/Cppsym2\$\$
    status=\$?
    ;;
esac
$rm -f /tmp/Cppsym\$\$ /tmp/Cppsym2\$\$
exit \$status
EOSS
chmod +x Cppsym
$eunicefix Cppsym
echo "Your C preprocessor defines the following symbols:"
Cppsym -l $attrlist >Cppsym.true
cat Cppsym.true
rmlist="$rmlist Cppsym Cppsym.know Cppsym.true"

: see if this is a termio system
: Prefer POSIX-approved termios.h over all else.
:
echo " "
d_termios="$undef"
d_termio="$undef"
if $test -r /usr/include/termios.h ; then
    set tcsetattr d_termios
    eval $inlibc
fi
if $test "$d_termios" = "$define" ; then
    echo "You have POSIX termios.h... good!"
elif Cppsym pyr ; then
    if $test "`/bin/universe`" = "ucb" ; then
    if $test -r /usr/include/sgtty.h ; then
        echo "sgtty.h found."
    else
        echo "System is a pyramid, and universe is bsd,"
        echo "sgtty.h not found--you could have problems."
    fi
    else
    if $test -r /usr/include/termio.h ; then
        d_termio="$define"
        echo "termio.h found."
    else
        echo "System is a pyramid, and universe is att,"
        echo "termio.h not found--you could have problems."
    fi
    fi
elif bsd ; then
    if $test -r /usr/include/sgtty.h ; then
    echo "sgtty.h found."
    elif $test -r /usr/include/termio.h ; then
    d_termio="$define"
    echo "termio.h found."
    else
    echo "Neither termio.h nor sgtty.h found--you could have problems."
    fi
else
    if $test -r /usr/include/termio.h ; then
    d_termio="$define"
    echo "termio.h found."
    elif $test -r /usr/include/sgtty.h ; then
    echo "sgtty.h found."
    else
    echo "Neither termio.h nor sgtty.h found--you could have problems."
    fi
fi

: see if we should include time.h, sys/time.h, or both
cat <<'EOM'

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

timeincl=""
if $test "$i_time" = define ; then
    timeincl="/usr/include/time.h"
fi
if $test "$i_systime" = define ; then
    timeincl="$timeincl /usr/include/sys/time.h"
fi
$cat $timeincl /dev/null | $cppstdin $cppminus > try.c 2>&1
if $contains 'tz_minuteswest' try.c > /dev/null 2>&1 ; then
    echo "You have tz_minuteswest defined in $timeincl rather than timezone."
    d_tz_min="$define"
else
    echo "You have timezone defined in $timeincl rather than tz_minuteswest."
    d_tz_min="$undef"
fi
$rm -f try.c
: check for valid reply/to fields
case "$d_useembed" in
"$define")    dflt=y;;
"$undef")    dflt=n;;
*)            if $test "$d_internet" = "$define" ; then
                dflt=y
            else
                dflt=n
            fi
            ;;
esac
$cat <<EOM

One of the more annoying quirks of the UUCP network and various other
systems that interact with it are that everyone seems to have different
ideas about how to do routing, etc.  Therefore, a lot of times email
will arrive from offsite with corrupt, unreply-able "Reply-To:" and
"From:" fields.  This next question relates to whether your site is
liable to get mangled fields or not...

Does your site receive email with valid "Reply-To:" and "From:" fields?

EOM
$echo $n "Use Reply-To: and From: addresses? [$dflt] $c"
rp="Are Reply-to: and From: addresses reliable? [$dflt]"
. myread
case "$ans" in
y*) d_useembed="$define";;
*)  d_useembed="$undef";;
esac

: check for utimbuf structure
echo " "
case "$d_utimbuf" in
"$define")    ;;
"$undef")    ;;
*)
: Pyramid passes the att compile test but still needs the definition
    if Cppsym pyr ; then
        if $test "`/bin/universe`" = "att" ; then
        d_utimbuf="$define"
        echo "I will use my 'utimbuf' structure..."
            fi
        fi
    if $test "$d_utimbuf" != "$define"; then
        echo "Checking to see if struct utimbuf exists."
        $cat >try.c <<'EOCP'
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#define far /* to keep XENIX from complaining */
#include <sys/file.h>
#include <time.h>
main()
{
struct utimbuf test;
test.actime = 0;
exit(1);
}
EOCP
        if $cc try.c -o try >/dev/null 2>&1 ; then
        d_utimbuf="$undef"
        echo "You have the 'utimbuf' structure..."
        else
        echo "I will use my 'utimbuf' structure..."
        d_utimbuf="$define"
        fi
        $rm -f try.c try.o try
    fi
    ;;
esac

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

: see if signal is declared as pointer to function returning int or void
echo " "
$cppstdin $cppflags < /usr/include/signal.h >$$.tmp
if $contains 'int.*signal' $$.tmp >/dev/null 2>&1 ; then
    echo "You have int (*signal())() instead of void."
    d_voidsig="$undef"
elif $contains 'void.*signal' $$.tmp >/dev/null 2>&1 ; then
    echo "You have void (*signal())() instead of int."
    d_voidsig="$define"
elif $contains 'extern[     ]*[(\*]*signal' $$.tmp >/dev/null 2>&1 ; then
    echo "You have int (*signal())() instead of void."
    d_voidsig="$undef"
elif $test -n "$d_voidsig"; then
    echo $n "As you already told me, signal handlers return "
    if $test "$d_voidsig" = "$define"; then
    echo void
    else
    echo int
    fi
else
    echo "I can't determine whether signal handlers return void or int..."
    echo "I'm assuming they return void like ANSI and POSIX want."
    echo "If not, you will have to change d_voidsig from $define to $undef"
    echo "in config.sh at the edit question at the end of Configure"
    d_voidsig="$define"
fi
rm -f $$.tmp

: get user and system aliases sizes
$cat <<EOM

The number of aliases allowed for users of the Elm system can vary
based on system speed and memory available.  If you have a fast system
and/or a lot of memory you can enter a fairly large number of aliases
for the next two questions...if not, you'll probably want to enter the
suggested small-system values.  (This applies to the speed of the
swapping on your system too - if you're on a FAST system, use the big
values!)

First, how many aliases should be allowed for an individual user?
The suggested values are 503 for blindly fast systems,
251 for average systems and 127 for slow systems.
EOM

case "$maxuseralias" in
    '') dflt=251;;
    *)  dflt=$maxuseralias;;
esac
cont=true
while $test "$cont" ; do
    echo " "
    rp="Number of user aliases: [$dflt]"
    $echo $n "$rp $c"
    . myread
    maxuseralias="$ans"
    if $test "$maxuseralias" -lt 50 -o "$maxuseralias" -gt 1000 ; then
    $cat <<EOM
Pretty strange answer!  I think you should reconsider and try a number
from the range 50-1000.
EOM
    odflt=$dflt
    if $test "$fastread" = yes; then
        dflt=y
    else
        dflt=n
    fi
    rp="Should I use your answer of $maxuseralias user aliases anyway? [$dflt]"
    $echo $n "$rp $c"
    . myread
    dflt=$odflt
    case "$ans" in
    y*) cont='';;
    esac
    else
    cont=''
    fi
done

case "$maxsysalias" in
    '') case "$maxuseralias" in
    127) dflt=223;;
    503) dflt=739;;
    *  ) dflt=503;;
    esac
    ;;
    *)  dflt=$maxsysalias;;
esac
cont=true
while $test "$cont" ; do
    echo " "
    rp="Maximum number of system aliases: [$dflt]"
    $echo $n "$rp $c"
    . myread
    maxsysalias="$ans"
    if $test "$maxsysalias" -lt 50 -o "$maxsysalias" -gt 1000 ; then
    $cat <<EOM
Pretty strange answer!  I think you should reconsider and try a number
from the range 50-1000.
EOM
    odflt=$dflt
    if $test "$fastread" = yes; then
        dflt=y
    else
        dflt=n
    fi
    rp="Should I use your answer of $maxsysalias system aliases anyway? [$dflt]"
    $echo $n "$rp $c"
    . myread
    dflt=$odflt
    case "$ans" in
    y*) cont='';;
    esac
    else
    cont=''
    fi
done
elmalias="$maxsysalias"

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

: see if symlink exists
set symlink d_symlink
eval $inlibc

: get default batch subject
$cat <<EOM

Elm will provide a default subject for mail messages that are sent
in batch mode (redirected from a file.)
EOM

case "$defbatsub" in
    '') dflt='no subject (file transmission)';;
    *)  dflt=$defbatsub;;
esac
echo " "
rp="Default batch subject: [$dflt]"
$echo $n "$rp $c"
. myread
defbatsub="$ans"

: determine default editor
case "$defeditor" in
'')
    case "$_vi" in
    */*) dflt="$_vi";;
    *) dflt=/usr/ucb/vi;;
    esac
    ;;
*)  dflt="$defeditor"
    ;;
esac
cont=true
while $test "$cont" ; do
    echo " "
    rp="What is the default editor on your system? [$dflt]"
    $echo $n "$rp $c"
    . myread
    defeditor="$ans"
    if $test -f $ans; then
    cont=''
    else
    if $test "$fastread" = yes; then
        dflt=y
    else
        dflt=n
    fi
    rp="File $ans doesn't exist.  Use that name anyway? [$dflt]"
    $echo $n "$rp $c"
    . myread
    dflt=''
    case "$ans" in
    y*) cont='';;
    esac
    fi
done

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

: ask the preferred line printer and options for this system.
case "$linepr" in
'')
    if $test -f "$lp"; then
    dflt="$lp"
    elif $test -f "$lpr"; then
    dflt="$lpr"
    else
    dflt=
    fi
    ;;
*)  dflt="$linepr";;
esac

linepr='blurfl/dyick'
$cat <<EOM

Elm has an option to send messages to the printer.  This question
asks for the default spooler name.  You can also specify options
to the command by separating them from the command by at least one space.

EOM
cont=true
while $test "$cont" ; do
    rp="What print spooler do you prefer to use with Elm? [$dflt]"
    $echo $n "$rp $c"
    . myread
    linepr="$ans"
    ans=`$expr "$linepr" : "\([^ ]*\).*"`
    case "$ans" in
    /*)
    if $test -f "$ans"; then
        cont=''
    else
        if $test "$fastread" = yes; then
        dflt=y
        else
        dflt=n
        fi
        rp="File $ans doesn't exist.  Use that name anyway? [$dflt]"
        $echo $n "$rp $c"
        . myread
        case "$ans" in
        y*) cont='';;
        esac
    fi
    ;;
    *)
    echo "Please give the full path name."
    ;;
    esac
done

: determine where mail is spooled
case "$maildir" in
'')
    dflt=`loc . /usr/spool/mail /usr/spool/mail /usr/mail`
    ;;
*)  dflt="$maildir"
    ;;
esac
cont=true
while $test "$cont" ; do
    echo " "
    rp="Where is yet-to-be-read mail spooled? [$dflt]"
    $echo $n "$rp $c"
    . myread
    maildir=`filexp "$ans"`
    if test -d $maildir; then
    cont=''
    else
    if $test "$fastread" = yes; then
        dflt=y
    else
        dflt=n
    fi
    rp="Directory $maildir doesn't exist.  Use that name anyway? [$dflt]"
    $echo $n "$rp $c"
    . myread
    dflt=''
    case "$ans" in
    y*) cont='';;
    esac
    fi
done

: ask about setgid running of Elm
case "$d_setgid" in
"$define")    dflt=y;;
"$undef")    dflt=n;;
*)        dflt=y;;
esac
echo " "
rp="Am I going to be running as a setgid program? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
y*) d_setgid="$define";;
*)  d_setgid="$undef";;
esac
case "$d_setgid" in
"$define")    mailermode=2755;;
*)        mailermode=755;;
esac

: determine the group of the mail directory- what group elm should use
mailgrp=`$ls -lgd $maildir`
mailgrp=`$expr "$mailgrp" : "[ld][rwxstS-]*[ 0123456789]*\(.*\)"`
: now mailgrp is either    user group size mon day time/year name
: or                       group size mon day time/year name
try1=`$expr "$mailgrp" : "[A-Za-z_0-9]* *\([A-Za-z_0-9]*\).*"`
try1a=`$expr "$try1" : "\([0-9]*\).*"`
if $test "$try1" = "$try1a"; then
    mailgrp=`$expr "$mailgrp" : "\([A-Za-z_0-9]*\).*"`
else
    mailgrp="$try1"
fi
case "$mailgrp" in
'')
    mailgrp=mail
    ;;
esac
echo " "
echo "Mail group is $mailgrp"

: ask the preferred pager for this system.
case "$pager" in
'') dflt="builtin+";;
*)  dflt="$pager";;
esac

pager='blurfl/dyick'
echo " "
cont=true
while $test "$cont" ; do
    rp="What pager do you prefer to use with $package? [$dflt]"
    $echo $n "$rp $c"
    . myread
    pager="$ans"
    case "$ans" in
    builtin)
        cont=''
    ;;
    builtin+)
        cont=''
    ;;
    /*)
    if $test -f "$ans"; then
        cont=''
    else
        if $test "$fastread" = yes; then
        dflt=y
        else
        dflt=n
        fi
        rp="File $ans doesn't exist.  Use that name anyway? [$dflt]"
        $echo $n "$rp $c"
        . myread
        case "$ans" in
        y*) cont='';;
        esac
    fi
    ;;
    *)
    echo "Please give the full path name."
    ;;
    esac
done

: find out which shell people like to use most
case "$prefshell" in
'')
    if $test -f /bin/ksh; then
    dflt='/bin/ksh'
    elif $test -f /bin/csh; then
    dflt='/bin/csh'
    else
    dflt='/bin/sh'
    fi
    ;;
*)  dflt="$prefshell";;
esac
cont=true
while $test "$cont" ; do
    echo " "
    echo "Give the full path name of the shell most people like to use on your"
    $echo $n "system: [$dflt] $c"
    rp="Preferred shell: [$dflt]"
    . myread
    prefshell=$ans
    if test -f $ans; then
    cont=''
    else
    if $test "$fastread" = yes; then
        dflt=y
    else
        dflt=n
    fi
    rp="File $ans doesn't exist.  Use that name anyway? [$dflt]"
    $echo $n "$rp $c"
    . myread
    dflt=''
    case "$ans" in
    y*) cont='';;
    esac
    fi
done

: determine the name of the tape device
rmttape=`loc rct0 "" /dev`
if $test -z "$rmttape"; then
    rmttape=`loc rmt0 "" /dev`
fi
if $test -z "$rmttape"; then
    rmttape=`loc rtp0 "unknown-remote-tape-unit" /dev`
fi
echo "remote tape drive is $rmttape"
echo " "
: where do we get termlib routines from
echo " "
ans=`loc libcurses.a x $libpth`
if $test "$ans" = x; then
    ans=`loc Slibcurses.a x $libpth`
fi
case "$ans" in
/*)
    ar t $ans >grimble
    if $contains tputs.o grimble >/dev/null 2>&1; then
    termlib='-lcurses'
    d_havetlib="$define"
    echo "Terminfo library found."
    else
    ans=x
    fi
    rm -f grimble
    ;;
esac
case "$ans" in
x)
    ans=`loc libtermlib.a x $libpth`
    if $test "$ans" = x; then
    ans=`loc Slibtermlib.a x $libpth`
    fi
    case "$ans" in
    /usr/lib*|/lib*)
    termlib='-ltermlib'
    d_havetlib="$define"
    echo "Termlib library found."
    ;;
    /*)
    termlib="$ans"
    d_havetlib="$define"
    echo "Termlib library found."
    ;;
    *)
    ans=`loc libtermcap.a x $libpth`
    if $test "$ans" = x; then
        ans=`loc Slibtermcap.a x $libpth`
    fi
    case "$ans" in
    /usr/lib*|/lib*)
        termlib='-ltermcap'
        d_havetlib="$define"
        echo "Termcap library found."
        ;;
    /*)
        termlib="$ans"
        d_havetlib="$define"
        echo "Termcap library found."
        ;;
    *)
        case "$termlib" in
        '')
        dflt=y
        rp="Your system appears to NOT have termlib-style routines.  Is this true? [$dflt]"
        $echo $n "$rp $c"
        . myread
        case "$ans" in
            n*|f*) d_havetlib="$define"
              echo "Then where are the termlib-style routines kept (specify either -llibname"
              $echo $n " or full pathname (~name ok))? $c"
              rp='Specify termlib:'
              . myread
              termlib=`filexp $ans`
              ;;
            *)    d_havetlib="$undef"
              termlib=''
              echo "You will have to play around with term.c then."
              ;;
        esac
        echo " "
        ;;
        *)  echo "You said termlib was $termlib before."
        ;;
        esac
        ;;
    esac
    ;;
    esac
    ;;
esac

: determine where temporary files should go
case "$tmpdir" in
'')
    dflt=`loc . "." "/tmp /usr/tmp"`
    ;;
*)  dflt="$tmpdir"
    ;;
esac
if $test -d "$tmpdir" -a "$tmpdir" != ""; then
    $echo " "
    $echo "Temporary files will be put in the $tmpdir directory"
else
    cont=true
    while $test "$cont" ; do
        $echo " "
        rp="Where do you want to put the temporary files? [$dflt]"
        $echo $n "$rp $c"
        . myread
        tmpdir="$ans"
        tmpdir=`filexp $tmpdir`
        if $test -d "$tmpdir" -a "$tmpdir" != ""; then
        cont=''
        else
        if $test "$fastread" = yes; then
            dflt=y
        else
            dflt=n
        fi
        rp="Directory $tmpdir doesn't exist.  Use that name anyway? [$dflt]"
        $echo $n "$rp $c"
        . myread
        dflt=''
        case "$ans" in
        y*) cont='';;
        esac
        fi
    done
fi

: if pmake exists, allow its use for parallel make

if $test -f "$pmake" ; then
    case "$use_pmake" in
    n)  dflt=n;;
    *)  dflt=y;;
    esac

    $cat <<EOM

The executable file pmake was found on this system.  Usually this
file indicates a parallel make, which executes much faster.  Should
this system use the pmake command as its make command?

EOM
    rp="Does this system use pmake as its make? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
    y*) use_pmake=y
        make="$pmake";;
    *)  use_pmake=n;;
    esac
else
    use_pmake=n
fi
echo " "
echo "End of configuration questions."
echo " "

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

define='$define'
eunicefix='$eunicefix'
Log='$Log'
Header='$Header'
bin='$bin'
byteorder='$byteorder'
contains='$contains'
cppstdin='$cppstdin'
cppminus='$cppminus'
d_crypt='$d_crypt'
cryptlib='$cryptlib'
d_getopt='$d_getopt'
d_havetlib='$d_havetlib'
termlib='$termlib'
d_mkdir='$d_mkdir'
d_rename='$d_rename'
d_sigvec='$d_sigvec'
d_sigvectr='$d_sigvectr'
d_symlink='$d_symlink'
d_vfork='$d_vfork'
d_whoami='$d_whoami'
defeditor='$defeditor'
hostname='$hostname'
phostname='$phostname'
mydomain='$mydomain'
i_time='$i_time'
i_systime='$i_systime'
d_systimekernel='$d_systimekernel'
maildir='$maildir'
n='$n'
c='$c'
package='$package'
pager='$pager'
prefshell='$prefshell'
spitshell='$spitshell'
shsharp='$shsharp'
sharpbang='$sharpbang'
startsh='$startsh'
d_eunice='$d_eunice'
loclist='$loclist'
expr='$expr'
sed='$sed'
echo='$echo'
cat='$cat'
rm='$rm'
mv='$mv'
cp='$cp'
tail='$tail'
tr='$tr'
mkdir='$mkdir'
sort='$sort'
uniq='$uniq'
grep='$grep'
trylist='$trylist'
test='$test'
inews='$inews'
egrep='$egrep'
more='$more'
pg='$pg'
Mcc='$Mcc'
vi='$vi'
mailx='$mailx'
mail='$mail'
cpp='$cpp'
perl='$perl'
emacs='$emacs'
ls='$ls'
rmail='$rmail'
sendmail='$sendmail'
shar='$shar'
smail='$smail'
submit='$submit'
tbl='$tbl'
troff='$troff'
nroff='$nroff'
uname='$uname'
uuname='$uuname'
line='$line'
chgrp='$chgrp'
chmod='$chmod'
lint='$lint'
sleep='$sleep'
pr='$pr'
tar='$tar'
ln='$ln'
lpr='$lpr'
lp='$lp'
touch='$touch'
make='$make'
date='$date'
csh='$csh'
pmake='$pmake'
c_date='$c_date'
d_ascii='$d_ascii'
d_calendar='$d_calendar'
calendar='$calendar'
d_cuserid='$d_cuserid'
d_flock='$d_flock'
d_flockonly='$d_flockonly'
lock_dir='$lock_dir'
d_gethname='$d_gethname'
d_douname='$d_douname'
d_phostname='$d_phostname'
d_host_comp='$d_host_comp'
ign_hname='$ign_hname'
d_havedbm='$d_havedbm'
dbm='$dbm'
d_index='$d_index'
d_internet='$d_internet'
d_mboxedit='$d_mboxedit'
d_mmdf='$d_mmdf'
d_newauto='$d_newauto'
d_nfs='$d_nfs'
d_networkorder='$d_networkorder'
d_noxheader='$d_noxheader'
d_optreturn='$d_optreturn'
d_pafirst='$d_pafirst'
d_notouchadd='$d_notouchadd'
d_noaddfrom='$d_noaddfrom'
d_usedomain='$d_usedomain'
d_nocheckvalid='$d_nocheckvalid'
d_pidcheck='$d_pidcheck'
d_portable='$d_portable'
d_ptem='$d_ptem'
d_remlock='$d_remlock'
maxattempts='$maxattempts'
d_setgid='$d_setgid'
mailermode='$mailermode'
d_strcspn='$d_strcspn'
d_strspn='$d_strspn'
d_strings='$d_strings'
d_pwdinsys='$d_pwdinsys'
strings='$strings'
includepath='$includepath'
d_subshell='$d_subshell'
d_tempnam='$d_tempnam'
tempnamo='$tempnamo'
tempnamc='$tempnamc'
d_termio='$d_termio'
d_termios='$d_termios'
d_tz_min='$d_tz_min'
d_useembed='$d_useembed'
d_utimbuf='$d_utimbuf'
d_voidsig='$d_voidsig'
defbatsub='$defbatsub'
elmalias='$elmalias'
maxsysalias='$maxsysalias'
maxuseralias='$maxuseralias'
lib='$lib'
libc='$libc'
linepr='$linepr'
mailer='$mailer'
mailgrp='$mailgrp'
mansrc='$mansrc'
manext='$manext'
models='$models'
split='$split'
small='$small'
medium='$medium'
large='$large'
huge='$huge'
optimize='$optimize'
ccflags='$ccflags'
cppflags='$cppflags'
ldflags='$ldflags'
cc='$cc'
libs='$libs'
nametype='$nametype'
d_passnames='$d_passnames'
d_berknames='$d_berknames'
d_usgnames='$d_usgnames'
passcat='$passcat'
pathalias='$pathalias'
domains='$domains'
rmttape='$rmttape'
roff='$roff'
tmpdir='$tmpdir'
use_pmake='$use_pmake'
xencf='$xencf'
xenlf='$xenlf'
d_xenix='$d_xenix'
d_bsd='$d_bsd'
CONFIG=true
EOT

CONFIG=true

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

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

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

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

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

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