conf.sh

早期freebsd实现

	$RM || exit
	if ($CL a.c $L && ./a.out) >&2
	then h=1
	else h=0
	fi
esac
echo "$a#define has_getpwuid $h $z/* Does getpwuid() work?  */"

: has_link
cat >a.c <<'EOF'
#include "a.h"
int main() { exitmain(link("a.c","a.d") != 0); }
EOF
$RM a.d || exit
if ($CL a.c $L && ./a.out && cmp a.c a.d) >&2
then h=1
else h=0
fi
rm -f a.d || exit
echo "#define has_link $h /* Does link() work?  */"

: has_memcmp
cat >a.c <<'EOF'
#include "a.h"
int main() { exitmain(memcmp("beautiful","beautiful",10) != 0); }
EOF
$RM || exit
if ($CL a.c $L && ./a.out) >&2
then h=1
else h=0
fi
echo "#define has_memcmp $h /* Does memcmp() work?  */"

: has_memcpy
cat >a.c <<'EOF'
#include "a.h"
char a[3];
int main() {
	memcpy(a,"xy",3);
	exitmain(strcmp(a,"xy")!=0);
}
EOF
$RM || exit
if ($CL a.c $L && ./a.out) >&2
then h=1
else h=0
fi
echo "#define has_memcpy $h /* Does memcpy() work?  */"

: has_memmove
cat >a.c <<'EOF'
#include "a.h"
char a[4];
int main() {
	strcpy(a, "xy");
	memmove(a+1, a, 3);
	exitmain(strcmp(a,"xxy")!=0);
}
EOF
$RM || exit
if ($CL a.c $L && ./a.out) >&2
then h=1
else h=0
fi
echo "#define has_memmove $h /* Does memmove() work?  */"

: has_mmap, has_madvise
cat >a.c <<'EOF'
#define CHAR1 '#' /* the first character in this file */
#include "a.h"
#ifndef mmap
	caddr_t mmap();
#endif
caddr_t a;
struct stat b;
#ifndef MADVISE_OK
#	define MADVISE_OK (madvise(a,b.st_size,MADV_SEQUENTIAL)==0 && madvise(a,b.st_size,MADV_NORMAL)==0)
#endif
int main()
{
	if (fstat(fileno(stdin), &b) != 0)
		exitmain(1);
	a = mmap(
		(caddr_t)0, b.st_size, PROT_READ, MAP_SHARED,
		fileno(stdin), (off_t)0
	);
	exitmain(
		a == (caddr_t)-1  ||
		!MADVISE_OK ||
		*a != CHAR1  ||
		munmap(a, b.st_size)  !=  0
	);
}
EOF
a=0 has_mmap=0
$RM || exit
if ($CL -DMADVISE_OK=1 a.c $L && ./a.out <a.c) >&2
then
	has_mmap=1
	$RM || exit
	($CL a.c $L && ./a.out <a.c) >&2 && a=1
fi
echo "#define has_madvise $a /* Does madvise() work?  */"
echo "#define has_mmap $has_mmap /* Does mmap() work on regular files?  */"

: has_rename, bad_a_rename, bad_b_rename
cat >a.c <<'EOF'
#include "a.h"
int main() { exitmain(rename("a.a","a.b") != 0); }
EOF
echo a >a.a && $RM a.b || exit
if ($CL a.c $L && ./a.out && test -f a.b) >&2
then
	h=1
	rm -f a.a a.b &&
	echo a >a.a && chmod -w a.a || exit
	if ./a.out && test ! -f a.a && test -f a.b
	then a=0
	else a=1
	fi
	rm -f a.a a.b &&
	echo a >a.a && echo b >a.b && chmod -w a.b || exit
	if ./a.out && test ! -f a.a && test -f a.b
	then b=0
	else b=1
	fi
	rm -f a.a a.b || exit
else h=0 a=0 b=0
fi
echo "#define has_rename $h /* Does rename() work?  */"
echo "#define bad_a_rename $a /* Does rename(A,B) fail if A is unwritable?  */"
echo "#define bad_b_rename $b /* Does rename(A,B) fail if B is unwritable?  */"

: void, VOID
cat >a.c <<'EOF'
#include "a.h"
void f() {}
int main() {f(); exitmain(0);}
EOF
if $CS a.c $LS >&2
then
	v='(void) '
else
	v=
	echo 'typedef int void;'
fi
echo "#define VOID $v/* 'VOID e;' discards the value of an expression 'e'.  */"

: has_seteuid
case $has_getuid in
0)
	a='/* ' z='*/ ' has_seteuid=?;;
*)
	a= z=
	cat >a.c <<'EOF'
#include "a.h"
#ifndef geteuid
	uid_t geteuid();
#endif
int main() {
/* Guess, don't test.  Ugh.  Testing would require running conf.sh setuid.  */
/* seteuid() isn't standardized yet, so the guess below may well be wrong.  */
#if !_POSIX_VERSION || _POSIX_VERSION<=199009L&&!defined(sgi)&&!defined(__sgi__)&&!defined(sun)&&!defined(__sun__)
	exitmain(1);
#else
	exitmain(seteuid(geteuid()) != 0);
#endif
}
EOF
	$RM || exit
	if ($CL a.c $L && ./a.out) >&2
	then has_seteuid=1
	else has_seteuid=0
	fi
esac
echo "$a#define has_seteuid $has_seteuid $z/* Does seteuid() work?  See README.  */"

: has_setuid
h=$has_seteuid
case $h in
0)
	cat >a.c <<'EOF'
#include "a.h"
#ifndef getuid
	uid_t getuid();
#endif
int main() { exitmain(setuid(getuid()) != 0); }
EOF
	$RM || exit
	($CL a.c $L && ./a.out) >&2 && h=1
esac
echo "$a#define has_setuid $h $z/* Does setuid() exist?  */"

: has_signal, signal_args, signal_type, sig_zaps_handler
cat >a.c <<'EOF'
#include "a.h"
#ifndef getpid
	pid_t getpid();
#endif
#if !defined(signal) && declare_signal
	signal_type (*signal P((int,signal_type(*)signal_args)))signal_args;
#endif
signal_type nothing(i) int i; {}
int main(argc, argv) int argc; char **argv;
{
	signal(SIGINT, nothing);
	while (--argc)
		kill(getpid(), SIGINT);
	exitmain(0);
}
EOF
for declare_signal in 1 0
do
	for signal_type in void int
	do
		for signal_args in 'P((int))' '()'
		do
			$RM || exit
			($CL \
				-Ddeclare_signal=$declare_signal \
				-Dsignal_args="$signal_args" \
				-Dsignal_type=$signal_type \
					a.c $L && ./a.out 1) >&2 && break
		done && break
	done && break
done || {
	echo >&2 "cannot deduce signal_args, signal_type"
	exit 1
}
if ./a.out 1 2 >&2
then z=0
else z=1
fi
cat <<EOF
#define has_signal $has_signal /* Does signal() work?  */
#define signal_args $signal_args /* arguments of signal handlers */
#define signal_type $signal_type /* type returned by signal handlers */
#define sig_zaps_handler $z /* Must a signal handler reinvoke signal()?  */
EOF

: has_sigaction
cat >a.c <<'EOF'
#include "a.h"
#ifndef getpid
	pid_t getpid();
#endif
static sig_atomic_t volatile gotsig;
static void getsig(i) int i; { gotsig = 1; }
int main(argc, argv) int argc; char **argv;
{
	struct sigaction s;
	sigset_t t;
	if (sigemptyset(&t) != 0  ||  sigaddset(&t, SIGINT) != 0)
		exitmain(1);
	if (sigaction(SIGINT, (struct sigaction const*)0, &s) != 0)
		exitmain(1);
	s.sa_handler = getsig;
	s.sa_mask = t;
	if (sigaction(SIGINT, &s, (struct sigaction*)0) != 0)
		exitmain(1);
	kill(getpid(), SIGINT);
	exitmain(gotsig != 1);
}
EOF
$RM || exit
if ($CL a.c $L && ./a.out) >&2
then has_sigaction=1
else has_sigaction=0
fi
echo "#define has_sigaction $has_sigaction /* Does struct sigaction work?  */"

: has_sigblock, sigmask
a='/* ' z='*/ '
b='/* ' y='*/ '
case $has_sigaction in
1)
	h=? n=?;;
*)
	a= z=
	cat >a.c <<'EOF'
#include "a.h"
#include <signal.h>
#if define_sigmask
#	define sigmask(s) (1 << ((s)-1))
#endif
int main()
{
	sigblock(sigmask(SIGHUP));
	exitmain(kill(getpid(), SIGHUP) != 0);
}
EOF
	if $RM || exit; ($CL a.c $L && ./a.out) >&2
	then h=1
	elif $RM || exit; ($CL -Ddefine_sigmask=1 a.c $L && ./a.out) >&2
	then h=1 b= y=
	else h=0
	fi
esac
echo "$a#define has_sigblock $h $z/* Does sigblock() work?  */"
echo "$b#define sigmask(s) (1 << ((s)-1)) $y/* Yield mask for signal number.  */"

: has_sys_siglist
cat >a.c <<'EOF'
#include "a.h"
#ifndef sys_siglist
	extern char const *sys_siglist[];
#endif
int main() { exitmain(!sys_siglist[1][0]); }
EOF
$RM || exit
if ($CL a.c $L && ./a.out) >&2
then h=1
else h=0
fi
echo "#define has_sys_siglist $h /* Does sys_siglist[] work?  */"

: fread_type, Fread, Fwrite
cat >a.c <<'EOF'
#define CHAR1 '#' /* the first character in this file */
#include "a.h"
#if !defined(fread) && declare_fread
	fread_type fread P((void*,freadarg_type,freadarg_type,FILE*));
#endif
int main()
{
	char b;
	exitmain(!(
		fread(&b, (freadarg_type)1, (freadarg_type)1, stdin) == 1  &&
		b==CHAR1
	));
}
EOF
for declare_fread in 1 0
do
	for fread_type in ssize_t size_t int unsigned
	do
		for freadarg_type in size_t ssize_t unsigned int
		do
			$RM || exit
			(
				$CL \
					-Ddeclare_fread=$declare_fread \
					-Dfreadarg_type=$freadarg_type \
					-Dfread_type=$fread_type \
					a.c $L &&
				./a.out <a.c
			) >&2 && break
		done && break
	done && break
done || {
	echo >&2 "cannot deduce fread types"
	exit 1
}
cat <<EOF
typedef $fread_type fread_type; /* type returned by fread() and fwrite() */
typedef $freadarg_type freadarg_type; /* type of their size arguments */
EOF

: malloc_type
cat >a.c <<'EOF'
#include "a.h"
typedef void *malloc_type;
#ifndef malloc
	malloc_type malloc();
#endif
int main() { exitmain(!malloc(1)); }
EOF
if $CS a.c $LS >&2
then t=void
else t=char
fi
echo "typedef $t *malloc_type; /* type returned by malloc() */"

: has_getcwd
cat >a.c <<'EOF'
#include "a.h"
#ifndef getcwd
	char *getcwd();
#endif
char buf[10000];
int main() { exitmain(!getcwd(buf,10000)); }
EOF
$RM || exit
if ($CL a.c $L && ./a.out) >&2
then has_getcwd=1
else has_getcwd=0
fi
echo "#define has_getcwd $has_getcwd /* Does getcwd() work?  */"

: has_getwd
case $has_getcwd in
1)
	a='/* ' z='*/ ' h=?;;
*)
	a= z=
	cat >a.c <<'EOF'
#include "a.h"
#include <sys/param.h>
#ifndef getwd
	char *getwd();
#endif
char buf[MAXPATHLEN];
int main() { exitmain(!getwd(buf)); }
EOF
	$RM || exit
	if ($CL a.c $L && ./a.out) >&2
	then h=1
	else h=0
	fi
esac
echo "$a#define has_getwd $h $z/* Does getwd() work?  */"

: has_mktemp
cat >a.c <<'EOF'
#include "a.h"
#ifndef mktemp
	char *mktemp();
#endif
int main()
{
	char b[9];
	strcpy(b, "a.XXXXXX");
	exitmain(!mktemp(b));
}
EOF
$RM || exit
if ($CL a.c $L && ./a.out) >&2
then h=1
else h=0
fi
echo "#define has_mktemp $h /* Does mktemp() work?  */"

: has_NFS
echo "#define has_NFS 1 /* Might NFS be used?  */"

: strchr
cat >a.c <<'EOF'
#include "a.h"
#ifndef strchr
	char *strchr();
#endif
int main() {exitmain(!strchr("abc", 'c'));}
EOF
$RM || exit
if ($CL a.c $L && ./a.out) >&2
then a='/* ' z='*/ '
else a= z=
fi
echo "$a#define strchr index $z/* Use old-fashioned name for strchr()?  */"

: strrchr
cat >a.c <<'EOF'
#include "a.h"
#ifndef strrchr
	char *strrchr();
#endif
int main() {exitmain(!strrchr("abc", 'c'));}
EOF
$RM || exit
if ($CL a.c $L && ./a.out) >&2
then a='/* ' z='*/ '
else a= z=
fi
echo "$a#define strrchr rindex $z/* Use old-fashioned name for strrchr()?  */"

: bad_unlink
cat >a.c <<'EOF'
#include "a.h"
int main() { exitmain(unlink("a.c") != 0); }
EOF
$RM && chmod -w a.c || exit
if $CL a.c $L >&2 && ./a.out >/dev/null && test ! -f a.c
then b=0
else b=1
fi
rm -f a.c || exit
echo "#define bad_unlink $b /* Does unlink() fail on unwritable files?  */"

: has_vfork, has_fork, has_spawn, has_wait, has_waitpid, RCS_SHELL
cat >a.c <<'EOF'
#include "a.h"
#ifndef getpid
	pid_t getpid();
#endif
#if TRY_VFORK
#	ifndef vfork
		pid_t vfork();
#	endif
#else
#	ifndef fork
		pid_t fork();
#	endif
#	undef vfork
#	define vfork fork
#endif
#if TRY_WAITPID
#	ifndef waitpid
		pid_t waitpid();
#	endif
#else
#	ifndef wait
		pid_t wait();
#	endif
#endif
pid_t child;
int status;
struct stat st;
int main()
{
	pid_t parent = getpid();
	if (!(child = vfork())) {
		/* Tickle vfork/compiler bug (e.g. sparc gcc -O (1.37.1).  */
		pid_t i = getpid(), j = getpid();
		if (i!=getpid() || j!=getpid())
			_exit(!i);
		/* Tickle file descriptor bug (e.g. IRIX 3.3).  */
		_exit(close(1) != 0);
	} else {
#		if TRY_WAITPID
			if (waitpid(child, &status, 0) != child)
				exitmain(1);
#		else
			while (wait(&status) != child)
				;
#		endif
		/* Test for presence of bugs.  */
		exitmain(status  ||  parent != getpid()  ||  fstat(1,&st) != 0);
	}
}
EOF
$RM || exit
if ($CL -DTRY_VFORK=1 a.c $L && ./a.out) >&2
then has_vfork=1
else has_vfork=0
fi
echo "#define has_vfork $has_vfork /* Does vfork() work?  */"
h=$has_vfork
case $h in
0)
	$RM || exit
	($CL a.c $L && ./a.out) >&2 && h=1
esac
echo "#define has_fork $h /* Does fork() work?  */"
$RM || exit
if ($CL -DTRY_VFORK=$has_vfork -DTRY_WAITPID=1 a.c $L && ./a.out) >&2
then h=1
else h=0
fi
echo "#define has_spawn 0 /* Does spawn*() work?  */"
echo "#define has_wait 1 /* Does wait() work?  */"
echo "#define has_waitpid $h /* Does waitpid() work?  */"
echo '#define RCS_SHELL "/bin/sh" /* shell to run RCS subprograms */'

: has_vfprintf
cat >a.c <<'EOF'
#include "a.h"
#if has_prototypes
int p(char const*format,...)