configure

早期freebsd实现

	esac
	rp="What flag indicates huge model? [$dflt]"
	$echo $n "$rp $c"
	. myread
	case "$ans" in
	none) ans='';
	esac
	huge="$ans"
	;;
    *) huge="$large";;
    esac
    case "$models" in
    *medium*)
	case "$medium" in
	'') dflt='-Mm';;
	*) dflt="$medium";;
	esac
	rp="What flag indicates medium model? [$dflt]"
	$echo $n "$rp $c"
	. myread
	case "$ans" in
	none) ans='';
	esac
	medium="$ans"
	;;
    *) medium="$large";;
    esac
    case "$models" in
    *small*)
	case "$small" in
	'') dflt='none';;
	*) dflt="$small";;
	esac
	rp="What flag indicates small model? [$dflt]"
	$echo $n "$rp $c"
	. myread
	case "$ans" in
	none) ans='';
	esac
	small="$ans"
	;;
    *) small='';;
    esac
    ;;
*)
    echo "Unrecognized memory models--you may have to edit Makefile.SH"
    ;;
esac

: see if we need a special compiler
echo " "
if usg; then
    case "$cc" in
    '')
	case "$Mcc" in
	/*) dflt='Mcc'
	    ;;
	*)
	    case "$large" in
	    -M*)
		dflt='cc'
		;;
	    *)
		if $contains '\-M' $mansrc/cc.1 >/dev/null 2>&1 ; then
		    dflt='cc -M'
		else
		    dflt='cc'
		fi
		;;
	    esac
	    ;;
	esac
	;;
    *)  dflt="$cc";;
    esac
    $cat <<'EOM'
  
On some systems the default C compiler will not resolve multiple global
references that happen to have the same name.  On some such systems the
"Mcc" command may be used to force these to be resolved.  On other systems
a "cc -M" command is required.  (Note that the -M flag on other systems
indicates a memory model to use!)  If you have the Gnu C compiler, you
might wish to use that instead.  What command will force resolution on
EOM
    $echo $n "this system? [$dflt] $c"
    rp="Command to resolve multiple refs? [$dflt]"
    . myread
    cc="$ans"
else
    case "$cc" in
    '') dflt=cc;;
    *) dflt="$cc";;
    esac
    rp="Use which C compiler? [$dflt]"
    $echo $n "$rp $c"
    . myread
    cc="$ans"
fi
case "$cc" in
*gcc*) cpp=`./loc gcc-cpp $cpp $pth`
    case "$nativegcc" in
    '') case "$ccflags" in
	*-fpcc-struct-return*) dflt=n;;
	*) dflt=y;;
	esac
	;;
    undef) dflt=n;;
    *) dflt=y;;
    esac
    echo " "
    rp="Are your system (especially dbm) libraries compiled with gcc? [$dflt]"
    $echo $n "$rp $c"
    . myread
    case "$ans" in
    n*) nativegcc="$undef"; gccflags='-fpcc-struct-return';;
    *) nativegcc="$define"; gccflags='';;
    esac
    case "$gccflags" in
    *-ansi*) ;;
    *-traditional*) ;;
    *) gccflags="$gccflags -traditional -Dvolatile=__volatile__" ;;
    esac
    ;;
esac

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

Some C compilers have problems with their optimizers, by default, $package
compiles with the -O flag to use the optimizer.  Alternately, you might
want to use the symbolic debugger, which uses the -g flag (on traditional
Unix systems).  Either flag can be specified here.  To use neither flag,
specify the word "none".
  
EOH
rp="What optimizer/debugger flag should be used? [$dflt]"
$echo $n "$rp $c"
. myread
optimize="$ans"
case "$optimize" in
'none') optimize=" "
     ;;
esac

case "$ccflags" in
'') case "$cc" in
    *gcc*) dflt="$gccflags";;
    *) dflt='';;
    esac
    ;;
*-fpcc-struct-return*) dflt="$ccflags";;
*) case "$cc" in
    *gcc*) dflt="$ccflags $gccflags";;
    *) dflt="$ccflags";;
    esac
    ;;
esac
for thisincl in $inclwanted; do
    if test -d $thisincl; then
	if test "x$thisincl" != "x$usrinclude"; then
	    case "$dflt" in
	    *$thisincl*);;
	    *) dflt="$dflt -I$thisincl";;
	    esac
	fi
    fi
done
case "$optimize" in
-g*)
    case "$dflt" in
    *DEBUGGING*);;
    *) dflt="$dflt -DDEBUGGING";;
    esac
    ;;
esac
if $contains 'LANGUAGE_C' $usrinclude/signal.h >/dev/null 2>&1; then
    case "$dflt" in
    *LANGUAGE_C*);;
    *) dflt="$dflt -DLANGUAGE_C";;
    *) if osf1; then
          dflt="$dflt -D__LANGUAGE_C__"
       else
          dflt="$dflt -DLANGUAGE_C"
       fi
       ;;
    esac
fi
if $contains '_NO_PROTO' $usrinclude/signal.h >/dev/null 2>&1; then
    case "$dflt" in
    *_NO_PROTO*);;
    *) osf1 || dflt="$dflt -D_NO_PROTO";;
    esac
fi
case "$dflt" in
'') dflt=none;;
esac
cat <<EOH

Your C compiler may want other flags.  For this question you should
include -I/whatever and -DWHATEVER flags and any other flags used by
the C compiler, but you should NOT include libraries or ld flags like
-lwhatever.  For instance, this would be a good place to specify
-DDEBUGGING.  To use no flags, specify the word "none".
  
EOH
rp="Any additional cc flags? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
none) ans='';
esac
ccflags="$ans"

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

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

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

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

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

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

: check for size of random number generator
echo " "
case "$alignbytes" in
'')
    echo "Checking alignment constraints..."
    $cat >try.c <<'EOCP'
struct foobar {
    char foo;
    double bar;
} try;
main()
{
    printf("%d\n", (char*)&try.bar - (char*)&try.foo);
}
EOCP
    if $cc $ccflags try.c -o try >/dev/null 2>&1 ; then
	dflt=`./try`
    else
	dflt='?'
	echo "(I can't seem to compile the test program...)"
    fi
    ;;
*)
    dflt="$alignbytes"
    ;;
esac
rp="Doubles must be aligned on a how-many-byte boundary? [$dflt]"
$echo $n "$rp $c"
. myread
alignbytes="$ans"
$rm -f try.c try

: determine where public executables go
cat <<EOF
 
The following questions distinguish the directory in which executables
reside from the directory in which they are installed (and from which they
are presumably copied to the former directory by occult means).  This
distinction is often necessary under afs.  On most other systems, however,
the two directories are the same.
 
EOF
case "$bin" in
'')
    dflt=`./loc . /usr/local/bin /usr/local/bin /usr/lbin /usr/local /usr/bin /bin`
    ;;
*)  dflt="$bin"
    ;;
esac
cont=true
while $test "$cont" ; do
    rp="In which directory will public executables reside (~name ok)? [$dflt]"
    $echo "In which directory will public executables reside (~name ok)?"
    $echo $n "[$dflt] $c"
    . myread
    bin="$ans"
    bin=`./filexp $bin`
    if test -d $bin; then
	cont=''
    else
	case "$fastread" in
	yes) dflt=y;;
	*) dflt=n;;
	esac
	rp="Directory $bin doesn't exist.  Use that name anyway? [$dflt]"
	$echo $n "$rp $c"
	. myread
	dflt=''
	case "$ans" in
	y*) cont='';;
	esac
    fi
done

case "$bin" in
  ?????????????????????????)
    cat <<EOF

NOTE: you have a fairly long path name there.  Some systems have trouble
executing a script if the #! line ends up longer than 32 characters.  If
you have this trouble you may have to reinstall somewhere else, or make
a symbolic link from someplace with a shorter name.

EOF
    ;;
esac

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

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

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

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

blech() { exit(3); }

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

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

: see how we invoke the C preprocessor
echo " "
echo "Now, how can we feed standard input to your C preprocessor..."
cat <<'EOT' >testcpp.c
#define ABC abc
#define XYZ xyz
ABC.XYZ
EOT

cd ..
echo 'cat >.$$.c; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' >cppstdin
chmod 755 cppstdin