Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/1/1344/Configure

Text File | 1990-12-28 | 33.5 KB | 1,600 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: Head.U,v 2.0 88/06/28 23:13:13 lwall Locked $
#
# Yes, you may rip this off to use in other distribution packages.
# (Note: this Configure script was generated automatically.  Rather than
# working with this copy of Configure, you may wish to get metaconfig.)

: sanity checks
PATH='.:/bin:/usr/bin:/usr/local/bin:/usr/ucb:/usr/local:/usr/lbin:/etc:/usr/new:/usr/new/bin:/usr/nbin'
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

:
: Loop through all commandline parameters
:

while test $# != 0 ; do
    case "$1" in
    -d) shift; fastread='yes';;
    -f) shift; f_flag='yes' ;;
    *) echo "Warning : I don't understand parameter \"$1\"."; shift;;
    esac
done
d_eunice=''
eunicefix=''
loclist=''
expr=''
sed=''
echo=''
cat=''
rm=''
mv=''
cp=''
tail=''
tr=''
mkdir=''
sort=''
uniq=''
grep=''
trylist=''
test=''
inews=''
egrep=''
more=''
pg=''
Mcc=''
vi=''
mailx=''
mail=''
cpp=''
perl=''
contains=''
d_bcopy=''
d_charsprf=''
d_index=''
d_memcpy=''
libc=''
mansrc=''
manext=''
models=''
split=''
small=''
medium=''
large=''
huge=''
ccflags=''
ldflags=''
cc=''
n=''
c=''
package=''
spitshell=''
shsharp=''
sharpbang=''
startsh=''
define=''
cppstdin=''
cppminus=''
d_intfree=''
d_reread=''
d_termio=''
systermio=''
look4char=''
use_select=''
use_rdchk=''
use_fionread=''
wait4char=''
CONFIG=''
: set package name
package=KEF

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

define='define'
undef='undef'
libpth='/usr/lib /usr/local/lib /lib'
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

if test "X$f_flag" = "X" ; then
    echo "First let's make sure your kit is complete.  Checking..."
    : mg : original test does not work for NFS
    current=`pwd`
    cd ..
    missing=""
    for i in `awk 'NR>2{print $1}' MANIFEST` ; do
        if test ! \( -f $i -o -d $i \) ; then
            missing="$missing $i"
        fi
    done
    if test "X$missing" != "X" ; then
        echo "The following files are missing : $missing"
        exit 1
    fi
    echo " "
    cd $current
fi
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"
pth="/usr/ucb /bin /usr/bin /usr/local /usr/local/bin /usr/lbin /etc /usr/lib /lib /usr/local/lib"
d_newshome="/usr/NeWS"
defvoidused=7

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

: first determine how to suppress newline on echo command
echo "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.  This script was generated by "metaconfig" written by
Larry Wall ([e-mail]), but any errors are probably
mine, not his.  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="
expr
sed
echo
cat
rm
tr
grep
"
trylist="
test
Mcc
cpp
"
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"

: get list of predefined functions in a handy place
echo " "
if test -f /lib/libc.a; then
    echo "Your C library is in /lib/libc.a.  You're normal."
    libc=/lib/libc.a
else
    ans=`loc libc.a blurfl/dyick $libpth`
    if test ! -f $ans; then
    ans=`loc clib blurfl/dyick $libpth`
    fi
    if test ! -f $ans; then
    ans=`loc libc blurfl/dyick $libpth`
    fi
    if test -f $ans; then
    echo "Your C library is in $ans, of all places."
    libc=$ans
    else
    if test -f "$libc"; then
        echo "Your C library is in $libc, like you said before."
    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
fi
echo " "
$echo $n "Extracting names from $libc for later perusal...$c"
nm $libc 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/^.* 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
    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
        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
        echo "Ok."
        else
            echo "That didn't work either.  Giving up."
            exit 1
        fi
    fi
    fi
fi
rmlist="$rmlist libc.tmp libc.list"

: make some quick guesses about what we are up against
echo " "
$echo $n "Hmm...  $c"
if $contains SIGTSTP /usr/include/signal.h >/dev/null 2>&1 ; then
    echo "Looks kind of like a BSD system, but we'll see..."
    echo exit 0 >bsd
    echo exit 1 >usg
    echo exit 1 >v7
elif $contains '^fcntl$' libc.list >/dev/null 2>&1 ; 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
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
if $contains '^vmssystem$' libc.list >/dev/null 2>&1 ; then
    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
    eunicefix=unixtovms
    d_eunice="$define"
: it so happens the Eunice I know will not run shell scripts in Unix format
else
    echo " "
    echo "Congratulations.  You aren't running Eunice."
    eunicefix=':'
    d_eunice="$undef"
    echo "exit 1" >eunice
fi
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
rmlist="$rmlist bsd usg v7 eunice venix xenix"

: 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

: see if bcopy exists
echo " "
if $contains '^bcopy$' libc.list >/dev/null 2>&1; then
    echo 'bcopy() found.'
    d_bcopy="$define"
else
    echo 'bcopy() not found.'
    d_bcopy="$undef"
fi

: 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 manual pages go
case "$mansrc" in
'')
    dflt=`loc . /usr/man/man1 /usr/man/mann /usr/man/manl /usr/man/local/man1 /usr/man/u_man/man1 /usr/man/man1`
    ;;
*)  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
    dflt=n
    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
    ;;
*C)
    manext=C
    ;;
*)
    manext=1
    ;;
esac

: see what memory models we can support
case "$models" in
'')
    : We may not use Cppsym or we get a circular dependency through cc.
    : But this should work regardless of which cc we eventually use.
    cat >pdp11.c <<'EOP'
main() {
#ifdef pdp11
    exit(0);
#else
    exit(1);
#endif
}
EOP
    cc -o pdp11 pdp11.c >/dev/null 2>&1
    if pdp11 2>/dev/null; then
    dflt='unsplit split'
    else
    ans=`loc . X /lib/small /lib/large /usr/lib/small /usr/lib/large /lib/medium /usr/lib/medium /lib/huge`
    case "$ans" in
    X) dflt='none';;
    *)  if $test -d /lib/small || $test -d /usr/lib/small; then
        dflt='small'
        else
        dflt=''
        fi
        if $test -d /lib/medium || $test -d /usr/lib/medium; then
        dflt="$dflt medium"
        fi
        if $test -d /lib/large || $test -d /usr/lib/large; then
        dflt="$dflt large"
        fi
        if $test -d /lib/huge || $test -d /usr/lib/huge; then
        dflt="$dflt huge"
        fi
    esac
    fi
    ;;
*)  dflt="$models" ;;
esac
$cat <<EOM

Some systems have different model sizes.  On most systems they are called
small, medium, large, and huge.  On the PDP11 they are called unsplit and
split.  If your system doesn't support different memory models, say "none".
If you wish to force everything to one memory model, say "none" here and
put the appropriate flags later when it asks you for other cc and ld flags.
Venix systems may wish to put "none" and let the compiler figure things out.
(In the following question multiple model names should be space separated.)

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

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

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

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

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

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

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

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

: see if memcpy exists
echo " "
if $contains '^memcpy$' libc.list >/dev/null 2>&1; then
    echo 'memcpy() found.'
    d_memcpy="$define"
else
    echo 'memcpy() not found.'
    d_memcpy="$undef"
fi

$echo " "
cat << EOM
Does "read" restart when interrupted ?
This is the default behaviour on e.g. BSD4.3 and SUN OS 3.5.

I am now compiling and running a test program to determine the default
EOM
$echo $n "for your system. Just a few seconds ..."

$cat >tread.c <<'-stop-here-'
/*
 * Test whether "read" restarts when interrupted by a signal,
 * or whether it returns an error code.
 * Returns:
 * 0 : read restarts
 * 1 : read returns error code
 * 2 : some error
 *
 * Don't use "wait" and "SIGCHLD". What with "wait" and "wait3" or even
 * "wait4" and SYS V's "SIGCLD" braindamage ..
 */
#include <stdio.h>
#include <errno.h>
#include <signal.h>

#define    SECS    5        /* how long to wait before interrupting */

int pid;
extern int errno;

ignore (n)
    int n;
{
    signal (SIGINT, ignore);        /* be on the safe side */
}

intr2 (n)
    int n;
/*
 * This routine gets called by "alarm", if read does not return.
 * Kind of an emergency break.
 */
{
    exit (0);
}

intr1 (n)
    int n;
{
    signal (SIGALRM, intr2);
    alarm (SECS);
    kill (getpid (), SIGINT);
}

main (argc, argv)
    int argc;
    char ** argv;
{
    int i, err;
    char buf [80];

    signal (SIGINT, ignore);
    signal (SIGALRM, intr1);
    alarm (5);
    for (;;) {
        /*
         * Loop : stupid user may type something. Only exit on EINTR.
         */
        i = read (fileno(stdin), buf, 80);
        if (i == -1) {
            err = errno;
            if (err == EINTR)
                exit (1);
        }
    }
    /* not reached */
}
-stop-here-

dflt="yes"
if $cc tread.c >.out 2>&1 ; then
    a.out
    rp=$?
    if $test "X$rp" = "X1" ; then
        dflt="no"
    else
        dflt="yes"
    fi
    $rm a.out
else
    dflt="none"
fi
$echo " done."
$rm tread.c .out

tmp="no"
while $test "X$tmp" = "Xno" ; do
    rp="Does 'read' restart ? [$dflt]"
    $echo $n "$rp $c"
    . myread
    tmp=yes
    case "$ans" in
        y*)    d_reread="define" ;;
        n*)    d_reread="undef" ;;
        *)    echo "Answer yes or no" ; tmp="no";;
    esac
done
: 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

num=0
#
# mg 24-apr-90
# The following stuff was difficult to look over. Unrolled into a while
# loop instead of nested "if"s
#
while test "$num" != 100 ; do
    case "$num" in
    0)    echo '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 "Yup, it does."
            cppstdin="$cc -E"
            cppminus=''
            num=100
        else
            num=1
        fi
        ;;
    1)    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=''
            num=100
        else
            num=2
        fi
        ;;
    2)    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='-';
            num=100
        else
            num=3
        fi
        ;;
    3)    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='-';
            num=100
        else
            num=4
        fi
        ;;
    4)    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='';
            num=100
        else
            num=5
        fi
        ;;
    5) 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='-';
            num=100
        else
            num=6
        fi
        ;;
    6)    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."
            num=100
        else
            num=7
        fi
        ;;
    7)    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."
            num=100
        else
            num=8
        fi
        ;;
    8)    echo 'Uh-uh.  Time to get fancy...'
        cd ..
        echo 'Trying shell script.'
cat > cppstdin << 'GROK meets BC'
: use /bin/sh
# gnowb'd cpp  v1.3  14.jul.88   by mg
#
# usage :: my_cpp [option] ... [file] ...
# only 0, 1 or 2 files, parameters start with a '-'
#
# run over the parameters, gather them in two
# strings : pars and files
#
# use "cc -E" instead of "cpp"; it inserts lines starting with "#"
#
pars=''
files=''
j=0
for i in $*
do
    case $i in
    -*)        pars="$pars $i" ;;
    *)        files="$files $i" ; j=`expr $j + 1` ;;
    esac
done
f=/tmp/CPP$$.c
case "$j" in
    0 )    cat > $f ;
        set "$pars $f" ;
        cc -E $@ ;
        /bin/rm -f $f ;;
    1 ) set "$pars $files";
        cc -E $@;;
    2 ) set "$files";
        from=$1;
        to=$2;
        set "$pars $1";
        cc -E $@ > $2;;
    * )    echo "cpp :: too much file parameter" >&- >&2 ;
        exit 1 ;;
esac
exit 0
GROK meets BC
        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!."
            num=100
        else
            echo "Sorry, I can't get that to work.  Go find one."
            exit 1
        fi
        ;;
    esac
done
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, and if, remember where the header file is
echo " "
systermio="$undef"
d_termio="$undef"
if Cppsym pyr && $test -r /usr/include/sgtty.h ; then
    echo "sgtty.h found."
elif $test -r /usr/include/termio.h -o -r /usr/include/sys/termio.h ; then
       echo "termio.h found."
    if $test -r /usr/include/sgtty.h ; then
        $echo "sgtty.h found too"
        $echo " "
        dflt="termio"
        rp="You have both stty and termio. What should I use ? [$dflt]"
        $echo $n "$rp $c"
        . myread
        case "$ans" in
        stty)    d_termio="$undef" ;;
        termio)    d_termio="$define" ;;
        esac
    fi
    if $test "X$d_termio" = "X$define" ; then
        if $test -r /usr/include/sys/termio.h ; then
            systermio="$define"
        fi
    fi
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
: Ask the user !
$echo " "
dflt="void"
cat << EOM
What method should be used to look whether characters are waiting from
a terminal?
Type one of the following numbers to select the corresponding method.

1 : select
2 : rdchk
3 : fionread

EOM

tmp="no"
while $test "X$tmp" = "Xno" ; do
    rp="What routine should I use ?"
    $echo $n "$rp $c"
    . myread
    tmp=yes
    case "$ans" in
        1)    look4char="USE_SELECT" ;;
        2)    look4char="USE_RDCHK" ;;
        3)    look4char="USE_FIONREAD" ;;
        *)    echo "Choose one from 1 through 3" ; tmp="no";;
    esac
done
: Ask the user !
$echo " "
dflt="void"
cat << EOM
How should your program wait for a character from a terminal ?
Enter

1 : select
2 : rdchk

EOM

tmp="no"
while $test "X$tmp" = "Xno" ; do
    rp="What routine should I use ?"
    $echo $n "$rp $c"
    . myread
    tmp=yes
    case "$ans" in
        1)    wait4char="USE_SELECT" ;;
        2)    wait4char="USE_RDCHK" ;;
        *)    echo "Choose one from 1 through 2" ; tmp="no";;
    esac
done
: see if free is defined as "int" or "void"
: Ask the user !
$echo " "
dflt="void"
cat << EOM
Specifiy how the routine 'free' is defined on your system ?
Typically it is 'void free ();' but if you are on a SUN running
SUN OS 3.* it is 'int free();'.
Specify either 'void' or 'int' here.

EOM

tmp="no"
while $test "X$tmp" = "Xno" ; do
    rp="How is your 'free' routine defined ? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
        void)    d_intfree="void" ; tmp="yes" ;;
        int)    d_intfree="int" ; tmp="yes" ;;
        *)        echo "Sorry, I don't think that's correct." ;;
    esac
done
echo " "
echo "End of configuration questions."
echo " "

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

d_eunice='$d_eunice'
eunicefix='$eunicefix'
loclist='$loclist'
expr='$expr'
sed='$sed'
echo='$echo'
cat='$cat'
rm='$rm'
mv='$mv'
cp='$cp'
tail='$tail'
tr='$tr'
mkdir='$mkdir'
sort='$sort'
uniq='$uniq'
grep='$grep'
trylist='$trylist'
test='$test'
inews='$inews'
egrep='$egrep'
more='$more'
pg='$pg'
Mcc='$Mcc'
vi='$vi'
mailx='$mailx'
mail='$mail'
cpp='$cpp'
perl='$perl'
contains='$contains'
d_bcopy='$d_bcopy'
d_charsprf='$d_charsprf'
d_index='$d_index'
d_memcpy='$d_memcpy'
libc='$libc'
mansrc='$mansrc'
manext='$manext'
models='$models'
split='$split'
small='$small'
medium='$medium'
large='$large'
huge='$huge'
ccflags='$ccflags'
ldflags='$ldflags'
cc='$cc'
n='$n'
c='$c'
package='$package'
spitshell='$spitshell'
shsharp='$shsharp'
sharpbang='$sharpbang'
startsh='$startsh'
define='$define'
cppstdin='$cppstdin'
cppminus='$cppminus'
d_intfree='$d_intfree'
d_reread='$d_reread'
d_termio='$d_termio'
systermio='$systermio'
look4char='$look4char'
use_select='$use_select'
use_rdchk='$use_rdchk'
use_fionread='$use_fionread'
wait4char='$wait4char'
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
. ./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