configure

早期freebsd实现

: see if gethostent exists
set gethostent d_gethent
eval $inlibc

: see if getpgrp exists
set getpgrp d_getpgrp
eval $inlibc

: see if getpgrp2 exists
set getpgrp2 d_getpgrp2
eval $inlibc

: see if getpriority exists
set getpriority d_getprior
eval $inlibc

: see if htonl exists
set htonl d_htonl
eval $inlibc

: index or strcpy
echo " "
case "$d_index" in
undef) dflt=y;;
define) dflt=n;;
*)  if $test -f /unix; then
	dflt=n
    else
	dflt=y
    fi
    ;;
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 isascii exists
set isascii d_isascii
eval $inlibc

: see if killpg exists
set killpg d_killpg
eval $inlibc

: see if lstat exists
set lstat d_lstat
eval $inlibc

: see if memcmp exists
set memcmp d_memcmp
eval $inlibc

: see if memcpy exists
set memcpy d_memcpy
eval $inlibc

case "$d_safemcpy" in
'')
    : assume the worst
    d_safemcpy=undef
    case "$d_memcpy" in
    define)
	echo "Checking to see if your memcpy() can do overlapping copies..."
	$cat >safemcpy.c <<'EOCP'
main()
{
    char buf[128];
    register char *b;
    register int len;
    register int off;
    register int align;

    for (align = 7; align >= 0; align--) {
	for (len = 36; len; len--) {
	    b = buf+align;
	    memcpy(b,"abcdefghijklmnopqrstuvwxyz0123456789", len);
	    for (off = 1; off <= len; off++) {
		memcpy(b+off, b, len);
		memcpy(b, b+off, len);
		if (memcmp(b, "abcdefghijklmnopqrstuvwxyz0123456789", len))
		    exit(1);
	    }
	}
    }
    exit(0);
}
EOCP
	if $cc safemcpy.c -o safemcpy $ccflags $libs >/dev/null 2>&1 ; then
	    if ./safemcpy; then
		echo "It can."
		d_safemcpy=define
	    else
		echo "It can't."
	    fi
	else
	    echo "(I can't compile the test program, so we'll assume not...)"
	fi
	;;
    esac
    ;;
esac

: see if memmove exists
set memmove d_memmove
eval $inlibc

: see if memset exists
set memset d_memset
eval $inlibc

: see if mkdir exists
set mkdir d_mkdir
eval $inlibc

: see if msgctl exists
set msgctl d_msgctl
eval $inlibc

: see if msgget exists
set msgget d_msgget
eval $inlibc

: see if msgsnd exists
set msgsnd d_msgsnd
eval $inlibc

: see if msgrcv exists
set msgrcv d_msgrcv
eval $inlibc

: see how much of the 'msg*(2)' library is present.
h_msg=true
echo " "
case "$d_msgctl$d_msgget$d_msgsnd$d_msgrcv" in
*undef*) h_msg=false;;
esac
: we could also check for sys/ipc.h ...
if $h_msg && $test -r $usrinclude/sys/msg.h; then
    echo "You have the full msg*(2) library."
    val="$define"
else
    echo "You don't have the full msg*(2) library."
    val="$undef"
fi
set d_msg
eval $setvar

: determine which malloc to compile in
echo " "
case "$d_mymalloc" in
'')
    case "$usemymalloc" in
    '')
	if bsd || v7; then
	    dflt='y'
	else
	    dflt='n'
	fi
	;;
    n*) dflt=n;;
    *)  dflt=y;;
    esac
    ;;
define)  dflt="y"
    ;;
*)  dflt="n"
    ;;
esac
rp="Do you wish to attempt to use the malloc that comes with $package? [$dflt]"
$echo $n "$rp $c"
. myread
case "$ans" in
'') ans=$dflt;;
esac
case "$ans" in
y*) mallocsrc='malloc.c'; mallocobj='malloc.o'
    libs=`echo $libs | sed 's/-lmalloc//'`
    val="$define"
    case "$mallocptrtype" in
    '')
	cat >usemymalloc.c <<'END'
#ifdef __STDC__
#include <stdlib.h>
#else
#include <malloc.h>
#endif
void *malloc();
END
	if $cc $ccflags -c usemymalloc.c >/dev/null 2>&1; then
	    mallocptrtype=void
	else
	    mallocptrtype=char
	fi
	;;
    esac
    echo " "
    echo "Your system wants malloc to return $mallocptrtype*, it would seem."
    ;;
*)  mallocsrc='';
    mallocobj='';
    mallocptrtype=void
    val="$undef"
    ;;
esac
set d_mymalloc
eval $setvar

: see if ndbm is available
echo " "
xxx=`./loc ndbm.h x $usrinclude /usr/local/include $inclwanted`
if test -f $xxx; then
    val="$define"
    echo "ndbm.h found."
else
    val="$undef"
    echo "ndbm.h NOT found."
fi
set d_ndbm
eval $setvar

: see if we have the old dbm
echo " "
xxx=`./loc dbm.h x $usrinclude /usr/local/include $inclwanted`
if test -f $xxx; then
    val="$define"
    echo "dbm.h found."
else
    val="$undef"
    echo "dbm.h NOT found."
fi
set d_odbm
eval $setvar

: see whether socket exists
echo " "
socketlib=''
if $contains socket libc.list >/dev/null 2>&1; then
    echo "Looks like you have Berkeley networking support."
    val="$define"
    : now check for advanced features
    if $contains setsockopt libc.list >/dev/null 2>&1; then
	val2="$undef"
    else
	echo "...but it uses the old 4.1c interface, rather than 4.2"
	val2="$define"
    fi
else
    : hpux, for one, puts all the socket stuff in socklib.o
    if $contains socklib libc.list >/dev/null 2>&1; then
	echo "Looks like you have Berkeley networking support."
	val="$define"
	: we will have to assume that it supports the 4.2 BSD interface
	val2="$undef"
    else
	echo "Hmmm...you don't have Berkeley networking in libc.a..."
	: look for an optional networking library
	if test -f /usr/lib/libnet.a; then
	    (ar t /usr/lib/libnet.a ||
		nm -g /usr/lib/libnet.a) 2>/dev/null >> libc.list
	    if $contains socket libc.list >/dev/null 2>&1; then
		echo "but the Wollongong group seems to have hacked it in."
		socketlib="-lnet -lnsl_s"
		val="$define"
		: now check for advanced features
		if $contains setsockopt libc.list >/dev/null 2>&1; then
		    val2="$undef"
		else
		    echo "...using the old 4.1c interface, rather than 4.2"
		    val2="$define"
		fi
	    else
		echo "or even in libnet.a, which is peculiar."
		val="$undef"
		val2="$undef"
	    fi
	else
	    echo "or anywhere else I see."
	    val="$undef"
	    val2="$undef"
	fi
    fi
fi
set d_socket
eval $setvar

if $contains socketpair libc.list >/dev/null 2>&1; then
    val="$define"
else
    val="$undef"
fi
set d_sockpair
eval $setvar
val=$val2
set d_oldsock
eval $setvar

: Locate the flags for 'open()'
echo " "
$cat >open3.c <<'EOCP'
#include <sys/types.h>
#ifdef I_FCNTL
#include <fcntl.h>
#endif
#ifdef I_SYS_FILE
#include <sys/file.h>
#endif
main() {

	if(O_RDONLY);

#ifdef O_TRUNC
	exit(0);
#else
	exit(1);
#endif
}
EOCP
: check sys/file.h first to get FREAD on Sun
if $test -r $usrinclude/sys/file.h && \
   $cc $cppflags "-DI_SYS_FILE" open3.c -o open3 >/dev/null 2>&1 ; then
    h_sys_file=true;
    echo "sys/file.h defines the O_* constants..."
    if ./open3; then
	echo "and you have the 3 argument form of open()."
	val="$define"
    else
	echo "but not the 3 argument form of open().  Oh, well."
	val="$undef"
    fi
elif $test -r $usrinclude/fcntl.h && \
   $cc "-DI_FCNTL" open3.c -o open3 >/dev/null 2>&1 ; then
    h_fcntl=true;
    echo "fcntl.h defines the O_* constants..."
    if ./open3; then
	echo "and you have the 3 argument form of open()."
	val="$define"
    else
	echo "but not the 3 argument form of open().  Oh, well."
	val="$undef"
    fi
else
    val="$undef"
    echo "I can't find the O_* constant definitions!  You got problems."
fi
set d_open3
eval $setvar

: see if how pwd stuff is defined
echo " "
if $test -r $usrinclude/pwd.h ; then
    i_pwd="$define"
    echo "pwd.h found."
    $cppstdin $cppflags $cppminus <$usrinclude/pwd.h | \
	sed -n '/struct[ 	][ 	]*passwd/,/^};/p' >pwd.txt
    if $contains 'pw_quota' pwd.txt >/dev/null 2>&1; then
	d_pwquota="$define"
    else
	d_pwquota="$undef"
    fi
    if $contains 'pw_age' pwd.txt >/dev/null 2>&1; then
	d_pwage="$define"
    else
	d_pwage="$undef"
    fi
    if $contains 'pw_change' pwd.txt >/dev/null 2>&1; then
	d_pwchange="$define"
    else
	d_pwchange="$undef"
    fi
    if $contains 'pw_class' pwd.txt >/dev/null 2>&1; then
	d_pwclass="$define"
    else
	d_pwclass="$undef"
    fi
    if $contains 'pw_expire' pwd.txt >/dev/null 2>&1; then
	d_pwexpire="$define"
    else
	d_pwexpire="$undef"
    fi
    if $contains 'pw_comment' pwd.txt >/dev/null 2>&1; then
	d_pwcomment="$define"
    else
	d_pwcomment="$undef"
    fi
else
    i_pwd="$undef"
    d_pwquota="$undef"
    d_pwage="$undef"
    d_pwchange="$undef"
    d_pwclass="$undef"
    d_pwexpire="$undef"
    d_pwcomment="$undef"
    echo "No pwd.h found."
fi

: see if rename exists
set rename d_rename
eval $inlibc

: see if rewindir exists
set rewinddir d_rewindir
eval $inlibc

: see if rmdir exists
set rmdir d_rmdir
eval $inlibc

: see if seekdir exists
set seekdir d_seekdir
eval $inlibc

: see if select exists
set select d_select
eval $inlibc

: see if semctl exists
set semctl d_semctl
eval $inlibc

: see if semget exists
set semget d_semget
eval $inlibc

: see if semop exists
set semop d_semop
eval $inlibc

: see how much of the 'sem*(2)' library is present.
h_sem=true
echo " "
case "$d_semctl$d_semget$d_semop" in
*undef*) h_sem=false;;
esac
: we could also check for sys/ipc.h ...
if $h_sem && $test -r $usrinclude/sys/sem.h; then
    echo "You have the full sem*(2) library."
    val="$define"
else
    echo "You don't have the full sem*(2) library."
    val="$undef"
fi
set d_sem
eval $setvar

: see if setegid exists
set setegid d_setegid
eval $inlibc

: see if seteuid exists
set seteuid d_seteuid
eval $inlibc

: see if setpgrp exists
set setpgrp d_setpgrp
eval $inlibc

: see if setpgrp2 exists
set setpgrp2 d_setpgrp2
eval $inlibc

: see if setpriority exists
set setpriority d_setprior
eval $inlibc

: see if setregid exists
set setregid d_setregid
eval $inlibc
set setresgid d_setresgid
eval $inlibc

: see if setreuid exists
set setreuid d_setreuid
eval $inlibc
set setresuid d_setresuid
eval $inlibc

: see if setrgid exists
set setrgid d_setrgid
eval $inlibc

: see if setruid exists
set setruid d_setruid
eval $inlibc

: see if shmctl exists
set shmctl d_shmctl
eval $inlibc

: see if shmget exists
set shmget d_shmget
eval $inlibc

: see if shmat exists
set shmat d_shmat
eval $inlibc

d_voidshmat="$undef"
case "$d_shmat" in
define)
    $cppstdin $cppflags $cppminus < $usrinclude/sys/shm.h >voidshmat.txt 2>/dev/null
    if $contains "void.*shmat" voidshmat.txt >/dev/null 2>&1; then
	echo "and shmat returns (void*)"
	d_voidshmat="$define"
    else
	echo "and shmat returns (char*)"
    fi
    ;;
esac

: see if shmdt exists
set shmdt d_shmdt
eval $inlibc

: see how much of the 'shm*(2)' library is present.
h_shm=true
echo " "
case "$d_shmctl$d_shmget$d_shmat$d_shmdt" in
*undef*) h_shm=false;;
esac
: we could also check for sys/ipc.h ...
if $h_shm && $test -r $usrinclude/sys/shm.h; then
    echo "You have the full shm*(2) library."
    val="$define"
else
    echo "You don't have the full shm*(2) library."
    val="$undef"
fi
set d_shm
eval $setvar

: see if stat knows about block sizes
echo " "
if $contains 'st_blocks;' $usrinclude/sys/stat.h >/dev/null 2>&1 ; then
    if $contains 'st_blksize;' $usrinclude/sys/stat.h >/dev/null 2>&1 ; then
	echo "Your stat knows about block sizes."
	val="$define"
    else
	echo "Your stat doesn't know about block sizes."
	val="$undef"
    fi
else
    echo "Your stat doesn't know about block sizes."
    val="$undef"
fi
set d_statblks
eval $setvar

: see if stdio is really std
echo " "
if $contains 'char.*_ptr.*;' $usrinclude/stdio.h >/dev/null 2>&1 ; then
    if $contains '_cnt;' $usrinclude/stdio.h >/dev/null 2>&1 ; then
	echo "Your stdio is pretty std."
	val="$define"
    else
	echo "Your stdio isn't very std."
	val="$undef"
    fi
else
    echo "Your stdio isn't very std."
    val="$undef"
fi
set d_stdstdio
eval $setvar

: check for structure copying
echo " "
echo "Checking to see if your C compiler can copy structs..."
$cat >st