#!/bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf version 1.11
# Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
# This configure script 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 script 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.
# Save the original args to write them into config.status later.
configure_args="$*"
# Only options that might do something get documented.
ac_usage="Usage: configure [options] [host]
Options: [defaults in brackets after descriptions]
--build=BUILD configure for building on BUILD [BUILD=HOST]
--disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
--enable-FEATURE[=ARG] include FEATURE [ARG=yes]
--exec-prefix=PREFIX install host dependent files in PREFIX [/usr/local]
--help print this message
--host=HOST configure for HOST [guessed]
--prefix=PREFIX install host independent files in PREFIX [/usr/local]
--quiet, --silent do not print \`checking for...' messages
--srcdir=DIR find the sources in DIR [configure dir or ..]
--target=TARGET configure for TARGET [TARGET=HOST]
--verbose print results of checks
--version print the version of autoconf that created configure
--with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
--without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
--x-includes=DIR X include files are in DIR
--x-libraries=DIR X library files are in DIR"
# Initialize some variables set by options.
# The variables have the same names as the options, with
# dashes changed to underlines.
build=NONE
exec_prefix=
host=NONE
no_create=
nonopt=NONE
norecursion=
prefix=
program_prefix=
program_suffix=
program_transform_name=
silent=
srcdir=
target=NONE
verbose=
x_includes=
x_libraries=
ac_prev=
for ac_option
do
# If the previous option needs an argument, assign it.
if test -n "$ac_prev"; then
eval "$ac_prev=\$ac_option"
ac_prev=
continue
fi
# Accept (but ignore some of) the important Cygnus configure
# options, so we can diagnose typos.
case "$ac_option" in
-*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
*) ac_optarg= ;;
esac
case "$ac_option" in
-build | --build | --buil | --bui | --bu | --b)
ac_prev=build ;;
-build=* | --build=* | --buil=* | --bui=* | --bu=* | --b=*)
build="$ac_optarg" ;;
-disable-* | --disable-*)
ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
# Reject names that aren't valid shell variable names.
if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
echo "configure: $ac_feature: invalid feature name" >&2; exit 1
fi
ac_feature=`echo $ac_feature| sed 's/-/_/g'`
eval "enable_${ac_feature}=no" ;;
-enable-* | --enable-*)
ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
# Reject names that aren't valid shell variable names.
if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
echo "configure: $ac_feature: invalid feature name" >&2; exit 1
fi
ac_feature=`echo $ac_feature| sed 's/-/_/g'`
case "$ac_option" in
*=*) ;;
*) ac_optarg=yes ;;
esac
eval "enable_${ac_feature}='$ac_optarg'" ;;
# 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)
ac_prev=exec_prefix ;;
-exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
| --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
| --exec=* | --exe=* | --ex=*)
exec_prefix="$ac_optarg" ;;
-gas | --gas | --ga | --g)
with_gas=yes ;; # Obsolete; use --with-gas.
-help | --help | --hel | --he)
cat << EOF
$ac_usage
EOF
exit 0 ;;
-host | --host | --hos | --ho)
ac_prev=host ;;
-host=* | --host=* | --hos=* | --ho=*)
host="$ac_optarg" ;;
-nfp | --nfp | --nf)
with_fp=no ;; # Obsolete; use --without-fp.
-no-create | --no-create | --no-creat | --no-crea | --no-cre \
| --no-cr | --no-c)
no_create=yes ;;
-norecursion | --norecursion | --norecursio | --norecursi \
| --norecurs | --norecur | --norecu | --norec | --nore | --nor)
norecursion=yes ;;
-prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
ac_prev=prefix ;;
-prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
prefix="$ac_optarg" ;;
-program-prefix | --program-prefix | --program-prefi | --program-pref \
| --program-pre | --program-pr | --program-p)
ac_prev=program_prefix ;;
-program-prefix=* | --program-prefix=* | --program-prefi=* \
| --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
program_prefix="$ac_optarg" ;;
-program-suffix | --program-suffix | --program-suffi | --program-suff \
| --program-suf | --program-su | --program-s)
ac_prev=program_suffix ;;
-program-suffix=* | --program-suffix=* | --program-suffi=* \
| --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
program_suffix="$ac_optarg" ;;
-program-transform-name | --program-transform-name \
| --program-transform-nam | --program-transform-na \
| --program-transform-n | --program-transform- \
| --program-transform | --program-transfor \
| --program-transfo | --program-transf \
| --program-trans | --program-tran \
| --progr-tra | --program-tr | --program-t)
ac_prev=program_transform_name ;;
-program-transform-name=* | --program-transform-name=* \
| --program-transform-nam=* | --program-transform-na=* \
| --program-transform-n=* | --program-transform-=* \
| --program-transform=* | --program-transfor=* \
| --program-transfo=* | --program-transf=* \
| --program-trans=* | --program-tran=* \
| --progr-tra=* | --program-tr=* | --program-t=*)
program_transform_name="$ac_optarg" ;;
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
| -silent | --silent | --silen | --sile | --sil)
silent=yes ;;
-srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
ac_prev=srcdir ;;
-srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
srcdir="$ac_optarg" ;;
-target | --target | --targe | --targ | --tar | --ta | --t)
ac_prev=target ;;
-target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
target="$ac_optarg" ;;
-v | -verbose | --verbose | --verbos | --verbo | --verb)
verbose=yes ;;
-version | --version | --versio | --versi | --vers)
echo "configure generated by autoconf version 1.11"
exit 0 ;;
-with-* | --with-*)
ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
# Reject names that aren't valid shell variable names.
if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
echo "configure: $ac_package: invalid package name" >&2; exit 1
fi
ac_package=`echo $ac_package| sed 's/-/_/g'`
case "$ac_option" in
*=*) ;;
*) ac_optarg=yes ;;
esac
eval "with_${ac_package}='$ac_optarg'" ;;
-without-* | --without-*)
ac_package=`echo $ac_option|sed -e 's/-*without-//'`
# Reject names that aren't valid shell variable names.
if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
echo "configure: $ac_package: invalid package name" >&2; exit 1
fi
ac_package=`echo $ac_package| sed 's/-/_/g'`
eval "with_${ac_package}=no" ;;
--x) with_x=yes ;; # Obsolete; use --with-x.
-x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
| --x-incl | --x-inc | --x-in | --x-i)
ac_prev=x_includes ;;
-x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
| --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
x_includes="$ac_optarg" ;;
-x-libraries | --x-libraries | --x-librarie | --x-librari \
| --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
ac_prev=x_libraries ;;
-x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
| --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
x_libraries="$ac_optarg" ;;
-*) echo "configure: $ac_option: invalid option; use --help to show usage" >&2; exit 1
;;
*)
if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
echo "configure: warning: $ac_option: invalid host type" >&2
fi
if test "x$nonopt" != xNONE; then
echo "configure: can only configure for one host and one target at a time" >&2; exit 1
fi
nonopt="$ac_option"
;;
esac
done
if test -n "$ac_prev"; then
echo "configure: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" >&2; exit 1
fi
trap 'rm -fr conftest* confdefs* core $ac_clean_files; exit 1' 1 2 15
trap 'rm -fr confdefs* $ac_clean_files' 0
# Save the original args if we used an alternate arg parser.
ac_configure_temp="${configure_args-$*}"
# Strip out --no-create and --norecursion so they don't pile up.
configure_args=
for ac_arg in $ac_configure_temp; do
case "$ac_arg" in
-no-create | --no-create | --no-creat | --no-crea | --no-cre \
| --no-cr | --no-c) ;;
-norecursion | --norecursion | --norecursio | --norecursi \
| --norecurs | --norecur | --norecu | --norec | --nore | --nor) ;;
*) configure_args="$configure_args $ac_arg" ;;
esac
done
# 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
# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -rf conftest* confdefs.h
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
echo > confdefs.h
# 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.
ac_unique_file=mudconf.h
# Find the source files, if location was not specified.
if test -z "$srcdir"; then
ac_srcdir_defaulted=yes
# Try the directory containing this script, then `../src'.
ac_prog=$0
ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
srcdir=$ac_confdir
if test ! -r $srcdir/$ac_unique_file; then
srcdir=../src
fi
fi
if test ! -r $srcdir/$ac_unique_file; then
if test x$ac_srcdir_defaulted = xyes; then
echo "configure: can not find sources in ${ac_confdir} or ../src" >&2; exit 1
else
echo "configure: can not find sources in ${srcdir}" >&2; exit 1
fi
fi
ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='${CPP}'
ac_compile='${CC-cc} $CFLAGS $LDFLAGS conftest.${ac_ext} -o conftest $LIBS >/dev/null 2>&1'
if test -z "$CC"; then
# Extract the first word of `gcc', so it can be a program name with args.
set ac_dummy gcc; ac_word=$2
test -n "$silent" || echo "checking for $ac_word"
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
for ac_dir in $PATH; do
test -z "$ac_dir" && ac_dir=.
if test -f $ac_dir/$ac_word; then
CC="gcc"
break
fi
done
IFS="$ac_save_ifs"
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*
test -n "$silent" || 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.${ac_ext} <<EOF
#include "confdefs.h"
#include <stdio.h>
Syntax Error
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
:
else
rm -rf conftest*
CPP="${CC-cc} -E -traditional-cpp"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <stdio.h>
Syntax Error
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
:
else
rm -rf conftest*
CPP=/lib/cpp
fi
rm -f conftest*
fi
rm -f conftest*
fi
test -n "$verbose" && echo " setting CPP to $CPP"
test -n "$silent" || echo "checking for POSIXized ISC"
if test -d /etc/conf/kconfig.d &&
grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1
then
ISC=1 # If later tests want to check for ISC.
{
test -n "$verbose" && \
echo " defining _POSIX_SOURCE"
echo "#define" _POSIX_SOURCE "1" >> confdefs.h
DEFS="$DEFS -D_POSIX_SOURCE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_POSIX_SOURCE\${ac_dB}_POSIX_SOURCE\${ac_dC}1\${ac_dD}
\${ac_uA}_POSIX_SOURCE\${ac_uB}_POSIX_SOURCE\${ac_uC}1\${ac_uD}
\${ac_eA}_POSIX_SOURCE\${ac_eB}_POSIX_SOURCE\${ac_eC}1\${ac_eD}
"
}
if test -n "$GCC"; then
CC="$CC -posix"
else
CC="$CC -Xp"
fi
fi
test -n "$silent" || echo "checking for minix/config.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <minix/config.h>
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
rm -rf conftest*
MINIX=1
fi
rm -f conftest*
# The Minix shell can't assign to the same variable on the same line!
if test -n "$MINIX"; then
{
test -n "$verbose" && \
echo " defining _POSIX_SOURCE"
echo "#define" _POSIX_SOURCE "1" >> confdefs.h
DEFS="$DEFS -D_POSIX_SOURCE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_POSIX_SOURCE\${ac_dB}_POSIX_SOURCE\${ac_dC}1\${ac_dD}
\${ac_uA}_POSIX_SOURCE\${ac_uB}_POSIX_SOURCE\${ac_uC}1\${ac_uD}
\${ac_eA}_POSIX_SOURCE\${ac_eB}_POSIX_SOURCE\${ac_eC}1\${ac_eD}
"
}
{
test -n "$verbose" && \
echo " defining" _POSIX_1_SOURCE to be "2"
echo "#define" _POSIX_1_SOURCE "2" >> confdefs.h
DEFS="$DEFS -D_POSIX_1_SOURCE=2"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_POSIX_1_SOURCE\${ac_dB}_POSIX_1_SOURCE\${ac_dC}2\${ac_dD}
\${ac_uA}_POSIX_1_SOURCE\${ac_uB}_POSIX_1_SOURCE\${ac_uC}2\${ac_uD}
\${ac_eA}_POSIX_1_SOURCE\${ac_eB}_POSIX_1_SOURCE\${ac_eC}2\${ac_eD}
"
}
{
test -n "$verbose" && \
echo " defining _MINIX"
echo "#define" _MINIX "1" >> confdefs.h
DEFS="$DEFS -D_MINIX=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_MINIX\${ac_dB}_MINIX\${ac_dC}1\${ac_dD}
\${ac_uA}_MINIX\${ac_uB}_MINIX\${ac_uC}1\${ac_uD}
\${ac_eA}_MINIX\${ac_eB}_MINIX\${ac_eC}1\${ac_eD}
"
}
fi
test -n "$silent" || echo "checking for ANSI C header files"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <float.h>
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
rm -rf conftest*
# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
echo '#include "confdefs.h"
#include <string.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "memchr" conftest.out >/dev/null 2>&1; then
rm -rf conftest*
# SGI's /bin/cc from Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
#define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
#define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
#define XOR(e,f) (((e) && !(f)) || (!(e) && (f)))
int main () { int i; for (i = 0; i < 256; i++)
if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2);
exit (0); }
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
echo '#include "confdefs.h"
#include <stdlib.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "free" conftest.out >/dev/null 2>&1; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining STDC_HEADERS"
echo "#define" STDC_HEADERS "1" >> confdefs.h
DEFS="$DEFS -DSTDC_HEADERS=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}STDC_HEADERS\${ac_dB}STDC_HEADERS\${ac_dC}1\${ac_dD}
\${ac_uA}STDC_HEADERS\${ac_uB}STDC_HEADERS\${ac_uC}1\${ac_uD}
\${ac_eA}STDC_HEADERS\${ac_eB}STDC_HEADERS\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
fi
rm -fr conftest*
fi
rm -f conftest*
fi
rm -f conftest*
for ac_hdr in unistd.h memory.h string.h errno.h malloc.h sys/select.h
do
ac_tr_hdr=HAVE_`echo $ac_hdr | tr '[a-z]./' '[A-Z]__'`
test -n "$silent" || echo "checking for ${ac_hdr}"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <${ac_hdr}>
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_err"; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining ${ac_tr_hdr}"
echo "#define" ${ac_tr_hdr} "1" >> confdefs.h
DEFS="$DEFS -D${ac_tr_hdr}=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_hdr}\${ac_dB}${ac_tr_hdr}\${ac_dC}1\${ac_dD}
\${ac_uA}${ac_tr_hdr}\${ac_uB}${ac_tr_hdr}\${ac_uC}1\${ac_uD}
\${ac_eA}${ac_tr_hdr}\${ac_eB}${ac_tr_hdr}\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
done
test -n "$silent" || echo "checking for whether time.h and sys/time.h may both be included"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/time.h>
#include <time.h>
int main() { return 0; }
int t() { struct tm *tp;; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining TIME_WITH_SYS_TIME"
echo "#define" TIME_WITH_SYS_TIME "1" >> confdefs.h
DEFS="$DEFS -DTIME_WITH_SYS_TIME=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}TIME_WITH_SYS_TIME\${ac_dB}TIME_WITH_SYS_TIME\${ac_dC}1\${ac_dD}
\${ac_uA}TIME_WITH_SYS_TIME\${ac_uB}TIME_WITH_SYS_TIME\${ac_uC}1\${ac_uD}
\${ac_eA}TIME_WITH_SYS_TIME\${ac_eB}TIME_WITH_SYS_TIME\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
test -n "$silent" || echo "checking for pid_t in sys/types.h"
echo '#include "confdefs.h"
#include <sys/types.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > 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"
ac_sed_defs="${ac_sed_defs}\${ac_dA}pid_t\${ac_dB}pid_t\${ac_dC}int\${ac_dD}
\${ac_uA}pid_t\${ac_uB}pid_t\${ac_uC}int\${ac_uD}
\${ac_eA}pid_t\${ac_eB}pid_t\${ac_eC}int\${ac_eD}
"
}
fi
rm -f conftest*
test -n "$silent" || echo "checking for vfork.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <vfork.h>
EOF
# Some shells (Coherent) do redirections in the wrong order, so need
# the parens.
ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"`
if test -z "$ac_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"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_VFORK_H\${ac_dB}HAVE_VFORK_H\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_VFORK_H\${ac_uB}HAVE_VFORK_H\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_VFORK_H\${ac_eB}HAVE_VFORK_H\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
test -n "$silent" || echo "checking for working vfork"
test -n "$silent" || echo "checking for return type of signal handlers"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <signal.h>
#ifdef signal
#undef signal
#endif
extern void (*signal ()) ();
int main() { return 0; }
int t() { int i;; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining" RETSIGTYPE to be "void"
echo "#define" RETSIGTYPE "void" >> confdefs.h
DEFS="$DEFS -DRETSIGTYPE=void"
ac_sed_defs="${ac_sed_defs}\${ac_dA}RETSIGTYPE\${ac_dB}RETSIGTYPE\${ac_dC}void\${ac_dD}
\${ac_uA}RETSIGTYPE\${ac_uB}RETSIGTYPE\${ac_uC}void\${ac_uD}
\${ac_eA}RETSIGTYPE\${ac_eB}RETSIGTYPE\${ac_eC}void\${ac_eD}
"
}
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining" RETSIGTYPE to be "int"
echo "#define" RETSIGTYPE "int" >> confdefs.h
DEFS="$DEFS -DRETSIGTYPE=int"
ac_sed_defs="${ac_sed_defs}\${ac_dA}RETSIGTYPE\${ac_dB}RETSIGTYPE\${ac_dC}int\${ac_dD}
\${ac_uA}RETSIGTYPE\${ac_uB}RETSIGTYPE\${ac_uC}int\${ac_uD}
\${ac_eA}RETSIGTYPE\${ac_eB}RETSIGTYPE\${ac_eC}int\${ac_eD}
"
}
fi
rm -f conftest*
cat > conftest.${ac_ext} <<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 $ac_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"
ac_sed_defs="${ac_sed_defs}\${ac_dA}vfork\${ac_dB}vfork\${ac_dC}fork\${ac_dD}
\${ac_uA}vfork\${ac_uB}vfork\${ac_uC}fork\${ac_uD}
\${ac_eA}vfork\${ac_eB}vfork\${ac_eC}fork\${ac_eD}
"
}
fi
rm -fr conftest*
test -n "$silent" || echo "checking for vprintf"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { vprintf();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_VPRINTF"
echo "#define" HAVE_VPRINTF "1" >> confdefs.h
DEFS="$DEFS -DHAVE_VPRINTF=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_VPRINTF\${ac_dB}HAVE_VPRINTF\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_VPRINTF\${ac_uB}HAVE_VPRINTF\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_VPRINTF\${ac_eB}HAVE_VPRINTF\${ac_eC}1\${ac_eD}
"
}
else
rm -rf conftest*
ac_vprintf_missing=1
fi
rm -f conftest*
if test -n "$ac_vprintf_missing"; then
test -n "$silent" || echo "checking for _doprnt"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { _doprnt();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_DOPRNT"
echo "#define" HAVE_DOPRNT "1" >> confdefs.h
DEFS="$DEFS -DHAVE_DOPRNT=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_DOPRNT\${ac_dB}HAVE_DOPRNT\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_DOPRNT\${ac_uB}HAVE_DOPRNT\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_DOPRNT\${ac_eB}HAVE_DOPRNT\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
fi
for ac_func in setrlimit getrusage timelocal mktime srandom
do
ac_tr_func=HAVE_`echo $ac_func | tr '[a-z]' '[A-Z]'`
test -n "$silent" || echo "checking for ${ac_func}"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 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_${ac_func}) || defined (__stub___${ac_func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error. */
extern char ${ac_func}(); ${ac_func}();
#endif
; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining ${ac_tr_func}"
echo "#define" ${ac_tr_func} "1" >> confdefs.h
DEFS="$DEFS -D${ac_tr_func}=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_func}\${ac_dB}${ac_tr_func}\${ac_dC}1\${ac_dD}
\${ac_uA}${ac_tr_func}\${ac_uB}${ac_tr_func}\${ac_uC}1\${ac_uD}
\${ac_eA}${ac_tr_func}\${ac_eB}${ac_tr_func}\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
done
for ac_func in getpagesize getdtablesize socket gethostbyaddr
do
ac_tr_func=HAVE_`echo $ac_func | tr '[a-z]' '[A-Z]'`
test -n "$silent" || echo "checking for ${ac_func}"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 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_${ac_func}) || defined (__stub___${ac_func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error. */
extern char ${ac_func}(); ${ac_func}();
#endif
; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining ${ac_tr_func}"
echo "#define" ${ac_tr_func} "1" >> confdefs.h
DEFS="$DEFS -D${ac_tr_func}=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_func}\${ac_dB}${ac_tr_func}\${ac_dC}1\${ac_dD}
\${ac_uA}${ac_tr_func}\${ac_uB}${ac_tr_func}\${ac_uC}1\${ac_uD}
\${ac_eA}${ac_tr_func}\${ac_eB}${ac_tr_func}\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
done
for ac_func in gettimeofday
do
ac_tr_func=HAVE_`echo $ac_func | tr '[a-z]' '[A-Z]'`
test -n "$silent" || echo "checking for ${ac_func}"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 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_${ac_func}) || defined (__stub___${ac_func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error. */
extern char ${ac_func}(); ${ac_func}();
#endif
; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining ${ac_tr_func}"
echo "#define" ${ac_tr_func} "1" >> confdefs.h
DEFS="$DEFS -D${ac_tr_func}=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_func}\${ac_dB}${ac_tr_func}\${ac_dC}1\${ac_dD}
\${ac_uA}${ac_tr_func}\${ac_uB}${ac_tr_func}\${ac_uC}1\${ac_uD}
\${ac_eA}${ac_tr_func}\${ac_eB}${ac_tr_func}\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
done
test -n "$silent" || echo "checking for return type of signal handlers"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <signal.h>
#ifdef signal
#undef signal
#endif
extern void (*signal ()) ();
int main() { return 0; }
int t() { int i;; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining" RETSIGTYPE to be "void"
echo "#define" RETSIGTYPE "void" >> confdefs.h
DEFS="$DEFS -DRETSIGTYPE=void"
ac_sed_defs="${ac_sed_defs}\${ac_dA}RETSIGTYPE\${ac_dB}RETSIGTYPE\${ac_dC}void\${ac_dD}
\${ac_uA}RETSIGTYPE\${ac_uB}RETSIGTYPE\${ac_uC}void\${ac_uD}
\${ac_eA}RETSIGTYPE\${ac_eB}RETSIGTYPE\${ac_eC}void\${ac_eD}
"
}
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining" RETSIGTYPE to be "int"
echo "#define" RETSIGTYPE "int" >> confdefs.h
DEFS="$DEFS -DRETSIGTYPE=int"
ac_sed_defs="${ac_sed_defs}\${ac_dA}RETSIGTYPE\${ac_dB}RETSIGTYPE\${ac_dC}int\${ac_dD}
\${ac_uA}RETSIGTYPE\${ac_uB}RETSIGTYPE\${ac_uC}int\${ac_uD}
\${ac_eA}RETSIGTYPE\${ac_eB}RETSIGTYPE\${ac_eC}int\${ac_eD}
"
}
fi
rm -f conftest*
test -n "$silent" || echo "checking for struct sigcontext argument in signal handlers"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/signal.h>
int main() { return 0; }
int t() { struct sigcontext scp;; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_STRUCT_SIGCONTEXT"
echo "#define" HAVE_STRUCT_SIGCONTEXT "1" >> confdefs.h
DEFS="$DEFS -DHAVE_STRUCT_SIGCONTEXT=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_STRUCT_SIGCONTEXT\${ac_dB}HAVE_STRUCT_SIGCONTEXT\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_STRUCT_SIGCONTEXT\${ac_uB}HAVE_STRUCT_SIGCONTEXT\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_STRUCT_SIGCONTEXT\${ac_eB}HAVE_STRUCT_SIGCONTEXT\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
test -n "$silent" || echo "checking for wait3 that fills in rusage"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <stdio.h>
/* HP-UX has wait3 but does not fill in rusage at all. */
main() {
struct rusage r;
int i;
/* Use a field that we can force nonzero --
voluntary context switches.
For systems like NeXT and OSF/1 that don't set it,
also use the system CPU time. */
r.ru_nvcsw = 0;
r.ru_stime.tv_sec = 0;
r.ru_stime.tv_usec = 0;
switch (fork()) {
case 0: /* Child. */
sleep(1); /* Give up the CPU. */
_exit(0);
case -1: _exit(0); /* What can we do? */
default: /* Parent. */
wait3(&i, 0, &r);
sleep(1); /* Avoid "text file busy" from rm on fast HP-UX machines. */
exit(r.ru_nvcsw == 0
&& r.ru_stime.tv_sec == 0 && r.ru_stime.tv_usec == 0);
}
}
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
{
test -n "$verbose" && \
echo " defining HAVE_WAIT3"
echo "#define" HAVE_WAIT3 "1" >> confdefs.h
DEFS="$DEFS -DHAVE_WAIT3=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_WAIT3\${ac_dB}HAVE_WAIT3\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_WAIT3\${ac_uB}HAVE_WAIT3\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_WAIT3\${ac_eB}HAVE_WAIT3\${ac_eC}1\${ac_eD}
"
}
fi
rm -fr conftest*
test -n "$silent" || echo "checking for struct tm in time.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <time.h>
int main() { return 0; }
int t() { struct tm *tp; tp->tm_sec;; return 0; }
EOF
if eval $ac_compile; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining TM_IN_SYS_TIME"
echo "#define" TM_IN_SYS_TIME "1" >> confdefs.h
DEFS="$DEFS -DTM_IN_SYS_TIME=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}TM_IN_SYS_TIME\${ac_dB}TM_IN_SYS_TIME\${ac_dC}1\${ac_dD}
\${ac_uA}TM_IN_SYS_TIME\${ac_uB}TM_IN_SYS_TIME\${ac_uC}1\${ac_uD}
\${ac_eA}TM_IN_SYS_TIME\${ac_eB}TM_IN_SYS_TIME\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
ac_decl='#include <sys/types.h>
'
case "$DEFS" in
*TM_IN_SYS_TIME*) ac_decl="$ac_decl
#include <sys/time.h>
" ;;
*) ac_decl="$ac_decl
#include <time.h>
" ;;
esac
test -n "$silent" || echo "checking for tm_zone in struct tm"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
$ac_decl
int main() { return 0; }
int t() { struct tm tm; tm.tm_zone;; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_TM_ZONE"
echo "#define" HAVE_TM_ZONE "1" >> confdefs.h
DEFS="$DEFS -DHAVE_TM_ZONE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_TM_ZONE\${ac_dB}HAVE_TM_ZONE\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_TM_ZONE\${ac_uB}HAVE_TM_ZONE\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_TM_ZONE\${ac_eB}HAVE_TM_ZONE\${ac_eC}1\${ac_eD}
"
}
else
rm -rf conftest*
ac_no_tm_zone=1
fi
rm -f conftest*
if test -n "$ac_no_tm_zone"; then
test -n "$silent" || echo "checking for tzname"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <time.h>
#ifndef tzname /* For SGI. */
extern char *tzname[]; /* RS6000 and others want it this way. */
#endif
int main() { return 0; }
int t() { atoi(*tzname);; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_TZNAME"
echo "#define" HAVE_TZNAME "1" >> confdefs.h
DEFS="$DEFS -DHAVE_TZNAME=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_TZNAME\${ac_dB}HAVE_TZNAME\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_TZNAME\${ac_uB}HAVE_TZNAME\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_TZNAME\${ac_eB}HAVE_TZNAME\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
fi
test -n "$silent" || echo "checking for pid_t in sys/types.h"
echo '#include "confdefs.h"
#include <sys/types.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > 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"
ac_sed_defs="${ac_sed_defs}\${ac_dA}pid_t\${ac_dB}pid_t\${ac_dC}int\${ac_dD}
\${ac_uA}pid_t\${ac_uB}pid_t\${ac_uC}int\${ac_uD}
\${ac_eA}pid_t\${ac_eB}pid_t\${ac_eC}int\${ac_eD}
"
}
fi
rm -f conftest*
test -n "$silent" || echo "checking for union wait"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/wait.h>
int main() { return 0; }
int t() { union wait stat;; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_UNION_WAIT"
echo "#define" HAVE_UNION_WAIT "1" >> confdefs.h
DEFS="$DEFS -DHAVE_UNION_WAIT=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_UNION_WAIT\${ac_dB}HAVE_UNION_WAIT\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_UNION_WAIT\${ac_uB}HAVE_UNION_WAIT\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_UNION_WAIT\${ac_eB}HAVE_UNION_WAIT\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
echo checking for extended string dcls
echo '#include "confdefs.h"
#include <string.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "rindex" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining NEED_INDEX_DCL"
echo "#define" NEED_INDEX_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED_INDEX_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_INDEX_DCL\${ac_dB}NEED_INDEX_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_INDEX_DCL\${ac_uB}NEED_INDEX_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_INDEX_DCL\${ac_eB}NEED_INDEX_DCL\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
echo checking for malloc dcl
echo '#include "confdefs.h"
#include <stdlib.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "realloc" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining NEED_MALLOC_DCL"
echo "#define" NEED_MALLOC_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED_MALLOC_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_MALLOC_DCL\${ac_dB}NEED_MALLOC_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_MALLOC_DCL\${ac_uB}NEED_MALLOC_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_MALLOC_DCL\${ac_eB}NEED_MALLOC_DCL\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
echo checking for vsprintf dcl
echo '#include "confdefs.h"
#include <stdio.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "vsprintf" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining NEED_VSPRINTF_DCL"
echo "#define" NEED_VSPRINTF_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED_VSPRINTF_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_VSPRINTF_DCL\${ac_dB}NEED_VSPRINTF_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_VSPRINTF_DCL\${ac_uB}NEED_VSPRINTF_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_VSPRINTF_DCL\${ac_eB}NEED_VSPRINTF_DCL\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
echo checking for sprintf dcl
echo '#include "confdefs.h"
#include <stdio.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "\<sprintf|\<*sprintf" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining NEED_SPRINTF_DCL"
echo "#define" NEED_SPRINTF_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED_SPRINTF_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_SPRINTF_DCL\${ac_dB}NEED_SPRINTF_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_SPRINTF_DCL\${ac_uB}NEED_SPRINTF_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_SPRINTF_DCL\${ac_eB}NEED_SPRINTF_DCL\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
echo checking for extended stdio dcls
echo '#include "confdefs.h"
#include <stdio.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "fread" conftest.out >/dev/null 2>&1; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining EXTENDED_STDIO_DCLS"
echo "#define" EXTENDED_STDIO_DCLS "1" >> confdefs.h
DEFS="$DEFS -DEXTENDED_STDIO_DCLS=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}EXTENDED_STDIO_DCLS\${ac_dB}EXTENDED_STDIO_DCLS\${ac_dC}1\${ac_dD}
\${ac_uA}EXTENDED_STDIO_DCLS\${ac_uB}EXTENDED_STDIO_DCLS\${ac_uC}1\${ac_uD}
\${ac_eA}EXTENDED_STDIO_DCLS\${ac_eB}EXTENDED_STDIO_DCLS\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
echo checking for extended socket dcls
echo '#include "confdefs.h"
#include <sys/socket.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "setsockopt" conftest.out >/dev/null 2>&1; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining EXTENDED_SOCKET_DCLS"
echo "#define" EXTENDED_SOCKET_DCLS "1" >> confdefs.h
DEFS="$DEFS -DEXTENDED_SOCKET_DCLS=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}EXTENDED_SOCKET_DCLS\${ac_dB}EXTENDED_SOCKET_DCLS\${ac_dC}1\${ac_dD}
\${ac_uA}EXTENDED_SOCKET_DCLS\${ac_uB}EXTENDED_SOCKET_DCLS\${ac_uC}1\${ac_uD}
\${ac_eA}EXTENDED_SOCKET_DCLS\${ac_eB}EXTENDED_SOCKET_DCLS\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
echo checking for signal SIGCHLD braindamage
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/signal.h>
#ifndef SIGCHLD
#define SIGCHLD SIGCLD
#endif
int rlev;
sighand(sig,code)
int sig, code;
{
int stat;
if (rlev++ > 2)
exit(1);
signal(SIGCHLD, sighand);
wait(&stat);
return;
}
main(argc, argv)
int argc;
char **argv;
{
rlev = 0;
signal(SIGCHLD, sighand);
if (fork()) {
sleep(10);
} else {
sleep(2);
exit(1);
}
exit(0);
}
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
:
else
{
test -n "$verbose" && \
echo " defining SIGNAL_SIGCHLD_BRAINDAMAGE"
echo "#define" SIGNAL_SIGCHLD_BRAINDAMAGE "1" >> confdefs.h
DEFS="$DEFS -DSIGNAL_SIGCHLD_BRAINDAMAGE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}SIGNAL_SIGCHLD_BRAINDAMAGE\${ac_dB}SIGNAL_SIGCHLD_BRAINDAMAGE\${ac_dC}1\${ac_dD}
\${ac_uA}SIGNAL_SIGCHLD_BRAINDAMAGE\${ac_uB}SIGNAL_SIGCHLD_BRAINDAMAGE\${ac_uC}1\${ac_uD}
\${ac_eA}SIGNAL_SIGCHLD_BRAINDAMAGE\${ac_eB}SIGNAL_SIGCHLD_BRAINDAMAGE\${ac_eC}1\${ac_eD}
"
}
fi
rm -fr conftest*
test -n "$silent" || echo "checking for sys_siglist"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 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_sys_siglist) || defined (__stub___sys_siglist)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error. */
extern char sys_siglist(); sys_siglist();
#endif
; return 0; }
EOF
if eval $ac_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"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_SYS_SIGLIST\${ac_dB}HAVE_SYS_SIGLIST\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_SYS_SIGLIST\${ac_uB}HAVE_SYS_SIGLIST\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_SYS_SIGLIST\${ac_eB}HAVE_SYS_SIGLIST\${ac_eC}1\${ac_eD}
"
}
else
rm -rf conftest*
siglist_missing=1
fi
rm -f conftest*
if test -n "$siglist_missing"; then
test -n "$silent" || echo "checking for _sys_siglist"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 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__sys_siglist) || defined (__stub____sys_siglist)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error. */
extern char _sys_siglist(); _sys_siglist();
#endif
; return 0; }
EOF
if eval $ac_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"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE__SYS_SIGLIST\${ac_dB}HAVE__SYS_SIGLIST\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE__SYS_SIGLIST\${ac_uB}HAVE__SYS_SIGLIST\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE__SYS_SIGLIST\${ac_eB}HAVE__SYS_SIGLIST\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
fi
case "$DEFS" in
*HAVE_SYS_SIGLIST*)
echo checking for sys_siglist dcl
echo '#include "confdefs.h"
#include <signal.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "sys_siglist" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining NEED_SYS_SIGLIST_DCL"
echo "#define" NEED_SYS_SIGLIST_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED_SYS_SIGLIST_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_SYS_SIGLIST_DCL\${ac_dB}NEED_SYS_SIGLIST_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_SYS_SIGLIST_DCL\${ac_uB}NEED_SYS_SIGLIST_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_SYS_SIGLIST_DCL\${ac_eB}NEED_SYS_SIGLIST_DCL\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
;;
*)
case "$DEFS" in
*HAVE__SYS_SIGLIST*)
echo '#include "confdefs.h"
#include <signal.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "_sys_siglist" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining NEED__SYS_SIGLIST_DCL"
echo "#define" NEED__SYS_SIGLIST_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED__SYS_SIGLIST_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED__SYS_SIGLIST_DCL\${ac_dB}NEED__SYS_SIGLIST_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED__SYS_SIGLIST_DCL\${ac_uB}NEED__SYS_SIGLIST_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED__SYS_SIGLIST_DCL\${ac_eB}NEED__SYS_SIGLIST_DCL\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
;;
esac ;;
esac
case "$DEFS" in
*HAVE_ERRNO_H*)
{
test -n "$verbose" && \
echo " defining NEED_SYS_ERRLIST_DCL"
echo "#define" NEED_SYS_ERRLIST_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED_SYS_ERRLIST_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_SYS_ERRLIST_DCL\${ac_dB}NEED_SYS_ERRLIST_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_SYS_ERRLIST_DCL\${ac_uB}NEED_SYS_ERRLIST_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_SYS_ERRLIST_DCL\${ac_eB}NEED_SYS_ERRLIST_DCL\${ac_eC}1\${ac_eD}
"
}
;;
*)
echo checking for sys_errlist dcl
echo '#include "confdefs.h"
#include <errno.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "sys_errlist" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining NEED_SYS_ERRLIST_DCL"
echo "#define" NEED_SYS_ERRLIST_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED_SYS_ERRLIST_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_SYS_ERRLIST_DCL\${ac_dB}NEED_SYS_ERRLIST_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_SYS_ERRLIST_DCL\${ac_uB}NEED_SYS_ERRLIST_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_SYS_ERRLIST_DCL\${ac_eB}NEED_SYS_ERRLIST_DCL\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
;;
esac
echo checking for perror dcl
echo '#include "confdefs.h"
#include <errno.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "perror" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining NEED_PERROR_DCL"
echo "#define" NEED_PERROR_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED_PERROR_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_PERROR_DCL\${ac_dB}NEED_PERROR_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_PERROR_DCL\${ac_uB}NEED_PERROR_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_PERROR_DCL\${ac_eB}NEED_PERROR_DCL\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
echo checking for getrusage dcl
echo '#include "confdefs.h"
#include <sys/resource.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "getrusage" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining NEED_GETRUSAGE_DCL"
echo "#define" NEED_GETRUSAGE_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED_GETRUSAGE_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_GETRUSAGE_DCL\${ac_dB}NEED_GETRUSAGE_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_GETRUSAGE_DCL\${ac_uB}NEED_GETRUSAGE_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_GETRUSAGE_DCL\${ac_eB}NEED_GETRUSAGE_DCL\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
echo checking for getrlimit dcl
echo '#include "confdefs.h"
#include <sys/resource.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "getrlimit" conftest.out >/dev/null 2>&1; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining NEED_GETRLIMIT_DCL"
echo "#define" NEED_GETRLIMIT_DCL "1" >> confdefs.h
DEFS="$DEFS -DNEED_GETRLIMIT_DCL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_GETRLIMIT_DCL\${ac_dB}NEED_GETRLIMIT_DCL\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_GETRLIMIT_DCL\${ac_uB}NEED_GETRLIMIT_DCL\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_GETRLIMIT_DCL\${ac_eB}NEED_GETRLIMIT_DCL\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
ac_prog='/* Ultrix mips cc rejects this. */
typedef int charset[2]; const charset x;
/* SunOS 4.1.1 cc rejects this. */
char const *const *ccp;
char **p;
/* AIX XL C 1.02.0.0 rejects this.
It does not let you subtract one const X* pointer from another in an arm
of an if-expression whose if-part is not a constant expression */
const char *g = "string";
ccp = &g + (g ? g-g : 0);
/* HPUX 7.0 cc rejects these. */
++ccp;
p = (char**) ccp;
ccp = (char const *const *) p;
{ /* SCO 3.2v4 cc rejects this. */
char *t;
char const *s = 0 ? (char *) 0 : (char const *) 0;
*t++ = 0;
}
{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */
int x[] = {25,17};
const int *foo = &x[0];
++foo;
}
{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
typedef const int *iptr;
iptr p = 0;
++p;
}
{ /* AIX XL C 1.02.0.0 rejects this saying
"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
struct s { int j; const int *ap[3]; };
struct s *b; b->j = 5;
}
{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
const int foo = 10;
}'
test -n "$silent" || echo "checking for lack of working const"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { $ac_prog; return 0; }
EOF
if eval $ac_compile; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining" const to be empty
echo "#define" const "" >> confdefs.h
DEFS="$DEFS -Dconst="
ac_sed_defs="${ac_sed_defs}\${ac_dA}const\${ac_dB}const\${ac_dC}\${ac_dD}
\${ac_uA}const\${ac_uB}const\${ac_uC}\${ac_uD}
\${ac_eA}const\${ac_eB}const\${ac_eC}\${ac_eD}
"
}
fi
rm -f conftest*
test -n "$silent" || echo "checking for unsigned characters"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
/* volatile prevents gcc2 from optimizing the test away on sparcs. */
#if !__STDC__
#define volatile
#endif
main() {
#ifdef __CHAR_UNSIGNED__
exit(1); /* No need to redefine it. */
#else
volatile char c = 255; exit(c < 0);
#endif
}
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
{
test -n "$verbose" && \
echo " defining __CHAR_UNSIGNED__"
echo "#define" __CHAR_UNSIGNED__ "1" >> confdefs.h
DEFS="$DEFS -D__CHAR_UNSIGNED__=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}__CHAR_UNSIGNED__\${ac_dB}__CHAR_UNSIGNED__\${ac_dC}1\${ac_dD}
\${ac_uA}__CHAR_UNSIGNED__\${ac_uB}__CHAR_UNSIGNED__\${ac_uC}1\${ac_uD}
\${ac_eA}__CHAR_UNSIGNED__\${ac_eB}__CHAR_UNSIGNED__\${ac_eC}1\${ac_eD}
"
}
fi
rm -fr conftest*
if test -n "$GCC"; then
test -n "$silent" || echo "checking for inline"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { } inline foo() {; return 0; }
EOF
if eval $ac_compile; then
:
else
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining" inline to be "__inline"
echo "#define" inline "__inline" >> confdefs.h
DEFS="$DEFS -Dinline=__inline"
ac_sed_defs="${ac_sed_defs}\${ac_dA}inline\${ac_dB}inline\${ac_dC}__inline\${ac_dD}
\${ac_uA}inline\${ac_uB}inline\${ac_uC}__inline\${ac_uD}
\${ac_eA}inline\${ac_eB}inline\${ac_eC}__inline\${ac_eD}
"
}
fi
rm -f conftest*
fi
test -n "$silent" || echo "checking for linger"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/socket.h>
int main() { return 0; }
int t() { struct linger ling; ling.l_onoff = 1;; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_LINGER"
echo "#define" HAVE_LINGER "1" >> confdefs.h
DEFS="$DEFS -DHAVE_LINGER=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LINGER\${ac_dB}HAVE_LINGER\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_LINGER\${ac_uB}HAVE_LINGER\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_LINGER\${ac_eB}HAVE_LINGER\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
echo "checking for ndbm routines in libc:"
LIBS_predbm="$LIBS"
test -n "$silent" || echo "checking for dbm_close"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 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_dbm_close) || defined (__stub___dbm_close)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error. */
extern char dbm_close(); dbm_close();
#endif
; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_NDBM"
echo "#define" HAVE_NDBM "1" >> confdefs.h
DEFS="$DEFS -DHAVE_NDBM=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_NDBM\${ac_dB}HAVE_NDBM\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_NDBM\${ac_uB}HAVE_NDBM\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_NDBM\${ac_eB}HAVE_NDBM\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
case "$DEFS" in
*HAVE_NDBM*)
;;
*)
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lndbm"
ac_have_lib=""
test -n "$silent" || echo "checking for -lndbm"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
ac_have_lib="1"
fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
{
test -n "$verbose" && \
echo " defining HAVE_LIBNDBM"
echo "#define" HAVE_LIBNDBM "1" >> confdefs.h
DEFS="$DEFS -DHAVE_LIBNDBM=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBNDBM\${ac_dB}HAVE_LIBNDBM\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_LIBNDBM\${ac_uB}HAVE_LIBNDBM\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_LIBNDBM\${ac_eB}HAVE_LIBNDBM\${ac_eC}1\${ac_eD}
"
}
LIBS="${LIBS} -lndbm"
fi
case "$DEFS" in
*HAVE_LIBNDBM*)
{
test -n "$verbose" && \
echo " defining HAVE_NDBM"
echo "#define" HAVE_NDBM "1" >> confdefs.h
DEFS="$DEFS -DHAVE_NDBM=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_NDBM\${ac_dB}HAVE_NDBM\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_NDBM\${ac_uB}HAVE_NDBM\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_NDBM\${ac_eB}HAVE_NDBM\${ac_eC}1\${ac_eD}
"
}
;;
*)
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -ldbm"
ac_have_lib=""
test -n "$silent" || echo "checking for -ldbm"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
ac_have_lib="1"
fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
{
test -n "$verbose" && \
echo " defining HAVE_LIBDBM"
echo "#define" HAVE_LIBDBM "1" >> confdefs.h
DEFS="$DEFS -DHAVE_LIBDBM=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBDBM\${ac_dB}HAVE_LIBDBM\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_LIBDBM\${ac_uB}HAVE_LIBDBM\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_LIBDBM\${ac_eB}HAVE_LIBDBM\${ac_eC}1\${ac_eD}
"
}
LIBS="${LIBS} -ldbm"
fi
case "$DEFS" in
*HAVE_LIBDBM*)
echo "checking for ndbm routines in libdbm:"
test -n "$silent" || echo "checking for dbm_close"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 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_dbm_close) || defined (__stub___dbm_close)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error. */
extern char dbm_close(); dbm_close();
#endif
; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_NDBM"
echo "#define" HAVE_NDBM "1" >> confdefs.h
DEFS="$DEFS -DHAVE_NDBM=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_NDBM\${ac_dB}HAVE_NDBM\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_NDBM\${ac_uB}HAVE_NDBM\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_NDBM\${ac_eB}HAVE_NDBM\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
case "$DEFS" in
*HAVE_NDBM*)
;;
*)
LIBS_withdbm="$LIBS"
LIBS="$LIBS_predbm"
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lsdbm"
ac_have_lib=""
test -n "$silent" || echo "checking for -lsdbm"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
ac_have_lib="1"
fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
{
test -n "$verbose" && \
echo " defining HAVE_LIBSDBM"
echo "#define" HAVE_LIBSDBM "1" >> confdefs.h
DEFS="$DEFS -DHAVE_LIBSDBM=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBSDBM\${ac_dB}HAVE_LIBSDBM\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_LIBSDBM\${ac_uB}HAVE_LIBSDBM\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_LIBSDBM\${ac_eB}HAVE_LIBSDBM\${ac_eC}1\${ac_eD}
"
}
LIBS="${LIBS} -lsdbm"
fi
case "$DEFS" in
*HAVE_SDBM*)
{
test -n "$verbose" && \
echo " defining HAVE_NDBM"
echo "#define" HAVE_NDBM "1" >> confdefs.h
DEFS="$DEFS -DHAVE_NDBM=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_NDBM\${ac_dB}HAVE_NDBM\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_NDBM\${ac_uB}HAVE_NDBM\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_NDBM\${ac_eB}HAVE_NDBM\${ac_eC}1\${ac_eD}
"
}
;;
*)
LIBS="$LIBS_withdbm" ;;
esac ;;
esac ;;
esac ;;
esac ;;
esac
case "$DEFS" in
*HAVE_NDBM*)
;;
*)
LIBS="$LIBS_predbm"
echo checking for dbm routines in libc
test -n "$silent" || echo "checking for dbmclose"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { return 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_dbmclose) || defined (__stub___dbmclose)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error. */
extern char dbmclose(); dbmclose();
#endif
; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
{
test -n "$verbose" && \
echo " defining HAVE_DBM"
echo "#define" HAVE_DBM "1" >> confdefs.h
DEFS="$DEFS -DHAVE_DBM=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_DBM\${ac_dB}HAVE_DBM\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_DBM\${ac_uB}HAVE_DBM\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_DBM\${ac_eB}HAVE_DBM\${ac_eC}1\${ac_eD}
"
}
fi
rm -f conftest*
case "$DEFS" in
*HAVE_DBM*)
;;
*)
case "$DEFS" in
*HAVE_LIBDBM*)
{
test -n "$verbose" && \
echo " defining HAVE_DBM"
echo "#define" HAVE_DBM "1" >> confdefs.h
DEFS="$DEFS -DHAVE_DBM=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_DBM\${ac_dB}HAVE_DBM\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_DBM\${ac_uB}HAVE_DBM\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_DBM\${ac_eB}HAVE_DBM\${ac_eC}1\${ac_eD}
"
}
LIBS="$LIBS_withdbm" ;;
esac ;;
esac
case "$DEFS" in
*HAVE_DBM*)
;;
*)
LIBOBJS="$LIBOBJS myndbm.o" ;;
esac ;;
esac
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lresolv"
ac_have_lib=""
test -n "$silent" || echo "checking for -lresolv"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
ac_have_lib="1"
fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
{
test -n "$verbose" && \
echo " defining HAVE_LIBRESOLV"
echo "#define" HAVE_LIBRESOLV "1" >> confdefs.h
DEFS="$DEFS -DHAVE_LIBRESOLV=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBRESOLV\${ac_dB}HAVE_LIBRESOLV\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_LIBRESOLV\${ac_uB}HAVE_LIBRESOLV\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_LIBRESOLV\${ac_eB}HAVE_LIBRESOLV\${ac_eC}1\${ac_eD}
"
}
LIBS="${LIBS} -lresolv"
fi
case "$DEFS" in
*HAVE_SOCKET*)
;;
*)
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lsocket"
ac_have_lib=""
test -n "$silent" || echo "checking for -lsocket"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
ac_have_lib="1"
fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
{
test -n "$verbose" && \
echo " defining HAVE_LIBSOCKET"
echo "#define" HAVE_LIBSOCKET "1" >> confdefs.h
DEFS="$DEFS -DHAVE_LIBSOCKET=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBSOCKET\${ac_dB}HAVE_LIBSOCKET\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_LIBSOCKET\${ac_uB}HAVE_LIBSOCKET\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_LIBSOCKET\${ac_eB}HAVE_LIBSOCKET\${ac_eC}1\${ac_eD}
"
}
LIBS="${LIBS} -lsocket"
fi
;;
esac
case "$DEFS" in
*HAVE_GETHOSTBYADDR*)
;;
*)
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -linet"
ac_have_lib=""
test -n "$silent" || echo "checking for -linet"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
ac_have_lib="1"
fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
{
test -n "$verbose" && \
echo " defining HAVE_LIBINET"
echo "#define" HAVE_LIBINET "1" >> confdefs.h
DEFS="$DEFS -DHAVE_LIBINET=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBINET\${ac_dB}HAVE_LIBINET\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_LIBINET\${ac_uB}HAVE_LIBINET\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_LIBINET\${ac_eB}HAVE_LIBINET\${ac_eC}1\${ac_eD}
"
}
LIBS="${LIBS} -linet"
fi
;;
esac
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lseq"
ac_have_lib=""
test -n "$silent" || echo "checking for -lseq"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
ac_have_lib="1"
fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
:; LIBS="$LIBS -lseq"
else
:;
fi
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lsun"
ac_have_lib=""
test -n "$silent" || echo "checking for -lsun"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
ac_have_lib="1"
fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
:; LIBS="$LIBS -lsun"
else
:;
fi
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lnsl"
ac_have_lib=""
test -n "$silent" || echo "checking for -lnsl"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int main() { return 0; }
int t() { main();; return 0; }
EOF
if eval $ac_compile; then
rm -rf conftest*
ac_have_lib="1"
fi
rm -f conftest*
LIBS="${ac_save_LIBS}"
if test -n "${ac_have_lib}"; then
{
test -n "$verbose" && \
echo " defining HAVE_LIBNSL"
echo "#define" HAVE_LIBNSL "1" >> confdefs.h
DEFS="$DEFS -DHAVE_LIBNSL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBNSL\${ac_dB}HAVE_LIBNSL\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_LIBNSL\${ac_uB}HAVE_LIBNSL\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_LIBNSL\${ac_eB}HAVE_LIBNSL\${ac_eC}1\${ac_eD}
"
}
LIBS="${LIBS} -lnsl"
fi
# The preferred way to propogate these variables is regular @ substitutions.
if test -n "$prefix"; then
ac_prsub="s%^prefix\\([ ]*\\)=\\([ ]*\\).*$%prefix\\1=\\2$prefix%"
else
prefix=/usr/local
fi
if test -n "$exec_prefix"; then
ac_prsub="$ac_prsub
s%^exec_prefix\\([ ]*\\)=\\([ ]*\\).*$%exec_prefix\\1=\\2$exec_prefix%"
else
exec_prefix='${prefix}' # Let make expand it.
fi
# Any assignment to VPATH causes Sun make to only execute
# the first set of double-colon rules, so remove it if not needed.
# If there is a colon in the path, we need to keep it.
if test "x$srcdir" = x.; then
ac_vpsub='/^[ ]*VPATH[ ]*=[^:]*$/d'
fi
# Quote sed substitution magic chars in DEFS.
cat >conftest.def <<EOF
$DEFS
EOF
ac_escape_ampersand_and_backslash='s%[&\\]%\\&%g'
DEFS=`sed "$ac_escape_ampersand_and_backslash" <conftest.def`
rm -f conftest.def
# Substitute for predefined variables.
trap 'rm -f config.status; exit 1' 1 2 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
ac_cs_usage="Usage: config.status [--recheck] [--version] [--help]"
for ac_option
do
case "\$ac_option" in
-recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
echo running \${CONFIG_SHELL-/bin/sh} $0 $configure_args --no-create
exec \${CONFIG_SHELL-/bin/sh} $0 $configure_args --no-create ;;
-version | --version | --versio | --versi | --vers | --ver | --ve | --v)
echo "config.status generated by autoconf version 1.11"
exit 0 ;;
-help | --help | --hel | --he | --h)
echo "\$ac_cs_usage"; exit 0 ;;
*) echo "\$ac_cs_usage"; exit 1 ;;
esac
done
trap 'rm -fr Makefile autoconf.h conftest*; exit 1' 1 2 15
CC='$CC'
CPP='$CPP'
LIBOBJS='$LIBOBJS'
LIBS='$LIBS'
srcdir='$srcdir'
top_srcdir='$top_srcdir'
prefix='$prefix'
exec_prefix='$exec_prefix'
ac_prsub='$ac_prsub'
ac_vpsub='$ac_vpsub'
extrasub='$extrasub'
EOF
cat >> config.status <<\EOF
ac_given_srcdir=.
CONFIG_FILES=${CONFIG_FILES-"Makefile"}
for ac_file in .. ${CONFIG_FILES}; do if test "x$ac_file" != x..; then
# Remove last slash and all that follows it. Not all systems have dirname.
ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
# The file is in a subdirectory.
test ! -d "$ac_dir" && mkdir "$ac_dir"
ac_dir_suffix="/$ac_dir"
else
ac_dir_suffix=
fi
# A "../" for each directory in $ac_dir_suffix.
ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
case "$ac_given_srcdir" in
.) if test -z "$ac_dir_suffix"; then top_srcdir=.
else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
/*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
*) # Relative path.
srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
top_srcdir="$ac_dots$ac_given_srcdir" ;;
esac
echo creating "$ac_file"
rm -f "$ac_file"
comment_str="Generated automatically from `echo $ac_file|sed 's|.*/||'`.in by configure."
case "$ac_file" in
*.c | *.h | *.C | *.cc | *.m ) echo "/* $comment_str */" > "$ac_file" ;;
* ) echo "# $comment_str" > "$ac_file" ;;
esac
sed -e "
$ac_prsub
$ac_vpsub
$extrasub
s%@CC@%$CC%g
s%@CPP@%$CPP%g
s%@LIBOBJS@%$LIBOBJS%g
s%@LIBS@%$LIBS%g
s%@srcdir@%$srcdir%g
s%@top_srcdir@%$top_srcdir%g
s%@prefix@%$prefix%g
s%@exec_prefix@%$exec_prefix%g
s%@DEFS@%-DHAVE_CONFIG_H%" $ac_given_srcdir/${ac_file}.in >> $ac_file
fi; done
# These sed commands are put into ac_sed_defs when defining a macro.
# They are broken into pieces to make the sed script easier to manage.
# They are passed to sed as "A NAME B NAME C VALUE D", where NAME
# is the cpp macro being defined and VALUE is the value it is being given.
# Each defining turns into a single global substitution command.
# Hopefully no one uses "!" as a variable value.
# Other candidates for the sed separators, like , and @, do get used.
#
# ac_d sets the value in "#define NAME VALUE" lines.
ac_dA='s!^\([ ]*\)#\([ ]*define[ ][ ]*\)'
ac_dB='\([ ][ ]*\)[^ ]*!\1#\2'
ac_dC='\3'
ac_dD='!g'
# ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
ac_uA='s!^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)'
ac_uB='\([ ]\)!\1#\2define\3'
ac_uC=' '
ac_uD='\4!g'
# ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
ac_eA='s!^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)'
ac_eB='$!\1#\2define\3'
ac_eC=' '
ac_eD='!g'
rm -f conftest.sed
EOF
# Turn off quoting long enough to insert the sed commands.
rm -f conftest.sh
cat > conftest.sh <<EOF
$ac_sed_defs
EOF
# Break up $ac_sed_defs (now in conftest.sh) because some shells have a limit
# on the size of here documents.
# Maximum number of lines to put in a single here document.
ac_max_sh_lines=9
while :
do
# wc gives bogus results for an empty file on some AIX systems.
ac_lines=`grep -c . conftest.sh`
if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
rm -f conftest.s1 conftest.s2
sed ${ac_max_sh_lines}q conftest.sh > conftest.s1 # Like head -9.
sed 1,${ac_max_sh_lines}d conftest.sh > conftest.s2 # Like tail +10.
# Write a limited-size here document to append to conftest.sed.
echo 'cat >> conftest.sed <<CONFEOF' >> config.status
cat conftest.s1 >> config.status
echo 'CONFEOF' >> config.status
rm -f conftest.s1 conftest.sh
mv conftest.s2 conftest.sh
done
rm -f conftest.sh
# Now back to your regularly scheduled config.status.
cat >> config.status <<\EOF
# This sed command replaces #undef's with comments. This is necessary, for
# example, in the case of _POSIX_SOURCE, which is predefined and required
# on some systems where configure will not decide to define it in
# autoconf.h.
cat >> conftest.sed <<\CONFEOF
s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
CONFEOF
rm -f conftest.h
# Break up the sed commands because old seds have small limits.
ac_max_sed_lines=20
CONFIG_HEADERS=${CONFIG_HEADERS-"autoconf.h"}
for ac_file in .. ${CONFIG_HEADERS}; do if test "x$ac_file" != x..; then
echo creating $ac_file
cp $ac_given_srcdir/$ac_file.in conftest.h1
cp conftest.sed conftest.stm
while :
do
ac_lines=`grep -c . conftest.stm`
if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
rm -f conftest.s1 conftest.s2 conftest.h2
sed ${ac_max_sed_lines}q conftest.stm > conftest.s1 # Like head -20.
sed 1,${ac_max_sed_lines}d conftest.stm > conftest.s2 # Like tail +21.
sed -f conftest.s1 < conftest.h1 > conftest.h2
rm -f conftest.s1 conftest.h1 conftest.stm
mv conftest.h2 conftest.h1
mv conftest.s2 conftest.stm
done
rm -f conftest.stm conftest.h
echo "/* $ac_file. Generated automatically by configure. */" > conftest.h
cat conftest.h1 >> conftest.h
rm -f conftest.h1
if cmp -s $ac_file conftest.h 2>/dev/null; then
# The file exists and we would not be changing it.
echo "$ac_file is unchanged"
rm -f conftest.h
else
rm -f $ac_file
mv conftest.h $ac_file
fi
fi; done
rm -f conftest.sed
exit 0
EOF
chmod +x config.status
# Some shells look in PATH for config.status without the "./".
test -n "$no_create" || ${CONFIG_SHELL-/bin/sh} ./config.status