#!/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=c_ksh.c

# 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 `..'.
  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=..
  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 .." >&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'



 LDSTATIC=${LDSTATIC-}
test X"$LDSTATIC" != X && LDFLAGS="$LDSTATIC $LDFLAGS"
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"

if test -n "$GCC"; then
  test -n "$silent" || echo "checking whether -traditional is needed"
  ac_pattern="Autoconf.*'x'"
  ac_prog='#include <sgtty.h>
Autoconf TIOCGETP'
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
$ac_prog
EOF
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "$ac_pattern" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  ac_need_trad=1

fi
rm -f conftest*


  if test -z "$ac_need_trad"; then
    ac_prog='#include <termio.h>
Autoconf TCGETA'
    cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
$ac_prog
EOF
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "$ac_pattern" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  ac_need_trad=1

fi
rm -f conftest*

  fi
  test -n "$ac_need_trad" && CC="$CC -traditional"
fi

           GCC_WARNFLAGS=
  if test -n "$GCC" && test -f $srcdir/Warn-flags; then
    GCC_WARNFLAGS="`cat $srcdir/Warn-flags`"
  fi
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 directory library header"
ac_dir_header=
if test -z "$ac_dir_header"; then
  test -n "$silent" || echo "checking for dirent.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <dirent.h>
int main() { return 0; }
int t() { DIR *dirp = 0;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining DIRENT"
echo "#define" DIRENT "1" >> confdefs.h
DEFS="$DEFS -DDIRENT=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}DIRENT\${ac_dB}DIRENT\${ac_dC}1\${ac_dD}
\${ac_uA}DIRENT\${ac_uB}DIRENT\${ac_uC}1\${ac_uD}
\${ac_eA}DIRENT\${ac_eB}DIRENT\${ac_eC}1\${ac_eD}
"
}
 ac_dir_header=dirent.h

fi
rm -f conftest*
fi
if test -z "$ac_dir_header"; then
  test -n "$silent" || echo "checking for sys/ndir.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/ndir.h>
int main() { return 0; }
int t() { DIR *dirp = 0;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining SYSNDIR"
echo "#define" SYSNDIR "1" >> confdefs.h
DEFS="$DEFS -DSYSNDIR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}SYSNDIR\${ac_dB}SYSNDIR\${ac_dC}1\${ac_dD}
\${ac_uA}SYSNDIR\${ac_uB}SYSNDIR\${ac_uC}1\${ac_uD}
\${ac_eA}SYSNDIR\${ac_eB}SYSNDIR\${ac_eC}1\${ac_eD}
"
}
 ac_dir_header=sys/ndir.h

fi
rm -f conftest*
fi
if test -z "$ac_dir_header"; then
  test -n "$silent" || echo "checking for sys/dir.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/dir.h>
int main() { return 0; }
int t() { DIR *dirp = 0;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining SYSDIR"
echo "#define" SYSDIR "1" >> confdefs.h
DEFS="$DEFS -DSYSDIR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}SYSDIR\${ac_dB}SYSDIR\${ac_dC}1\${ac_dD}
\${ac_uA}SYSDIR\${ac_uB}SYSDIR\${ac_uC}1\${ac_uD}
\${ac_eA}SYSDIR\${ac_eB}SYSDIR\${ac_eC}1\${ac_eD}
"
}
 ac_dir_header=sys/dir.h

fi
rm -f conftest*
fi
if test -z "$ac_dir_header"; then
  test -n "$silent" || echo "checking for ndir.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <ndir.h>
int main() { return 0; }
int t() { DIR *dirp = 0;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining NDIR"
echo "#define" NDIR "1" >> confdefs.h
DEFS="$DEFS -DNDIR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NDIR\${ac_dB}NDIR\${ac_dC}1\${ac_dD}
\${ac_uA}NDIR\${ac_uB}NDIR\${ac_uC}1\${ac_uD}
\${ac_eA}NDIR\${ac_eB}NDIR\${ac_eC}1\${ac_eD}
"
}
 ac_dir_header=ndir.h

fi
rm -f conftest*
fi

test -n "$silent" || echo "checking for closedir return value"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <$ac_dir_header>
int closedir(); main() { exit(closedir(opendir(".")) != 0); }
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else
  
{
test -n "$verbose" && \
echo "	defining VOID_CLOSEDIR"
echo "#define" VOID_CLOSEDIR "1" >> confdefs.h
DEFS="$DEFS -DVOID_CLOSEDIR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}VOID_CLOSEDIR\${ac_dB}VOID_CLOSEDIR\${ac_dC}1\${ac_dD}
\${ac_uA}VOID_CLOSEDIR\${ac_uB}VOID_CLOSEDIR\${ac_uC}1\${ac_uD}
\${ac_eA}VOID_CLOSEDIR\${ac_eB}VOID_CLOSEDIR\${ac_eC}1\${ac_eD}
"
}

fi
rm -fr conftest*

test -n "$silent" || echo "checking for Xenix"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#if defined(M_XENIX) && !defined(M_UNIX)
  yes
#endif

EOF
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "yes" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  XENIX=1

fi
rm -f conftest*

if test -n "$XENIX"; then
  LIBS="$LIBS -lx"
  case "$DEFS" in
  *SYSNDIR*) ;;
  *) LIBS="-ldir $LIBS" ;; # Make sure -ldir precedes any -lx.
  esac
fi

  test -n "$silent" || echo "checking for sane unistd.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <unistd.h>
#ifdef _POSIX_VERSION
# include <dirent.h>
#endif
    
int main() { return 0; }
int t() { ; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining HAVE_UNISTD_H"
echo "#define" HAVE_UNISTD_H "1" >> confdefs.h
DEFS="$DEFS -DHAVE_UNISTD_H=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_UNISTD_H\${ac_dB}HAVE_UNISTD_H\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_UNISTD_H\${ac_uB}HAVE_UNISTD_H\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_UNISTD_H\${ac_eB}HAVE_UNISTD_H\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

  test -n "$silent" || echo "checking for sane termios.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <termios.h>
int main() { return 0; }
int t() { struct termios t;
#if defined(ultrix) || defined(__ultrix__)
     Termios in ultrix 4.2 botches type-ahead when going from cooked to
     cbreak mode.  The BSD tty interface works fine though, so use it
     (would be good to know if alter versions of ultrix work).
#endif /* ultrix */
     tcgetattr(0, &t); tcsetattr(0, TCSADRAIN, &t);
     ; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining HAVE_TERMIOS_H"
echo "#define" HAVE_TERMIOS_H "1" >> confdefs.h
DEFS="$DEFS -DHAVE_TERMIOS_H=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_TERMIOS_H\${ac_dB}HAVE_TERMIOS_H\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_TERMIOS_H\${ac_uB}HAVE_TERMIOS_H\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_TERMIOS_H\${ac_eB}HAVE_TERMIOS_H\${ac_eC}1\${ac_eD}
"
}


else
  rm -rf conftest*
  test -n "$silent" || echo "checking for BSD tty interface"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/ioctl.h>
int main() { return 0; }
int t() { 
	  struct sgttyb sb; ioctl(0, TIOCGETP, &sb);
#ifdef TIOCGATC
	  { struct ttychars lc; ioctl(0, TIOCGATC, &lc); }
#else /* TIOCGATC */
	  { struct tchars tc; ioctl(0, TIOCGETC, &tc); }
# ifdef TIOCGLTC
	  { struct ltchars ltc; ioctl(0, TIOCGLTC, &ltc); }
# endif /* TIOCGLTC */
#endif /* TIOCGATC */
	; return 0; }
EOF
if eval $ac_compile; then
  :
else
  rm -rf conftest*
  for ac_hdr in termio.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

fi
rm -f conftest*

fi
rm -f conftest*

for ac_hdr in stddef.h stdlib.h string.h memory.h \
    fcntl.h limits.h paths.h values.h ulimit.h sys/time.h sys/wait.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 off_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 "(^|[^a-zA-Z0-9_])off_t([^a-zA-Z0-9_]|\$)" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" off_t to be "long"
echo "#define" off_t "long" >> confdefs.h
DEFS="$DEFS -Doff_t=long"
ac_sed_defs="${ac_sed_defs}\${ac_dA}off_t\${ac_dB}off_t\${ac_dC}long\${ac_dD}
\${ac_uA}off_t\${ac_uB}off_t\${ac_uC}long\${ac_uD}
\${ac_eA}off_t\${ac_eB}off_t\${ac_eC}long\${ac_eD}
"
}

fi
rm -f conftest*

test -n "$silent" || echo "checking for mode_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 "(^|[^a-zA-Z0-9_])mode_t([^a-zA-Z0-9_]|\$)" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" mode_t to be "int"
echo "#define" mode_t "int" >> confdefs.h
DEFS="$DEFS -Dmode_t=int"
ac_sed_defs="${ac_sed_defs}\${ac_dA}mode_t\${ac_dB}mode_t\${ac_dC}int\${ac_dD}
\${ac_uA}mode_t\${ac_uB}mode_t\${ac_uC}int\${ac_uD}
\${ac_eA}mode_t\${ac_eB}mode_t\${ac_eC}int\${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 "(^|[^a-zA-Z0-9_])pid_t([^a-zA-Z0-9_]|\$)" 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 uid_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 "(^|[^a-zA-Z0-9_])uid_t([^a-zA-Z0-9_]|\$)" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" uid_t to be "int"
echo "#define" uid_t "int" >> confdefs.h
DEFS="$DEFS -Duid_t=int"
ac_sed_defs="${ac_sed_defs}\${ac_dA}uid_t\${ac_dB}uid_t\${ac_dC}int\${ac_dD}
\${ac_uA}uid_t\${ac_uB}uid_t\${ac_uC}int\${ac_uD}
\${ac_eA}uid_t\${ac_eB}uid_t\${ac_eC}int\${ac_eD}
"
}
 
{
test -n "$verbose" && \
echo "	defining" gid_t to be "int"
echo "#define" gid_t "int" >> confdefs.h
DEFS="$DEFS -Dgid_t=int"
ac_sed_defs="${ac_sed_defs}\${ac_dA}gid_t\${ac_dB}gid_t\${ac_dC}int\${ac_dD}
\${ac_uA}gid_t\${ac_uB}gid_t\${ac_uC}int\${ac_uD}
\${ac_eA}gid_t\${ac_eB}gid_t\${ac_eC}int\${ac_eD}
"
}

fi
rm -f conftest*


test -n "$silent" || echo "checking for signed 32 bit integer type"
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
main() { if (sizeof(long) != 4) exit(1); exit(0); }
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  
{
test -n "$verbose" && \
echo "	defining" INT32 to be "long"
echo "#define" INT32 "long" >> confdefs.h
DEFS="$DEFS -DINT32=long"
ac_sed_defs="${ac_sed_defs}\${ac_dA}INT32\${ac_dB}INT32\${ac_dC}long\${ac_dD}
\${ac_uA}INT32\${ac_uB}INT32\${ac_uC}long\${ac_uD}
\${ac_eA}INT32\${ac_eB}INT32\${ac_eC}long\${ac_eD}
"
}


else
  
{
test -n "$verbose" && \
echo "	defining" INT32 to be "int"
echo "#define" INT32 "int" >> confdefs.h
DEFS="$DEFS -DINT32=int"
ac_sed_defs="${ac_sed_defs}\${ac_dA}INT32\${ac_dB}INT32\${ac_dC}int\${ac_dD}
\${ac_uA}INT32\${ac_uB}INT32\${ac_uC}int\${ac_uD}
\${ac_eA}INT32\${ac_eB}INT32\${ac_eC}int\${ac_eD}
"
}

fi
rm -fr conftest*
test -n "$silent" || echo "checking for clock_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 "(^|[^a-zA-Z0-9_])clock_t([^a-zA-Z0-9_]|\$)" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*
  echo '#include "confdefs.h"
#include <sys/times.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "(^|^a-zA-Z0-9_)clock_t(^a-zA-Z0-9_|\$)" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining CLOCK_T_IN_SYS_TIMES_H"
echo "#define" CLOCK_T_IN_SYS_TIMES_H "1" >> confdefs.h
DEFS="$DEFS -DCLOCK_T_IN_SYS_TIMES_H=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}CLOCK_T_IN_SYS_TIMES_H\${ac_dB}CLOCK_T_IN_SYS_TIMES_H\${ac_dC}1\${ac_dD}
\${ac_uA}CLOCK_T_IN_SYS_TIMES_H\${ac_uB}CLOCK_T_IN_SYS_TIMES_H\${ac_uC}1\${ac_uD}
\${ac_eA}CLOCK_T_IN_SYS_TIMES_H\${ac_eB}CLOCK_T_IN_SYS_TIMES_H\${ac_eC}1\${ac_eD}
"
}


else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" clock_t to be "INT32"
echo "#define" clock_t "INT32" >> confdefs.h
DEFS="$DEFS -Dclock_t=INT32"
ac_sed_defs="${ac_sed_defs}\${ac_dA}clock_t\${ac_dB}clock_t\${ac_dC}INT32\${ac_dD}
\${ac_uA}clock_t\${ac_uB}clock_t\${ac_uC}INT32\${ac_uD}
\${ac_eA}clock_t\${ac_eB}clock_t\${ac_eC}INT32\${ac_eD}
"
}

fi
rm -f conftest*

fi
rm -f conftest*

test -n "$silent" || echo "checking for time_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 "(^|[^a-zA-Z0-9_])time_t([^a-zA-Z0-9_]|\$)" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" time_t to be "INT32"
echo "#define" time_t "INT32" >> confdefs.h
DEFS="$DEFS -Dtime_t=INT32"
ac_sed_defs="${ac_sed_defs}\${ac_dA}time_t\${ac_dB}time_t\${ac_dC}INT32\${ac_dD}
\${ac_uA}time_t\${ac_uB}time_t\${ac_uC}INT32\${ac_uD}
\${ac_eA}time_t\${ac_eB}time_t\${ac_eC}INT32\${ac_eD}
"
}

fi
rm -f conftest*

test -n "$silent" || echo "checking for sigset_t in signal.h"
  echo '#include "confdefs.h"
#include <signal.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "(^|[^a-zA-Z0-9_])sigset_t([^a-zA-Z0-9_]|\$)" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" sigset_t to be "unsigned"
echo "#define" sigset_t "unsigned" >> confdefs.h
DEFS="$DEFS -Dsigset_t=unsigned"
ac_sed_defs="${ac_sed_defs}\${ac_dA}sigset_t\${ac_dB}sigset_t\${ac_dC}unsigned\${ac_dD}
\${ac_uA}sigset_t\${ac_uB}sigset_t\${ac_uC}unsigned\${ac_uD}
\${ac_eA}sigset_t\${ac_eB}sigset_t\${ac_eC}unsigned\${ac_eD}
"
}

fi
rm -f conftest*

test -n "$silent" || echo "checking for rlim_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 "(^|[^a-zA-Z0-9_])rlim_t([^a-zA-Z0-9_]|\$)" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*
  test -n "$silent" || echo "checking size of struct rlimit fields"
      cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
main()
{
  struct rlimit rl;
  if (sizeof(rl.rlim_cur) == sizeof(quad_t))
    exit(0);
  exit(1);
}
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  
{
test -n "$verbose" && \
echo "	defining" rlim_t to be "quad_t"
echo "#define" rlim_t "quad_t" >> confdefs.h
DEFS="$DEFS -Drlim_t=quad_t"
ac_sed_defs="${ac_sed_defs}\${ac_dA}rlim_t\${ac_dB}rlim_t\${ac_dC}quad_t\${ac_dD}
\${ac_uA}rlim_t\${ac_uB}rlim_t\${ac_uC}quad_t\${ac_uD}
\${ac_eA}rlim_t\${ac_eB}rlim_t\${ac_eC}quad_t\${ac_eD}
"
}


else
  
{
test -n "$verbose" && \
echo "	defining" rlim_t to be "long"
echo "#define" rlim_t "long" >> confdefs.h
DEFS="$DEFS -Drlim_t=long"
ac_sed_defs="${ac_sed_defs}\${ac_dA}rlim_t\${ac_dB}rlim_t\${ac_dC}long\${ac_dD}
\${ac_uA}rlim_t\${ac_uB}rlim_t\${ac_uC}long\${ac_uD}
\${ac_eA}rlim_t\${ac_eB}rlim_t\${ac_eC}long\${ac_eD}
"
}

fi
rm -fr conftest*
fi
rm -f conftest*

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*


for ac_func in bcopy confstr getcwd killpg lstat memset memmove nice setrlimit \
	strerror strcasecmp strstr sysconf tcsetpgrp ulimit waitpid wait3
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 working mmap"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
/* Thanks to Mike Haertel and Jim Avera for this test. */
#include <sys/types.h>
#include <fcntl.h>
#include <sys/mman.h>

#ifdef BSD
#ifndef BSD4_1
#define HAVE_GETPAGESIZE
#endif
#endif
#ifndef HAVE_GETPAGESIZE
#include <sys/param.h>
#ifdef EXEC_PAGESIZE
#define getpagesize() EXEC_PAGESIZE
#else
#ifdef NBPG
#define getpagesize() NBPG * CLSIZE
#ifndef CLSIZE
#define CLSIZE 1
#endif /* no CLSIZE */
#else /* no NBPG */
#ifdef NBPC
#define getpagesize() NBPC
#else /* no NBPC */
#define getpagesize() PAGESIZE /* SVR4 */
#endif /* no NBPC */
#endif /* no NBPG */
#endif /* no EXEC_PAGESIZE */
#endif /* not HAVE_GETPAGESIZE */

#ifdef __osf__
#define valloc malloc
#endif

#ifndef MAP_FILE
# define MAP_FILE 0
#endif /* MAP_FILE */

extern char *valloc();
extern char *malloc();

int
main()
{
  char *buf1, *buf2, *buf3;
  int i = getpagesize(), j;
  int i2 = getpagesize()*2;
  int fd;

  buf1 = valloc(i2);
  buf2 = valloc(i);
  buf3 = malloc(i2);
  for (j = 0; j < i2; ++j)
    *(buf1 + j) = rand();
  fd = open("conftestmmap", O_CREAT | O_RDWR, 0666);
  write(fd, buf1, i2);
  mmap(buf2, i, PROT_READ | PROT_WRITE, MAP_FILE | MAP_FIXED | MAP_PRIVATE, fd, 0);
  for (j = 0; j < i; ++j)
    if (*(buf1 + j) != *(buf2 + j))
      exit(1);
  lseek(fd, (long)i, 0);
  read(fd, buf2, i); /* read into mapped memory -- file should not change */
  /* (it does in i386 SVR4.0 - Jim Avera) */
  lseek(fd, (long)0, 0);
  read(fd, buf3, i2);
  for (j = 0; j < i2; ++j)
    if (*(buf1 + j) != *(buf3 + j))
      exit(1);
  exit(0);
}

EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  
{
test -n "$verbose" && \
echo "	defining HAVE_MMAP"
echo "#define" HAVE_MMAP "1" >> confdefs.h
DEFS="$DEFS -DHAVE_MMAP=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_MMAP\${ac_dB}HAVE_MMAP\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_MMAP\${ac_uB}HAVE_MMAP\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_MMAP\${ac_eB}HAVE_MMAP\${ac_eC}1\${ac_eD}
"
}


fi
rm -fr conftest*

  test -n "$silent" || echo "checking for sys_errlist declaration in errno.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <errno.h>
int main() { return 0; }
int t() { char *msg = *(sys_errlist + sys_nerr - 1);; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining HAVE_SYS_ERRLIST"
echo "#define" HAVE_SYS_ERRLIST "1" >> confdefs.h
DEFS="$DEFS -DHAVE_SYS_ERRLIST=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_SYS_ERRLIST\${ac_dB}HAVE_SYS_ERRLIST\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_SYS_ERRLIST\${ac_uB}HAVE_SYS_ERRLIST\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_SYS_ERRLIST\${ac_eB}HAVE_SYS_ERRLIST\${ac_eC}1\${ac_eD}
"
}
 
{
test -n "$verbose" && \
echo "	defining SYS_ERRLIST_DECLARED"
echo "#define" SYS_ERRLIST_DECLARED "1" >> confdefs.h
DEFS="$DEFS -DSYS_ERRLIST_DECLARED=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}SYS_ERRLIST_DECLARED\${ac_dB}SYS_ERRLIST_DECLARED\${ac_dC}1\${ac_dD}
\${ac_uA}SYS_ERRLIST_DECLARED\${ac_uB}SYS_ERRLIST_DECLARED\${ac_uC}1\${ac_uD}
\${ac_eA}SYS_ERRLIST_DECLARED\${ac_eB}SYS_ERRLIST_DECLARED\${ac_eC}1\${ac_eD}
"
}


else
  rm -rf conftest*
  test -n "$silent" || echo "checking for sys_errlist"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <errno.h>
int main() { return 0; }
int t() { 
	extern char *sys_errlist[];
	extern int sys_nerr;
	char *p;
	p = sys_errlist[sys_nerr - 1];
      ; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining HAVE_SYS_ERRLIST"
echo "#define" HAVE_SYS_ERRLIST "1" >> confdefs.h
DEFS="$DEFS -DHAVE_SYS_ERRLIST=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_SYS_ERRLIST\${ac_dB}HAVE_SYS_ERRLIST\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_SYS_ERRLIST\${ac_uB}HAVE_SYS_ERRLIST\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_SYS_ERRLIST\${ac_eB}HAVE_SYS_ERRLIST\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

fi
rm -f conftest*

  test -n "$silent" || echo "checking for sys_siglist declaration in signal.h or unistd.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <signal.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
      
int main() { return 0; }
int t() { char *msg = sys_siglist[1];; 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}
"
}
 
{
test -n "$verbose" && \
echo "	defining SYS_SIGLIST_DECLARED"
echo "#define" SYS_SIGLIST_DECLARED "1" >> confdefs.h
DEFS="$DEFS -DSYS_SIGLIST_DECLARED=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}SYS_SIGLIST_DECLARED\${ac_dB}SYS_SIGLIST_DECLARED\${ac_dC}1\${ac_dD}
\${ac_uA}SYS_SIGLIST_DECLARED\${ac_uB}SYS_SIGLIST_DECLARED\${ac_uC}1\${ac_uD}
\${ac_eA}SYS_SIGLIST_DECLARED\${ac_eB}SYS_SIGLIST_DECLARED\${ac_eC}1\${ac_eD}
"
}


else
  rm -rf conftest*
  test -n "$silent" || echo "checking for sys_siglist"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <signal.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
	  
int main() { return 0; }
int t() { 
	extern char *sys_siglist[];
	char *p = sys_siglist[2];
	if (p)
		return 12;
      ; 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
rm -f conftest*

  test -n "$silent" || echo "checking for time() declaration in time.h"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <time.h>
int main() { return 0; }
int t() { time_t (*f)() = time;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining TIME_DECLARED"
echo "#define" TIME_DECLARED "1" >> confdefs.h
DEFS="$DEFS -DTIME_DECLARED=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}TIME_DECLARED\${ac_dB}TIME_DECLARED\${ac_dC}1\${ac_dD}
\${ac_uA}TIME_DECLARED\${ac_uB}TIME_DECLARED\${ac_uC}1\${ac_uD}
\${ac_eA}TIME_DECLARED\${ac_eB}TIME_DECLARED\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

 test -n "$silent" || echo "checking for broken/missing times()"
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <sys/types.h>
#include <sys/times.h>

      main()
      {
	extern clock_t times();
	struct tms tms;
	times(&tms);
	sleep(1);
	if (times(&tms) == 0)
	  exit(1);
	exit(0);
      }
    
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else
  
{
test -n "$verbose" && \
echo "	defining TIMES_BROKEN"
echo "#define" TIMES_BROKEN "1" >> confdefs.h
DEFS="$DEFS -DTIMES_BROKEN=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}TIMES_BROKEN\${ac_dB}TIMES_BROKEN\${ac_dC}1\${ac_dD}
\${ac_uA}TIMES_BROKEN\${ac_uB}TIMES_BROKEN\${ac_uC}1\${ac_uD}
\${ac_eA}TIMES_BROKEN\${ac_eB}TIMES_BROKEN\${ac_eC}1\${ac_eD}
"
}
for ac_func in getrusage
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

fi
rm -fr conftest*
test -n "$silent" || echo "checking for broken stat file mode macros"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/stat.h>
#ifdef S_ISBLK
#if S_ISBLK (S_IFDIR)
You lose.
#endif
#ifdef S_IFCHR
#if S_ISBLK (S_IFCHR)
You lose.
#endif
#endif /* S_IFCHR */
#endif /* S_ISBLK */
#ifdef S_ISLNK
#if S_ISLNK (S_IFREG)
You lose.
#endif
#endif /* S_ISLNK */
#ifdef S_ISSOCK
#if S_ISSOCK (S_IFREG)
You lose.
#endif
#endif /* S_ISSOCK */

EOF
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "You lose" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining STAT_MACROS_BROKEN"
echo "#define" STAT_MACROS_BROKEN "1" >> confdefs.h
DEFS="$DEFS -DSTAT_MACROS_BROKEN=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}STAT_MACROS_BROKEN\${ac_dB}STAT_MACROS_BROKEN\${ac_dC}1\${ac_dD}
\${ac_uA}STAT_MACROS_BROKEN\${ac_uB}STAT_MACROS_BROKEN\${ac_uC}1\${ac_uD}
\${ac_eA}STAT_MACROS_BROKEN\${ac_eB}STAT_MACROS_BROKEN\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

test -n "$silent" || echo "checking for st_rdev in struct stat"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/stat.h>
int main() { return 0; }
int t() { struct stat s; s.st_rdev;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining HAVE_ST_RDEV"
echo "#define" HAVE_ST_RDEV "1" >> confdefs.h
DEFS="$DEFS -DHAVE_ST_RDEV=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ST_RDEV\${ac_dB}HAVE_ST_RDEV\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_ST_RDEV\${ac_uB}HAVE_ST_RDEV\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_ST_RDEV\${ac_eB}HAVE_ST_RDEV\${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 lack of working void"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

      void foo() { }
      /* Some compilers (old pcc ones) like "void *a;", but a can't be used */
      void *bar(a) void *a; { int *b = (int *) a; *b = 1; }
    
int main() { return 0; }
int t() { ; return 0; }
EOF
if eval $ac_compile; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" void to be "char"
echo "#define" void "char" >> confdefs.h
DEFS="$DEFS -Dvoid=char"
ac_sed_defs="${ac_sed_defs}\${ac_dA}void\${ac_dB}void\${ac_dC}char\${ac_dD}
\${ac_uA}void\${ac_uB}void\${ac_uC}char\${ac_uD}
\${ac_eA}void\${ac_eB}void\${ac_eC}char\${ac_eD}
"
}

fi
rm -f conftest*

  test -n "$silent" || echo "checking for lack of working volatile"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
int x, y, z;
int main() { return 0; }
int t() { volatile int a; int * volatile b = x ? &y : &z;
    /* Older MIPS compilers (eg., in Ultrix 4.2) don't like *b = 0 */
    *b = 0;; return 0; }
EOF
if eval $ac_compile; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" volatile to be empty
echo "#define" volatile "" >> confdefs.h
DEFS="$DEFS -Dvolatile="
ac_sed_defs="${ac_sed_defs}\${ac_dA}volatile\${ac_dB}volatile\${ac_dC}\${ac_dD}
\${ac_uA}volatile\${ac_uB}volatile\${ac_uC}\${ac_uD}
\${ac_eA}volatile\${ac_eB}volatile\${ac_eC}\${ac_eD}
"
}

fi
rm -f conftest*

  test -n "$silent" || echo "checking for working function prototypes"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <stdarg.h>
void foo(char *fmt, ...);
int bar(int a, char b, char *c);
int bar(a, b, c) int a; char b; char *c;
{ foo("%d%c%s\n", a, b, c); return a + b + *c; }
void foo(char *fmt, ...) { va_list a; va_start(a, fmt); va_end(a); }
    
int main() { return 0; }
int t() { ; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining HAVE_PROTOTYPES"
echo "#define" HAVE_PROTOTYPES "1" >> confdefs.h
DEFS="$DEFS -DHAVE_PROTOTYPES=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_PROTOTYPES\${ac_dB}HAVE_PROTOTYPES\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_PROTOTYPES\${ac_uB}HAVE_PROTOTYPES\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_PROTOTYPES\${ac_eB}HAVE_PROTOTYPES\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

test -n "$silent" || echo "checking whether \`#!' works in shell scripts"
echo '#!/bin/cat
exit 69
' > conftest
chmod u+x conftest
(SHELL=/bin/sh; export SHELL; ./conftest > /dev/null)
if test $? -ne 69; then
   :; test -n "$verbose" && echo "	it does"
else
   :; test -n "$verbose" && echo "	it doesn't"
{
test -n "$verbose" && \
echo "	defining SHARPBANG"
echo "#define" SHARPBANG "1" >> confdefs.h
DEFS="$DEFS -DSHARPBANG=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}SHARPBANG\${ac_dB}SHARPBANG\${ac_dC}1\${ac_dD}
\${ac_uA}SHARPBANG\${ac_uB}SHARPBANG\${ac_uC}1\${ac_uD}
\${ac_eA}SHARPBANG\${ac_eB}SHARPBANG\${ac_eC}1\${ac_eD}
"
}

fi
rm -f conftest
# 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', or /sbin/install on IRIX which has incompatible command-line
# syntax.  Sigh.
#
#     On most BSDish systems install is in /usr/bin, not /usr/ucb
#     anyway.
# This turns out not to be true, so the mere pathname isn't an indication
# of whether the program works.  What we really need is a set of tests for
# the install program to see if it actually works in all the required ways.
#
# Avoid using ./install, which might have been erroneously created
# by make from ./install.sh.
if test -z "${INSTALL}"; then
  test -n "$silent" || echo "checking for a BSD compatible install"
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    case "$ac_dir" in
    ''|.|/etc|/sbin|/usr/sbin|/usr/etc|/usr/afsws/bin|/usr/ucb) ;;
    *)
      # OSF1 and SCO ODT 3.0 have their own names for install.
      for ac_prog in installbsd scoinst install; do
        if test -f $ac_dir/$ac_prog; then
	  if test $ac_prog = install &&
            grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
	    # AIX install.  It has an incompatible calling convention.
	    # OSF/1 installbsd also uses dspmsg, but is usable.
	    :
	  else
	    INSTALL="$ac_dir/$ac_prog -c"
	    break 2
	  fi
	fi
      done
      ;;
    esac
  done
  IFS="$ac_save_ifs"
fi

if test -z "$INSTALL"; then
  # As a last resort, use the slow shell script.
  for ac_dir in ${srcdir} ${srcdir}/.. ${srcdir}/../..; do
    if test -f $ac_dir/install.sh; then
      INSTALL="$ac_dir/install.sh -c"; break
    fi
  done
fi
if test -z "$INSTALL"; then
  echo "configure: can not find install.sh in ${srcdir} or ${srcdir}/.. or ${srcdir}/../.." >&2; exit 1
fi
test -n "$verbose" && echo "	setting INSTALL to $INSTALL"

# Use test -z because SunOS4 sh mishandles ${INSTALL_PROGRAM-'${INSTALL}'}.
# It thinks the first close brace ends the variable substitution.
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
test -n "$verbose" && echo "	setting INSTALL_PROGRAM to $INSTALL_PROGRAM"

test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
test -n "$verbose" && echo "	setting INSTALL_DATA to $INSTALL_DATA"

test -n "$silent" || echo "checking if dup2() fails to reset the close-on-exec flag"
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <sys/types.h>
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#endif /* HAVE_FCNTL_H */

#ifndef F_GETFD
# define F_GETFD 1
#endif
#ifndef F_SETFD
# define F_SETFD 2
#endif
#ifndef O_RDONLY
# define O_RDONLY 0
#endif

/* On some systems (Ultrix 2.1..4.2 (and more?)), dup2() does not clear
   the close on exec flag */
main()
{
  int fd1, fd2;
  fd1 = open("/dev/null", O_RDONLY);
  if (fcntl(fd1, F_SETFD, 1) < 0)
    exit(1);
  fd2 = dup2(fd1, fd1 + 1);
  if (fd2 < 0)
    exit(2);
  exit(fcntl(fd2, F_GETFD, 0) == 0 ? 0 : 3);
}
  
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else
  
{
test -n "$verbose" && \
echo "	defining DUP2_BROKEN"
echo "#define" DUP2_BROKEN "1" >> confdefs.h
DEFS="$DEFS -DDUP2_BROKEN=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}DUP2_BROKEN\${ac_dB}DUP2_BROKEN\${ac_dC}1\${ac_dD}
\${ac_uA}DUP2_BROKEN\${ac_uB}DUP2_BROKEN\${ac_uC}1\${ac_uD}
\${ac_eA}DUP2_BROKEN\${ac_eB}DUP2_BROKEN\${ac_eC}1\${ac_eD}
"
}

fi
rm -fr conftest*
  test -n "$silent" || echo "checking for posix signals"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <signal.h>
int main() { return 0; }
int t() { 
    sigset_t ss;
    struct sigaction sa;
    sigemptyset(&ss); sigsuspend(&ss);
    sigaction(SIGINT, &sa, (struct sigaction *) 0);
    sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0);
  ; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining POSIX_SIGNALS"
echo "#define" POSIX_SIGNALS "1" >> confdefs.h
DEFS="$DEFS -DPOSIX_SIGNALS=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}POSIX_SIGNALS\${ac_dB}POSIX_SIGNALS\${ac_dC}1\${ac_dD}
\${ac_uA}POSIX_SIGNALS\${ac_uB}POSIX_SIGNALS\${ac_uC}1\${ac_uD}
\${ac_eA}POSIX_SIGNALS\${ac_eB}POSIX_SIGNALS\${ac_eC}1\${ac_eD}
"
}


else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining USE_FAKE_SIGACT"
echo "#define" USE_FAKE_SIGACT "1" >> confdefs.h
DEFS="$DEFS -DUSE_FAKE_SIGACT=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}USE_FAKE_SIGACT\${ac_dB}USE_FAKE_SIGACT\${ac_dC}1\${ac_dD}
\${ac_uA}USE_FAKE_SIGACT\${ac_uB}USE_FAKE_SIGACT\${ac_uC}1\${ac_uD}
\${ac_eA}USE_FAKE_SIGACT\${ac_eB}USE_FAKE_SIGACT\${ac_eC}1\${ac_eD}
"
}
   test -n "$silent" || echo "checking for BSD4.2 signals"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <signal.h>
int main() { return 0; }
int t() { 
    int mask = sigmask(SIGINT);
    sigsetmask(mask); sigblock(mask); sigpause(mask);
  ; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining BSD42_SIGNALS"
echo "#define" BSD42_SIGNALS "1" >> confdefs.h
DEFS="$DEFS -DBSD42_SIGNALS=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}BSD42_SIGNALS\${ac_dB}BSD42_SIGNALS\${ac_dC}1\${ac_dD}
\${ac_uA}BSD42_SIGNALS\${ac_uB}BSD42_SIGNALS\${ac_uC}1\${ac_uD}
\${ac_eA}BSD42_SIGNALS\${ac_eB}BSD42_SIGNALS\${ac_eC}1\${ac_eD}
"
}


else
  rm -rf conftest*
  test -n "$silent" || echo "checking for BSD4.1 signals"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

    #include <signal.h>
    RETSIGTYPE foo() { }
  
int main() { return 0; }
int t() { 
    int mask = sigmask(SIGINT);
    sigset(SIGINT, foo); sigrelse(SIGINT); sighold(SIGINT); sigpause(SIGINT);
  ; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining BSD41_SIGNALS"
echo "#define" BSD41_SIGNALS "1" >> confdefs.h
DEFS="$DEFS -DBSD41_SIGNALS=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}BSD41_SIGNALS\${ac_dB}BSD41_SIGNALS\${ac_dC}1\${ac_dD}
\${ac_uA}BSD41_SIGNALS\${ac_uB}BSD41_SIGNALS\${ac_uC}1\${ac_uD}
\${ac_eA}BSD41_SIGNALS\${ac_eB}BSD41_SIGNALS\${ac_eC}1\${ac_eD}
"
}


else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining V7_SIGNALS"
echo "#define" V7_SIGNALS "1" >> confdefs.h
DEFS="$DEFS -DV7_SIGNALS=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}V7_SIGNALS\${ac_dB}V7_SIGNALS\${ac_dC}1\${ac_dD}
\${ac_uA}V7_SIGNALS\${ac_uB}V7_SIGNALS\${ac_uC}1\${ac_uD}
\${ac_eA}V7_SIGNALS\${ac_eB}V7_SIGNALS\${ac_eC}1\${ac_eD}
"
}

fi
rm -f conftest*

fi
rm -f conftest*

fi
rm -f conftest*

  test -n "$silent" || echo "checking for POSIX vs BSD vs SYSV setpgrp()/getpgrp()"
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <signal.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif /* HAVE_UNISTD_H */

    main()
    {
      int ecode = 0, child = fork();
      if (child < 0)
	exit(1);
      if (child == 0) {
	signal(SIGTERM, SIG_DFL); /* just to make sure */
	sleep(10);
	exit(9);
      }
      if (setpgrp(child, child) < 0)
	ecode = 2;
      else if (getpgrp(child) != child)
	ecode = 3;
      kill(child, SIGTERM);
      exit(ecode);
    }
  
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  
{
test -n "$verbose" && \
echo "	defining BSD_PGRP"
echo "#define" BSD_PGRP "1" >> confdefs.h
DEFS="$DEFS -DBSD_PGRP=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}BSD_PGRP\${ac_dB}BSD_PGRP\${ac_dC}1\${ac_dD}
\${ac_uA}BSD_PGRP\${ac_uB}BSD_PGRP\${ac_uC}1\${ac_uD}
\${ac_eA}BSD_PGRP\${ac_eB}BSD_PGRP\${ac_eC}1\${ac_eD}
"
}


else
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif /* HAVE_UNISTD_H */

      main()
      {
	int child;
	int n, p1[2], p2[2];
	char buf[1];

	if (pipe(p1) < 0 || pipe(p2) < 0)
	  exit(1);
	if ((child = fork()) < 0)
	  exit(2);
	if (child == 0) {
	  n = read(p1[0], buf, sizeof(buf)); /* wait for parent to setpgid */
	  buf[0] = (n != 1 ? 10 : (getpgrp() != getpid() ? 11 : 0));
	  if (write(p2[1], buf, sizeof(buf)) != 1)
	    exit(12);
	  exit(0);
	}
	if (setpgid(child, child) < 0)
	  exit(3);
	if (write(p1[1], buf, 1) != 1)
	  exit(4);
	if (read(p2[0], buf, 1) != 1)
	  exit(5);
	exit((int) buf[0]);
      }
    
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  
{
test -n "$verbose" && \
echo "	defining POSIX_PGRP"
echo "#define" POSIX_PGRP "1" >> confdefs.h
DEFS="$DEFS -DPOSIX_PGRP=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}POSIX_PGRP\${ac_dB}POSIX_PGRP\${ac_dC}1\${ac_dD}
\${ac_uA}POSIX_PGRP\${ac_uB}POSIX_PGRP\${ac_uC}1\${ac_uD}
\${ac_eA}POSIX_PGRP\${ac_eB}POSIX_PGRP\${ac_eC}1\${ac_eD}
"
}


else
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif /* HAVE_UNISTD_H */

	  main()
	  {
	    int child;
	    int n, p[2];
	    char buf[1];

	    if (pipe(p) < 0)
	      exit(1);
	    if ((child = fork()) < 0)
	      exit(2);
	    if (child == 0) {
	      buf[0] = (setpgrp() < 0 ? 10 : (getpgrp() != getpid() ? 11 : 0));
	      if (write(p[1], buf, sizeof(buf)) != 1)
		exit(11);
	      exit(0);
	    }
	    if (read(p[0], buf, 1) != 1)
	      exit(3);
	    exit((int) buf[0]);
	  }
        
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  
{
test -n "$verbose" && \
echo "	defining SYSV_PGRP"
echo "#define" SYSV_PGRP "1" >> confdefs.h
DEFS="$DEFS -DSYSV_PGRP=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}SYSV_PGRP\${ac_dB}SYSV_PGRP\${ac_dC}1\${ac_dD}
\${ac_uA}SYSV_PGRP\${ac_uB}SYSV_PGRP\${ac_uC}1\${ac_uD}
\${ac_eA}SYSV_PGRP\${ac_eB}SYSV_PGRP\${ac_eC}1\${ac_eD}
"
}


fi
rm -fr conftest*
fi
rm -fr conftest*
fi
rm -fr conftest*
 test -n "$silent" || echo "checking if process group synchronization is required"
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

      main()
      {
#if defined(POSIX_PGRP) || defined(BSD_PGRP)
# ifdef POSIX_PGRP
#  define getpgID()	getpgrp()
# else
#  define getpgID()	getpgrp(0)
#  define setpgid(x,y)	setpgrp(x,y)
# endif
	int pid1, pid2, fds[2];
	int status;
	char ok;

	switch (pid1 = fork()) {
	  case -1:
	    exit(1);
	  case 0:
	    setpgid(0, getpid());
	    exit(0);
	}
	setpgid(pid1, pid1);

	sleep(2);	/* let first child die */

	if (pipe(fds) < 0)
	  exit(2);

	switch (pid2 = fork()) {
	  case -1:
	    exit(3);
	  case 0:
	    setpgid(0, pid1);
	    ok = getpgID() == pid1;
	    write(fds[1], &ok, 1);
	    exit(0);
	}
	setpgid(pid2, pid1);

	close(fds[1]);
	if (read(fds[0], &ok, 1) != 1)
	  exit(4);
	wait(&status);
	wait(&status);
	exit(ok ? 0 : 5);
#else /* POSIX_PGRP || BSD_PGRP */
	exit(20);
#endif /* POSIX_PGRP || BSD_PGRP */
      }
    
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else
  
{
test -n "$verbose" && \
echo "	defining NEED_PGRP_SYNC"
echo "#define" NEED_PGRP_SYNC "1" >> confdefs.h
DEFS="$DEFS -DNEED_PGRP_SYNC=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}NEED_PGRP_SYNC\${ac_dB}NEED_PGRP_SYNC\${ac_dC}1\${ac_dD}
\${ac_uA}NEED_PGRP_SYNC\${ac_uB}NEED_PGRP_SYNC\${ac_uC}1\${ac_uD}
\${ac_eA}NEED_PGRP_SYNC\${ac_eB}NEED_PGRP_SYNC\${ac_eC}1\${ac_eD}
"
}

fi
rm -fr conftest*
test -n "$silent" || echo "checking if C compiler groks __attribute__(( .. ))"
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <stdarg.h>
void test_fmt(char *fmt, ...) __attribute__((format(printf, 1, 2)));
void test_fmt(char *fmt, ...) { return; }
void test_cnst(int) __attribute__((const));
void test_cnst(int x) { return x + 1; }
void test_nr() __attribute__((noreturn));
void test_nr() { exit(1); }
void test_uk() __attribute__((blah));
void test_uk() { return; }

int main() { return 0; }
int t() { test_nr("%d", 10); test_cnst(2); test_uk(); test_nr();; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining HAVE_GCC_FUNC_ATTR"
echo "#define" HAVE_GCC_FUNC_ATTR "1" >> confdefs.h
DEFS="$DEFS -DHAVE_GCC_FUNC_ATTR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_GCC_FUNC_ATTR\${ac_dB}HAVE_GCC_FUNC_ATTR\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_GCC_FUNC_ATTR\${ac_uB}HAVE_GCC_FUNC_ATTR\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_GCC_FUNC_ATTR\${ac_eB}HAVE_GCC_FUNC_ATTR\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

 test -n "$silent" || echo "checking if opendir() opens non-directories"
  cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <stdio.h>
#include <sys/types.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif /* HAVE_UNISTD_H */
#if defined(DIRENT) || defined(_POSIX_VERSION)
# include <dirent.h>
#else
# define dirent direct
# ifdef SYSNDIR
#  include <sys/ndir.h>
# endif /* SYSNDIR */
# ifdef SYSDIR
#  include <sys/dir.h>
# endif /* SYSDIR */
# ifdef NDIR
#  include <ndir.h>
# endif /* NDIR */
#endif /* DIRENT || _POSIX_VERSION */

      main()
      {
	int i, ret = 0;
	FILE *fp;
	char *fname = "conftestod", buf[256];

	for (i = 0; i < sizeof(buf); i++) /* memset(buf, 0, sizeof(buf)) */
	  buf[i] = 0;
	unlink(fname); /* paranoia */
	i = ((fp = fopen(fname, "w")) == (FILE *) 0 && (ret = 1))
	     || (fwrite(buf, sizeof(buf), 1, fp) != 1 && (ret = 2))
	     || (fclose(fp) == EOF && (ret = 3))
	     || (opendir(fname) && (ret = 4))
	     || (opendir("/dev/null") && (ret = 5));

	unlink(fname);
	exit(ret);
      }
    
EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else
  
{
test -n "$verbose" && \
echo "	defining OPENDIR_DOES_NONDIR"
echo "#define" OPENDIR_DOES_NONDIR "1" >> confdefs.h
DEFS="$DEFS -DOPENDIR_DOES_NONDIR=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}OPENDIR_DOES_NONDIR\${ac_dB}OPENDIR_DOES_NONDIR\${ac_dC}1\${ac_dD}
\${ac_uA}OPENDIR_DOES_NONDIR\${ac_uB}OPENDIR_DOES_NONDIR\${ac_uC}1\${ac_uD}
\${ac_eA}OPENDIR_DOES_NONDIR\${ac_eB}OPENDIR_DOES_NONDIR\${ac_eC}1\${ac_eD}
"
}

fi
rm -fr conftest*
  test -n "$silent" || echo "checking for union wait"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/wait.h>
int main() { return 0; }
int t() { union wait status; int pid; pid = wait (&status);
#ifdef WEXITSTATUS
      /* Some POSIXoid systems have both the new-style macros and the old
	 union wait type, and they do not work together.  If union wait
	 conflicts with WEXITSTATUS et al, we don't want to use it at all.  */
      if (WEXITSTATUS (status) != 0) pid = -1;
#endif
#ifdef HAVE_WAITPID
      /* Make sure union wait works with waitpid.  */
      pid = waitpid (-1, &status, 0);
#endif
    ; 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*


# 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 config.h conftest*; exit 1' 1 2 15
LDSTATIC='$LDSTATIC'
CC='$CC'
CPP='$CPP'
GCC_WARNFLAGS='$GCC_WARNFLAGS'
INSTALL='$INSTALL'
INSTALL_PROGRAM='$INSTALL_PROGRAM'
INSTALL_DATA='$INSTALL_DATA'
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=$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
  .)  srcdir=.
      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%@LDSTATIC@%$LDSTATIC%g
s%@CC@%$CC%g
s%@CPP@%$CPP%g
s%@GCC_WARNFLAGS@%$GCC_WARNFLAGS%g
s%@INSTALL@%$INSTALL%g
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
s%@INSTALL_DATA@%$INSTALL_DATA%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
# config.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-"config.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

