#!/bin/sh
# From configure.in 1.10 (rev. 16 Jun 1994)

#!/bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf.
# Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

# Usage: configure [--srcdir=DIR] [--host=HOST] [--gas] [--nfp]
#        [--prefix=PREFIX] [--exec-prefix=PREFIX] [--with-PACKAGE[=VALUE]]
# Ignores all args except --srcdir, --prefix, --exec-prefix, and
# --with-PACKAGE[=VALUE] unless this script has special code to handle it.

for arg
do
  # Handle --exec-prefix with a space before the argument.
  if test x$next_exec_prefix = xyes; then exec_prefix=$arg; next_exec_prefix=
  # Handle --host with a space before the argument.
  elif test x$next_host = xyes; then next_host=
  # Handle --prefix with a space before the argument.
  elif test x$next_prefix = xyes; then prefix=$arg; next_prefix=
  # Handle --srcdir with a space before the argument.
  elif test x$next_srcdir = xyes; then srcdir=$arg; next_srcdir=
  else
    case $arg in
     # For backward compatibility, recognize -exec-prefix and --exec_prefix.
     -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* | --exec=* | --exe=* | --ex=* | --e=*)
	exec_prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;;
     -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- | --exec | --exe | --ex | --e)
	next_exec_prefix=yes ;;

     -gas | --gas | --ga | --g) ;;

     -host=* | --host=* | --hos=* | --ho=* | --h=*) ;;
     -host | --host | --hos | --ho | --h)
	next_host=yes ;;

     -nfp | --nfp | --nf) ;;

     -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
	prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;;
     -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
	next_prefix=yes ;;

     -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=* | --s=*)
	srcdir=`echo $arg | sed 's/[-a-z_]*=//'` ;;
     -srcdir | --srcdir | --srcdi | --srcd | --src | --sr | --s)
	next_srcdir=yes ;;

     -with-* | --with-*)
       package=`echo $arg|sed -e 's/-*with-//' -e 's/=.*//'`
       # Reject names that aren't valid shell variable names.
       if test -n "`echo $package| sed 's/[-a-zA-Z0-9_]//g'`"; then
         echo "configure: $package: invalid package name" >&2; exit 1
       fi
       package=`echo $package| sed 's/-/_/g'`
       case "$arg" in
         *=*) val="`echo $arg|sed 's/[^=]*=//'`" ;;
         *) val=1 ;;
       esac
       eval "with_$package='$val'" ;;

     -v | -verbose | --verbose | --verbos | --verbo | --verb | --ver | --ve | --v)
       verbose=yes ;;

     *) ;;
    esac
  fi
done

trap 'rm -fr conftest* core; exit 1' 1 3 15
 trap ' : ; exit 1' 0	#preserve non-zero exit status on abnormal exits

# NLS nuisances.
# These must not be set unconditionally because not all systems understand
# e.g. LANG=C (notably SCO).
if test "${LC_ALL+set}" = 'set' ; then LC_ALL=C; export LC_ALL; fi
if test "${LANG+set}"   = 'set' ; then LANG=C;   export LANG;   fi

rm -f conftest*
compile='eval "${CC-cc} $CFLAGS $DEFS conftest.c -o conftest $LIBS >/dev/null 2>&1"'

# sed commands to quote -Dname=value for use in "$DEFS" by AC DEFINE_UNQUOTED.
# Embedded newlines are replaced with "\n", and shell meta characters are
# protected from evaluation by the shell.
quote_define_sedprog='
	:T
	$!{
		N
		s/\n/\\n/
		b T
	}
	/[^-a-zA-Z0-9_@+=.:]/{
		'"s/'/'\\\\''/g"'
		s/^/'\''/
		s/$/'\''/
	}'

# A filename unique to this package, relative to the directory that
# configure is in, which we can look for to find out if srcdir is correct.
unique_file=utils/slipd.c

# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  srcdirdefaulted=yes
  # Try the directory containing this script, then `..'.
  prog=$0
  confdir=`echo $prog|sed 's%/[^/][^/]*$%%'`
  test "X$confdir" = "X$prog" && confdir=.
  srcdir=$confdir
  if test ! -r $srcdir/$unique_file; then
    srcdir=..
  fi
fi
if test ! -r $srcdir/$unique_file; then
  if test x$srcdirdefaulted = xyes; then
    echo "configure: Can not find sources in \`${confdir}' or \`..'." 1>&2
  else
    echo "configure: Can not find sources in \`${srcdir}'." 1>&2
  fi
  exit 1
fi
# Preserve a srcdir of `.' to avoid automounter screwups with pwd.
# But we can't avoid them for `..', to make subdirectories work.
case $srcdir in
  .|/*|~*) ;;
  *) srcdir=`cd $srcdir; pwd` ;; # Make relative path absolute.
esac


# Save the original args to write them into config.status later.
configure_args="$*"



# Define the name of the driver as known to idinstall 
DRIVER_NAME=tslip


# Locate the Taylor UUCP source directory.  Set taylorsrc and taylorobj vars.
eval `srcdir="$srcdir" sh $srcdir/guess_tuucpsrc`
if test "X$taylorobj" = X ; then taylorobj="$taylorsrc" ; fi
echo
if test "X$taylorsrc" != X ; then
	echo Found Taylor UUCP $taylorver source in $taylorsrc
	if test "$taylorver" != 1.05 ; then
	    egrep -l INIT_NOCLOSE ${taylorsrc}/unix/init.c >/dev/null  2>&1
	    if test $? -ne 0 ; then
		echo 'However, the necessary patch has not been applied.'
		echo 
	        echo '********************************************************'
		(cd $srcdir;
		 echo Please apply the patch in PATCHES_TO_STOCK_TAYLOR*
		)
		echo 'and then re-run configure.'
	        echo '********************************************************'
		echo '(If configure found the wrong version of Taylor UUCP,'
		echo "then edit $srcdir/$tuucp_guesses to list the correct version first)"
		exit 1
	    else
		echo '    ...it appears to have the proper patches.'
	    fi
	fi
	if test "X$taylorsrc" = "X$taylorobj" ; then
	    echo '    ...and has been compiled.'
	else
	    echo "However, object files were found in $taylorobj .  I will"
	    echo "assume that those .o files are the result of compiling $taylorsrc ."
	fi
else
	myparent=`pwd | sed -e 's@\(.*/\).*@\1@'`
	echo 
	echo 'configure could not find the Taylor UUCP source directory.'
	echo '****************************************************************'
	echo 'Taylor uucp-1.05 must be obtained (and compiled) before building tslip.'
	echo '(uucp-1.04 may also be used, with the patch included with tslip)'
	echo 'If the Taylor UUCP source directory is called "uucp-*" and is in'
	echo "the same parent directory as tslip (${myparent}), then configure"
	echo 'will find it automatically.  Otherwise please edit the file'
	echo "$srcdir/$tuucp_guesses to list the correct path."
	echo '****************************************************************'
	exit 1
fi


if egrep -l '^fconn_init.*, 	*ttype' $taylorsrc/conn.c >/dev/null ; then
	# A 3rd "port type" arg was added to fconn_init in uucp-1.05
	{
  test -n "$verbose" && echo "	defining FCONN_INIT_PORTTYPE"
    DEFS="$DEFS -DFCONN_INIT_PORTTYPE=1"

}

fi

# Tell user about the patch to the SAS serial driver, if it appears relevant
srcdir="$srcdir" sh $srcdir/warn_of_sasbug

if test -z "$CC"; then
  # Extract the first word of `gcc', so it can be a program name with args.
  set dummy gcc; word=$2
  echo checking for $word
  IFS="${IFS= 	}"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$word; then
      CC="gcc"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$CC" && CC="cc"
test -n "$CC" && test -n "$verbose" && echo "	setting CC to $CC"

# Find out if we are using GNU C, under whatever name.
cat > conftest.c <<EOF
#ifdef __GNUC__
  yes
#endif
EOF
${CC-cc} -E conftest.c > conftest.out 2>&1
if egrep yes conftest.out >/dev/null 2>&1; then
  GCC=1 # For later tests.
fi
rm -f conftest*

echo checking how to run the C preprocessor
if test -z "$CPP"; then
  # This must be in double quotes, not single quotes, because CPP may get
  # substituted into the Makefile and ``${CC-cc}'' will simply confuse
  # make.  It must be expanded now.
  CPP="${CC-cc} -E"
  cat > conftest.c <<EOF
#include <stdio.h>
Syntax Error
EOF
err=`eval "($CPP \$DEFS conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  :
else
  rm -rf conftest*
  CPP=/lib/cpp
fi
rm -f conftest*
fi
test ".${verbose}" != "." && echo "	setting CPP to $CPP"

# Make sure to not get the incompatible SysV /etc/install and
# /usr/sbin/install, which might be in PATH before a BSD-like install,
# or the SunOS /usr/etc/install directory, or the AIX /bin/install,
# or the AFS install, which mishandles nonexistent args, or
# /usr/ucb/install on SVR4, which tries to use the nonexistent group
# `staff'.  On most BSDish systems install is in /usr/bin, not /usr/ucb
# anyway.  Sigh.
if test "z${INSTALL}" = "z" ; then
  echo checking for install
  IFS="${IFS= 	}"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    case $dir in
    /etc|/usr/sbin|/usr/etc|/usr/afsws/bin|/usr/ucb) ;;
    *)
      if test -f $dir/installbsd; then
	INSTALL="$dir/installbsd -c" # OSF1
	INSTALL_PROGRAM='$(INSTALL)'
	INSTALL_DATA='$(INSTALL) -m 644'
	break
      fi
      if test -f $dir/install; then
	if grep dspmsg $dir/install >/dev/null 2>&1; then
	  : # AIX
	else
	  INSTALL="$dir/install -c"
	  INSTALL_PROGRAM='$(INSTALL)'
	  INSTALL_DATA='$(INSTALL) -m 644'
	  break
	fi
      fi
      ;;
    esac
  done
  IFS="$saveifs"
fi
INSTALL=${INSTALL-cp}
test -n "$verbose" && echo "	setting INSTALL to $INSTALL"
INSTALL_PROGRAM=${INSTALL_PROGRAM-'$(INSTALL)'}
test -n "$verbose" && echo "	setting INSTALL_PROGRAM to $INSTALL_PROGRAM"
INSTALL_DATA=${INSTALL_DATA-'$(INSTALL)'}
test -n "$verbose" && echo "	setting INSTALL_DATA to $INSTALL_DATA"

if test -z "$RANLIB"; then
  # Extract the first word of `ranlib', so it can be a program name with args.
  set dummy ranlib; word=$2
  echo checking for $word
  IFS="${IFS= 	}"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$word; then
      RANLIB="ranlib"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$RANLIB" && RANLIB=":"
test -n "$RANLIB" && test -n "$verbose" && echo "	setting RANLIB to $RANLIB"


CFLAGS=${CFLAGS--O}
LDFLAGS=${LDFLAGS--O}


echo checking for minix/config.h
cat > conftest.c <<EOF
#include <minix/config.h>
EOF
err=`eval "($CPP \$DEFS conftest.c >/dev/null) 2>&1"`
if test -z "$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"
    DEFS="$DEFS -D_POSIX_SOURCE=1"

}

  {
  test -n "$verbose" && echo '	defining _POSIX_1_SOURCE to be 2'
  DEFS="$DEFS -D_POSIX_1_SOURCE=2"
}

  {
  test -n "$verbose" && echo "	defining _MINIX"
    DEFS="$DEFS -D_MINIX=1"

}

fi

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"
    DEFS="$DEFS -D_POSIX_SOURCE=1"

}

  if test -n "$GCC"; then
    CC="$CC -posix"
  else
    CC="$CC -Xp"
  fi
fi

echo checking for AIX
cat > conftest.c <<EOF
#ifdef _AIX
  yes
#endif

EOF
eval "$CPP \$DEFS conftest.c > conftest.out 2>&1"
if egrep "yes" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  {
  test -n "$verbose" && echo "	defining _ALL_SOURCE"
    DEFS="$DEFS -D_ALL_SOURCE=1"

}


fi
rm -f conftest*



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;
}'
echo checking for lack of working const
cat > conftest.c <<EOF

int main() { exit(0); }
int t() { $prog }
EOF
if eval $compile; then
  :
else
  {
  test -n "$verbose" && echo '	defining const to be empty'
  DEFS="$DEFS -Dconst="
}

fi
rm -f conftest*

echo checking for ANSI C header files
cat > conftest.c <<EOF
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <float.h>
EOF
err=`eval "($CPP \$DEFS conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
echo '#include <string.h>' > conftest.c
eval "$CPP \$DEFS conftest.c > 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.c <<EOF
#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 $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  {
  test -n "$verbose" && echo "	defining STDC_HEADERS"
    DEFS="$DEFS -DSTDC_HEADERS=1"

}


fi
rm -fr conftest*

fi
rm -f conftest*


fi
rm -f conftest*

echo checking for return type of signal handlers
cat > conftest.c <<EOF
#include <sys/types.h>
#include <signal.h>
#ifdef signal
#undef signal
#endif
extern void (*signal ()) ();
int main() { exit(0); }
int t() { int i; }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo '	defining RETSIGTYPE to be void'
  DEFS="$DEFS -DRETSIGTYPE=void"
}

else
  {
  test -n "$verbose" && echo '	defining RETSIGTYPE to be int'
  DEFS="$DEFS -DRETSIGTYPE=int"
}

fi
rm -f conftest*



echo checking for unsigned char
cat > conftest.c <<EOF

int main() { exit(0); }
int t() { unsigned char i = (unsigned char) -1; }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo "	defining HAVE_UNSIGNED_CHAR"
    DEFS="$DEFS -DHAVE_UNSIGNED_CHAR=1"

}

fi
rm -f conftest*


echo checking for void
cat > conftest.c <<EOF

int main() { exit(0); }
int t() { extern void foo (); (void) exit (0); }
EOF
if eval $compile; then
  have_void=yes;
	{
  test -n "$verbose" && echo "	defining HAVE_VOID"
    DEFS="$DEFS -DHAVE_VOID=1"

}

fi
rm -f conftest*


test -n "$have_void" && {
echo checking for void \*
cat > conftest.c <<EOF

int main() { exit(0); }
int t() { 
#if ! __STDC__ 
#define volatile
#endif
	volatile void *p; char c; int i; p = &c; p = &i; }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo "	defining HAVE_VOID_POINTER"
    DEFS="$DEFS -DHAVE_VOID_POINTER=1"

}

fi
rm -f conftest*


echo checking for ANSI prototype support
cat > conftest.c <<EOF
static int foo (int,int, ...);
	 static int foo (int a,int b, ...) {}
int main() { exit(0); }
int t() { foo(1,2,"abc",4,5);  }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo "	defining HAVE_ANSI_PROTOS"
    DEFS="$DEFS -DHAVE_ANSI_PROTOS=1"

}

fi
rm -f conftest*


}

echo checking for pid_t in sys/types.h
echo '#include <sys/types.h>' > conftest.c
eval "$CPP \$DEFS conftest.c > conftest.out 2>&1"
if egrep "pid_t" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*
  {
  test -n "$verbose" && echo '	defining pid_t to be int'
  DEFS="$DEFS -Dpid_t=int"
}

fi
rm -f conftest*

echo checking for uid_t in sys/types.h
echo '#include <sys/types.h>' > conftest.c
eval "$CPP \$DEFS conftest.c > 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'
  DEFS="$DEFS -Duid_t=int"
}
 {
  test -n "$verbose" && echo '	defining gid_t to be int'
  DEFS="$DEFS -Dgid_t=int"
}

fi
rm -f conftest*

echo checking for size_t in sys/types.h
echo '#include <sys/types.h>' > conftest.c
eval "$CPP \$DEFS conftest.c > 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'
  DEFS="$DEFS -Dsize_t=unsigned"
}

fi
rm -f conftest*

echo checking for off_t in sys/types.h
echo '#include <sys/types.h>' > conftest.c
eval "$CPP \$DEFS conftest.c > 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'
  DEFS="$DEFS -Doff_t=long"
}

fi
rm -f conftest*

echo checking for mode_t in sys/types.h
echo '#include <sys/types.h>' > conftest.c
eval "$CPP \$DEFS conftest.c > 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'
  DEFS="$DEFS -Dmode_t=int"
}

fi
rm -f conftest*

echo checking for whether time.h and sys/time.h may both be included
cat > conftest.c <<EOF
#include <sys/types.h>
#include <sys/time.h>
#include <time.h>
int main() { exit(0); }
int t() { struct tm *tp; }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo "	defining TIME_WITH_SYS_TIME"
    DEFS="$DEFS -DTIME_WITH_SYS_TIME=1"

}

fi
rm -f conftest*

for hdr in unistd.h string.h memory.h fcntl.h sys/wait.h sys/time.h
do
trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
echo checking for ${hdr}
cat > conftest.c <<EOF
#include <${hdr}>
EOF
err=`eval "($CPP \$DEFS conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  {
  test -n "$verbose" && echo "	defining ${trhdr}"
    DEFS="$DEFS -D${trhdr}=1"

}


fi
rm -f conftest*
done

for hdr in termio.h termios.h
do
trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
echo checking for ${hdr}
cat > conftest.c <<EOF
#include <${hdr}>
EOF
err=`eval "($CPP \$DEFS conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  {
  test -n "$verbose" && echo "	defining ${trhdr}"
    DEFS="$DEFS -D${trhdr}=1"

}


fi
rm -f conftest*
done


# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
# for constant arguments.  Useless!
echo checking for working alloca.h
cat > conftest.c <<EOF
#include <alloca.h>
int main() { exit(0); }
int t() { char *p = alloca(2 * sizeof(int)); }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo "	defining HAVE_ALLOCA_H"
    DEFS="$DEFS -DHAVE_ALLOCA_H=1"

}

fi
rm -f conftest*

decl="#ifdef __GNUC__
#define alloca __builtin_alloca
#else
#if HAVE_ALLOCA_H
#include <alloca.h>
#else
#ifdef _AIX
 #pragma alloca
#else
char *alloca ();
#endif
#endif
#endif
"
echo checking for alloca
cat > conftest.c <<EOF
$decl
int main() { exit(0); }
int t() { char *p = (char *) alloca(1); }
EOF
if eval $compile; then
  :
else
  alloca_missing=1
cat > conftest.c <<EOF

#if defined(CRAY) && ! defined(CRAY2)
winnitude
#else
lossage
#endif

EOF
eval "$CPP \$DEFS conftest.c > conftest.out 2>&1"
if egrep "winnitude" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  echo checking for _getb67
cat > conftest.c <<EOF
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub__getb67) || defined (__stub____getb67)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char _getb67(); _getb67();
#endif
 }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo '	defining CRAY_STACKSEG_END to be _getb67'
  DEFS="$DEFS -DCRAY_STACKSEG_END=_getb67"
}

else
  echo checking for GETB67
cat > conftest.c <<EOF
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_GETB67) || defined (__stub___GETB67)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char GETB67(); GETB67();
#endif
 }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo '	defining CRAY_STACKSEG_END to be GETB67'
  DEFS="$DEFS -DCRAY_STACKSEG_END=GETB67"
}

else
  echo checking for getb67
cat > conftest.c <<EOF
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_getb67) || defined (__stub___getb67)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char getb67(); getb67();
#endif
 }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo '	defining CRAY_STACKSEG_END to be getb67'
  DEFS="$DEFS -DCRAY_STACKSEG_END=getb67"
}

fi
rm -f conftest*

fi
rm -f conftest*

fi
rm -f conftest*


fi
rm -f conftest*


fi
rm -f conftest*

if test -n "$alloca_missing"; then
  # The SVR3 libPW and SVR4 libucb both contain incompatible functions
  # that cause trouble.  Some versions do not even contain alloca or
  # contain a buggy version.  If you still want to use their alloca,
  # use ar to extract alloca.o from them instead of compiling alloca.c.
  ALLOCA=alloca.o
  {
  test -n "$verbose" && echo "	defining C_ALLOCA"
    DEFS="$DEFS -DC_ALLOCA=1"

}


  echo 'checking stack direction for C alloca'
  echo checking whether cross-compiling
# If we cannot run a trivial program, we must be cross compiling.
cat > conftest.c <<EOF
main(){exit(0);}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else
  cross_compiling=1
fi
rm -fr conftest*

if test -n "$cross_compiling"
then
  {
  test -n "$verbose" && echo '	defining STACK_DIRECTION to be 0'
  DEFS="$DEFS -DSTACK_DIRECTION=0"
}

else
cat > conftest.c <<EOF
find_stack_direction ()
{
  static char *addr = 0;
  auto char dummy;
  if (addr == 0)
    {
      addr = &dummy;
      return find_stack_direction ();
    }
  else
    return (&dummy > addr) ? 1 : -1;
}
main ()
{
  exit (find_stack_direction() < 0);
}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  {
  test -n "$verbose" && echo '	defining STACK_DIRECTION to be 1'
  DEFS="$DEFS -DSTACK_DIRECTION=1"
}


else
  {
  test -n "$verbose" && echo '	defining STACK_DIRECTION to be -1'
  DEFS="$DEFS -DSTACK_DIRECTION=-1"
}

fi
fi
rm -fr conftest*
fi

echo checking for vfork.h
cat > conftest.c <<EOF
#include <vfork.h>
EOF
err=`eval "($CPP \$DEFS conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  {
  test -n "$verbose" && echo "	defining HAVE_VFORK_H"
    DEFS="$DEFS -DHAVE_VFORK_H=1"

}


fi
rm -f conftest*

echo checking for working vfork

cat > conftest.c <<EOF
/* Thanks to Paul Eggert for this test.  */
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_VFORK_H
#include <vfork.h>
#endif
static int signalled;
static RETSIGTYPE catch (s) int s; { signalled = 1; }
main() {
  pid_t parent = getpid ();
  pid_t child;

  signal (SIGINT, catch);

  child = vfork ();

  if (child == 0) {
    /* On sparc systems, changes by the child to local and incoming
       argument registers are propagated back to the parent.
       The compiler is told about this with #include <vfork.h>,
       but some compilers (e.g. gcc -O) don't grok <vfork.h>.
       Test for this by using lots of local variables, at least
       as many local variables as main has allocated so far
       including compiler temporaries.  4 locals are enough for
       gcc 1.40.3 on a sparc, but we use 8 to be safe.
       A buggy compiler should reuse the register of parent
       for one of the local variables, since it will think that
       parent can't possibly be used any more in this routine.
       Assigning to the local variable will thus munge parent
       in the parent process.  */
    pid_t
      p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(),
      p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid();
    /* Convince the compiler that p..p7 are live; otherwise, it might
       use the same hardware register for all 8 local variables.  */
    if (p != p1 || p != p2 || p != p3 || p != p4
	|| p != p5 || p != p6 || p != p7)
      _exit(1);

    /* On some systems (e.g. SunOS 5.2), if the parent is catching
       a signal, the child ignores the signal before execing,
       and the parent later receives that signal, the parent dumps core.
       Test for this by ignoring SIGINT in the child.  */
    signal (SIGINT, SIG_IGN);

    /* On some systems (e.g. IRIX 3.3),
       vfork doesn't separate parent from child file descriptors.
       If the child closes a descriptor before it execs or exits,
       this munges the parent's descriptor as well.
       Test for this by closing stdout in the child.  */
    _exit(close(fileno(stdout)) != 0);
  } else {
    int status;
    struct stat st;

    while (wait(&status) != child)
      ;
    exit(
	 /* Was there some problem with vforking?  */
	 child < 0

	 /* Did the child fail?  (This shouldn't happen.)  */
	 || status

	 /* Did the vfork/compiler bug occur?  */
	 || parent != getpid()

	 /* Did the signal handling bug occur?  */
	 || kill(parent, SIGINT) != 0
	 || signalled != 1

	 /* Did the file descriptor bug occur?  */
	 || fstat(fileno(stdout), &st) != 0
	 );
  }
}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else
  {
  test -n "$verbose" && echo '	defining vfork to be fork'
  DEFS="$DEFS -Dvfork=fork"
}

fi
rm -fr conftest*

cat > conftest.c <<EOF
#include <stdio.h>
/* If setvbuf has the reversed format, exit 0. */
main () {
  /* This call has the arguments reversed.
     A reversed system may check and see that the address of main
     is not _IOLBF, _IONBF, or _IOFBF, and return nonzero.  */
  if (setvbuf(stdout, _IOLBF, (char *) main, BUFSIZ) != 0)
    exit(1);
  putc('\r', stdout);
  exit(0);			/* Non-reversed systems segv here.  */
}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  {
  test -n "$verbose" && echo "	defining SETVBUF_REVERSED"
    DEFS="$DEFS -DSETVBUF_REVERSED=1"

}


fi
rm -fr conftest*
rm -f core

echo checking for broken stat file mode macros
cat > conftest.c <<EOF
#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 "$CPP \$DEFS conftest.c > 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"
    DEFS="$DEFS -DSTAT_MACROS_BROKEN=1"

}


fi
rm -f conftest*
	
for func in lockf
do
trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
echo checking for ${func}
cat > conftest.c <<EOF
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo "	defining ${trfunc}"
    DEFS="$DEFS -D${trfunc}=1"

}

fi
rm -f conftest*
done


trfrom='[a-z]' trto='[A-Z]'
for i in socket t_open; do
  def=HAVE_`echo $i|tr "$trfrom" "$trto"`
  echo checking for $i
cat > conftest.c <<EOF
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_$i) || defined (__stub___$i)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char $i(); $i();
#endif
 }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo "	defining $def"
    DEFS="$DEFS -D$def=1"

}

else
  missing=1
fi
rm -f conftest*
  for lib in "-lsocket" "-lsocket -lnsl" "-lnsl" "-lxti"; do
    if test -n "$missing"; then
      case $LIBS in
      *${lib}*) ;;
      *)
	SAVELIBS="$LIBS"
	LIBS="$LIBS $lib"
	missing=
	echo checking for $i with $lib
cat > conftest.c <<EOF

int main() { exit(0); }
int t() { extern char $i(); $i(); }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo "	defining $def"
    DEFS="$DEFS -D$def=1"

}

else
  missing=1; LIBS="$SAVELIBS"
fi
rm -f conftest*
	;;
      esac
    fi
  done
done

LIBS_save="${LIBS}"
LIBS="${LIBS} -lresolv"
have_lib=""
echo checking for -lresolv
cat > conftest.c <<EOF

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  have_lib="1"
fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   {
  test -n "$verbose" && echo "	defining HAVE_LIBRESOLV"
    DEFS="$DEFS -DHAVE_LIBRESOLV=1"

}

   LIBS="${LIBS} -lresolv"
fi


echo checking for DNS resolver support
cat > conftest.c <<EOF

#include <sys/types.h>
#include <netinet/in.h>
#undef NOERROR	/* clash between sys/stream.h and arpa/nameser.h */
#include <arpa/nameser.h>
#include <resolv.h>

int main() { exit(0); }
int t() {  _res.options |= RES_USEVC;  }
EOF
if eval $compile; then
  {
  test -n "$verbose" && echo "	defining HAVE_RESOLVER"
    DEFS="$DEFS -DHAVE_RESOLVER=1"

}

fi
rm -f conftest*


if test -n "$prefix"; then
  test -z "$exec_prefix" && exec_prefix='${prefix}'
  prsub="s%^prefix\\([ 	]*\\)=\\([ 	]*\\).*$%prefix\\1=\\2$prefix%"
fi
if test -n "$exec_prefix"; then
  prsub="$prsub
s%^exec_prefix\\([ 	]*\\)=\\([ 	]*\\).*$%exec_prefix\\1=\\2$exec_prefix%"
fi


SAVE_DEFS="${DEFS}"
DEFS="-DHAVE_CONFIG_H"
trap 'rm -f config.status; exit 1' 1 3 15
echo creating config.status
rm -f config.status
cat > config.status <<EOF
#!/bin/sh
# Generated automatically by configure.
# Run this file to recreate the current configuration.
# This directory was configured as follows,
# on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
#
# $0 $configure_args

for arg
do
  case "\$arg" in
    -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    echo running \${CONFIG_SHELL-/bin/sh} $0 $configure_args
    exec \${CONFIG_SHELL-/bin/sh} $0 $configure_args ;;
    *) echo "Usage: config.status --recheck" 2>&1; exit 1 ;;
  esac
done

trap 'rm -fr Makefile utils/Makefile dialin/Makefile dialin/Makefile.real driver/io/Makefile driver/ID/mk_idfiles.sh man/Makefile tslip_config.h conftest*; exit 1' 1 3 15
prefix='$prefix'
exec_prefix='$exec_prefix'
prsub='$prsub'
EOF
sedprog='
:T
/_ACUTAG_$/!{
	N
	s/^[ 	]*\n//
	b T
}
s/_ACUTAG_$//
/^DEFS=/{
	:M
s/\\\(\\*#\)/<BACKSLASH>\1/g
t M
s/<BACKSLASH>/\\\\/g
s/#/\\#/g
s/\$/$$/g

}
s/\([\&%\\]\)/\\\1/g
s/\(\n\)/\\\1/g
'"
s/'/'\\\\''/g
/[^-a-zA-Z0-9_@+=.:]/{
	s/=/='/
	s/\$/'/
}
"

{


sed -e "$sedprog" <<_ACEOF_
DRIVER_NAME=${DRIVER_NAME}_ACUTAG_

taylorsrc=${taylorsrc}_ACUTAG_

taylorobj=${taylorobj}_ACUTAG_

CC=${CC}_ACUTAG_

CPP=${CPP}_ACUTAG_

INSTALL=${INSTALL}_ACUTAG_

INSTALL_PROGRAM=${INSTALL_PROGRAM}_ACUTAG_

INSTALL_DATA=${INSTALL_DATA}_ACUTAG_

RANLIB=${RANLIB}_ACUTAG_

_ACEOF_

sed -e "$sedprog" <<_ACEOF_
CFLAGS=${CFLAGS}_ACUTAG_

LDFLAGS=${LDFLAGS}_ACUTAG_

ALLOCA=${ALLOCA}_ACUTAG_

LIBS=${LIBS}_ACUTAG_

srcdir=${srcdir}_ACUTAG_

DEFS=${DEFS}_ACUTAG_
_ACEOF_
} >>config.status

cat >> config.status <<\EOF

top_srcdir=$srcdir

CONFIG_FILES=${CONFIG_FILES-"Makefile utils/Makefile dialin/Makefile dialin/Makefile.real driver/io/Makefile driver/ID/mk_idfiles.sh man/Makefile"}
for file in .. ${CONFIG_FILES}; do if test "x$file" != x..; then
  srcdir=$top_srcdir
  # Create directories if necessary.  Leave srcdir set to the directory part.
  match='/*[^/][^/]*'
  while : ; do
    dir=`echo $file|sed -n -e 's%^\('"${match}"'\).*%\1%p'`
    test "$dir" = $file && break
    test "$top_srcdir" != . && srcdir=$top_srcdir/$dir
    test ! -d $dir && mkdir $dir
    match="$match/[^/][^/]*"
  done
  echo creating $file
  rm -f $file conftest.err conftest.in
  # Put "Generated automatically..." comment AFTER the first line if 
  # the file appears to be a shell script, i.e., it begins with #!/bin/sh,
  # :, or @ (an expansion which may produce the correct first line).
  t="# Generated automatically from `echo $file|sed 's|.*/||'`.in by configure."
  sed <$top_srcdir/${file}.in -e "
1{
	/^[@:]/b F
	/^#!/{
		:F
		s/\$/\\
${t}/
		b T
	}
	s/^/${t}\\
/
:T
}
$prsub
$extrasub

" > conftest.out
mv conftest.out conftest.in
sed <conftest.in -e "/@/!b
s%@DRIVER_NAME@%$DRIVER_NAME%g
s%@taylorsrc@%$taylorsrc%g
s%@taylorobj@%$taylorobj%g
s%@CC@%$CC%g
s%@CPP@%$CPP%g
s%@INSTALL@%$INSTALL%g
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
s%@INSTALL_DATA@%$INSTALL_DATA%g
s%@RANLIB@%$RANLIB%g
s%@CFLAGS@%$CFLAGS%g
s%@LDFLAGS@%$LDFLAGS%g
s%@ALLOCA@%$ALLOCA%g
s%@LIBS@%$LIBS%g
s%@srcdir@%$srcdir%g
s%@DEFS@%$DEFS%g
/@[A-Za-z_][A-Za-z0-9_]*@/w conftest.err
" > $file
if test -s conftest.err ; then
	echo "WARNING: Undefined substitutions in $file:"
	sed 's/[^@]*\(@[A-Za-z_][A-Za-z0-9_]*@\)[^@]*/\1/g
	     s/@@/@\
	@/g
	     s/^/	/' conftest.err | sort | uniq
fi
rm -f conftest.in conftest.err
fi; done
EOF
cat >> config.status <<\EOF

CONFIG_HEADERS=${CONFIG_HEADERS-"tslip_config.h"}
for file in .. ${CONFIG_HEADERS}; do if test "x$file" != x..; then
echo creating $file
rm -f conftest.h
sed <$top_srcdir/$file.in -e "

1i\\
/* $file.  Generated automatically by configure.  */
"'
EOF

# Generate a sequence of sed -e '...' invocations in config.status which
# generate header files.  To avoid exceeding sed's limits, each sed
# has at most 20 edit commands.
# SAVE_DEFS contains -DNAME=value arguments, protected against
# reading by the shell.  The eval "set -- $SAVE_DEFS" evaluates away
# the protection.
sedprog='
s/\([\&@\\]\)/\\\1/g
s/\(\n\)/\\\1/g

'"s/'/'\\\\''/g"'
s/-D\([^=]*\)=\(.*\)/s@^\\([ 	]*#[ 	]*define[ 	][ 	]*\1[ 	][ 	]*\\)[^\/]*@\\1\2 @g\
s@^\\([ 	]*#[ 	]*\\)undef\\([ 	][ 	]*\1\\)\\([ 	]\\)@\\1define\\2 \2\\3@g\
s@^\\([ 	]*#[ 	]*\\)undef\\([ 	][ 	]*\1\\)$@\\1define\\2 \2@g/
'
sedlimit_dots=....................	# 20 of them
eval "set -- $SAVE_DEFS"
(
dashDlines=
dots=.
for arg do 
    dots="${dots}..."	# we generate 3 sed cmds each time
    case $dots in  #(
    ${sedlimit_dots}*)
        	echo "$dashDlines" | sed -e "$sedprog"
	echo "' > conftest.h2; rm -f conftest.h1; mv conftest.h2 conftest.h1"
	echo "sed <conftest.h1 -e '"
	dots=
	dashDlines=
	;;
    esac
    dashDlines="$dashDlines
$arg"
done
test -n "$dashDlines" && {
    echo "$dashDlines" | sed -e "$sedprog"
}
case "${dots}." in  #(
    ${sedlimit_dots}*)
	echo "' > conftest.h2; rm -f conftest.h1; mv conftest.h2 conftest.h1"
	echo "sed <conftest.h1 -e '"
	;;
esac
# 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
# tslip_config.h.
echo 's,^[ 	]*#[ 	]*undef[ 	][ 	]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,'
) >> config.status

cat >> config.status <<\EOF
' > conftest.h
rm -f conftest.h1

if cmp -s $file conftest.h 2>/dev/null; then
  # The file exists and we would not be changing it.
  rm -f conftest.h
else
  rm -f $file
  mv conftest.h $file
fi

fi; done

EOF

cat >> config.status <<\EOF

exit 0
EOF
trap 0
chmod +x config.status
${CONFIG_SHELL-/bin/sh} config.status
exit $?

