mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-24 11:29:10 +00:00
Code Issues Releases Activity
f1420840d1
freebsd/gnu/usr.bin/groff/configure
Paul Traina f84f13d3d0 groff-1.09
1995-01-15 08:10:00 +00:00

1410 lines
32 KiB
Bash
Executable File
Raw Blame History

#!/bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf.
# Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
# Usage: configure [--srcdir=DIR] [--host=HOST] [--gas] [--nfp]
# [--prefix=PREFIX] [--exec-prefix=PREFIX] [--with-PACKAGE[=VALUE]]
# Ignores all args except --srcdir, --prefix, --exec-prefix, and
# --with-PACKAGE[=VALUE] unless this script has special code to handle it.
for arg
do
# Handle --exec-prefix with a space before the argument.
if test x$next_exec_prefix = xyes; then exec_prefix=$arg; next_exec_prefix=
# Handle --host with a space before the argument.
elif test x$next_host = xyes; then next_host=
# Handle --prefix with a space before the argument.
elif test x$next_prefix = xyes; then prefix=$arg; next_prefix=
# Handle --srcdir with a space before the argument.
elif test x$next_srcdir = xyes; then srcdir=$arg; next_srcdir=
else
case $arg in
# For backward compatibility, recognize -exec-prefix and --exec_prefix.
-exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* | --exec=* | --exe=* | --ex=* | --e=*)
exec_prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;;
-exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- | --exec | --exe | --ex | --e)
next_exec_prefix=yes ;;
-gas | --gas | --ga | --g) ;;
-host=* | --host=* | --hos=* | --ho=* | --h=*) ;;
-host | --host | --hos | --ho | --h)
next_host=yes ;;
-nfp | --nfp | --nf) ;;
-prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;;
-prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
next_prefix=yes ;;
-srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=* | --s=*)
srcdir=`echo $arg | sed 's/[-a-z_]*=//'` ;;
-srcdir | --srcdir | --srcdi | --srcd | --src | --sr | --s)
next_srcdir=yes ;;
-with-* | --with-*)
package=`echo $arg|sed -e 's/-*with-//' -e 's/=.*//'`
# Reject names that aren't valid shell variable names.
if test -n "`echo $package| sed 's/[-a-zA-Z0-9_]//g'`"; then
echo "configure: $package: invalid package name" >&2; exit 1
fi
package=`echo $package| sed 's/-/_/g'`
case "$arg" in
*=*) val="`echo $arg|sed 's/[^=]*=//'`" ;;
*) val=1 ;;
esac
eval "with_$package='$val'" ;;
-v | -verbose | --verbose | --verbos | --verbo | --verb | --ver | --ve | --v)
verbose=yes ;;
*) ;;
esac
fi
done
trap 'rm -fr conftest* confdefs* core; exit 1' 1 3 15
trap 'rm -f confdefs*' 0
# NLS nuisances.
# These must not be set unconditionally because not all systems understand
# e.g. LANG=C (notably SCO).
if test "${LC_ALL+set}" = 'set' ; then LC_ALL=C; export LC_ALL; fi
if test "${LANG+set}" = 'set' ; then LANG=C; export LANG; fi
rm -f conftest* confdefs.h
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
echo > confdefs.h
compile='${CC-cc} $CFLAGS conftest.c -o conftest $LIBS >/dev/null 2>&1'
# A filename unique to this package, relative to the directory that
# configure is in, which we can look for to find out if srcdir is correct.
unique_file=groff/groff.cc
# Find the source files, if location was not specified.
if test -z "$srcdir"; then
srcdirdefaulted=yes
# Try the directory containing this script, then `..'.
prog=$0
confdir=`echo $prog|sed 's%/[^/][^/]*$%%'`
test "X$confdir" = "X$prog" && confdir=.
srcdir=$confdir
if test ! -r $srcdir/$unique_file; then
srcdir=..
fi
fi
if test ! -r $srcdir/$unique_file; then
if test x$srcdirdefaulted = xyes; then
echo "configure: Can not find sources in \`${confdir}' or \`..'." 1>&2
else
echo "configure: Can not find sources in \`${srcdir}'." 1>&2
fi
exit 1
fi
# Preserve a srcdir of `.' to avoid automounter screwups with pwd.
# But we can't avoid them for `..', to make subdirectories work.
case $srcdir in
.|/*|~*) ;;
*) srcdir=`cd $srcdir; pwd` ;; # Make relative path absolute.
esac
# Save the original args to write them into config.status later.
configure_args="$*"
if test -z "$prefix"
then
echo checking for grops to derive installation directory prefix
IFS="${IFS= }"; saveifs="$IFS"; IFS="$IFS:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test $dir != . && test -f $dir/grops; then
# Not all systems have dirname.
prefix=`echo $dir|sed 's%/[^/][^/]*$%%'`
break
fi
done
IFS="$saveifs"
echo " chose installation directory prefix ${prefix}"
fi
if test -z "$prefix"
then
echo checking for gcc to derive installation directory prefix
IFS="${IFS= }"; saveifs="$IFS"; IFS="$IFS:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test $dir != . && test -f $dir/gcc; then
# Not all systems have dirname.
prefix=`echo $dir|sed 's%/[^/][^/]*$%%'`
break
fi
done
IFS="$saveifs"
echo " chose installation directory prefix ${prefix}"
fi
if test -z "$CC"; then
# Extract the first word of `gcc', so it can be a program name with args.
set dummy gcc; word=$2
echo checking for $word
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/$word; then
CC="gcc"
break
fi
done
IFS="$saveifs"
fi
test -z "$CC" && CC="cc"
test -n "$CC" && test -n "$verbose" && echo " setting CC to $CC"
# Find out if we are using GNU C, under whatever name.
cat > conftest.c <<EOF
#ifdef __GNUC__
yes
#endif
EOF
${CC-cc} -E conftest.c > conftest.out 2>&1
if egrep yes conftest.out >/dev/null 2>&1; then
GCC=1 # For later tests.
fi
rm -f conftest*
cc_compile='$CCC conftest.cc -o conftest $CCLIBS $LIBS >/dev/null 2>&1'
if test -z "$CCC"; then
# See whether the C compiler is also a C++ compiler.
echo checking if C compiler is also a C++ compiler
cat <<EOF > conftest.cc
#ifdef __cplusplus
yes
#endif
EOF
$CC -E conftest.cc >conftest.out 2>&1
if egrep yes conftest.out >/dev/null 2>&1; then
CCC="$CC"
fi
fi
if test -z "$CCC"; then
# Extract the first word of `g++', so it can be a program name with args.
set dummy g++; word=$2
echo checking for $word
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/$word; then
CCC="g++"
break
fi
done
IFS="$saveifs"
fi
test -n "$CCC" && test -n "$verbose" && echo " setting CCC to $CCC"
if test -z "$CCC"; then
# Extract the first word of `CC', so it can be a program name with args.
set dummy CC; word=$2
echo checking for $word
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/$word; then
CCC="CC"
break
fi
done
IFS="$saveifs"
fi
test -n "$CCC" && test -n "$verbose" && echo " setting CCC to $CCC"
if test -z "$CCC"; then
# Extract the first word of `cc++', so it can be a program name with args.
set dummy cc++; word=$2
echo checking for $word
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/$word; then
CCC="cc++"
break
fi
done
IFS="$saveifs"
fi
test -n "$CCC" && test -n "$verbose" && echo " setting CCC to $CCC"
if test -z "$CCC"; then
cat <<EOM
This package requires a C++ compiler, but I couldn't find one.
Set the environment variable CCC to the name of your C++ compiler.
EOM
rm -f conftest* core; exit 1
fi
echo checking that C++ compiler can compile very simple C++ program
cat <<EOF > conftest.cc
int main() { return 0; }
EOF
rm -f conftest
eval $cc_compile
if test -s conftest && (./conftest) 2>/dev/null; then
:
else
cat <<EOM
$CCC was unable successfully to compile a very simple C++ program
(the C++ program was in a file with a suffix of .cc)
EOM
rm -f conftest* core; exit 1
fi
rm -f conftest*
echo checking that C++ static constructors and destructors are called
cat <<EOF > conftest.cc
extern "C" {
void _exit(int);
}
int i;
struct A {
char dummy;
A() { i = 1; }
~A() { if (i == 1) _exit(0); }
};
A a;
int main() { return 1; }
EOF
rm -f conftest
eval $cc_compile
if test -s conftest && (./conftest) 2>/dev/null; then
:
else
cat <<EOM
$CCC is not installed correctly: static constructors and destructors do not work
EOM
rm -f conftest* core; exit 1
fi
rm -f conftest*
echo checking for C++ header files
cat <<EOF >conftest.cc
#include <stdio.h>
int main() { return 0; } void t() { fopen(0, 0); }
EOF
if eval $cc_compile; then
:
else
cat <<\EOF
Your header files do not appear to support C++.
I was unable to compile and link a simple C++ program that used a function
declared in <stdio.h>.
If you're using a version of gcc/g++ earlier than 2.5,
you should install libg++.
EOF
rm -f conftest* core; exit 1
fi
rm -f conftest*
if test -z "$PSPRINT"
then
for p in lpr
do
if test -z "$LPR"; then
# Extract the first word of `$p', so it can be a program name with args.
set dummy $p; word=$2
echo checking for $word
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/$word; then
LPR="$p"
break
fi
done
IFS="$saveifs"
fi
test -n "$LPR" && test -n "$verbose" && echo " setting LPR to $LPR"
test -n "$LPR" && break
done
for p in lp
do
if test -z "$LP"; then
# Extract the first word of `$p', so it can be a program name with args.
set dummy $p; word=$2
echo checking for $word
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/$word; then
LP="$p"
break
fi
done
IFS="$saveifs"
fi
test -n "$LP" && test -n "$verbose" && echo " setting LP to $LP"
test -n "$LP" && break
done
if test -n "$LPR" && test -n "$LP"
then
# HP-UX provides an lpr command that emulates lpr using lp,
# but it doesn't have lpq; in this case we want to use lp
# rather than lpr.
for p in lpq
do
if test -z "$LPQ"; then
# Extract the first word of `$p', so it can be a program name with args.
set dummy $p; word=$2
echo checking for $word
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/$word; then
LPQ="$p"
break
fi
done
IFS="$saveifs"
fi
test -n "$LPQ" && test -n "$verbose" && echo " setting LPQ to $LPQ"
test -n "$LPQ" && break
done
test -n "$LPQ" || LPR=
fi
if test -n "$LPR"
then
PSPRINT="$LPR"
elif test -n "$LP"
then
PSPRINT="$LP"
fi
fi
# Figure out DVIPRINT from PSPRINT.
if test -n "$PSPRINT" && test -z "$DVIPRINT"
then
if test "X$PSPRINT" = "Xlpr"
then
DVIPRINT="lpr -d"
else
DVIPRINT="$PSPRINT"
fi
fi
echo checking for perl
PERLPATH=
saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/perl; then
PERLPATH="$dir/perl"
break
fi
done
IFS="$saveifs"
if test -z "$YACC"; then
# Extract the first word of `byacc', so it can be a program name with args.
set dummy byacc; word=$2
echo checking for $word
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/$word; then
YACC="byacc"
break
fi
done
IFS="$saveifs"
fi
test -n "$YACC" && test -n "$verbose" && echo " setting YACC to $YACC"
if test -z "$YACC"; then
# Extract the first word of `bison', so it can be a program name with args.
set dummy bison; word=$2
echo checking for $word
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/$word; then
YACC="bison -y"
break
fi
done
IFS="$saveifs"
fi
test -z "$YACC" && YACC="yacc"
test -n "$YACC" && test -n "$verbose" && echo " setting YACC to $YACC"
if test -z "$RANLIB"; then
# Extract the first word of `ranlib', so it can be a program name with args.
set dummy ranlib; word=$2
echo checking for $word
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
if test -f $dir/$word; then
RANLIB="ranlib"
break
fi
done
IFS="$saveifs"
fi
test -z "$RANLIB" && RANLIB=":"
test -n "$RANLIB" && test -n "$verbose" && echo " setting RANLIB to $RANLIB"
# Make sure to not get the incompatible SysV /etc/install and
# /usr/sbin/install, which might be in PATH before a BSD-like install,
# or the SunOS /usr/etc/install directory, or the AIX /bin/install,
# or the AFS install, which mishandles nonexistent args, or
# /usr/ucb/install on SVR4, which tries to use the nonexistent group
# `staff'. On most BSDish systems install is in /usr/bin, not /usr/ucb
# anyway. Sigh.
if test "z${INSTALL}" = "z" ; then
echo checking for install
IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
test -z "$dir" && dir=.
case $dir in
/etc|/usr/sbin|/usr/etc|/usr/afsws/bin|/usr/ucb) ;;
*)
if test -f $dir/installbsd; then
INSTALL="$dir/installbsd -c" # OSF1
INSTALL_PROGRAM='$(INSTALL)'
INSTALL_DATA='$(INSTALL) -m 644'
break
fi
if test -f $dir/install; then
if grep dspmsg $dir/install >/dev/null 2>&1; then
: # AIX
else
INSTALL="$dir/install -c"
INSTALL_PROGRAM='$(INSTALL)'
INSTALL_DATA='$(INSTALL) -m 644'
break
fi
fi
;;
esac
done
IFS="$saveifs"
fi
INSTALL=${INSTALL-cp}
test -n "$verbose" && echo " setting INSTALL to $INSTALL"
INSTALL_PROGRAM=${INSTALL_PROGRAM-'$(INSTALL)'}
test -n "$verbose" && echo " setting INSTALL_PROGRAM to $INSTALL_PROGRAM"
INSTALL_DATA=${INSTALL_DATA-'$(INSTALL)'}
test -n "$verbose" && echo " setting INSTALL_DATA to $INSTALL_DATA"
echo checking for ln -s
rm -f conftestdata
if ln -s X conftestdata 2>/dev/null
then
rm -f conftestdata
LN_S="ln -s"
else
LN_S=ln
fi
echo checking for etags C++ option
for flag in p C
do
test -z "$ETAGSCCFLAG" || break
>conftest.c
(etags -$flag -o /dev/null conftest.c >/dev/null 2>&1) 2>/dev/null &&
ETAGSCCFLAG="-$flag"
rm -f conftest.c
done
echo 'checking for csh # hack'
cat <<EOF >conftest.sh
#!/bin/sh
true || exit 0
export PATH || exit 0
exit 1
EOF
chmod +x conftest.sh
if echo ./conftest.sh | (csh >/dev/null 2>&1) >/dev/null 2>&1
then
:; SH_SCRIPT_SED_CMD='1s/.*/:/'
else
:; SH_SCRIPT_SED_CMD=''
fi
rm -f conftest.sh
for hdr in unistd.h dirent.h limits.h sys/dir.h stdlib.h
do
trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
echo checking for ${hdr}
echo checking how to run the C preprocessor
if test -z "$CPP"; then
# This must be in double quotes, not single quotes, because CPP may get
# substituted into the Makefile and ``${CC-cc}'' will simply confuse
# make. It must be expanded now.
CPP="${CC-cc} -E"
cat > conftest.c <<EOF
#include "confdefs.h"
#include <stdio.h>
Syntax Error
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
:
else
rm -rf conftest*
CPP=/lib/cpp
fi
rm -f conftest*
fi
test ".${verbose}" != "." && echo " setting CPP to $CPP"
cat > conftest.c <<EOF
#include "confdefs.h"
#include <${hdr}>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining ${trhdr}"
echo "#define" ${trhdr} 1 >> confdefs.h
DEFS="$DEFS -D${trhdr}=1"
}
fi
rm -f conftest*
done
echo 'checking for ISC 3.x or 4.x'
if grep '[34]\.' /usr/options/cb.name >/dev/null 2>&1
then
{
test -n "$verbose" && \
echo " defining _SYSV3"
echo "#define" _SYSV3 1 >> confdefs.h
DEFS="$DEFS -D_SYSV3=1"
}
fi
echo checking for whether -D_POSIX_SOURCE is necessary
cat <<EOF >conftest.cc
#include <stdio.h>
int main() { return 0; } void t() { (void)fileno(stdin); }
EOF
if eval $cc_compile; then
:
else
{
test -n "$verbose" && \
echo " defining _POSIX_SOURCE"
echo "#define" _POSIX_SOURCE 1 >> confdefs.h
DEFS="$DEFS -D_POSIX_SOURCE=1"
}
fi
rm -f conftest*
echo checking for 'C++ <limits.h>'
cat <<EOF >conftest.cc
#include <limits.h>
int main() { return 0; } void t() { int x = INT_MIN; int y = INT_MAX; int z = UCHAR_MAX; }
EOF
if eval $cc_compile; then
{
test -n "$verbose" && \
echo " defining HAVE_CC_LIMITS_H"
echo "#define" HAVE_CC_LIMITS_H 1 >> confdefs.h
DEFS="$DEFS -DHAVE_CC_LIMITS_H=1"
}
fi
rm -f conftest*
echo checking for 'C++ <osfcn.h>'
cat <<EOF >conftest.cc
#include <osfcn.h>
int main() { return 0; } void t() { read(0, 0, 0); open(0, 0); }
EOF
if eval $cc_compile; then
{
test -n "$verbose" && \
echo " defining HAVE_CC_OSFCN_H"
echo "#define" HAVE_CC_OSFCN_H 1 >> confdefs.h
DEFS="$DEFS -DHAVE_CC_OSFCN_H=1"
}
fi
rm -f conftest*
echo checking for declaration of getopt in stdlib.h
cat <<EOF >conftest.cc
#include <stdlib.h>
extern "C" { void getopt(int); }
int main() { return 0; } void t() { }
EOF
if eval $cc_compile; then
:
else
{
test -n "$verbose" && \
echo " defining STDLIB_H_DECLARES_GETOPT"
echo "#define" STDLIB_H_DECLARES_GETOPT 1 >> confdefs.h
DEFS="$DEFS -DSTDLIB_H_DECLARES_GETOPT=1"
}
fi
rm -f conftest*
echo checking for declaration of getopt in unistd.h
cat <<EOF >conftest.cc
#include <sys/types.h>
#include <unistd.h>
extern "C" { void getopt(int); }
int main() { return 0; } void t() { }
EOF
if eval $cc_compile; then
:
else
{
test -n "$verbose" && \
echo " defining UNISTD_H_DECLARES_GETOPT"
echo "#define" UNISTD_H_DECLARES_GETOPT 1 >> confdefs.h
DEFS="$DEFS -DUNISTD_H_DECLARES_GETOPT=1"
}
fi
rm -f conftest*
echo checking for declaration of putenv
cat <<EOF >conftest.cc
#include <stdlib.h>
extern "C" { void putenv(int); }
int main() { return 0; } void t() { }
EOF
if eval $cc_compile; then
:
else
{
test -n "$verbose" && \
echo " defining STDLIB_H_DECLARES_PUTENV"
echo "#define" STDLIB_H_DECLARES_PUTENV 1 >> confdefs.h
DEFS="$DEFS -DSTDLIB_H_DECLARES_PUTENV=1"
}
fi
rm -f conftest*
echo checking for declaration of popen
cat <<EOF >conftest.cc
#include <stdio.h>
extern "C" { void popen(int); }
int main() { return 0; } void t() { }
EOF
if eval $cc_compile; then
:
else
{
test -n "$verbose" && \
echo " defining STDIO_H_DECLARES_POPEN"
echo "#define" STDIO_H_DECLARES_POPEN 1 >> confdefs.h
DEFS="$DEFS -DSTDIO_H_DECLARES_POPEN=1"
}
fi
rm -f conftest*
echo checking for declaration of pclose
cat <<EOF >conftest.cc
#include <stdio.h>
extern "C" { void pclose(int); }
int main() { return 0; } void t() { }
EOF
if eval $cc_compile; then
:
else
{
test -n "$verbose" && \
echo " defining STDIO_H_DECLARES_PCLOSE"
echo "#define" STDIO_H_DECLARES_PCLOSE 1 >> confdefs.h
DEFS="$DEFS -DSTDIO_H_DECLARES_PCLOSE=1"
}
fi
rm -f conftest*
echo checking for time_t
cat <<EOF >conftest.cc
#include <time.h>
int main() { return 0; } void t() { time_t t = time(0); struct tm *p = localtime(&t); }
EOF
if eval $cc_compile; then
:
else
{
test -n "$verbose" && \
echo " defining LONG_FOR_TIME_T"
echo "#define" LONG_FOR_TIME_T 1 >> confdefs.h
DEFS="$DEFS -DLONG_FOR_TIME_T=1"
}
fi
rm -f conftest*
echo checking for return type of signal handlers
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <signal.h>
#ifdef signal
#undef signal
#endif
extern void (*signal ()) ();
int main() { exit(0); }
int t() { int i; }
EOF
if eval $compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining" RETSIGTYPE to be void
echo "#define" RETSIGTYPE void >> confdefs.h
DEFS="$DEFS -DRETSIGTYPE=void"
}
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining" RETSIGTYPE to be int
echo "#define" RETSIGTYPE int >> confdefs.h
DEFS="$DEFS -DRETSIGTYPE=int"
}
fi
rm -f conftest*
echo checking for struct exception
cat > conftest.c <<EOF
#include "confdefs.h"
#include <math.h>
int main() { exit(0); }
int t() { struct exception e; }
EOF
if eval $compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_STRUCT_EXCEPTION"
echo "#define" HAVE_STRUCT_EXCEPTION 1 >> confdefs.h
DEFS="$DEFS -DHAVE_STRUCT_EXCEPTION=1"
}
fi
rm -f conftest*
echo checking for mmap
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/mman.h>
int main() { exit(0); }
int t() { char *p = mmap(0, 0, PROT_READ, MAP_PRIVATE, 0, 0); munmap(p, 0); }
EOF
if eval $compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_MMAP"
echo "#define" HAVE_MMAP 1 >> confdefs.h
DEFS="$DEFS -DHAVE_MMAP=1"
}
fi
rm -f conftest*
echo checking for pid_t in sys/types.h
echo '#include "confdefs.h"
#include <sys/types.h>' > conftest.c
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "pid_t" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining" pid_t to be int
echo "#define" pid_t int >> confdefs.h
DEFS="$DEFS -Dpid_t=int"
}
fi
rm -f conftest*
echo checking for vfork.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <vfork.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_VFORK_H"
echo "#define" HAVE_VFORK_H 1 >> confdefs.h
DEFS="$DEFS -DHAVE_VFORK_H=1"
}
fi
rm -f conftest*
echo checking for working vfork
cat > conftest.c <<EOF
#include "confdefs.h"
/* Thanks to Paul Eggert for this test. */
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_VFORK_H
#include <vfork.h>
#endif
static int signalled;
static RETSIGTYPE catch (s) int s; { signalled = 1; }
main() {
pid_t parent = getpid ();
pid_t child;
signal (SIGINT, catch);
child = vfork ();
if (child == 0) {
/* On sparc systems, changes by the child to local and incoming
argument registers are propagated back to the parent.
The compiler is told about this with #include <vfork.h>,
but some compilers (e.g. gcc -O) don't grok <vfork.h>.
Test for this by using lots of local variables, at least
as many local variables as main has allocated so far
including compiler temporaries. 4 locals are enough for
gcc 1.40.3 on a sparc, but we use 8 to be safe.
A buggy compiler should reuse the register of parent
for one of the local variables, since it will think that
parent can't possibly be used any more in this routine.
Assigning to the local variable will thus munge parent
in the parent process. */
pid_t
p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(),
p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid();
/* Convince the compiler that p..p7 are live; otherwise, it might
use the same hardware register for all 8 local variables. */
if (p != p1 || p != p2 || p != p3 || p != p4
|| p != p5 || p != p6 || p != p7)
_exit(1);
/* On some systems (e.g. SunOS 5.2), if the parent is catching
a signal, the child ignores the signal before execing,
and the parent later receives that signal, the parent dumps core.
Test for this by ignoring SIGINT in the child. */
signal (SIGINT, SIG_IGN);
/* On some systems (e.g. IRIX 3.3),
vfork doesn't separate parent from child file descriptors.
If the child closes a descriptor before it execs or exits,
this munges the parent's descriptor as well.
Test for this by closing stdout in the child. */
_exit(close(fileno(stdout)) != 0);
} else {
int status;
struct stat st;
while (wait(&status) != child)
;
exit(
/* Was there some problem with vforking? */
child < 0
/* Did the child fail? (This shouldn't happen.) */
|| status
/* Did the vfork/compiler bug occur? */
|| parent != getpid()
/* Did the signal handling bug occur? */
|| kill(parent, SIGINT) != 0
|| signalled != 1
/* Did the file descriptor bug occur? */
|| fstat(fileno(stdout), &st) != 0
);
}
}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
:
else
{
test -n "$verbose" && \
echo " defining" vfork to be fork
echo "#define" vfork fork >> confdefs.h
DEFS="$DEFS -Dvfork=fork"
}
fi
rm -fr conftest*
saved_libs="$LIBS"
LIBS="$LIBS -lm"
for func in fmod strtol getcwd strerror putenv
do
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() {
/* The GNU C library defines this for functions which it implements
to always fail with ENOSYS. Some functions are actually named
something starting with __ and the normal name is an alias. */
#if defined (__stub_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error. */
extern char ${func}(); ${func}();
#endif
}
EOF
if eval $compile; then
:
else
rm -rf conftest*
LIBOBJS="$LIBOBJS ${func}.o"
test -n "$verbose" && echo " using ${func}.o instead"
fi
rm -f conftest*
done
LIBS="$saved_libs"
for func in rename mkstemp
do
trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() {
/* The GNU C library defines this for functions which it implements
to always fail with ENOSYS. Some functions are actually named
something starting with __ and the normal name is an alias. */
#if defined (__stub_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error. */
extern char ${func}(); ${func}();
#endif
}
EOF
if eval $compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining ${trfunc}"
echo "#define" ${trfunc} 1 >> confdefs.h
DEFS="$DEFS -D${trfunc}=1"
}
fi
rm -f conftest*
done
echo checking for sys_siglist
cat > conftest.c <<EOF
#include "confdefs.h"
int main() { exit(0); }
int t() { extern char *sys_siglist[]; sys_siglist[0] = 0; }
EOF
if eval $compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_SYS_SIGLIST"
echo "#define" HAVE_SYS_SIGLIST 1 >> confdefs.h
DEFS="$DEFS -DHAVE_SYS_SIGLIST=1"
}
fi
rm -f conftest*
echo checking for gcc/g++ delete bug
cat <<EOF > conftest.cc
#include <stdlib.h>
#include <stddef.h>
int testit = 0;
int main()
{
testit = 1;
int *p = new int;
delete p;
testit = 0;
return 1;
}
static unsigned dummy[3];
void *operator new(size_t n)
{
if (testit) {
dummy[1] = -(unsigned)(dummy + 2);
return dummy + 2;
}
else
return (void *)malloc(n);
}
void operator delete(void *p)
{
if (testit) {
if (p == dummy)
exit(0);
}
else
free(p);
}
EOF
rm -f conftest
eval $cc_compile
if test -s conftest && (./conftest) 2>/dev/null; then
{
test -n "$verbose" && \
echo " defining COOKIE_BUG"
echo "#define" COOKIE_BUG 1 >> confdefs.h
DEFS="$DEFS -DCOOKIE_BUG=1"
}
fi
rm -f conftest*
echo checking for cfront ANSI C INT_MIN bug
cat <<EOF > conftest.cc
#include <stdlib.h>
#ifdef HAVE_CC_LIMITS_H
#include <limits.h>
#else
#define INT_MAX 2147483647
#endif
#undef INT_MIN
#define INT_MIN (-INT_MAX-1)
int main()
{
int z = 0;
return INT_MIN < z;
}
EOF
rm -f conftest
eval $cc_compile
if test -s conftest && (./conftest) 2>/dev/null; then
{
test -n "$verbose" && \
echo " defining CFRONT_ANSI_BUG"
echo "#define" CFRONT_ANSI_BUG 1 >> confdefs.h
DEFS="$DEFS -DCFRONT_ANSI_BUG=1"
}
fi
rm -f conftest*
echo checking for new array delete syntax
cat <<EOF >conftest.cc
int main() { return 0; } void t() { char *p = new char[5]; delete [] p; }
EOF
if eval $cc_compile; then
:
else
{
test -n "$verbose" && \
echo " defining ARRAY_DELETE_NEEDS_SIZE"
echo "#define" ARRAY_DELETE_NEEDS_SIZE 1 >> confdefs.h
DEFS="$DEFS -DARRAY_DELETE_NEEDS_SIZE=1"
}
fi
rm -f conftest*
echo checking for traditional preprocessor
cat <<EOF >conftest.cc
#define name2(a,b) a/**/b
int main() { return 0; } void t() { int name2(foo,bar); }
EOF
if eval $cc_compile; then
{
test -n "$verbose" && \
echo " defining TRADITIONAL_CPP"
echo "#define" TRADITIONAL_CPP 1 >> confdefs.h
DEFS="$DEFS -DTRADITIONAL_CPP=1"
}
fi
rm -f conftest*
echo checking for w_coredump
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/wait.h>
main()
{
#ifdef WCOREFLAG
exit(1);
#else
int i = 0;
((union wait *)&i)->w_coredump = 1;
exit(i != 0200);
#endif
}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
{
test -n "$verbose" && \
echo " defining" WCOREFLAG to be 0200
echo "#define" WCOREFLAG 0200 >> confdefs.h
DEFS="$DEFS -DWCOREFLAG=0200"
}
fi
rm -fr conftest*
test -n "${BROKEN_SPOOLER_FLAGS}" || BROKEN_SPOOLER_FLAGS=7
echo using default value of ${BROKEN_SPOOLER_FLAGS} for grops -b option
if test -z "$PAGE" && test -r $prefix/lib/groff/font/devps/DESC
then
if grep "^paperlength 841890" \
$prefix/lib/groff/font/devps/DESC >/dev/null 2>&1
then
PAGE=A4
else
PAGE=letter
fi
fi
if test -z "$PAGE"
then
dom=`awk '($1 == "dom" || $1 == "search") { print $2; exit}' \
/etc/resolv.conf 2>/dev/null`
if test -z "$dom"
then
dom=`(domainname) 2>/dev/null | tr -d '+'`
if test -z "$dom"
then
dom=`(hostname) 2>/dev/null | grep '\.'`
fi
fi
# If the top-level domain is two letters and it's not `us' or `ca'
# then they probably use A4 paper.
case "$dom" in
*.[Uu][Ss]|*.[Cc][Aa]) ;;
*.[A-Za-z][A-Za-z]) PAGE=A4 ;;
esac
fi
test -n "$PAGE" || PAGE=letter
echo guessing $PAGE size paper
# Set default prefixes.
if test -n "$prefix"; then
test -z "$exec_prefix" && exec_prefix='${prefix}'
prsub="s%^prefix\\([ ]*\\)=\\([ ]*\\).*$%prefix\\1=\\2$prefix%"
fi
if test -n "$exec_prefix"; then
prsub="$prsub
s%^exec_prefix\\([ ]*\\)=\\([ ]*\\).*$%exec_prefix\\1=\\2$exec_prefix%"
fi
# Quote sed substitution magic chars in DEFS.
cat >conftest.def <<EOF
$DEFS
EOF
escape_ampersand_and_backslash='s%[&\\]%\\&%g'
DEFS=`sed "$escape_ampersand_and_backslash" <conftest.def`
rm -f conftest.def
# Substitute for predefined variables.
trap 'rm -f config.status; exit 1' 1 3 15
echo creating config.status
rm -f config.status
cat > config.status <<EOF
#!/bin/sh
# Generated automatically by configure.
# Run this file to recreate the current configuration.
# This directory was configured as follows,
# on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
#
# $0 $configure_args
for arg
do
case "\$arg" in
-recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
echo running \${CONFIG_SHELL-/bin/sh} $0 $configure_args
exec \${CONFIG_SHELL-/bin/sh} $0 $configure_args ;;
*) echo "Usage: config.status --recheck" 2>&1; exit 1 ;;
esac
done
trap 'rm -f Makefile; exit 1' 1 3 15
CC='$CC'
CCLIBS='$CCLIBS'
CCC='$CCC'
LPR='$LPR'
LP='$LP'
LPQ='$LPQ'
PSPRINT='$PSPRINT'
DVIPRINT='$DVIPRINT'
PERLPATH='$PERLPATH'
YACC='$YACC'
RANLIB='$RANLIB'
INSTALL='$INSTALL'
INSTALL_PROGRAM='$INSTALL_PROGRAM'
INSTALL_DATA='$INSTALL_DATA'
LN_S='$LN_S'
ETAGSCCFLAG='$ETAGSCCFLAG'
SH_SCRIPT_SED_CMD='$SH_SCRIPT_SED_CMD'
CPP='$CPP'
LIBOBJS='$LIBOBJS'
BROKEN_SPOOLER_FLAGS='$BROKEN_SPOOLER_FLAGS'
PAGE='$PAGE'
LIBS='$LIBS'
srcdir='$srcdir'
DEFS='$DEFS'
prefix='$prefix'
exec_prefix='$exec_prefix'
prsub='$prsub'
extrasub='$extrasub'
EOF
cat >> config.status <<\EOF
top_srcdir=$srcdir
CONFIG_FILES=${CONFIG_FILES-"Makefile"}
for file in .. ${CONFIG_FILES}; do if test "x$file" != x..; then
srcdir=$top_srcdir
# Remove last slash and all that follows it. Not all systems have dirname.
dir=`echo $file|sed 's%/[^/][^/]*$%%'`
if test "$dir" != "$file"; then
test "$top_srcdir" != . && srcdir=$top_srcdir/$dir
test ! -d $dir && mkdir $dir
fi
echo creating $file
rm -f $file
echo "# Generated automatically from `echo $file|sed 's|.*/||'`.in by configure." > $file
sed -e "
$prsub
$extrasub
s%@CC@%$CC%g
s%@CCLIBS@%$CCLIBS%g
s%@CCC@%$CCC%g
s%@LPR@%$LPR%g
s%@LP@%$LP%g
s%@LPQ@%$LPQ%g
s%@PSPRINT@%$PSPRINT%g
s%@DVIPRINT@%$DVIPRINT%g
s%@PERLPATH@%$PERLPATH%g
s%@YACC@%$YACC%g
s%@RANLIB@%$RANLIB%g
s%@INSTALL@%$INSTALL%g
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
s%@INSTALL_DATA@%$INSTALL_DATA%g
s%@LN_S@%$LN_S%g
s%@ETAGSCCFLAG@%$ETAGSCCFLAG%g
s%@SH_SCRIPT_SED_CMD@%$SH_SCRIPT_SED_CMD%g
s%@CPP@%$CPP%g
s%@LIBOBJS@%$LIBOBJS%g
s%@BROKEN_SPOOLER_FLAGS@%$BROKEN_SPOOLER_FLAGS%g
s%@PAGE@%$PAGE%g
s%@LIBS@%$LIBS%g
s%@srcdir@%$srcdir%g
s%@DEFS@%$DEFS%
" $top_srcdir/${file}.in >> $file
fi; done
exit 0
EOF
chmod +x config.status
${CONFIG_SHELL-/bin/sh} config.status
Reference in New Issue View Git Blame Copy Permalink