dnl configure.in
dnl
dnl Process this file with autoconf to produce a configure script.
dnl Requires GNU autoconf 1.8 or later.
dnl
dnl Copyright (C) 1992, 1993, 1994 John W. Eaton
dnl 
dnl This file is part of Octave.
dnl 
dnl Octave is free software; you can redistribute it and/or modify it
dnl under the terms of the GNU General Public License as published by the
dnl Free Software Foundation; either version 2, or (at your option) any
dnl later version.
dnl 
dnl Octave is distributed in the hope that it will be useful, but WITHOUT
dnl ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
dnl FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
dnl for more details.
dnl 
dnl You should have received a copy of the GNU General Public License
dnl along with Octave; see the file COPYING.  If not, write to the Free
dnl Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
dnl
AC_REVISION($Revision: 1.69 $)dnl
AC_PREREQ(2.0)
AC_INIT(src/octave.cc)
AC_CONFIG_HEADER(config.h kpathsea/c-auto.h)
dnl
AC_DEFINE(OCTAVE_SOURCE, 1)dnl
dnl
dnl See if we were given the target host type.  If not, use
dnl config.guess to try to guess the target host type.
dnl
AC_CANONICAL_HOST
target_host_type=${host:=unknown}
canonical_host_type=${host:=unknown}
if test "$host" = "unknown"; then
AC_MSG_WARN([configuring Octave for unknown system type
])
fi
AC_SUBST(target_host_type)dnl
dnl
dnl Allow the user to force us to use f2c.
dnl
AC_ARG_WITH(f2c,
  [  --with-f2c              use f2c even if Fortran compiler is available],
  use_f2c=true, use_f2c=false)dnl
dnl
dnl Allow the user to experiment with dynamic linking using GNU dld.
dnl
AC_ARG_ENABLE(dld,
  [  --enable-dld            use DLD for dynamic linking (not all systems)],
  use_dld=true, use_dld=false)dnl
AC_SUBST(use_dld)dnl
dnl
dnl Allow compilation of smaller kernel.  This only works if some form
dnl of dynamic linking is also supported and used.
dnl
AC_ARG_ENABLE(lite-kernel,
  [  --enable-lite-kernel    compile smaller kernel (requires DLD)],
  lite_kernel=true, lite_kernel=false)dnl
if $lite_kernel; then
  AC_DEFINE(OCTAVE_LITE, 1)dnl
fi
AC_SUBST(lite_kernel)dnl
dnl
dnl some defaults
dnl
AC_PREFIX_DEFAULT(/usr/local)
dnl
exec_prefix='$(prefix)'
bindir='$(exec_prefix)/bin'
datadir='$(prefix)/lib'
libdir='$(exec_prefix)/lib'
includedir='$(prefix)/include/octave'
mandir='$(prefix)/man/man1'
infodir='$(prefix)/info'
fcnfiledir='$(datadir)/octave/$(version)/m'
localfcnfiledir='$(datadir)/octave/site/m'
localfcnfilepath='$(localfcnfiledir)//'
archlibdir='$(libdir)/octave/$(version)/exec/$(target_host_type)'
octfiledir='$(libdir)/octave/$(version)/oct/$(target_host_type)'
localoctfiledir='$(datadir)/octave/site/oct/$(target_host_type)'
localoctfilepath='$(localoctfiledir)//'
fcnfilepath='.:$(localoctfilepath):$(localfcnfilepath):$(octfiledir)//:$(fcnfiledir)//'
imagedir='$(datadir)/octave/$(version)/imagelib'
imagepath='.:$(imagedir)//'
dnl
AC_MSG_RESULT([defining prefix to be $prefix])
AC_MSG_RESULT([defining exec_prefix to be $exec_prefix])
AC_MSG_RESULT([defining bindir to be $bindir])
AC_MSG_RESULT([defining datadir to be $datadir])
AC_MSG_RESULT([defining libdir to be $libdir])
AC_MSG_RESULT([defining includedir to be $includedir])
AC_MSG_RESULT([defining mandir to be $mandir])
AC_MSG_RESULT([defining infodir to be $infodir])
AC_MSG_RESULT([defining fcnfiledir to be $fcnfiledir])
AC_MSG_RESULT([defining localfcnfiledir to be $localfcnfiledir])
AC_MSG_RESULT([defining localfcnfilepath to be $localfcnfilepath])
AC_MSG_RESULT([defining archlibdir to be $archlibdir])
AC_MSG_RESULT([defining octfiledir to be $octfiledir])
AC_MSG_RESULT([defining localoctfiledir to be $localoctfiledir])
AC_MSG_RESULT([defining localoctfilepath to be $localoctfilepath])
AC_MSG_RESULT([defining fcnfilepath to be $fcnfilepath])
AC_MSG_RESULT([defining imagedir to be $imagedir])
AC_MSG_RESULT([defining imagepath to be $imagepath])
AC_SUBST(exec_prefix)
AC_SUBST(bindir)
AC_SUBST(datadir)
AC_SUBST(libdir)
AC_SUBST(includedir)
AC_SUBST(mandir)
AC_SUBST(infodir)
AC_SUBST(fcnfiledir)
AC_SUBST(localfcnfiledir)
AC_SUBST(localfcnfilepath)
AC_SUBST(archlibdir)
AC_SUBST(octfiledir)
AC_SUBST(localoctfiledir)
AC_SUBST(localoctfilepath)
AC_SUBST(fcnfilepath)
AC_SUBST(imagedir)
AC_SUBST(imagepath)
dnl
dnl Do special stuff if using dld.
dnl
DLD_DIR=
LIBDLD=
LIBOCTDLD='liboctdld.a'
LD_STATIC_FLAG=
if $use_dld; then
  DLD_DIR=dld
  LIBDLD='../dld/libdld.a'
# don't link them in only if doing dynamic linking and small kernel
# requested.
  if $lite_kernel; then
    LIBOCTDLD=
  fi
  LD_STATIC_FLAG=-static
  AC_DEFINE(WITH_DLD, 1)dnl
fi
dnl
dnl Also use -static if compiling on Alpha OSF/1 1.3 systems.
dnl
case "$canonical_host_type" in
  alpha-dec-osf1.3)
    LD_STATIC_FLAG=-static
  ;;
esac
dnl
if test -n "$DLD_DIR"; then
  AC_MSG_RESULT([defining DLD_DIR to be $DLD_DIR])
fi
if test -n "$LIBDLD"; then
  AC_MSG_RESULT([defining LIBDLD to be $LIBDLD])
fi
if test -n "$LIBOCTDLD"; then
  AC_MSG_RESULT([defining LIBOCTDLD to be $LIBOCTDLD])
fi
if test -n "$LD_STATIC_FLAG"; then
  AC_MSG_RESULT([defining LD_STATIC_FLAG to be $LD_STATIC_FLAG])
fi
AC_SUBST(DLD_DIR)dnl
AC_SUBST(LIBDLD)dnl
AC_SUBST(LIBOCTDLD)dnl
AC_SUBST(LD_STATIC_FLAG)dnl
dnl
dnl See if the optional nonlinear programming code is present.
dnl
AC_MSG_CHECKING([for npsol])
if test -f $srcdir/libcruft/npsol/npsol.f; then
  AC_MSG_RESULT([yes])
else
  AC_MSG_RESULT([no])
  AC_DEFINE(NPSOL_MISSING, 1)dnl
fi
dnl
AC_MSG_CHECKING([for qpsol])
if test -f $srcdir/libcruft/qpsol/qpsol.f; then
  AC_MSG_RESULT([yes])
else
  AC_MSG_RESULT([no])
  AC_DEFINE(QPSOL_MISSING, 1)dnl
fi
dnl
AC_MSG_CHECKING([for fsqp])
if test -f $srcdir/libcruft/fsqp/fsqpd.f; then
  AC_MSG_RESULT([yes])
else
  AC_MSG_RESULT([no])
  AC_DEFINE(FSQP_MISSING, 1)dnl
fi
dnl
dnl See which C++ compiler to use (we expect to find g++).
dnl
AC_PROG_CXX
AC_PROG_CXXCPP
dnl
dnl Do special things for g++.
dnl
ADD_CXX_WALL=false
NO_IMPLICIT_TEMPLATES=
gxx_version=`$CXX -v 2>&1 | grep "^g.. version" | sed 's/^g.. version *//'`
case "$gxx_version" in
changequote(,)dnl
  2.[6789].*|2.[123456789][0123456789].*)
changequote([,])dnl
    CXXFLAGS="-g -O"
    AC_MSG_RESULT([defining CXXFLAGS to be $CXXFLAGS])
    NO_IMPLICIT_TEMPLATES="-fno-implicit-templates"
    AC_MSG_RESULT([defining NO_IMPLICIT_TEMPLATES to be $NO_IMPLICIT_TEMPLATES])
    ADD_CXX_WALL=true
  ;;
changequote(,)dnl
  1.*|2.[012345].*)
changequote([,])dnl
    AC_MSG_WARN([g++ version $gxx_version will not work to compile Octave])
  ;;
  *)
    AC_MSG_WARN([Octave has only been tested with g++, and I can't find it])
  ;;
esac
dnl
dnl See what libraries are used by the C++ compiler.  Need this for
dnl dynamic linking.
dnl
CXXLIBS=`sh $srcdir/cxxlibs.sh`
AC_MSG_RESULT([defining CXXLIBS to be $CXXLIBS])
dnl
AC_SUBST(CXXFLAGS)dnl
AC_SUBST(NO_IMPLICIT_TEMPLATES)dnl
AC_SUBST(CXXLIBS)dnl
dnl
dnl See which C compiler to use (we expect to find gcc).
dnl
AC_PROG_CC
AC_PROG_CPP
AC_PROG_GCC_TRADITIONAL
dnl
dnl Do special things for gcc.
dnl
ADD_CC_WALL=false
gcc_version=`$CC -v 2>&1 | grep "^gcc version" | sed 's/^gcc version *//'`
case "$gcc_version" in
  2.*)
    CFLAGS="-g -O"
    AC_MSG_RESULT([defining CFLAGS to be $CFLAGS])
    LDFLAGS="-g"
    AC_MSG_RESULT([defining LDFLAGS to be $LDFLAGS])
    ADD_CC_WALL=true
  ;;
  1.*)
    AC_MSG_WARN([gcc version $gcc_version is likely to cause problems])
  ;;
  *)
    AC_MSG_WARN([Octave has only been tested with gcc, and I can't find it])
  ;;
esac
dnl
AC_SUBST(CFLAGS)dnl
AC_SUBST(LDFLAGS)dnl
dnl
dnl On Linux systems we need to compile with -mieee-fp to get full
dnl support for IEEE floating point.
dnl
case "$canonical_host_type" in
  i386-*-linux | i486-*-linux | i586-*-linux)
    GCC_IEEE_FP_FLAG="-mieee-fp"
    AC_MSG_RESULT([defining GCC_IEEE_FP_FLAG to be $GCC_IEEE_FP_FLAG])
  ;;
esac
dnl
AC_SUBST(GCC_IEEE_FP_FLAG)dnl
dnl
dnl Special checks for odd OS specific things.
dnl
AC_ISC_POSIX
AC_MINIX
AC_AIX
AC_FUNC_STRFTIME
AC_CHECK_LIB(sun, getpwnam)
dnl
dnl How big are ints and how are they oriented?  These could probably
dnl be eliminated in favor of run-time checks.
dnl
AC_CHECK_SIZEOF(short)
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(long)
AC_C_BIGENDIAN
dnl
dnl Try to determine the floating point format.  This could probably
dnl be eliminated in favor of run-time checks.
dnl
AC_MSG_CHECKING([floating point format])
changequote(,)dnl
XCFLAGS=`echo $CFLAGS | sed 's/-O[^ \t]*//'`
changequote([,])dnl
${CC-cc} -DDP $XCFLAGS $LDFLAGS $srcdir/float-type.c -o conftest >/dev/null 2>&1
FLOAT_FORMAT=`./conftest`
case "$FLOAT_FORMAT" in
  IEEE_BIG_ENDIAN)
    AC_MSG_RESULT([IEEE big endian])
    AC_DEFINE(IEEE_BIG_ENDIAN, 1)dnl
  ;;
  IEEE_LITTLE_ENDIAN)
    AC_MSG_RESULT([IEEE little endian])
    AC_DEFINE(IEEE_LITTLE_ENDIAN, 1)dnl
  ;;
  VAX_D_FLOAT)
    AC_MSG_RESULT([VAX D floating])
    AC_DEFINE(VAX_D_FLOAT, 1)dnl
  ;;
  VAX_G_FLOAT)
    AC_MSG_RESULT([VAX G floating])
    AC_DEFINE(VAX_G_FLOAT, 1)dnl
  ;;
  *)
    AC_MSG_RESULT()
    AC_MSG_WARN("unrecognized floating point format!")
  ;;
esac
dnl
dnl Does the C compiler handle alloca() and const correctly?
dnl
AC_ALLOCA
dnl
dnl This one is for kpathsea.
dnl
dnl It would be nicer to test for the requisite putenv features directly,
dnl but can't figure out how to do that.
dnl
if test "`(uname) 2>/dev/null`" = NetBSD \
   || test "`(uname) 2>/dev/null`" = FreeBSD; then
  AC_DEFINE(SMART_PUTENV)
fi
dnl
AC_C_CONST
dnl
dnl If we haven't been forced to use f2c, try to find a Fortran compiler
dnl under any one of several common Un*x Fortran compiler names. 
dnl Put fc last to avoid confusion with some vendor's /bin/sh fc
dnl builtin.
dnl
dnl    xlf : IBM / AIX
dnl   cf77 : Cray / Unicos
dnl    g77 : GNU Fortran (someday...)
dnl     fc : Convex
dnl
dnl I don't think the Cray compiler will ever work like f2c...
dnl
if $use_f2c; then
  true
else
  F77=
  AC_CHECK_PROGS(F77, xlf cf77 f77 g77 fc)dnl

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

  if test -n "$F77"; then
    AC_MSG_CHECKING([$F77/f2c compatibility])
    export F77
    export CC
    tmpdef=`sh $srcdir/f2c-compat.sh $srcdir/flibs.sh`
    status=$?
    if test $status -eq 0; then
      AC_MSG_RESULT([yes])
      if test "$tmpdef" = '-DF77_APPEND_UNDERSCORE=1'; then
        AC_DEFINE(F77_APPEND_UNDERSCORE, 1)dnl
      fi
    else
      AC_MSG_RESULT([no])
      F77=
    fi
  fi
fi
dnl
dnl If we can't find a Fortran compiler, or if it looks like it isn't
dnl compatible with f2c, try to find f2c.
dnl
if test -z "$F77"; then
  AC_CHECK_PROG(F2C, f2c, f2c, [])dnl
fi
dnl
F2CFLAGS=
FFLAGS="-O"
AC_MSG_RESULT([defining FFLAGS to be $FFLAGS])
if test -n "$F77"; then
  export F77
  FLIBS=`sh $srcdir/flibs.sh`
  AC_MSG_RESULT([defining FLIBS to be $FLIBS])
  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
  AC_CHECK_LIB(f2c, main, FLIBS=-lf2c, [])dnl
  if test -z "$FLIBS" ; then
    AC_CHECK_LIB(F77, main, FLIBS=-lF77, [])dnl
    if test -n "$FLIBS" ; then
      AC_CHECK_LIB(I77, main, FLIBS="$FLIBS -lI77", [])dnl
    fi
  fi
  if test -z "$FLIBS" ; then
    AC_MSG_WARN([I found f2c but not libf2c.a, or libF77.a and libI77.a])
  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)'
  AC_MSG_RESULT([defining DEFAULT_DOT_C_FROM_DOT_F to be $DEFAULT_DOT_C_FROM_DOT_F])
  DEFAULT_DOT_O_FROM_DOT_F='\%.o : \%.f'
  AC_MSG_RESULT([defining DEFAULT_DOT_O_FROM_DOT_F to be $DEFAULT_DOT_O_FROM_DOT_F])
  AC_DEFINE(F77_APPEND_UNDERSCORE, 1)dnl
else
  AC_MSG_WARN([in order to build octave, you must have a compatible])
  AC_MSG_WARN([Fortran compiler or f2c installed and in your path.])
  AC_MSG_WARN([See the file INSTALL for more information.])
  AC_MSG_WARN([Continuing anyway...])
fi
dnl
AC_SUBST(F77)dnl
AC_SUBST(FFLAGS)dnl
AC_SUBST(FLIBS)dnl
AC_SUBST(F2C)dnl
AC_SUBST(F2CFLAGS)dnl
AC_SUBST(DEFAULT_DOT_C_FROM_DOT_F)dnl
AC_SUBST(DEFAULT_DOT_O_FROM_DOT_F)dnl
dnl
dnl Extract libraries and directories from FLIBS and CXXLIBS.
dnl
dnl Leave only libraries, with -lfoo converted to libfoo.a:
dnl
changequote(,)dnl
FLIB_LIST=`echo " $FLIBS " | sed -e 's/ -Xlinker *[^ ]*/ /g' \
	-e 's/ -L *[^ ]*/ /g' \
	-e 's/ -l *\([^ ]*\)/ lib\1.a/g' -e 's/ -u *[^ ]*/ /g' \
	-e 's/^ *//' -e 's/ *$//' -e 's/  */:/g'`
dnl
CXXLIB_LIST=`echo " $CXXLIBS " | sed -e 's/ -Xlinker *[^ ]*/ /g' \
	-e 's/ -L *[^ ]*/ /g' \
	-e 's/ -l *\([^ ]*\)/ lib\1.a/g' -e 's/ -u *[^ ]*/ /g' \
	-e 's/^ *//' -e 's/ *$//' -e 's/  */:/g'`
dnl
dnl Leave only directories where libraries might be found:
dnl
FLIB_PATH=`echo " $FLIBS " | sed \
	-e 's/ /  /g' -e 's/ -Xlinker *[^ ]*/ /g' \
	-e 's/ -L *\([^ ]*\)/ \1/g' -e 's, /[^ ]*\.a , ,g' \
	-e 's/ -l *[^ ]*/ /g' -e 's/ -u *[^ ]*/ /g' -e 's/^ *//' \
	-e 's/ *$//' -e 's/  */:/g'`
dnl
CXXLIB_PATH=`echo " $CXXLIBS " | sed -e 's/ -Xlinker *[^ ]*/ /g' \
	-e 's/ -L *\([^ ]*\)/ \1/g' -e 's, /[^ ]*\.a , ,g' \
	-e 's/ /  /g' -e 's/ -Xlinker *[^ ]*/ /g' \
	-e 's/ -l *[^ ]*/ /g' -e 's/ -u *[^ ]*/ /g' -e 's/^ *//' \
	-e 's/ *$//' -e 's/  */:/g'`
changequote([,])dnl
dnl
AC_MSG_RESULT([defining FLIB_LIST to be $FLIB_LIST])
AC_MSG_RESULT([defining FLIB_PATH to be $FLIB_PATH])
dnl
AC_MSG_RESULT([defining CXXLIB_LIST to be $CXXLIB_LIST])
AC_MSG_RESULT([defining CXXLIB_PATH to be $CXXLIB_PATH])
dnl
AC_SUBST(FLIB_LIST)dnl
AC_SUBST(FLIB_PATH)dnl
dnl
AC_SUBST(CXXLIB_LIST)dnl
AC_SUBST(CXXLIB_PATH)dnl
dnl
dnl Checks for header files.
dnl
AC_HEADER_STDC
AC_CHECK_HEADERS(assert.h float.h limits.h memory.h pwd.h stdlib.h)dnl
AC_CHECK_HEADERS(string.h varargs.h unistd.h floatingpoint.h)dnl
AC_CHECK_HEADERS(sys/utsname.h sys/time.h sys/fcntl.h)dnl
AC_CHECK_HEADERS(sys/ttold.h sys/ptem.h sys/select.h)dnl
AC_HEADER_DIRENT
AC_TIME_WITH_SYS_TIME
dnl
dnl Use sgtty on Ultrix so that using DEC Migrate to convert a Mips
dnl binary to an Alpha binary will work.  Also on Alpha/OSF to avoid
dnl a readline bug.
dnl
OCTAVE_HAVE_TERM_HEADER=false
case "$canonical_host_type" in
  mips-dec-ultrix* | alpha-dec-osf*)
    AC_CHECK_HEADER(sgtty.h, [AC_DEFINE(HAVE_SGTTY_H, 1)
      OCTAVE_HAVE_TERM_HEADER=true], [])
  ;;
esac
dnl
if $OCTAVE_HAVE_TERM_HEADER; then
  true
else
  AC_CHECK_HEADER(termios.h, [AC_DEFINE(HAVE_TERMIOS_H, 1)
    OCTAVE_HAVE_TERM_HEADER=true],
    AC_CHECK_HEADER(termio.h, [AC_DEFINE(HAVE_TERMIO_H, 1)
      OCTAVE_HAVE_TERM_HEADER=true],
      AC_CHECK_HEADER(sgtty.h, [AC_DEFINE(HAVE_SGTTY_H, 1)
	OCTAVE_HAVE_TERM_HEADER=true], [])))
fi
if $OCTAVE_HAVE_TERM_HEADER; then
  true
else
  AC_MSG_ERROR([I couldn't find termios.h, termio.h, or sgtty.h!])
fi
dnl
dnl Checks for functions.
dnl
AC_CHECK_FUNCS(setvbuf getcwd gethostname bzero rindex vfprintf vsprintf)dnl
AC_CHECK_FUNCS(stricmp strnicmp strcasecmp strncasecmp strerror)dnl
AC_CHECK_FUNCS(atexit on_exit tempnam memmove putenv gettimeofday)dnl
dnl
dnl Would like to get rid of this cruft, and just have
dnl
dnl   AC_CHECK_FUNCS(finite isnan isinf)
dnl
dnl instead, but that used to fail on some systems...
dnl
dnl Check to see if we have IEEE math functions, and if so, which ones.
dnl
dnl For Linux: add -mieee-fp flag to CFLAGS when checking for IEEE FP
dnl functions, otherwise we may not find them.
dnl
dnl Also just using AC_CHECK_FUNCS doesn't seem to work to find isinf
dnl and isnan on Linux systems, so we use AC_CHECK_FUNC, and if that
dnl fails, we try again by including math.h and invoking the function
dnl with an argument. 
dnl
dnl Also check for some additional trig functions that aren't ANSI but
dnl are often available.  If they are missing, we try to replace them
dnl with functions from the BSD/NET2 math library.
dnl
AC_CHECK_LIB(sunmath, main)dnl
AC_CHECK_LIB(m, main)dnl
dnl
XCFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $GCC_IEEE_FP_FLAG"
dnl
AC_CHECK_FUNCS(finite isnan isinf infinity quiet_nan erf erfc lgamma)dnl
dnl
AC_MSG_CHECKING([for signgam declaration in math.h])
AC_TRY_LINK([#include <math.h>],
  [int foo = signgam + 1;],
  AC_MSG_RESULT(yes)
  AC_DEFINE(SIGNGAM_DECLARED, 1),
  AC_MSG_RESULT(no))dnl
dnl
CFLAGS="$XCFLAGS"
dnl
dnl Check for nonstandard but common trig functions that we need.
dnl If they are missing, we replace them using functions from the BSD
dnl math library, and we may need to replace some other functions too.
dnl
AC_REPLACE_FUNCS(acosh asinh atanh)
dnl
if test -n "$LIBOBJS"; then
  for func in $LIBOBJS
  do
    case "$func" in
      *acosh.o*)
	AC_DEFINE(ACOSH_MISSING, 1)dnl
      ;;
      *asinh.o*)
	AC_DEFINE(ASINH_MISSING, 1)dnl
      ;;
      *atanh.o*)
	AC_DEFINE(ATANH_MISSING, 1)dnl
      ;;
    esac
  done
  case $LIBOBJS in
    *acosh.o* | *asinh.o*)
      AC_REPLACE_FUNCS(copysign)
    ;;
  esac
  case $LIBOBJS in
    *acosh.o* | *asinh.o* | *atanh.o*)
      AC_REPLACE_FUNCS(log1p)
    ;;
  esac
  case $LIBOBJS in
    *log1p*)
      AC_REPLACE_FUNCS(log__L)
    ;;
  esac
  case $LIBOBJS in
    *log1p*)
      AC_REPLACE_FUNCS(finite)
    ;;
  esac
  case $LIBOBJS in
    *copysign* | *finite* | *log1p*)
      AC_REPLACE_FUNCS(logb scalb)
    ;;
  esac
fi
dnl
dnl Checks for OS specific cruft.
dnl
AC_STRUCT_TM
AC_FUNC_SETVBUF_REVERSED
TERMLIBS=""
for termlib in termcap terminfo curses termlib ; do
  AC_CHECK_LIB(${termlib}, main, [TERMLIBS="${TERMLIBS} -l${termlib}"])
  case "${TERMLIBS}" in
    *-l${termlib}*)
      AC_MSG_RESULT([defining TERMLIBS to be $TERMLIBS])
      break
    ;;
  esac
done
dnl
AC_MSG_CHECKING([for struct exception in math.h])
AC_TRY_LINK([#include <math.h>],
  [struct exception *x; x->type; x->name;],
  AC_MSG_RESULT(yes)
  AC_DEFINE(EXCEPTION_IN_MATH, 1),
  AC_MSG_RESULT(no))dnl
dnl
AC_SUBST(TERMLIBS)
dnl
dnl Signal stuff.
dnl
AC_TYPE_SIGNAL
AC_SYS_SIGLIST_DECLARED
dnl
dnl Define VOID_SIGHANDLER for readline.
dnl
case "$RETSIGTYPE" in
  int)
  ;;
  *)
    VOID_SIGHANDLER="-DVOID_SIGHANDLER=1"
    AC_MSG_RESULT([defining VOID_SIGHANDLER to be 1])
  ;;
esac
AC_SUBST(VOID_SIGHANDLER)dnl
dnl
dnl Checks for other programs used for building, testing, installing,
dnl and running Octave.
dnl
dnl For now, don't define LEXLIB to be -lfl -- we don't use anything in
dnl it, and it might not be installed.
dnl
dnl Also make sure that we generate an interactive scanner if we are
dnl using flex.
dnl
AC_PROG_LEX
case "$LEX" in
  flex*)
    LFLAGS="-t -I"
    AC_MSG_RESULT([defining LFLAGS to be $LFLAGS])
    LEXLIB=
  ;;
  *)
    LFLAGS="-t"
    AC_MSG_RESULT([defining LFLAGS to be $LFLAGS])
    AC_MSG_WARN([I didn't find flex, but that's only a problem])
    AC_MSG_WARN([if you need to reconstruct lex.cc])
  ;;
esac
AC_SUBST(LFLAGS)dnl
dnl
AC_PROG_YACC
case "$YACC" in
  bison*)
  ;;
  *)
    AC_MSG_WARN([I didn't find bison, but that's only a problem])
    AC_MSG_WARN([if you need to reconstruct parse.cc])
  ;;
esac
dnl
AC_PROG_RANLIB
dnl
AC_CHECK_PROG(RUNTEST, runtest, runtest, [])dnl
AC_CHECK_PROG(EXPECT, expect, expect, [])dnl
if test -z "$EXPECT" ; then
  RUNTEST=
fi
AC_SUBST(RUNTEST)dnl
dnl
AC_PROG_INSTALL
dnl
AC_CHECK_PROG(GNUPLOT_BINARY, gnuplot, gnuplot, [])dnl
if test -z "$GNUPLOT_BINARY"; then
  AC_MSG_WARN([I didn't find gnuplot.  It isn't necessary to have gnuplot])
  AC_MSG_WARN([installed, but you won't be able to use any of Octave's])
  AC_MSG_WARN([plotting commands without it.])
  AC_MSG_WARN([])
  AC_MSG_WARN([If gnuplot is installed but it isn't in your path, you can])
  AC_MSG_WARN([tell Octave where to find it by typing the command])
  AC_MSG_WARN([])
  AC_MSG_WARN([gnuplot_binary = "/full/path/to/gnuplot/binary"])
  AC_MSG_WARN([])
  AC_MSG_WARN([at the Octave prompt.])
fi
dnl
AC_CHECK_PROGS(DEFAULT_PAGER, less more page pg, [])dnl
if test -z "$DEFAULT_PAGER"; then
  AC_MSG_WARN([I couldn't find `less', `more', `page', or `pg'])
elif test "$DEFAULT_PAGER" = less; then
  DEFAULT_PAGER="less -e"
  AC_MSG_RESULT([defining DEFAULT_PAGER to be $DEFAULT_PAGER])
fi
dnl
dnl Even though we include config.h in most files, some need to be
dnl compiled with the -D options on the compiler command line.  Use
dnl UGLY_DEFS for that.
dnl
AC_OUTPUT_MAKE_DEFS
UGLY_DEFS="$DEFS"
AC_MSG_RESULT([defining UGLY_DEFS to be $UGLY_DEFS])
AC_SUBST(UGLY_DEFS)dnl
dnl
dnl Maybe add -Wall to compiler flags now that we're done feature
dnl testing. 
dnl
dnl To get gcc and g++ to be really picky, try these adding these
dnl options to CFLAGS and CXXFLAGS along with -Wall:
dnl
dnl   -ansi
dnl   -pedantic
dnl   -Wwrite-strings
dnl   -Wid-clash-31
dnl   -Wpointer-arith
dnl   -Wcast-qual
dnl   -Wenum-clash
dnl   -Wcast-align
dnl   -Wtraditional
dnl   -Wstrict-prototypes
dnl   -Wmissing-prototypes
dnl   -Wnested-externs
dnl   -Woverloaded-virtual
dnl   -Winline
dnl   -felide-constructors
dnl   -fnonnull-objects
dnl
if $ADD_CXX_WALL; then
  CXXFLAGS="$CXXFLAGS -Wall"
  AC_MSG_RESULT([adding -Wall to CXXFLAGS])
fi
if $ADD_CC_WALL; then
  CFLAGS="$CFLAGS -Wall"
  AC_MSG_RESULT([adding -Wall to CFLAGS])
fi
dnl
dnl Do the substitutions in all the Makefiles.
dnl
define([tmpA], [Makefile octMakefile Makeconf])dnl
define([tmpB], [libcruft/Makefile libcruft/Makerules])dnl
define([tmpC], [liboctave/Makefile src/Makefile dld/Makefile])dnl
define([tmpD], [info/Makefile readline/Makefile readline/doc/Makefile])dnl
define([tmpE], [readline/examples/Makefile doc/Makefile])dnl
define([tmpF], [test/Makefile kpathsea/Makefile])dnl
define([srcdirs], [tmpA tmpB tmpC tmpD tmpE tmpF])dnl
dnl
define([tmpa], [libcruft/blas/Makefile libcruft/balgen/Makefile])dnl
define([tmpb], [libcruft/dassl/Makefile libcruft/eispack/Makefile])dnl
define([tmpc], [libcruft/fftpack/Makefile libcruft/fsqp/Makefile])dnl
define([tmpd], [libcruft/lapack/Makefile libcruft/linpack/Makefile])dnl
define([tmpe], [libcruft/minpack/Makefile libcruft/misc/Makefile])dnl
define([tmpf], [libcruft/npsol/Makefile libcruft/odepack/Makefile])dnl
define([tmpg], [libcruft/qpsol/Makefile libcruft/quadpack/Makefile])dnl
define([tmph], [libcruft/ranlib/Makefile libcruft/villad/Makefile])dnl 
dnl
define([cruftdirs], [tmpa tmpb tmpc tmpd tmpe tmpf tmpg tmph])dnl
define([tmpSA], [scripts/Makefile scripts/control/Makefile])dnl
define([tmpSB], [scripts/general/Makefile scripts/image/Makefile])dnl
define([tmpSC], [scripts/linear-algebra/Makefile])dnl
define([tmpSD], [scripts/miscellaneous/Makefile scripts/plot/Makefile])dnl
define([tmpSE], [scripts/polynomial/Makefile scripts/set/Makefile])dnl
define([tmpSF], [scripts/signal/Makefile scripts/special-matrix/Makefile])dnl
define([tmpSG], [scripts/startup/Makefile scripts/statistics/Makefile])dnl
define([tmpSH], [scripts/elfun/Makefile scripts/specfun/Makefile])dnl
define([scriptdirs], [tmpSA tmpSB tmpSC tmpSD tmpSE tmpSF tmpSG tmpSH])dnl
dnl
AC_OUTPUT([srcdirs cruftdirs scriptdirs])dnl
