#!/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] [--no-create]
#        [--prefix=PREFIX] [--exec-prefix=PREFIX] [--with-PACKAGE] [TARGET]
# Ignores all args except --srcdir, --prefix, --exec-prefix, --no-create, and
# --with-PACKAGE 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, also recognize exact --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) ;;

     -no-create | --no-create | --no-creat | --no-crea | --no-cre | --no-cr | --no-c | --no- | --no)
        no_create=1 ;;

     -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 's/-*with-//'`
       # Delete all the valid chars; see if any are left.
       if test -n "`echo $package|sed 's/[-a-zA-Z0-9_]*//g'`"; then
         echo "configure: $package: invalid package name" >&2; exit 1
       fi
       eval "with_`echo $package|sed s/-/_/g`=1" ;;

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

     *) ;;
    esac
  fi
done

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

# Needed for some versions of `tr' so that character classes in `[]' work.
if test "${LANG+set}" = "set" ; then
   LANG=C
fi

rm -f conftest*
compile='${CC-cc} $CFLAGS $DEFS 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

# See if we were given the target host type.  If not, guess.

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

case "$target_host_type" in
  unknown)
    echo "configuring Octave for an unknown system type"
  ;;
  *)
    echo "configuring Octave for a $target_host_type"
  ;;
esac

# Set up to handle --with-FOO options.

# check whether --with-f2c was given
if test -n "$with_f2c"; then
  use_f2c=true
else
  use_f2c=false
fi
# check whether --with-dld was given
if test -n "$with_dld"; 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
  DEFS="$DEFS -DWITH_DLD=1"
  LD_STATIC_FLAG=-static
fi

echo "checking for npsol"
if test -f $srcdir/libcruft/npsol/npsol.f; then
  :
else
  DEFS="$DEFS -DNPSOL_MISSING=1"
fi

echo "checking for qpsol"
if test -f $srcdir/libcruft/qpsol/qpsol.f; then
  :
else
  DEFS="$DEFS -DQPSOL_MISSING=1"
fi

echo "checking for fsqp"
if test -f $srcdir/libcruft/fsqp/fsqpd.f; then
  :
else
  DEFS="$DEFS -DFSQP_MISSING=1"
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" -a -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
  CPP='${CC-cc} -E'
  cat > conftest.c <<EOF
#include <stdio.h>
EOF
err=`eval "($CPP \$DEFS conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  :
else
  CPP=/lib/cpp
fi
rm -f conftest*
fi

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


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

  fi
  test -n "$need_trad" && CC="$CC -traditional"
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
  {
test -n "$verbose" && \
echo '	defining' _ALL_SOURCE
DEFS="$DEFS -D_ALL_SOURCE=1"
}

fi
rm -f conftest*



# Do special things for gcc.

case "$CC" in
  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
    ;;
  *)
    CFLAGS="-g"
    LDFLAGS="-g"
    ;;
esac

if test -z "$GXX"; 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
      GXX="g++"
      break
    fi
  done
  IFS="$saveifs"
fi

test -n "$GXX" -a -n "$verbose" && echo "	setting GXX to $GXX"
if test "$GXX" = 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
      ;;
    esac
else
  cat << EOF
warning: Octave has only been tested with g++, and I can't
         seem to find it.
EOF
fi

# If we haven't been forced to use f2c, try to find a Fortran compiler
# under any one of several common Un*x Fortran compiler names. 
# Put fc last to avoid confusion with some vendor's /bin/sh fc
# builtin.
#
#    g77 : GNU Fortran (someday...)
#    xlf : IBM / AIX
#   cf77 : Cray / Unicos
#     fc : Convex
#
# I don't think the Cray compiler will ever work like f2c...

if $use_f2c; then
  true
else
  F77=
  for p in g77 xlf cf77 f77 fc
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" -a -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
        DEFS="$DEFS $tmpdef"
      fi
    else
      F77=
    fi
  fi
fi

# If we can't find a Fortran compiler, or if it looks like it isn't
# compatible with f2c, try to find f2c.

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" -a -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

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
   :; 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

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
   :; 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

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
   :; FLIBS="$FLIBS -lI77"
else
   :; 
fi
    fi
  fi
  if test -z "$FLIBS" ; then
    cat << EOF
warning: I found I77 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'
  DEFS="$DEFS -DF77_APPEND_UNDERSCORE=1"
else
  cat << EOF
warning: in order to build octave, you must have a compatible
         Fortran compiler or I77 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}
INSTALL_PROGRAM=${INSTALL_PROGRAM-'$(INSTALL)'}
INSTALL_DATA=${INSTALL_DATA-'$(INSTALL)'}

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" -a -n "$verbose" && echo "	setting RANLIB to $RANLIB"

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
  # 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
  # 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 -f conftest*
fi
rm -f conftest*

fi
rm -f conftest*

echo checking for unistd.h
cat > conftest.c <<EOF
#include <unistd.h>
EOF
err=`eval "($CPP \$DEFS conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  {
test -n "$verbose" && \
echo '	defining' HAVE_UNISTD_H
DEFS="$DEFS -DHAVE_UNISTD_H=1"
}

fi
rm -f conftest*

echo checking for directory library header
dirheader=
if test -z "$dirheader"; then
  echo checking for dirent.h
cat > conftest.c <<EOF
#include <sys/types.h>
#include <dirent.h>
int main() { exit(0); }
int t() { DIR *dirp = opendir ("/"); }
EOF
if eval $compile; then
  {
test -n "$verbose" && \
echo '	defining' DIRENT
DEFS="$DEFS -DDIRENT=1"
}
 dirheader=dirent.h
fi
rm -f conftest*
fi
if test -z "$dirheader"; then
  echo checking for sys/ndir.h
cat > conftest.c <<EOF
#include <sys/types.h>
#include <sys/ndir.h>
int main() { exit(0); }
int t() { DIR *dirp = opendir ("/"); }
EOF
if eval $compile; then
  {
test -n "$verbose" && \
echo '	defining' SYSNDIR
DEFS="$DEFS -DSYSNDIR=1"
}
 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 <sys/types.h>
#include <sys/dir.h>
int main() { exit(0); }
int t() { DIR *dirp = opendir ("/"); }
EOF
if eval $compile; then
  {
test -n "$verbose" && \
echo '	defining' SYSDIR
DEFS="$DEFS -DSYSDIR=1"
}
 dirheader=sys/dir.h
fi
rm -f conftest*
fi
if test -z "$dirheader"; then
  echo checking for ndir.h
cat > conftest.c <<EOF
#include <sys/types.h>
#include <ndir.h>
int main() { exit(0); }
int t() { DIR *dirp = opendir ("/"); }
EOF
if eval $compile; then
  {
test -n "$verbose" && \
echo '	defining' NDIR
DEFS="$DEFS -DNDIR=1"
}
 dirheader=ndir.h
fi
rm -f conftest*
fi

echo checking for closedir return value
cat > conftest.c <<EOF
#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
DEFS="$DEFS -DVOID_CLOSEDIR=1"
}

fi
rm -f conftest*


# For now, don't define LEXLIB to be -lfl -- we don't use anything in
# it, and it might not be installed.
#
# Also make sure that we generate an interactive scanner if we are
# using flex.

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" -a -n "$verbose" && echo "	setting LEX to $LEX"

if test -z "$LEXLIB"
then
  case "$LEX" in
  flex*)
    # Should this be changed to use AC HAVE_LIBRARY? --friedman
    if test -r /usr/local/lib/libfl.a
    then LEXLIB=/usr/local/lib/libfl.a
    elif test -r ${prefix}/lib/libfl.a
    then LEXLIB=${prefix}/lib/libfl.a
    else LEXLIB="-lfl"
    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" -a -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

# Define VOID_SIGHANDLER for readline.

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*


case "$RETSIGTYPE" in
  int)
  ;;
  *)
    VOID_SIGHANDLER="-DVOID_SIGHANDLER=1"
  ;;
esac

for hdr in termio.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
  {
test -n "$verbose" && \
echo '	defining' ${trhdr}
DEFS="$DEFS -D${trhdr}=1"
}

fi
rm -f conftest*
done
case "$DEFS" in
  *HAVE_TERMIO_H*)
  ;;
  *)
    for hdr in sgtty.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
  {
test -n "$verbose" && \
echo '	defining' ${trhdr}
DEFS="$DEFS -D${trhdr}=1"
}

fi
rm -f conftest*
done
    case "$DEFS" in
      *HAVE_SGTTY_H*)
      ;;
      *)
        echo "I couldn't find either termio.h or sgtty.h!"
        exit 1
        ;;
    esac
    ;;
esac

# Hack for readline's sysdep.h

case "$target_host_type" in
  *next*)
    echo "using BSD version of readline/sysdep.h on the NeXT"
    rm -f readline/sysdep.h
    cp readline/sysdep-obsd.h readline/sysdep.h
  ;;
esac

# Check to see if we have IEEE math functions, and if so, which ones.
#
# Also check for some additional trig functions that aren't ANSI but
# are often available.  If they are missing, we try to replace them
# with functions from the BSD/NET2 math library.

XLIBS="$LIBS"
LIBS="$XLIBS -lm"
for func in finite isnan isinf
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
for func in acosh asinh atanh
do
echo checking for ${func}
cat > conftest.c <<EOF

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
  LIBOBJS="$LIBOBJS ${func}.o"
test -n "$verbose" && echo "	using ${func}.o instead"
fi
rm -f conftest*

done
LIBS="$XLIBS"

if test -n "$LIBOBJS"; then
  for func in $LIBOBJS
  do
    case "$func" in
      *acosh.o*)
	DEFS="$DEFS -DACOSH_MISSING=1"
	;;
      *asinh.o*)
	DEFS="$DEFS -DASINH_MISSING=1"
	;;
      *atanh.o*)
	DEFS="$DEFS -DATANH_MISSING=1"
	;;
    esac
  done

  case $LIBOBJS in
    *acosh.o* | *asinh.o*)
      for func in copysign
do
echo checking for ${func}
cat > conftest.c <<EOF

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
  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

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
  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

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
  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

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
  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

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
  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" -a -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

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

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

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

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

test -n "$DEFAULT_PAGER" -a -n "$verbose" && echo "	setting DEFAULT_PAGER to $DEFAULT_PAGER"
fi
if test -z "$DEFAULT_PAGER"; then
  echo "warning: I couldn't find less(1), more(1), page(1), or pg(1)"
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" -a -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" -a -n "$verbose" && echo "	setting EXPECT to $EXPECT"
if test -z "$EXPECT" ; then
  RUNTEST=
fi

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
DEFS="`echo \"$DEFS\" | sed 's%[&\\\]%\\\&%g'`"

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 $*

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

trap 'rm -f Makefile Makeconf libcruft/Makefile libcruft/Makerules liboctave/Makefile src/Makefile dld/Makefile readline/Makefile readline/doc/Makefile readline/examples/Makefile doc/Makefile scripts/Makefile test/Makefile test/config/Makefile test/octave/Makefile libcruft/blas/Makefile libcruft/dassl/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; exit 1' 1 3 15
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'
CFLAGS='$CFLAGS'
LDFLAGS='$LDFLAGS'
GXX='$GXX'
CXXFLAGS='$CXXFLAGS'
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'
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'
LIBS='$LIBS'
srcdir='$srcdir'
DEFS='$DEFS'
prefix='$prefix'
exec_prefix='$exec_prefix'
prsub='$prsub'
EOF
cat >> config.status <<\EOF

top_srcdir=$srcdir

# Allow make-time overrides of the generated file list.
test -n "$gen_files" || gen_files="Makefile Makeconf libcruft/Makefile libcruft/Makerules liboctave/Makefile src/Makefile dld/Makefile readline/Makefile readline/doc/Makefile readline/examples/Makefile doc/Makefile scripts/Makefile test/Makefile test/config/Makefile test/octave/Makefile libcruft/blas/Makefile libcruft/dassl/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 .. $gen_files; do if [ "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
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%@CFLAGS@%$CFLAGS%g
s%@LDFLAGS@%$LDFLAGS%g
s%@GXX@%$GXX%g
s%@CXXFLAGS@%$CXXFLAGS%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%@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%@LIBS@%$LIBS%g
s%@srcdir@%$srcdir%g
s%@DEFS@%$DEFS%
" $top_srcdir/${file}.in >> $file
fi; done

exit 0
EOF
chmod +x config.status
test -n "$no_create" || ./config.status