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

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

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

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

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

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

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

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

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

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

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

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

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

     *) ;;
    esac
  fi
done

trap 'rm -fr conftest* confdefs* core; exit 1' 1 3 15
trap 'rm -f confdefs*' 0

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

rm -f conftest* confdefs.h
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
echo > confdefs.h
compile='${CC-cc} $CFLAGS conftest.c -o conftest $LIBS >/dev/null 2>&1'

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

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


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

{
test -n "$verbose" && \
echo "	defining" OCTAVE_SOURCE to be 1
echo "#define" OCTAVE_SOURCE 1 >> confdefs.h
DEFS="$DEFS -DOCTAVE_SOURCE=1"
SEDDEFS="${SEDDEFS}\${SEDdA}OCTAVE_SOURCE\${SEDdB}OCTAVE_SOURCE\${SEDdC}1\${SEDdD}
\${SEDuA}OCTAVE_SOURCE\${SEDuB}OCTAVE_SOURCE\${SEDuC}1\${SEDuD}
\${SEDeA}OCTAVE_SOURCE\${SEDeB}OCTAVE_SOURCE\${SEDeC}1\${SEDeD}
"
}
if test $# -gt 0; then
  TARGET=`eval echo $\{\`echo $#\`\}`
  case $TARGET in
    -*) target_host_type= ;;
    *) target_host_type=$TARGET ;;
  esac
fi
if test -z "$target_host_type" -o "$target_host_type" = unknown; then
  target_host_type=`sh $srcdir/config.guess`
  if test -z "$target_host_type"; then
    echo "warning: unable to guess system type"
    target_host_type=unknown
  fi
fi
canonical_host_type=`sh $srcdir/config.sub $target_host_type 2>&1`
status=$?
if test $status -eq 0; then
  echo "configuring Octave for a $target_host_type"
else
  canonical_host_type=unknown
  echo "configuring Octave for an unknown system type"
fi
# check whether --with-f2c was given
withval="$with_f2c"
if test -n "$withval"; then
  use_f2c=true
else
  use_f2c=false
fi
# check whether --with-dld was given
withval="$with_dld"
if test -n "$withval"; then
  use_dld=true
else
  use_dld=false
fi
DYNAMIC_LD_OBJ=
DLD_DIR=
LIBDLD=
DLD_OBJECTS='$(DLD_OBJECTS)'
LD_STATIC_FLAG=
if $use_dld; then
  DYNAMIC_LD_OBJ='dynamic-ld.o'
  DLD_DIR=dld
  LIBDLD='../libdld.a'
  DLD_OBJECTS= : # don't link them in if doing dynamic linking
  
{
test -n "$verbose" && \
echo "	defining" WITH_DLD to be 1
echo "#define" WITH_DLD 1 >> confdefs.h
DEFS="$DEFS -DWITH_DLD=1"
SEDDEFS="${SEDDEFS}\${SEDdA}WITH_DLD\${SEDdB}WITH_DLD\${SEDdC}1\${SEDdD}
\${SEDuA}WITH_DLD\${SEDuB}WITH_DLD\${SEDuC}1\${SEDuD}
\${SEDeA}WITH_DLD\${SEDeB}WITH_DLD\${SEDeC}1\${SEDeD}
"
}
  LD_STATIC_FLAG=-static
fi
echo "checking for npsol"
if test -f $srcdir/libcruft/npsol/npsol.f; then
  :
else
  
{
test -n "$verbose" && \
echo "	defining" NPSOL_MISSING to be 1
echo "#define" NPSOL_MISSING 1 >> confdefs.h
DEFS="$DEFS -DNPSOL_MISSING=1"
SEDDEFS="${SEDDEFS}\${SEDdA}NPSOL_MISSING\${SEDdB}NPSOL_MISSING\${SEDdC}1\${SEDdD}
\${SEDuA}NPSOL_MISSING\${SEDuB}NPSOL_MISSING\${SEDuC}1\${SEDuD}
\${SEDeA}NPSOL_MISSING\${SEDeB}NPSOL_MISSING\${SEDeC}1\${SEDeD}
"
}
fi
echo "checking for qpsol"
if test -f $srcdir/libcruft/qpsol/qpsol.f; then
  :
else
  
{
test -n "$verbose" && \
echo "	defining" QPSOL_MISSING to be 1
echo "#define" QPSOL_MISSING 1 >> confdefs.h
DEFS="$DEFS -DQPSOL_MISSING=1"
SEDDEFS="${SEDDEFS}\${SEDdA}QPSOL_MISSING\${SEDdB}QPSOL_MISSING\${SEDdC}1\${SEDdD}
\${SEDuA}QPSOL_MISSING\${SEDuB}QPSOL_MISSING\${SEDuC}1\${SEDuD}
\${SEDeA}QPSOL_MISSING\${SEDeB}QPSOL_MISSING\${SEDeC}1\${SEDeD}
"
}
fi
echo "checking for fsqp"
if test -f $srcdir/libcruft/fsqp/fsqpd.f; then
  :
else
  
{
test -n "$verbose" && \
echo "	defining" FSQP_MISSING to be 1
echo "#define" FSQP_MISSING 1 >> confdefs.h
DEFS="$DEFS -DFSQP_MISSING=1"
SEDDEFS="${SEDDEFS}\${SEDdA}FSQP_MISSING\${SEDdB}FSQP_MISSING\${SEDdC}1\${SEDdD}
\${SEDuA}FSQP_MISSING\${SEDuB}FSQP_MISSING\${SEDuC}1\${SEDuD}
\${SEDeA}FSQP_MISSING\${SEDeB}FSQP_MISSING\${SEDeC}1\${SEDeD}
"
}
fi
if test -z "$CC"; then
  # Extract the first word of `gcc', so it can be a program name with args.
  set dummy gcc; word=$2
  echo checking for $word
  IFS="${IFS= 	}"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$word; then
      CC="gcc"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$CC" && CC="cc"
test -n "$CC" && test -n "$verbose" && echo "	setting CC to $CC"

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

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

if test -n "$GCC"; then
  echo checking whether -traditional is needed
  pattern="Autoconf.*'x'"
  prog='#include <sgtty.h>
Autoconf TIOCGETP'
  cat > conftest.c <<EOF
#include "confdefs.h"
$prog
EOF
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "$pattern" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  need_trad=1

fi
rm -f conftest*


  if test -z "$need_trad"; then
    prog='#include <termio.h>
Autoconf TCGETA'
    cat > conftest.c <<EOF
#include "confdefs.h"
$prog
EOF
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "$pattern" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  need_trad=1

fi
rm -f conftest*

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

echo checking for minix/config.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <minix/config.h>
EOF
err=`eval "($CPP 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"
echo "#define" _POSIX_SOURCE 1 >> confdefs.h
DEFS="$DEFS -D_POSIX_SOURCE=1"
SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_SOURCE\${SEDdB}_POSIX_SOURCE\${SEDdC}1\${SEDdD}
\${SEDuA}_POSIX_SOURCE\${SEDuB}_POSIX_SOURCE\${SEDuC}1\${SEDuD}
\${SEDeA}_POSIX_SOURCE\${SEDeB}_POSIX_SOURCE\${SEDeC}1\${SEDeD}
"
}

  
{
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"
SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_1_SOURCE\${SEDdB}_POSIX_1_SOURCE\${SEDdC}2\${SEDdD}
\${SEDuA}_POSIX_1_SOURCE\${SEDuB}_POSIX_1_SOURCE\${SEDuC}2\${SEDuD}
\${SEDeA}_POSIX_1_SOURCE\${SEDeB}_POSIX_1_SOURCE\${SEDeC}2\${SEDeD}
"
}

  
{
test -n "$verbose" && \
echo "	defining _MINIX"
echo "#define" _MINIX 1 >> confdefs.h
DEFS="$DEFS -D_MINIX=1"
SEDDEFS="${SEDDEFS}\${SEDdA}_MINIX\${SEDdB}_MINIX\${SEDdC}1\${SEDdD}
\${SEDuA}_MINIX\${SEDuB}_MINIX\${SEDuC}1\${SEDuD}
\${SEDeA}_MINIX\${SEDeB}_MINIX\${SEDeC}1\${SEDeD}
"
}

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"
echo "#define" _POSIX_SOURCE 1 >> confdefs.h
DEFS="$DEFS -D_POSIX_SOURCE=1"
SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_SOURCE\${SEDdB}_POSIX_SOURCE\${SEDdC}1\${SEDdD}
\${SEDuA}_POSIX_SOURCE\${SEDuB}_POSIX_SOURCE\${SEDuC}1\${SEDuD}
\${SEDeA}_POSIX_SOURCE\${SEDeB}_POSIX_SOURCE\${SEDeC}1\${SEDeD}
"
}

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

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

EOF
eval "$CPP 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"
echo "#define" _ALL_SOURCE 1 >> confdefs.h
DEFS="$DEFS -D_ALL_SOURCE=1"
SEDDEFS="${SEDDEFS}\${SEDdA}_ALL_SOURCE\${SEDdB}_ALL_SOURCE\${SEDdC}1\${SEDdD}
\${SEDuA}_ALL_SOURCE\${SEDuB}_ALL_SOURCE\${SEDuC}1\${SEDuD}
\${SEDeA}_ALL_SOURCE\${SEDeB}_ALL_SOURCE\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*


LIBS_save="${LIBS}"
LIBS="${LIBS} -lseq"
have_lib=""
echo checking for -lseq
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; LIBS="$LIBS -lseq"
else
   :; 
fi


# 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 "confdefs.h"
#include <alloca.h>
int main() { exit(0); }
int t() { char *p = alloca(2 * sizeof(int)); }
EOF
if eval $compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining HAVE_ALLOCA_H"
echo "#define" HAVE_ALLOCA_H 1 >> confdefs.h
DEFS="$DEFS -DHAVE_ALLOCA_H=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_ALLOCA_H\${SEDdB}HAVE_ALLOCA_H\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_ALLOCA_H\${SEDuB}HAVE_ALLOCA_H\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_ALLOCA_H\${SEDeB}HAVE_ALLOCA_H\${SEDeC}1\${SEDeD}
"
}


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
#include "confdefs.h"
$decl
int main() { exit(0); }
int t() { char *p = (char *) alloca(1); }
EOF
if eval $compile; then
  :
else
  rm -rf conftest*
  alloca_missing=1
cat > conftest.c <<EOF
#include "confdefs.h"

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

EOF
eval "$CPP 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 "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub__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
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "	defining" CRAY_STACKSEG_END to be _getb67
echo "#define" CRAY_STACKSEG_END _getb67 >> confdefs.h
DEFS="$DEFS -DCRAY_STACKSEG_END=_getb67"
SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}_getb67\${SEDdD}
\${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}_getb67\${SEDuD}
\${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}_getb67\${SEDeD}
"
}


else
  rm -rf conftest*
  echo checking for GETB67
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_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
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "	defining" CRAY_STACKSEG_END to be GETB67
echo "#define" CRAY_STACKSEG_END GETB67 >> confdefs.h
DEFS="$DEFS -DCRAY_STACKSEG_END=GETB67"
SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}GETB67\${SEDdD}
\${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}GETB67\${SEDuD}
\${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}GETB67\${SEDeD}
"
}


else
  rm -rf conftest*
  echo checking for getb67
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_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
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "	defining" CRAY_STACKSEG_END to be getb67
echo "#define" CRAY_STACKSEG_END getb67 >> confdefs.h
DEFS="$DEFS -DCRAY_STACKSEG_END=getb67"
SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}getb67\${SEDdD}
\${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}getb67\${SEDuD}
\${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}getb67\${SEDeD}
"
}


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"
echo "#define" C_ALLOCA 1 >> confdefs.h
DEFS="$DEFS -DC_ALLOCA=1"
SEDDEFS="${SEDDEFS}\${SEDdA}C_ALLOCA\${SEDdB}C_ALLOCA\${SEDdC}1\${SEDdD}
\${SEDuA}C_ALLOCA\${SEDuB}C_ALLOCA\${SEDuC}1\${SEDuD}
\${SEDeA}C_ALLOCA\${SEDeB}C_ALLOCA\${SEDeC}1\${SEDeD}
"
}


  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
#include "confdefs.h"
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
echo "#define" STACK_DIRECTION 0 >> confdefs.h
DEFS="$DEFS -DSTACK_DIRECTION=0"
SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}0\${SEDdD}
\${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}0\${SEDuD}
\${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}0\${SEDeD}
"
}

else
cat > conftest.c <<EOF
#include "confdefs.h"
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
echo "#define" STACK_DIRECTION 1 >> confdefs.h
DEFS="$DEFS -DSTACK_DIRECTION=1"
SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}1\${SEDdD}
\${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}1\${SEDuD}
\${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}1\${SEDeD}
"
}


else
  
{
test -n "$verbose" && \
echo "	defining" STACK_DIRECTION to be -1
echo "#define" STACK_DIRECTION -1 >> confdefs.h
DEFS="$DEFS -DSTACK_DIRECTION=-1"
SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}-1\${SEDdD}
\${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}-1\${SEDuD}
\${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}-1\${SEDeD}
"
}

fi
fi
rm -fr conftest*
fi

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
#include "confdefs.h"

int main() { exit(0); }
int t() { $prog }
EOF
if eval $compile; then
  :
else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" const to be empty
echo "#define" const  >> confdefs.h
DEFS="$DEFS -Dconst="
SEDDEFS="${SEDDEFS}\${SEDdA}const\${SEDdB}const\${SEDdC}\${SEDdD}
\${SEDuA}const\${SEDuB}const\${SEDuC}\${SEDuD}
\${SEDeA}const\${SEDeB}const\${SEDeC}\${SEDeD}
"
}

fi
rm -f conftest*

case "$CC" in
  gcc* | */gcc*)
    CFLAGS="-g -O -Wall"
    LDFLAGS="-g -O"
    gcc_version=`gcc -v 2>&1 | grep "^gcc version" | sed 's/^gcc version *//'`
    case "$gcc_version" in
      1.*)
        cat << EOF
warning: gcc version $gcc_version is likely to cause problems --
         you should probably consider getting version 2.x
EOF
        ;;
    esac
    ;;
  *)
    cat << EOF
warning: found environment variable CC = \`$CC'.  If this is not a
         derivative of GCC, you should probably consider using GCC
         version 2.x instead.
EOF
    CFLAGS="-g"
    LDFLAGS="-g"
    ;;
esac
if test -z "$CXX"; then
  # Extract the first word of `g++', so it can be a program name with args.
  set dummy g++; word=$2
  echo checking for $word
  IFS="${IFS= 	}"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$word; then
      CXX="g++"
      break
    fi
  done
  IFS="$saveifs"
fi

test -n "$CXX" && test -n "$verbose" && echo "	setting CXX to $CXX"
if test "$CXX" = g++ ; then
  CXXFLAGS="-g -O -Wall"
  gxx_version=`g++ -v 2>&1 | grep "^g.. version" | sed 's/^g.. version *//'`
  case "$gxx_version" in
    1.*)
      cat << EOF
warning: g++ version $gxx_version is likely to cause problems --
         you should probably consider getting version 2.x
EOF
      ;;
    2.5.*|2.6.*|2.7.*|2.8.*|2.9.*)
      EXTERNAL_TEMPLATES="-fexternal-templates"
      
{
test -n "$verbose" && \
echo "	defining" USE_EXTERNAL_TEMPLATES to be 1
echo "#define" USE_EXTERNAL_TEMPLATES 1 >> confdefs.h
DEFS="$DEFS -DUSE_EXTERNAL_TEMPLATES=1"
SEDDEFS="${SEDDEFS}\${SEDdA}USE_EXTERNAL_TEMPLATES\${SEDdB}USE_EXTERNAL_TEMPLATES\${SEDdC}1\${SEDdD}
\${SEDuA}USE_EXTERNAL_TEMPLATES\${SEDuB}USE_EXTERNAL_TEMPLATES\${SEDuC}1\${SEDuD}
\${SEDeA}USE_EXTERNAL_TEMPLATES\${SEDeB}USE_EXTERNAL_TEMPLATES\${SEDeC}1\${SEDeD}
"
}
      ;;
    esac
else
  cat << EOF
warning: Octave has only been tested with g++, and I can't
         seem to find it.
EOF
fi
case "$canonical_host_type" in
  i386-*-linux | i486-*-linux | i586-*-linux)
    GCC_IEEE_FP_FLAG="-mieee-fp"
  ;;
esac
if $use_f2c; then
  true
else
  F77=
  for p in xlf cf77 f77 fc g77
do
if test -z "$F77"; then
  # Extract the first word of `$p', so it can be a program name with args.
  set dummy $p; word=$2
  echo checking for $word
  IFS="${IFS= 	}"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$word; then
      F77="$p"
      break
    fi
  done
  IFS="$saveifs"
fi

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

test -n "$F77" && break
done

  # If it looks like we have a Fortran compiler, try to determine
  # whether it might be compatible with f2c.

  if test -n "$F77"; then
    echo "checking $F77/f2c compatibility"
    export F77
    export CC
    tmpdef=`sh $srcdir/f2c-compat.sh $srcdir/flibs.sh`
    status=$?
    if test $status -eq 0; then
      if test "$tmpdef" = '-DF77_APPEND_UNDERSCORE=1'; then
        
{
test -n "$verbose" && \
echo "	defining" F77_APPEND_UNDERSCORE to be 1
echo "#define" F77_APPEND_UNDERSCORE 1 >> confdefs.h
DEFS="$DEFS -DF77_APPEND_UNDERSCORE=1"
SEDDEFS="${SEDDEFS}\${SEDdA}F77_APPEND_UNDERSCORE\${SEDdB}F77_APPEND_UNDERSCORE\${SEDdC}1\${SEDdD}
\${SEDuA}F77_APPEND_UNDERSCORE\${SEDuB}F77_APPEND_UNDERSCORE\${SEDuC}1\${SEDuD}
\${SEDeA}F77_APPEND_UNDERSCORE\${SEDeB}F77_APPEND_UNDERSCORE\${SEDeC}1\${SEDeD}
"
}
      fi
    else
      F77=
    fi
  fi
fi
if test -z "$F77"; then
  if test -z "$F2C"; then
  # Extract the first word of `f2c', so it can be a program name with args.
  set dummy f2c; 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
      F2C="f2c"
      break
    fi
  done
  IFS="$saveifs"
fi

test -n "$F2C" && test -n "$verbose" && echo "	setting F2C to $F2C"
fi
F2CFLAGS=
FFLAGS="-O"
if test -n "$F77"; then
  export F77
  FLIBS=`sh $srcdir/flibs.sh`
  DOT_O_DOT_F_C1=
  DOT_O_DOT_F_C2=
  DOT_O_DOT_F_C3=
  DOT_O_DOT_F_C4=
  DEFAULT_DOT_C_FROM_DOT_F=
  DEFAULT_DOT_O_FROM_DOT_F=
elif test -n "$F2C" || $use_f2c; then
  LIBS_save="${LIBS}"
LIBS="${LIBS} -lf2c"
have_lib=""
echo checking for -lf2c
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; FLIBS=-lf2c
else
   :; 
fi
  if test -z "$FLIBS" ; then
    LIBS_save="${LIBS}"
LIBS="${LIBS} -lF77"
have_lib=""
echo checking for -lF77
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; FLIBS=-lF77
else
   :; 
fi
    if test -n "$FLIBS" ; then
      LIBS_save="${LIBS}"
LIBS="${LIBS} -lI77"
have_lib=""
echo checking for -lI77
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; FLIBS="$FLIBS -lI77"
else
   :; 
fi
    fi
  fi
  if test -z "$FLIBS" ; then
    cat << EOF
warning: I found f2c but I couldn't find libf2c.a, or
         libF77.a and libI77.a
EOF
  fi
DEFAULT_DOT_C_FROM_DOT_F='# A rule for making C source from Fortran source.\
# If we are using f2c we should also turn off the default rule for\
# making objects from .f files so that we do not invoke the fortran\
# compiler by mistake.\
\
\%.c : \%.f\
	cat $< | $(F2C) $(F2CFLAGS) > $(@F)'
  DEFAULT_DOT_O_FROM_DOT_F='\%.o : \%.f'
  
{
test -n "$verbose" && \
echo "	defining" F77_APPEND_UNDERSCORE to be 1
echo "#define" F77_APPEND_UNDERSCORE 1 >> confdefs.h
DEFS="$DEFS -DF77_APPEND_UNDERSCORE=1"
SEDDEFS="${SEDDEFS}\${SEDdA}F77_APPEND_UNDERSCORE\${SEDdB}F77_APPEND_UNDERSCORE\${SEDdC}1\${SEDdD}
\${SEDuA}F77_APPEND_UNDERSCORE\${SEDuB}F77_APPEND_UNDERSCORE\${SEDuC}1\${SEDuD}
\${SEDeA}F77_APPEND_UNDERSCORE\${SEDeB}F77_APPEND_UNDERSCORE\${SEDeC}1\${SEDeD}
"
}
else
  cat << EOF
warning: in order to build octave, you must have a compatible
         Fortran compiler or f2c installed and in your path.
         See the file INSTALL for more information.
         Continuing anyway...
EOF
fi
# 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"

echo checking for ANSI C header files
cat > conftest.c <<EOF
#include "confdefs.h"
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <float.h>
EOF
err=`eval "($CPP 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 "confdefs.h"
#include <string.h>' > conftest.c
eval "$CPP 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 "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 $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  
{
test -n "$verbose" && \
echo "	defining STDC_HEADERS"
echo "#define" STDC_HEADERS 1 >> confdefs.h
DEFS="$DEFS -DSTDC_HEADERS=1"
SEDDEFS="${SEDDEFS}\${SEDdA}STDC_HEADERS\${SEDdB}STDC_HEADERS\${SEDdC}1\${SEDdD}
\${SEDuA}STDC_HEADERS\${SEDuB}STDC_HEADERS\${SEDuC}1\${SEDuD}
\${SEDeA}STDC_HEADERS\${SEDeB}STDC_HEADERS\${SEDeC}1\${SEDeD}
"
}


fi
rm -fr conftest*

fi
rm -f conftest*


fi
rm -f conftest*

for hdr in string.h varargs.h unistd.h sys/utsname.h
do
trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
echo checking for ${hdr}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <${hdr}>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining ${trhdr}"
echo "#define" ${trhdr} 1 >> confdefs.h
DEFS="$DEFS -D${trhdr}=1"
SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD}
\${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD}
\${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*
done
for hdr in sys/time.h sys/fcntl.h sys/ttold.h sys/ptem.h sys/select.h
do
trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
echo checking for ${hdr}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <${hdr}>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining ${trhdr}"
echo "#define" ${trhdr} 1 >> confdefs.h
DEFS="$DEFS -D${trhdr}=1"
SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD}
\${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD}
\${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*
done
echo checking for directory library header
dirheader=
if test -z "$dirheader"; then
  echo checking for dirent.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <dirent.h>
int main() { exit(0); }
int t() { DIR *dirp = 0; }
EOF
if eval $compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining DIRENT"
echo "#define" DIRENT 1 >> confdefs.h
DEFS="$DEFS -DDIRENT=1"
SEDDEFS="${SEDDEFS}\${SEDdA}DIRENT\${SEDdB}DIRENT\${SEDdC}1\${SEDdD}
\${SEDuA}DIRENT\${SEDuB}DIRENT\${SEDuC}1\${SEDuD}
\${SEDeA}DIRENT\${SEDeB}DIRENT\${SEDeC}1\${SEDeD}
"
}
 dirheader=dirent.h

fi
rm -f conftest*
fi
if test -z "$dirheader"; then
  echo checking for sys/ndir.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/ndir.h>
int main() { exit(0); }
int t() { DIR *dirp = 0; }
EOF
if eval $compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining SYSNDIR"
echo "#define" SYSNDIR 1 >> confdefs.h
DEFS="$DEFS -DSYSNDIR=1"
SEDDEFS="${SEDDEFS}\${SEDdA}SYSNDIR\${SEDdB}SYSNDIR\${SEDdC}1\${SEDdD}
\${SEDuA}SYSNDIR\${SEDuB}SYSNDIR\${SEDuC}1\${SEDuD}
\${SEDeA}SYSNDIR\${SEDeB}SYSNDIR\${SEDeC}1\${SEDeD}
"
}
 dirheader=sys/ndir.h

fi
rm -f conftest*
fi
if test -z "$dirheader"; then
  echo checking for sys/dir.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/dir.h>
int main() { exit(0); }
int t() { DIR *dirp = 0; }
EOF
if eval $compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining SYSDIR"
echo "#define" SYSDIR 1 >> confdefs.h
DEFS="$DEFS -DSYSDIR=1"
SEDDEFS="${SEDDEFS}\${SEDdA}SYSDIR\${SEDdB}SYSDIR\${SEDdC}1\${SEDdD}
\${SEDuA}SYSDIR\${SEDuB}SYSDIR\${SEDuC}1\${SEDuD}
\${SEDeA}SYSDIR\${SEDeB}SYSDIR\${SEDeC}1\${SEDeD}
"
}
 dirheader=sys/dir.h

fi
rm -f conftest*
fi
if test -z "$dirheader"; then
  echo checking for ndir.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <ndir.h>
int main() { exit(0); }
int t() { DIR *dirp = 0; }
EOF
if eval $compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining NDIR"
echo "#define" NDIR 1 >> confdefs.h
DEFS="$DEFS -DNDIR=1"
SEDDEFS="${SEDDEFS}\${SEDdA}NDIR\${SEDdB}NDIR\${SEDdC}1\${SEDdD}
\${SEDuA}NDIR\${SEDuB}NDIR\${SEDuC}1\${SEDuD}
\${SEDeA}NDIR\${SEDeB}NDIR\${SEDeC}1\${SEDeD}
"
}
 dirheader=ndir.h

fi
rm -f conftest*
fi

echo checking for closedir return value
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <$dirheader>
int closedir(); main() { exit(closedir(opendir(".")) != 0); }
EOF
eval $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"
SEDDEFS="${SEDDEFS}\${SEDdA}VOID_CLOSEDIR\${SEDdB}VOID_CLOSEDIR\${SEDdC}1\${SEDdD}
\${SEDuA}VOID_CLOSEDIR\${SEDuB}VOID_CLOSEDIR\${SEDuC}1\${SEDuD}
\${SEDeA}VOID_CLOSEDIR\${SEDeB}VOID_CLOSEDIR\${SEDeC}1\${SEDeD}
"
}

fi
rm -fr conftest*

for func in setvbuf getcwd gethostname bzero rindex vfprintf vsprintf
do
trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "	defining ${trfunc}"
echo "#define" ${trfunc} 1 >> confdefs.h
DEFS="$DEFS -D${trfunc}=1"
SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
\${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
\${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
"
}


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


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


fi
rm -f conftest*
done
echo checking for struct tm in time.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <time.h>
int main() { exit(0); }
int t() { struct tm *tp; tp->tm_sec; }
EOF
if eval $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"
SEDDEFS="${SEDDEFS}\${SEDdA}TM_IN_SYS_TIME\${SEDdB}TM_IN_SYS_TIME\${SEDdC}1\${SEDdD}
\${SEDuA}TM_IN_SYS_TIME\${SEDuB}TM_IN_SYS_TIME\${SEDuC}1\${SEDuD}
\${SEDeA}TM_IN_SYS_TIME\${SEDeB}TM_IN_SYS_TIME\${SEDeC}1\${SEDeD}
"
}

fi
rm -f conftest*

cat > conftest.c <<EOF
#include "confdefs.h"
#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"
echo "#define" SETVBUF_REVERSED 1 >> confdefs.h
DEFS="$DEFS -DSETVBUF_REVERSED=1"
SEDDEFS="${SEDDEFS}\${SEDdA}SETVBUF_REVERSED\${SEDdB}SETVBUF_REVERSED\${SEDdC}1\${SEDdD}
\${SEDuA}SETVBUF_REVERSED\${SEDuB}SETVBUF_REVERSED\${SEDuC}1\${SEDuD}
\${SEDeA}SETVBUF_REVERSED\${SEDeB}SETVBUF_REVERSED\${SEDeC}1\${SEDeD}
"
}


fi
rm -fr conftest*
rm -f core

TERMLIBS=""
for termlib in termcap terminfo curses termlib ; do
  LIBS_save="${LIBS}"
LIBS="${LIBS} -l${termlib}"
have_lib=""
echo checking for -l${termlib}
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; TERMLIBS="${TERMLIBS} -l${termlib}"
else
   :; 
fi

  case "${TERMLIBS}" in
    *-l${termlib}*)
      break
    ;;
  esac
done

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

if test -z "$LEXLIB"
then
  case "$LEX" in
  flex*) LIBS_save="${LIBS}"
LIBS="${LIBS} -lfl"
have_lib=""
echo checking for -lfl
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; LEXLIB="-lfl"
else
   :; 
fi
 ;;
  *) LEXLIB="-ll" ;;
  esac
fi

case "$LEX" in
  flex*)
    LFLAGS="-t -I"
    LEXLIB=
  ;;
  *)
    LFLAGS="-t"
    cat << EOF
warning: I didn't find flex, but that's only a problem
         if you need to reconstruct lex.cc
EOF
  ;;
esac
for p in 'bison -y' byacc
do
if test -z "$YACC"; then
  # Extract the first word of `$p', so it can be a program name with args.
  set dummy $p; word=$2
  echo checking for $word
  IFS="${IFS= 	}"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$word; then
      YACC="$p"
      break
    fi
  done
  IFS="$saveifs"
fi

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

test -n "$YACC" && break
done
test -n "$YACC" || YACC="yacc"

case "$YACC" in
  bison*)
  ;;
  *)
    cat << EOF
warning: I didn't find bison, but that's only a problem
         if you need to reconstruct parse.cc
EOF
  ;;
esac
echo checking for return type of signal handlers
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <signal.h>
#ifdef signal
#undef signal
#endif
extern void (*signal ()) ();
int main() { exit(0); }
int t() { int i; }
EOF
if eval $compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" RETSIGTYPE to be void
echo "#define" RETSIGTYPE void >> confdefs.h
DEFS="$DEFS -DRETSIGTYPE=void"
SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}void\${SEDdD}
\${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}void\${SEDuD}
\${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}void\${SEDeD}
"
}


else
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" RETSIGTYPE to be int
echo "#define" RETSIGTYPE int >> confdefs.h
DEFS="$DEFS -DRETSIGTYPE=int"
SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}int\${SEDdD}
\${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}int\${SEDuD}
\${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}int\${SEDeD}
"
}

fi
rm -f conftest*


case "$RETSIGTYPE" in
  int)
  ;;
  *)
    VOID_SIGHANDLER="-DVOID_SIGHANDLER=1"
  ;;
esac
case "$canonical_host_type" in
  mips-dec-ultrix*)
    echo checking for sgtty.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sgtty.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" HAVE_SGTTY_H to be 1
echo "#define" HAVE_SGTTY_H 1 >> confdefs.h
DEFS="$DEFS -DHAVE_SGTTY_H=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_SGTTY_H\${SEDdB}HAVE_SGTTY_H\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_SGTTY_H\${SEDuB}HAVE_SGTTY_H\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_SGTTY_H\${SEDeB}HAVE_SGTTY_H\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*
  ;;
esac
case "$DEFS" in
  *HAVE_SGTTY_H*)
  ;;
  *)
    echo checking for termios.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <termios.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" HAVE_TERMIOS_H to be 1
echo "#define" HAVE_TERMIOS_H 1 >> confdefs.h
DEFS="$DEFS -DHAVE_TERMIOS_H=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_TERMIOS_H\${SEDdB}HAVE_TERMIOS_H\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_TERMIOS_H\${SEDuB}HAVE_TERMIOS_H\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_TERMIOS_H\${SEDeB}HAVE_TERMIOS_H\${SEDeC}1\${SEDeD}
"
}


else
  rm -rf conftest*
  echo checking for termio.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <termio.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" HAVE_TERMIO_H to be 1
echo "#define" HAVE_TERMIO_H 1 >> confdefs.h
DEFS="$DEFS -DHAVE_TERMIO_H=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_TERMIO_H\${SEDdB}HAVE_TERMIO_H\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_TERMIO_H\${SEDuB}HAVE_TERMIO_H\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_TERMIO_H\${SEDeB}HAVE_TERMIO_H\${SEDeC}1\${SEDeD}
"
}


else
  rm -rf conftest*
  echo checking for sgtty.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sgtty.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" HAVE_SGTTY_H to be 1
echo "#define" HAVE_SGTTY_H 1 >> confdefs.h
DEFS="$DEFS -DHAVE_SGTTY_H=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_SGTTY_H\${SEDdB}HAVE_SGTTY_H\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_SGTTY_H\${SEDuB}HAVE_SGTTY_H\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_SGTTY_H\${SEDeB}HAVE_SGTTY_H\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*

fi
rm -f conftest*

fi
rm -f conftest*

    case "$DEFS" in
      *HAVE_TERMIOS_H* | *HAVE_TERMIO_H* | *HAVE_SGTTY_H*)
      ;;
      *)
        cat << EOF
error: I couldn't find termios.h, termio.h, or sgtty.h, and I can't
       continue without them.  To compile Octave, your system must
       have at least one of these header files.
EOF
        exit 1
      ;;
    esac
  ;;
esac
LIBS_save="${LIBS}"
LIBS="${LIBS} -lm"
have_lib=""
echo checking for -lm
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   
{
test -n "$verbose" && \
echo "	defining HAVE_LIBM"
echo "#define" HAVE_LIBM 1 >> confdefs.h
DEFS="$DEFS -DHAVE_LIBM=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_LIBM\${SEDdB}HAVE_LIBM\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_LIBM\${SEDuB}HAVE_LIBM\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_LIBM\${SEDeB}HAVE_LIBM\${SEDeC}1\${SEDeD}
"
}

   LIBS="${LIBS} -lm"
fi
XCFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $GCC_IEEE_FP_FLAG"
for func in finite isnan isinf
do
  trfunc=`echo $func | tr 'a-z' 'A-Z'`
  echo checking for $func
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_$func) || defined (__stub___$func)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char $func(); $func();
#endif
 }
EOF
if eval $compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "	defining" HAVE_$trfunc to be 1
echo "#define" HAVE_$trfunc 1 >> confdefs.h
DEFS="$DEFS -DHAVE_$trfunc=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_$trfunc\${SEDdB}HAVE_$trfunc\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_$trfunc\${SEDuB}HAVE_$trfunc\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_$trfunc\${SEDeB}HAVE_$trfunc\${SEDeC}1\${SEDeD}
"
}


else
  rm -rf conftest*
  echo checking for $func
cat > conftest.c <<EOF
#include "confdefs.h"
#include <math.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.  */
$func (1.0);
#endif
 }
EOF
if eval $compile; then
  rm -rf conftest*
  
{
test -n "$verbose" && \
echo "	defining" HAVE_$trfunc to be 1
echo "#define" HAVE_$trfunc 1 >> confdefs.h
DEFS="$DEFS -DHAVE_$trfunc=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_$trfunc\${SEDdB}HAVE_$trfunc\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_$trfunc\${SEDuB}HAVE_$trfunc\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_$trfunc\${SEDeB}HAVE_$trfunc\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*

fi
rm -f conftest*
done
CFLAGS="$XCFLAGS"
for func in acosh asinh atanh
do
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  :
else
  rm -rf conftest*
  LIBOBJS="$LIBOBJS ${func}.o"
test -n "$verbose" && echo "	using ${func}.o instead"
fi
rm -f conftest*

done
if test -n "$LIBOBJS"; then
  for func in $LIBOBJS
  do
    case "$func" in
      *acosh.o*)
	
{
test -n "$verbose" && \
echo "	defining" ACOSH_MISSING to be 1
echo "#define" ACOSH_MISSING 1 >> confdefs.h
DEFS="$DEFS -DACOSH_MISSING=1"
SEDDEFS="${SEDDEFS}\${SEDdA}ACOSH_MISSING\${SEDdB}ACOSH_MISSING\${SEDdC}1\${SEDdD}
\${SEDuA}ACOSH_MISSING\${SEDuB}ACOSH_MISSING\${SEDuC}1\${SEDuD}
\${SEDeA}ACOSH_MISSING\${SEDeB}ACOSH_MISSING\${SEDeC}1\${SEDeD}
"
}
	;;
      *asinh.o*)
	
{
test -n "$verbose" && \
echo "	defining" ASINH_MISSING to be 1
echo "#define" ASINH_MISSING 1 >> confdefs.h
DEFS="$DEFS -DASINH_MISSING=1"
SEDDEFS="${SEDDEFS}\${SEDdA}ASINH_MISSING\${SEDdB}ASINH_MISSING\${SEDdC}1\${SEDdD}
\${SEDuA}ASINH_MISSING\${SEDuB}ASINH_MISSING\${SEDuC}1\${SEDuD}
\${SEDeA}ASINH_MISSING\${SEDeB}ASINH_MISSING\${SEDeC}1\${SEDeD}
"
}
	;;
      *atanh.o*)
	
{
test -n "$verbose" && \
echo "	defining" ATANH_MISSING to be 1
echo "#define" ATANH_MISSING 1 >> confdefs.h
DEFS="$DEFS -DATANH_MISSING=1"
SEDDEFS="${SEDDEFS}\${SEDdA}ATANH_MISSING\${SEDdB}ATANH_MISSING\${SEDdC}1\${SEDdD}
\${SEDuA}ATANH_MISSING\${SEDuB}ATANH_MISSING\${SEDuC}1\${SEDuD}
\${SEDeA}ATANH_MISSING\${SEDeB}ATANH_MISSING\${SEDeC}1\${SEDeD}
"
}
	;;
    esac
  done

  case $LIBOBJS in
    *acosh.o* | *asinh.o*)
      for func in copysign
do
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  :
else
  rm -rf conftest*
  LIBOBJS="$LIBOBJS ${func}.o"
test -n "$verbose" && echo "	using ${func}.o instead"
fi
rm -f conftest*

done
      ;;
  esac

  case $LIBOBJS in
    *acosh.o* | *asinh.o* | *atanh.o*)
      for func in log1p
do
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  :
else
  rm -rf conftest*
  LIBOBJS="$LIBOBJS ${func}.o"
test -n "$verbose" && echo "	using ${func}.o instead"
fi
rm -f conftest*

done
      ;;
  esac

  case $LIBOBJS in
    *log1p*)
      for func in log__L
do
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  :
else
  rm -rf conftest*
  LIBOBJS="$LIBOBJS ${func}.o"
test -n "$verbose" && echo "	using ${func}.o instead"
fi
rm -f conftest*

done
      ;;
  esac

  case $LIBOBJS in
    *log1p*)
      for func in finite
do
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  :
else
  rm -rf conftest*
  LIBOBJS="$LIBOBJS ${func}.o"
test -n "$verbose" && echo "	using ${func}.o instead"
fi
rm -f conftest*

done
      ;;
  esac

  case $LIBOBJS in
    *copysign* | *finite* | *log1p*)
      for func in logb scalb
do
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() { 
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  :
else
  rm -rf conftest*
  LIBOBJS="$LIBOBJS ${func}.o"
test -n "$verbose" && echo "	using ${func}.o instead"
fi
rm -f conftest*

done
      ;;
  esac
fi
if test -z "$GNUPLOT_BINARY"; then
  # Extract the first word of `gnuplot', so it can be a program name with args.
  set dummy gnuplot; 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
      GNUPLOT_BINARY="gnuplot"
      break
    fi
  done
  IFS="$saveifs"
fi

test -n "$GNUPLOT_BINARY" && test -n "$verbose" && echo "	setting GNUPLOT_BINARY to $GNUPLOT_BINARY"
if test -z "$GNUPLOT_BINARY"; then
  cat << EOF
warning: I didn't find gnuplot.  It isn't necessary to have gnuplot
         installed, but you won't be able to use any of Octave's
         plotting commands without it.

         If gnuplot is installed but it isn't in your path, you can
         tell Octave where to find it by typing the command

           gnuplot_binary = '/full/path/to/gnuplot/binary'

         at the Octave prompt.
EOF
fi
for p in less more page pg
do
if test -z "$DEFAULT_PAGER"; then
  # Extract the first word of `$p', so it can be a program name with args.
  set dummy $p; word=$2
  echo checking for $word
  IFS="${IFS= 	}"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$word; then
      DEFAULT_PAGER="$p"
      break
    fi
  done
  IFS="$saveifs"
fi

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

test -n "$DEFAULT_PAGER" && break
done
if test -z "$DEFAULT_PAGER"; then
  echo "warning: I couldn't find less(1), more(1), page(1), or pg(1)"
elif test "$DEFAULT_PAGER" = less; then
  DEFAULT_PAGER="less -e"
fi
if test -z "$RUNTEST"; then
  # Extract the first word of `runtest', so it can be a program name with args.
  set dummy runtest; 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
      RUNTEST="runtest"
      break
    fi
  done
  IFS="$saveifs"
fi

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

test -n "$EXPECT" && test -n "$verbose" && echo "	setting EXPECT to $EXPECT"
if test -z "$EXPECT" ; then
  RUNTEST=
fi
UGLY_DEFS="$DEFS"
# Set default prefixes.
if test -n "$prefix"; then
  test -z "$exec_prefix" && exec_prefix='${prefix}'
  prsub="s%^prefix\\([ 	]*\\)=\\([ 	]*\\).*$%prefix\\1=\\2$prefix%"
fi
if test -n "$exec_prefix"; then
  prsub="$prsub
s%^exec_prefix\\([ 	]*\\)=\\([ 	]*\\).*$%exec_prefix\\1=\\2$exec_prefix%"
fi
# Quote sed substitution magic chars in DEFS.
cat >conftest.def <<EOF
$DEFS
EOF
escape_ampersand_and_backslash='s%[&\\]%\\&%g'
DEFS=`sed "$escape_ampersand_and_backslash" <conftest.def`
rm -f conftest.def
# Substitute for predefined variables.

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

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

trap 'rm -fr Makefile Makeconf libcruft/Makefile libcruft/Makerules liboctave/Makefile src/Makefile dld/Makefile info/Makefile readline/Makefile readline/doc/Makefile readline/examples/Makefile doc/Makefile scripts/Makefile test/Makefile libcruft/blas/Makefile libcruft/balgen/Makefile libcruft/dassl/Makefile libcruft/eispack/Makefile libcruft/fftpack/Makefile libcruft/fsqp/Makefile libcruft/lapack/Makefile libcruft/linpack/Makefile libcruft/minpack/Makefile libcruft/misc/Makefile libcruft/npsol/Makefile libcruft/odepack/Makefile libcruft/qpsol/Makefile libcruft/quadpack/Makefile libcruft/ranlib/Makefile libcruft/villad/Makefile config.h conftest*; exit 1' 1 3 15
root_srcdir='$root_srcdir'
target_host_type='$target_host_type'
DYNAMIC_LD_OBJ='$DYNAMIC_LD_OBJ'
DLD_DIR='$DLD_DIR'
LIBDLD='$LIBDLD'
DLD_OBJECTS='$DLD_OBJECTS'
LD_STATIC_FLAG='$LD_STATIC_FLAG'
CC='$CC'
CPP='$CPP'
ALLOCA='$ALLOCA'
CFLAGS='$CFLAGS'
LDFLAGS='$LDFLAGS'
CXX='$CXX'
CXXFLAGS='$CXXFLAGS'
EXTERNAL_TEMPLATES='$EXTERNAL_TEMPLATES'
GCC_IEEE_FP_FLAG='$GCC_IEEE_FP_FLAG'
F77='$F77'
F2C='$F2C'
FFLAGS='$FFLAGS'
FLIBS='$FLIBS'
F2CFLAGS='$F2CFLAGS'
DEFAULT_DOT_C_FROM_DOT_F='$DEFAULT_DOT_C_FROM_DOT_F'
DEFAULT_DOT_O_FROM_DOT_F='$DEFAULT_DOT_O_FROM_DOT_F'
INSTALL='$INSTALL'
INSTALL_PROGRAM='$INSTALL_PROGRAM'
INSTALL_DATA='$INSTALL_DATA'
RANLIB='$RANLIB'
TERMLIBS='$TERMLIBS'
LEX='$LEX'
LEXLIB='$LEXLIB'
LFLAGS='$LFLAGS'
YACC='$YACC'
VOID_SIGHANDLER='$VOID_SIGHANDLER'
LIBOBJS='$LIBOBJS'
GNUPLOT_BINARY='$GNUPLOT_BINARY'
DEFAULT_PAGER='$DEFAULT_PAGER'
RUNTEST='$RUNTEST'
EXPECT='$EXPECT'
UGLY_DEFS='$UGLY_DEFS'
LIBS='$LIBS'
srcdir='$srcdir'
prefix='$prefix'
exec_prefix='$exec_prefix'
prsub='$prsub'
extrasub='$extrasub'
EOF
cat >> config.status <<\EOF

top_srcdir=$srcdir

CONFIG_FILES=${CONFIG_FILES-"Makefile Makeconf libcruft/Makefile libcruft/Makerules liboctave/Makefile src/Makefile dld/Makefile info/Makefile readline/Makefile readline/doc/Makefile readline/examples/Makefile doc/Makefile scripts/Makefile test/Makefile libcruft/blas/Makefile libcruft/balgen/Makefile libcruft/dassl/Makefile libcruft/eispack/Makefile libcruft/fftpack/Makefile libcruft/fsqp/Makefile libcruft/lapack/Makefile libcruft/linpack/Makefile libcruft/minpack/Makefile libcruft/misc/Makefile libcruft/npsol/Makefile libcruft/odepack/Makefile libcruft/qpsol/Makefile libcruft/quadpack/Makefile libcruft/ranlib/Makefile libcruft/villad/Makefile"}
for file in .. ${CONFIG_FILES}; do if test "x$file" != x..; then
  srcdir=$top_srcdir
  # Remove last slash and all that follows it.  Not all systems have dirname.
  dir=`echo $file|sed 's%/[^/][^/]*$%%'`
  if test "$dir" != "$file"; then
    test "$top_srcdir" != . && srcdir=$top_srcdir/$dir
    test ! -d $dir && mkdir $dir
  fi
  echo creating $file
  rm -f $file
  echo "# Generated automatically from `echo $file|sed 's|.*/||'`.in by configure." > $file
  sed -e "
$prsub
$extrasub
s%@root_srcdir@%$root_srcdir%g
s%@target_host_type@%$target_host_type%g
s%@DYNAMIC_LD_OBJ@%$DYNAMIC_LD_OBJ%g
s%@DLD_DIR@%$DLD_DIR%g
s%@LIBDLD@%$LIBDLD%g
s%@DLD_OBJECTS@%$DLD_OBJECTS%g
s%@LD_STATIC_FLAG@%$LD_STATIC_FLAG%g
s%@CC@%$CC%g
s%@CPP@%$CPP%g
s%@ALLOCA@%$ALLOCA%g
s%@CFLAGS@%$CFLAGS%g
s%@LDFLAGS@%$LDFLAGS%g
s%@CXX@%$CXX%g
s%@CXXFLAGS@%$CXXFLAGS%g
s%@EXTERNAL_TEMPLATES@%$EXTERNAL_TEMPLATES%g
s%@GCC_IEEE_FP_FLAG@%$GCC_IEEE_FP_FLAG%g
s%@F77@%$F77%g
s%@F2C@%$F2C%g
s%@FFLAGS@%$FFLAGS%g
s%@FLIBS@%$FLIBS%g
s%@F2CFLAGS@%$F2CFLAGS%g
s%@DEFAULT_DOT_C_FROM_DOT_F@%$DEFAULT_DOT_C_FROM_DOT_F%g
s%@DEFAULT_DOT_O_FROM_DOT_F@%$DEFAULT_DOT_O_FROM_DOT_F%g
s%@INSTALL@%$INSTALL%g
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
s%@INSTALL_DATA@%$INSTALL_DATA%g
s%@RANLIB@%$RANLIB%g
s%@TERMLIBS@%$TERMLIBS%g
s%@LEX@%$LEX%g
s%@LEXLIB@%$LEXLIB%g
s%@LFLAGS@%$LFLAGS%g
s%@YACC@%$YACC%g
s%@VOID_SIGHANDLER@%$VOID_SIGHANDLER%g
s%@LIBOBJS@%$LIBOBJS%g
s%@GNUPLOT_BINARY@%$GNUPLOT_BINARY%g
s%@DEFAULT_PAGER@%$DEFAULT_PAGER%g
s%@RUNTEST@%$RUNTEST%g
s%@EXPECT@%$EXPECT%g
s%@UGLY_DEFS@%$UGLY_DEFS%g
s%@LIBS@%$LIBS%g
s%@srcdir@%$srcdir%g
s%@DEFS@%-DHAVE_CONFIG_H%" $top_srcdir/${file}.in >> $file
fi; done

CONFIG_HEADERS=${CONFIG_HEADERS-"config.h"}
for file in .. ${CONFIG_HEADERS}; do if test "x$file" != x..; then
echo creating $file

# These sed commands are put into SEDDEFS 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.
#
# SEDd sets the value in "#define NAME VALUE" lines.
SEDdA='s@^\([ 	]*\)#\([ 	]*define[ 	][ 	]*\)'
SEDdB='\([ 	][ 	]*\)[^ 	]*@\1#\2'
SEDdC='\3'
SEDdD='@g'
# SEDu turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
SEDuA='s@^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'
SEDuB='\([ 	]\)@\1#\2define\3'
SEDuC=' '
SEDuD='\4@g'
# SEDe turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
SEDeA='s@^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'
SEDeB='$@\1#\2define\3'
SEDeC=' '
SEDeD='@g'
rm -f conftest.sed
EOF
# Turn off quoting long enough to insert the sed commands.
rm -f conftest.sh
cat > conftest.sh <<EOF
$SEDDEFS
EOF

# Break up $SEDDEFS (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.
maxshlines=9

while :
do
  # wc gives bogus results for an empty file on some systems.
  lines=`grep -c . conftest.sh`
  if test -z "$lines" || test "$lines" -eq 0; then break; fi
  rm -f conftest.s1 conftest.s2
  sed ${maxshlines}q conftest.sh > conftest.s1 # Like head -20.
  sed 1,${maxshlines}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.
maxsedlines=20
cp $top_srcdir/$file.in conftest.h1
while :
do
  lines=`grep -c . conftest.sed`
  if test -z "$lines" || test "$lines" -eq 0; then break; fi
  rm -f conftest.s1 conftest.s2 conftest.h2
  sed ${maxsedlines}q conftest.sed > conftest.s1 # Like head -20.
  sed 1,${maxsedlines}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 "/* $file.  Generated automatically by configure.  */" > conftest.h
cat conftest.h1 >> 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.
  echo "$file is unchanged"
  rm -f conftest.h
else
  rm -f $file
  mv conftest.h $file
fi
fi; done



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