#!/bin/sh
# From configure.in Revision: 1.3 
#!/bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf version 1.8 
# 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=1 ;; # 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.8"
    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=1 ;; # 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" -ne 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=Include/object.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 `..'.
  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
ac_cpp='${CPP} $CFLAGS'
ac_compile='${CC-cc} $CFLAGS $LDFLAGS conftest.${ac_ext} -o conftest $LIBS >/dev/null 2>&1'

if test -z "$prefix"
then
  test -n "$silent" || echo "checking for python to derive installation directory prefix"
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="$IFS:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test $ac_dir != . && test -f $ac_dir/python; then
      # Not all systems have dirname.
      prefix=`echo $ac_dir|sed 's%/[^/][^/]*$%%'`
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -n "$verbose" && echo "	chose installation directory prefix ${prefix}"
fi

# Don't suppress compiler output when --verbose is specified
test -n "$verbose" &&
	ac_compile=`echo "$ac_compile" | sed "s|>/dev/null 2>&1||"`
test -n "$verbose" && echo "	setting ac_compile to '$ac_compile'"

# checks for alternative programs
test -n "$silent" || echo "checking for --with(out)-gcc"
# check whether --with-gcc or --without-gcc was given.
withval="$with_gcc"
if test -n "$withval"; then
  
	case $withval in
	no)	withval=cc;;
	yes)	withval=gcc;;
	esac
	CC=$withval
fi

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*

# 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}" = "z" ; 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 grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
	    : # AIX
	  else
	    INSTALL="$ac_dir/$ac_prog -c"
	    INSTALL_PROGRAM='${INSTALL}'
	    INSTALL_DATA='${INSTALL} -m 644'
	    break 2
	  fi
	fi
      done
      ;;
    esac
  done
  IFS="$ac_save_ifs"
fi
if test -z "$INSTALL"; then
  if test -f ${srcdir}/install.sh; then
    # As a last resort, use the slow shell script.
    INSTALL='@top_srcdir@/install.sh -c'
  else
    echo "configure: warning: ${srcdir}/install.sh not found; using cp" >&2
    INSTALL=cp
  fi
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}'
test -n "$verbose" && echo "	setting INSTALL_DATA to $INSTALL_DATA"

if test -z "$RANLIB"; then
  # Extract the first word of `ranlib', so it can be a program name with args.
  set ac_dummy ranlib; 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
      RANLIB="ranlib"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
test -z "$RANLIB" && RANLIB=":"
test -n "$RANLIB" && test -n "$verbose" && echo "	setting RANLIB to $RANLIB"


for ac_prog in ar aal
do
if test -z "$AR"; then
  # Extract the first word of `$ac_prog', so it can be a program name with args.
  set ac_dummy $ac_prog; 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
      AR="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi

test -n "$AR" && test -n "$verbose" && echo "	setting AR to $AR"

test -n "$AR" && break
done
test -n "$AR" || AR="ar"


# checks for UNIX variants that set C preprocessor variables
test -n "$silent" || echo "checking for AIX"
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"

cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#ifdef _AIX
  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*
  
{
test -n "$verbose" && \
echo "	defining _ALL_SOURCE"
echo "#define" _ALL_SOURCE "1" >> confdefs.h
DEFS="$DEFS -D_ALL_SOURCE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_ALL_SOURCE\${ac_dB}_ALL_SOURCE\${ac_dC}1\${ac_dD}
\${ac_uA}_ALL_SOURCE\${ac_uB}_ALL_SOURCE\${ac_uC}1\${ac_uD}
\${ac_eA}_ALL_SOURCE\${ac_eB}_ALL_SOURCE\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*


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

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


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

#ifdef _NEXT_SOURCE
main() { exit(0); }
#endif

EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; 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}
"
}


fi
rm -fr conftest*

# checks for header files
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 dlfcn.h fcntl.h limits.h signal.h stdarg.h stdlib.h thread.h unistd.h utime.h sys/audioio.h sys/param.h sys/select.h sys/time.h sys/times.h sys/un.h sys/utsname.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 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*


# checks for typedefs
test -n "$silent" || echo "checking for clock_t in time.h"
echo '#include "confdefs.h"
#include <time.h>' > conftest.${ac_ext}
eval "$ac_cpp conftest.${ac_ext} > conftest.out 2>&1"
if egrep "clock_t" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" clock_t to be "long"
echo "#define" clock_t "long" >> confdefs.h
DEFS="$DEFS -Dclock_t=long"
ac_sed_defs="${ac_sed_defs}\${ac_dA}clock_t\${ac_dB}clock_t\${ac_dC}long\${ac_dD}
\${ac_uA}clock_t\${ac_uB}clock_t\${ac_uC}long\${ac_uD}
\${ac_eA}clock_t\${ac_eB}clock_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 "mode_t" 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 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 "off_t" 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 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 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 size_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 "size_t" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" size_t to be "unsigned"
echo "#define" size_t "unsigned" >> confdefs.h
DEFS="$DEFS -Dsize_t=unsigned"
ac_sed_defs="${ac_sed_defs}\${ac_dA}size_t\${ac_dB}size_t\${ac_dC}unsigned\${ac_dD}
\${ac_uA}size_t\${ac_uB}size_t\${ac_uC}unsigned\${ac_uD}
\${ac_eA}size_t\${ac_eB}size_t\${ac_eC}unsigned\${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 "uid_t" 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*


# checks for libraries
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -ldl"
ac_have_lib=""
test -n "$silent" || echo "checking for -ldl"
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_LIBDL"
echo "#define" HAVE_LIBDL "1" >> confdefs.h
DEFS="$DEFS -DHAVE_LIBDL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_LIBDL\${ac_dB}HAVE_LIBDL\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_LIBDL\${ac_uB}HAVE_LIBDL\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_LIBDL\${ac_eB}HAVE_LIBDL\${ac_eC}1\${ac_eD}
"
}

   LIBS="${LIBS} -ldl"
fi


test -n "$silent" || echo "checking for --with-svr4"
# check whether --with-svr4 or --without-svr4 was given.
withval="$with_svr4"
if test -n "$withval"; then
  
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

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

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


fi


test -n "$silent" || echo "checking for --with-readline"
# check whether --with-readline or --without-readline was given.
withval="$with_readline"
if test -n "$withval"; then
  
{
test -n "$verbose" && \
echo "	defining WITH_READLINE"
echo "#define" WITH_READLINE "1" >> confdefs.h
DEFS="$DEFS -DWITH_READLINE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}WITH_READLINE\${ac_dB}WITH_READLINE\${ac_dC}1\${ac_dD}
\${ac_uA}WITH_READLINE\${ac_uB}WITH_READLINE\${ac_uC}1\${ac_uD}
\${ac_eA}WITH_READLINE\${ac_eB}WITH_READLINE\${ac_eC}1\${ac_eD}
"
}

if test -d "$withval"
then LIBS="$LIBS -L$withval"
else echo "configure: proper usage is --with-readline=DIRECTORY" >&2; exit 1
fi
termcap=
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -ltermcap"
ac_have_lib=""
test -n "$silent" || echo "checking for -ltermcap"
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
   :; termcap=termcap
else
   :; ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -ltermlib"
ac_have_lib=""
test -n "$silent" || echo "checking for -ltermlib"
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
   :; termcap=termlib
else
   :; 
fi

fi

if test ! -z "$termcap"
then LIBS="$LIBS -lreadline"
     # Avoid possible conflict between shared libraries termcap and gl
     # on IRIX 5: both contain a routine called clear.
     if test -f /usr/lib/lib$termcap.a
     then LIBS="$LIBS /usr/lib/lib$termcap.a"
     else LIBS="$LIBS -l$termcap"
     fi
else echo "configure: no working termcap/termlib" >&2; exit 1
fi
fi


test -n "$silent" || echo "checking for --with-thread"
# check whether --with-thread or --without-thread was given.
withval="$with_thread"
if test -n "$withval"; then
  
if test -d "$withval"
then LIBS="$LIBS -L$withval"
fi
ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lpthreads"
ac_have_lib=""
test -n "$silent" || echo "checking for -lpthreads"
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 WITH_THREAD"
echo "#define" WITH_THREAD "1" >> confdefs.h
DEFS="$DEFS -DWITH_THREAD=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}WITH_THREAD\${ac_dB}WITH_THREAD\${ac_dC}1\${ac_dD}
\${ac_uA}WITH_THREAD\${ac_uB}WITH_THREAD\${ac_uC}1\${ac_uD}
\${ac_eA}WITH_THREAD\${ac_eB}WITH_THREAD\${ac_eC}1\${ac_eD}
"
}


{
test -n "$verbose" && \
echo "	defining _POSIX_THREADS"
echo "#define" _POSIX_THREADS "1" >> confdefs.h
DEFS="$DEFS -D_POSIX_THREADS=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}_POSIX_THREADS\${ac_dB}_POSIX_THREADS\${ac_dC}1\${ac_dD}
\${ac_uA}_POSIX_THREADS\${ac_uB}_POSIX_THREADS\${ac_uC}1\${ac_uD}
\${ac_eA}_POSIX_THREADS\${ac_eB}_POSIX_THREADS\${ac_eC}1\${ac_eD}
"
}

LIBS="$LIBS -lpthreads"
LIBOBJS="$LIBOBJS thread.o"
else
   :; 
fi

ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lmpc"
ac_have_lib=""
test -n "$silent" || echo "checking for -lmpc"
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 WITH_THREAD"
echo "#define" WITH_THREAD "1" >> confdefs.h
DEFS="$DEFS -DWITH_THREAD=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}WITH_THREAD\${ac_dB}WITH_THREAD\${ac_dC}1\${ac_dD}
\${ac_uA}WITH_THREAD\${ac_uB}WITH_THREAD\${ac_uC}1\${ac_uD}
\${ac_eA}WITH_THREAD\${ac_eB}WITH_THREAD\${ac_eC}1\${ac_eD}
"
}

LIBS="$LIBS -lmpc"
LIBOBJS="$LIBOBJS thread.o"
else
   :; 
fi

ac_save_LIBS="${LIBS}"
LIBS="${LIBS} -lthread"
ac_have_lib=""
test -n "$silent" || echo "checking for -lthread"
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 WITH_THREAD"
echo "#define" WITH_THREAD "1" >> confdefs.h
DEFS="$DEFS -DWITH_THREAD=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}WITH_THREAD\${ac_dB}WITH_THREAD\${ac_dC}1\${ac_dD}
\${ac_uA}WITH_THREAD\${ac_uB}WITH_THREAD\${ac_uC}1\${ac_uD}
\${ac_eA}WITH_THREAD\${ac_eB}WITH_THREAD\${ac_eC}1\${ac_eD}
"
}

LIBS="$LIBS -lthread"
LIBOBJS="$LIBOBJS thread.o"
else
   :; 
fi


fi


# -I${DLINCLDIR} is added to the compile rule for import.o

DLINCLDIR=/

test -n "$silent" || echo "checking for --with-sgi-dl"
# check whether --with-sgi-dl or --without-sgi-dl was given.
withval="$with_sgi_dl"
if test -n "$withval"; then
  
{
test -n "$verbose" && \
echo "	defining WITH_SGI_DL"
echo "#define" WITH_SGI_DL "1" >> confdefs.h
DEFS="$DEFS -DWITH_SGI_DL=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}WITH_SGI_DL\${ac_dB}WITH_SGI_DL\${ac_dC}1\${ac_dD}
\${ac_uA}WITH_SGI_DL\${ac_uB}WITH_SGI_DL\${ac_uC}1\${ac_uD}
\${ac_eA}WITH_SGI_DL\${ac_eB}WITH_SGI_DL\${ac_eC}1\${ac_eD}
"
}

dldir=$withval
if test -d "$dldir"
then LIBS="$LIBS -L$dldir"
else echo "configure: proper usage is --with-sgi-dl=DIRECTORY" >&2; exit 1
fi
DLINCLDIR=${dldir}
LIBS="$LIBS -ldl -lmld"
fi


test -n "$silent" || echo "checking for --with-dl-dld"
# check whether --with-dl-dld or --without-dl-dld was given.
withval="$with_dl_dld"
if test -n "$withval"; then
  
{
test -n "$verbose" && \
echo "	defining WITH_DL_DLD"
echo "#define" WITH_DL_DLD "1" >> confdefs.h
DEFS="$DEFS -DWITH_DL_DLD=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}WITH_DL_DLD\${ac_dB}WITH_DL_DLD\${ac_dC}1\${ac_dD}
\${ac_uA}WITH_DL_DLD\${ac_uB}WITH_DL_DLD\${ac_uC}1\${ac_uD}
\${ac_eA}WITH_DL_DLD\${ac_eB}WITH_DL_DLD\${ac_eC}1\${ac_eD}
"
}

dldir=`echo "$withval" | sed 's/,.*//'`
dlddir=`echo "$withval" | sed 's/.*,//'`
if test -d "$dldir" -a -d "$dlddir"
then LIBS="$LIBS -L$dldir -L$dlddir"
else echo "configure: proper usage is --with-dl-dld=DL_DIRECTORY" >&2; exit 1
fi
DLINCLDIR=${dldir}
LIBS="$LIBS -ldl -ldld"
fi


# checks for library functions
for ac_func in chown clock dlopen ftime gettimeofday getpeername getpgrp getpid getwd link lstat nice readlink select setgid setuid setsid setpgid setpgrp setvbuf siginterrupt symlink tcgetpgrp tcsetpgrp times uname waitpid
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 dup2 getcwd strerror memmove
do
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
  :
else
  rm -rf conftest*
  LIBOBJS="$LIBOBJS ${ac_func}.o"
test -n "$verbose" && echo "	using ${ac_func}.o instead"
fi
rm -f conftest*

done

test -n "$silent" || echo "checking for getpgrp"
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_getpgrp) || defined (__stub___getpgrp)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char getpgrp(); getpgrp();
#endif
; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  test -n "$silent" || echo "checking for argument to getpgrp"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <unistd.h>
int main() { return 0; }
int t() { getpgrp(0);; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining GETPGRP_HAVE_ARG"
echo "#define" GETPGRP_HAVE_ARG "1" >> confdefs.h
DEFS="$DEFS -DGETPGRP_HAVE_ARG=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}GETPGRP_HAVE_ARG\${ac_dB}GETPGRP_HAVE_ARG\${ac_dC}1\${ac_dD}
\${ac_uA}GETPGRP_HAVE_ARG\${ac_uB}GETPGRP_HAVE_ARG\${ac_uC}1\${ac_uD}
\${ac_eA}GETPGRP_HAVE_ARG\${ac_eB}GETPGRP_HAVE_ARG\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*


fi
rm -f conftest*


# checks for structures
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 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 whether we have altzone"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <time.h>
int main() { return 0; }
int t() { return altzone;; return 0; }
EOF
if eval $ac_compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining HAVE_ALTZONE"
echo "#define" HAVE_ALTZONE "1" >> confdefs.h
DEFS="$DEFS -DHAVE_ALTZONE=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ALTZONE\${ac_dB}HAVE_ALTZONE\${ac_dC}1\${ac_dD}
\${ac_uA}HAVE_ALTZONE\${ac_uB}HAVE_ALTZONE\${ac_uC}1\${ac_uD}
\${ac_eA}HAVE_ALTZONE\${ac_eB}HAVE_ALTZONE\${ac_eC}1\${ac_eD}
"
}


fi
rm -f conftest*

test -n "$silent" || echo "checking for whether sys/select.h and sys/time.h may both be included"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

#include <sys/types.h>
#include <sys/select.h>
#include <sys/time.h>

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


fi
rm -f conftest*


# checks for compiler characteristics

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*


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 wheter we have signed char"
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"

int main() { return 0; }
int t() { signed char c;; return 0; }
EOF
if eval $ac_compile; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" signed to be empty
echo "#define" signed "" >> confdefs.h
DEFS="$DEFS -Dsigned="
ac_sed_defs="${ac_sed_defs}\${ac_dA}signed\${ac_dB}signed\${ac_dC}\${ac_dD}
\${ac_uA}signed\${ac_uB}signed\${ac_uC}\${ac_uD}
\${ac_eA}signed\${ac_eB}signed\${ac_eC}\${ac_eD}
"
}

fi
rm -f conftest*


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

int foo(int x) { return 0; }
int main() { return foo(10); }

EOF
eval $ac_compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  
{
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}
"
}
 have_prototypes=1

fi
rm -fr conftest*

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

#include <stdarg.h>
int foo(int x, ...) { return 0; }
int main() { return foo(10, 11, 12); }

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

fi
rm -fr conftest*
if test "$have_prototypes"; then
test -n "$silent" || echo "checking for "bad exec* prototypes""
cat > conftest.${ac_ext} <<EOF
#include "confdefs.h"
#include <unistd.h>
int main() { return 0; }
int t() { char **t;execve("@",t,t);; return 0; }
EOF
if eval $ac_compile; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining BAD_EXEC_PROTOTYPES"
echo "#define" BAD_EXEC_PROTOTYPES "1" >> confdefs.h
DEFS="$DEFS -DBAD_EXEC_PROTOTYPES=1"
ac_sed_defs="${ac_sed_defs}\${ac_dA}BAD_EXEC_PROTOTYPES\${ac_dB}BAD_EXEC_PROTOTYPES\${ac_dC}1\${ac_dD}
\${ac_uA}BAD_EXEC_PROTOTYPES\${ac_uB}BAD_EXEC_PROTOTYPES\${ac_uC}1\${ac_uD}
\${ac_eA}BAD_EXEC_PROTOTYPES\${ac_eB}BAD_EXEC_PROTOTYPES\${ac_eC}1\${ac_eD}
"
}

fi
rm -f conftest*

fi

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

struct s { int a; int b; };
static struct s foo;
int foobar() { return !foo.a; }
static struct s foo = { 1, 2 };
main() { exit(foobar()); }

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

fi
rm -fr conftest*

# checks for system services
# (none yet)

# other checks for UNIX variants
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


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


# check for --with-libm=...

LIBM=-lm
# check whether --with-libm or --without-libm was given.
withval="$with_libm"
if test -n "$withval"; then
  if test "$withval" != yes
then LIBM=$withval
else echo "configure: proper usage is --with-libm=STRING" >&2; exit 1
fi
fi


# check for --with-libc=...

# check whether --with-libc or --without-libc was given.
withval="$with_libc"
if test -n "$withval"; then
  if test "$withval" != yes
then LIBC=$withval
else echo "configure: proper usage is --with-libc=STRING" >&2; exit 1
fi
fi


# generate output files
# Set default prefixes.
if test -n "$prefix"; then
  test -z "$exec_prefix" && exec_prefix='${prefix}' # Let make expand it.
  ac_prsub="s%^prefix\\([ 	]*\\)=\\([ 	]*\\).*$%prefix\\1=\\2$prefix%"
fi
if test -n "$exec_prefix"; then
  ac_prsub="$ac_prsub
s%^exec_prefix\\([ 	]*\\)=\\([ 	]*\\).*$%exec_prefix\\1=\\2$exec_prefix%"
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.8"
    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 Objects/Makefile Parser/Makefile Python/Makefile Modules/Makefile.pre config.h conftest*; exit 1' 1 2 15
CC='$CC'
INSTALL='$INSTALL'
INSTALL_PROGRAM='$INSTALL_PROGRAM'
INSTALL_DATA='$INSTALL_DATA'
RANLIB='$RANLIB'
AR='$AR'
CPP='$CPP'
DLINCLDIR='$DLINCLDIR'
LIBOBJS='$LIBOBJS'
LIBM='$LIBM'
LIBC='$LIBC'
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 Objects/Makefile Parser/Makefile Python/Makefile Modules/Makefile.pre"}
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"; 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=.; top_srcdir="$ac_dots." ;;
  /*) 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%@INSTALL@%$INSTALL%g
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
s%@INSTALL_DATA@%$INSTALL_DATA%g
s%@RANLIB@%$RANLIB%g
s%@AR@%$AR%g
s%@CPP@%$CPP%g
s%@DLINCLDIR@%$DLINCLDIR%g
s%@LIBOBJS@%$LIBOBJS%g
s%@LIBM@%$LIBM%g
s%@LIBC@%$LIBC%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 -20.
  sed 1,${ac_max_sh_lines}d conftest.sh > conftest.s2 # Like tail +21.
  # 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
  while :
  do
    ac_lines=`grep -c . conftest.sed`
    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.sed > conftest.s1 # Like head -20.
    sed 1,${ac_max_sed_lines}d conftest.sed > conftest.s2 # Like tail +21.
    sed -f conftest.s1 < conftest.h1 > conftest.h2
    rm -f conftest.s1 conftest.h1 conftest.sed
    mv conftest.h2 conftest.h1
    mv conftest.s2 conftest.sed
  done
  rm -f conftest.sed 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



exit 0
EOF
chmod +x config.status
test -n "$no_create" || ${CONFIG_SHELL-/bin/sh} config.status