dnl configure.in
dnl
dnl Process this file with autoconf to produce a configure script.
dnl
dnl Copyright (C) 1996, 1997 John W. Eaton
### 
### This file is part of Octave.
### 
### Octave 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.
### 
### Octave 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 Octave; see the file COPYING.  If not, write to the Free
### Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
### 02110-1301, USA. 

### Preserve CFLAGS and CXXFLAGS from the environment before doing
### anything else because we don't know which macros might call
### AC_PROG_CC or AC_PROG_CXX.

EXTERN_CFLAGS="$CFLAGS"
EXTERN_CXXFLAGS="$CXXFLAGS"

AC_INIT
AC_REVISION($Revision: 1.519 $)
AC_PREREQ(2.57)
AC_CONFIG_SRCDIR([src/octave.cc])
AC_CONFIG_HEADER(config.h)

OCTAVE_HOST_TYPE

AC_DEFINE(OCTAVE_SOURCE, 1, [Define if this is Octave.])
  
AC_GNU_SOURCE

AC_AIX
AC_MINIX
AC_ISC_POSIX

### Path separator.
sepchar=:
AC_ARG_WITH(sepchar,
  [AS_HELP_STRING([--with-sepchar=<char>],
     [use <char> as the path separation character])])
case $with_sepchar in
  yes | "")
    case "$canonical_host_type" in
      *-*-mingw*)
	sepchar=';'
        ;;
      esac
    ;;
  no)
    AC_MSG_ERROR([You are required to define a path separation character])
    ;;
  *)
    sepchar=$with_sepchar
    ;;
esac
AC_SUBST(sepchar)
AC_DEFINE_UNQUOTED(SEPCHAR, ['$sepchar'], [Define this to be the path separator for your system, as a character constant.])
AC_DEFINE_UNQUOTED(SEPCHAR_STR, ["$sepchar"], [Define this to the path separator, as a string.])

### some defaults

OCTAVE_SET_DEFAULT(man1dir, '$(mandir)/man1')
OCTAVE_SET_DEFAULT(man1ext, '.1')
OCTAVE_SET_DEFAULT(infofile, '$(infodir)/octave.info')
OCTAVE_SET_DEFAULT(octincludedir, '$(includedir)/octave-$(version)')
OCTAVE_SET_DEFAULT(fcnfiledir, '$(datadir)/octave/$(version)/m')
OCTAVE_SET_DEFAULT(localfcnfiledir, '$(datadir)/octave/site/m')
OCTAVE_SET_DEFAULT(localapifcnfiledir,
  '$(datadir)/octave/site/$(api_version)/m')
OCTAVE_SET_DEFAULT(localverfcnfiledir, '$(datadir)/octave/$(version)/site/m')
OCTAVE_SET_DEFAULT(octlibdir, '$(libdir)/octave-$(version)')
OCTAVE_SET_DEFAULT(archlibdir,
  '$(libexecdir)/octave/$(version)/exec/$(canonical_host_type)')
OCTAVE_SET_DEFAULT(localarchlibdir,
  '$(libexecdir)/octave/site/exec/$(canonical_host_type)')
OCTAVE_SET_DEFAULT(localapiarchlibdir,
  '$(libexecdir)/octave/$(api_version)/site/exec/$(canonical_host_type)')
OCTAVE_SET_DEFAULT(localverarchlibdir,
  '$(libexecdir)/octave/$(version)/site/exec/$(canonical_host_type)')
OCTAVE_SET_DEFAULT(octfiledir,
  '$(libexecdir)/octave/$(version)/oct/$(canonical_host_type)')
OCTAVE_SET_DEFAULT(localoctfiledir,
  '$(libexecdir)/octave/site/oct/$(canonical_host_type)')
OCTAVE_SET_DEFAULT(localapioctfiledir,
  '$(libexecdir)/octave/site/oct/$(api_version)/$(canonical_host_type)')
OCTAVE_SET_DEFAULT(localveroctfiledir,
  '$(libexecdir)/octave/$(version)/site/oct/$(canonical_host_type)')
OCTAVE_SET_DEFAULT(imagedir, '$(datadir)/octave/$(version)/imagelib')

### Make configure args available for other uses.

config_opts=$ac_configure_args
AC_SUBST(config_opts)

### Allow the user to force us to use f2c.

AC_ARG_WITH(f2c,
  [AS_HELP_STRING([--with-f2c],
     [use f2c even if Fortran compiler is available])],
  [if test "$withval" = no; then use_f2c=false; else use_f2c=true; fi],
  use_f2c=false)

### Allow the user to force us to use f77.

AC_ARG_WITH(f77,
  [AS_HELP_STRING([--with-f77], [use f77 to compile Fortran subroutines])],
  [if test "$withval" = no; then use_f77=false; else use_f77=true; fi],
  use_f77=false)

### Make sure only one of the above options for Fortran compilers was
### specified (multiple "no" or --without-FOO options are ok).

OCTAVE_CHECK_EXCLUSIVE_WITH_OPTIONS(f77, f2c,
  [warn_f2c_and_f77="--with-f2c and --with-f77 both specified!  Using f77..."
  AC_MSG_WARN($warn_f2c_and_f77)
  use_f2c=false])

### Make it possible to have Octave's array and matrix classes do bounds
### checking on element references.  This slows some operations down a
### bit, so it is turned off by default.

BOUNDS_CHECKING=false
AC_ARG_ENABLE(bounds-check,
  [AS_HELP_STRING([--enable-bounds-check],
     [for internal array classes (default is no)])],
  [if test "$enableval" = yes; then BOUNDS_CHECKING=true; fi], [])
if $BOUNDS_CHECKING; then
  AC_DEFINE(BOUNDS_CHECKING, 1, [Define to use internal bounds checking.])
fi

### If possible, use a 64-bit integer type for array dimensions and indexing.

USE_64_BIT_IDX_T=false
OCTAVE_IDX_TYPE=int
AC_ARG_ENABLE(64,
  [AS_HELP_STRING([--enable-64],
     [(EXPERIMENTAL) use 64-bit integers for array dimensions and indexing])],
  [if test "$enableval" = yes; then USE_64_BIT_IDX_T=true; fi], [])
if $USE_64_BIT_IDX_T; then
  AC_CHECK_SIZEOF(void *)
  AC_CHECK_SIZEOF(int)
  AC_CHECK_SIZEOF(long)
  if test $ac_cv_sizeof_void_p -eq 8; then
    if test $ac_cv_sizeof_int -eq 8; then
      OCTAVE_IDX_TYPE=int
    elif test $ac_cv_sizeof_long -eq 8; then
      OCTAVE_IDX_TYPE=long
      AC_DEFINE(IDX_TYPE_LONG, 1, [Define to 1 if octave index type is long])
    else
      warn_64_bit="no suitable type found for octave_idx_type so disabling 64-bit features"
      AC_MSG_WARN($warn_64_bit)
      USE_64_BIT_IDX_T=false
    fi
  else
    warn_64_bit="pointers are not 64-bits wide so disabling 64-bit features"
    AC_MSG_WARN($warn_64_bit)
    USE_64_BIT_IDX_T=false
  fi
fi
AC_SUBST(OCTAVE_IDX_TYPE)
if $USE_64_BIT_IDX_T; then
  AC_DEFINE(USE_64_BIT_IDX_T, 1, [Define if using 64-bit integers for array dimensions and indexing])
fi
AC_SUBST(USE_64_BIT_IDX_T)

### It seems that there are some broken inline assembly functions in
### the GNU libc.  Since I'm not sure how to test whether we are using
### GNU libc, just disable them for all platforms.

AC_MSG_NOTICE([defining __NO_MATH_INLINES avoids buggy GNU libc exp function])
AC_DEFINE(__NO_MATH_INLINES, 1, [Define if your version of GNU libc has buggy inline assembly code for math functions like exp.])

### See which C++ compiler to use (we expect to find g++).

AC_PROG_CXX
AC_PROG_CXXCPP

### Do special things for g++.

gxx_version=`$CXX -v 2>&1 | grep "^.*g.. version" | \
  sed -e 's/^.*g.. version *//' -e 's/cygnus-//' -e 's/egcs-//' -e 's/ .*//'`

case "$gxx_version" in
  1.* | 2.[[012345678]].*)
    AC_MSG_ERROR([g++ version $gxx_version will probably fail to compile Octave]
)
  ;;
  2.9*)
    warn_gxx_version="g++ version $gxx_version is likely to cause problems"
    AC_MSG_WARN($warn_gxx_version)
  ;;
esac

CXX_VERSION=
if test -n "$gxx_version"; then
  CXX_VERSION="$gxx_version"
fi
AC_SUBST(CXX_VERSION)

OCTAVE_CXX_NEW_FRIEND_TEMPLATE_DECL
OCTAVE_CXX_ISO_COMPLIANT_LIBRARY
OCTAVE_CXX_BROKEN_REINTERPRET_CAST

# Determine the ABI used the C++ compiler, needed by the dynamic loading
# code. Currently supported ABIs are GNU v2, GNU v3 and Sun Workshop.

OCTAVE_CXX_ABI

### See which C compiler to use (we expect to find gcc).

AC_PROG_CC
AC_PROG_CPP
AC_PROG_GCC_TRADITIONAL

### Do special things for gcc.

gcc_version=`$CC -v 2>&1 | grep "^.*gcc version" | \
  sed -e 's/^.*g.. version *//' -e 's/cygnus-//' -e 's/egcs-//'`
case "$gcc_version" in
  2.*)
    if test -z "$LDFLAGS"; then
      LDFLAGS="-g"
      AC_MSG_NOTICE([defining LDFLAGS to be $LDFLAGS])
    fi
  ;;
  1.*)
    warn_gcc_version="gcc version $gcc_version is likely to cause problems"
    AC_MSG_WARN($warn_gcc_version)
  ;;
esac

CC_VERSION=
if test -n "$gcc_version"; then
  CC_VERSION="$gcc_version"
fi
AC_SUBST(CC_VERSION)

### The flag to create dependency varies depending on the compier.

# Assume GCC.
DEPEND_FLAGS="-M"
DEPEND_EXTRA_SED_PATTERN=""
case "$canonical_host_type" in
  sparc-sun-solaris2* | i386-pc-solaris2*)
    if test "$GCC" = yes; then
      true
    else
      DEPEND_FLAGS="-xM1"
      DEPEND_EXTRA_SED_PATTERN="-e '/\/opt\/SUNWspro/d'"
    fi
  ;;
esac
AC_SUBST(DEPEND_FLAGS)
AC_SUBST(DEPEND_EXTRA_SED_PATTERN)

### On Intel systems with gcc, we may need to compile with -mieee-fp
### and -ffloat-store to get full support for IEEE floating point.
###
### On Alpha/OSF systems, we need -mieee.

ieee_fp_flag=
case "$canonical_host_type" in
  i[[3456789]]86-*-*)
    if test "$GCC" = yes; then
      OCTAVE_CC_FLAG(-mieee-fp, [
        ieee_fp_flag=-mieee-fp
        XTRA_CFLAGS="$XTRA_CFLAGS -mieee-fp"
        AC_MSG_NOTICE([adding -mieee-fp to XTRA_CFLAGS])])

###      OCTAVE_CC_FLAG(-ffloat-store, [
###        float_store_flag=-ffloat-store
###        XTRA_CFLAGS="$XTRA_CFLAGS -ffloat-store"
###        AC_MSG_RESULT([adding -ffloat-store to XTRA_CFLAGS])])
    fi
    if test "$GXX" = yes; then
      OCTAVE_CXX_FLAG(-mieee-fp, [
	ieee_fp_flag=-mieee-fp
	XTRA_CXXFLAGS="$XTRA_CXXFLAGS -mieee-fp"
	AC_MSG_NOTICE([adding -mieee-fp to XTRA_CXXFLAGS])])

###      OCTAVE_CXX_FLAG(-ffloat-store, [
###        float_store_flag=-ffloat-store
###        XTRA_CXXFLAGS="$XTRA_CXXFLAGS -ffloat-store"
###        AC_MSG_RESULT([adding -ffloat-store to XTRA_CXXFLAGS])])
    fi
  ;;
  alpha*-*-*)
    if test "$GCC" = yes; then
      OCTAVE_CC_FLAG(-mieee, [
	ieee_fp_flag=-mieee
	XTRA_CFLAGS="$XTRA_CFLAGS -mieee"
	AC_MSG_NOTICE([adding -mieee to XTRA_CFLAGS])])
    else
      OCTAVE_CC_FLAG(-ieee, [
	ieee_fp_flag=-ieee
	XTRA_CFLAGS="$XTRA_CFLAGS -ieee"
	AC_MSG_NOTICE([adding -ieee to XTRA_CFLAGS])])
    fi
    if test "$GXX" = yes; then
      OCTAVE_CXX_FLAG(-mieee, [
	ieee_fp_flag=-mieee
	XTRA_CXXFLAGS="$XTRA_CXXFLAGS -mieee"
	AC_MSG_NOTICE([adding -mieee to XTRA_CXXFLAGS])])
    else
      OCTAVE_CXX_FLAG(-ieee, [
	ieee_fp_flag=-ieee
	XTRA_CXXFLAGS="$XTRA_CXXFLAGS -ieee"
	AC_MSG_NOTICE([adding -ieee to XTRA_CXXFLAGS])])
    fi
  ;;
  *ibm-aix4*)
    OCTAVE_CC_FLAG(-mminimal-toc, [
      XTRA_CFLAGS="$XTRA_CFLAGS -mminimal-toc"])

    OCTAVE_CXX_FLAG(-mminimal-toc, [
      XTRA_CXXFLAGS="$XTRA_CXXFLAGS -mminimal-toc"])
  ;;
esac

AC_SUBST(XTRA_CFLAGS)
AC_SUBST(XTRA_CXXFLAGS)

### Use -static if compiling on Alpha OSF/1 1.3 systems.

case "$canonical_host_type" in
  alpha*-dec-osf1.3)
    LD_STATIC_FLAG=-static
  ;;
esac
if test -n "$LD_STATIC_FLAG"; then
  AC_MSG_NOTICE([defining LD_STATIC_FLAG to be $LD_STATIC_FLAG])
fi
AC_SUBST(LD_STATIC_FLAG)

OCTAVE_CXX_PREPENDS_UNDERSCORE

### Defaults for cross compiling.  BUILD_CC and BUILD_CXX are
### the compilers that we use for building tools on the build system.
### For now, we assume that the only cross compiling we can do is
### with gcc on a Unixy system, but the dedicated hacker can override these.

if test "$cross_compiling" = yes; then
  BUILD_CC="gcc"
  BUILD_CFLAGS="-O2 -g"
  BUILD_CXX="g++"
  BUILD_CXXFLAGS="-O2 -g"
  BUILD_LDFLAGS=""
  BUILD_EXEEXT=""
else
  BUILD_CC='$(CC)'
  BUILD_CFLAGS='$(CFLAGS)'
  BUILD_CXX='$(CXX)'
  BUILD_CXXFLAGS='$(CXXFLAGS)'
  BUILD_LDFLAGS='$(LDFLAGS)'
  case "$canonical_host_type" in
    sparc-sun-solaris2*)
      if test "$GCC" != yes; then
        ## The Sun C++ compiler never seems to complete compiling
	## gendoc.cc unless we reduce the optimization level...
	BUILD_CXXFLAGS="-g -O1"
      fi
    ;;
  esac
  BUILD_EXEEXT='$(EXEEXT)'
fi

AC_ARG_VAR(BUILD_CC, [build system C compiler (used if cross compiling)])
AC_ARG_VAR(BUILD_CFLAGS, [build system C compiler flags (used if cross compiling)])
AC_ARG_VAR(BUILD_CXX, [build system C++ compiler (used if cross compiling)])
AC_ARG_VAR(BUILD_CXXFLAGS, [build system C++ compiler flags (used if cross compiling)])
AC_ARG_VAR(BUILD_LDFLAGS, [build system C++ compiler link flags (used if cross compiling)])
AC_ARG_VAR(BUILD_EXEEXT, [build system executable extension (used if cross compiling)])

dnl This is bogus.  We shouldn't have to explicitly add libc too!

### Look for math library.  If found, this will add -lm to LIBS.

case "$canonical_host_type" in
  *-*-nextstep*)
  ;;  
  *-*-linux*)
    AC_CHECK_LIB(m, sin, , , -lc)
  ;;
  *)
    AC_CHECK_LIB(m, sin)
  ;;
esac

### Check for pcre/regex library.
AC_SUBST(REGEX_LIBS)
WITH_PCRE_CONFIG=no
AC_CHECK_HEADER(pcre.h, WITH_PCRE=yes, WITH_PCRE=no)
if test $WITH_PCRE = no ; then
  AC_CHECK_PROG(WITH_PCRE_CONFIG, pcre-config, yes, no)
  if test $WITH_PCRE_CONFIG = yes ; then
    WITH_PCRE=yes
  fi
fi
if test $WITH_PCRE = yes ; then
  AC_CHECK_LIB(pcre, pcre_compile, WITH_PCRE=yes, WITH_PCRE=no)
  if test $WITH_PCRE = yes ; then
    AC_DEFINE(HAVE_PCRE, 1, [Define if PCRE is available.])
    if test $WITH_PCRE_CONFIG = yes ; then
      REGEX_LIBS=`pcre-config --cflags --libs`
    else
      REGEX_LIBS="-lpcre"
    fi
  fi
fi
AC_CHECK_FUNCS(regexec, WITH_REGEX=yes , [
  AC_CHECK_LIB(regex, regexec, WITH_REGEX=yes, WITH_REGEX=no)])
if test $WITH_REGEX = yes ; then
  AC_DEFINE(HAVE_REGEX, 1, [Define if regex is available.])
  if test $WITH_PCRE = no ; then
    AC_CHECK_FUNCS(regexec, REGEX_LIBS= , [
      AC_CHECK_LIB(regex, regexec, REGEX_LIBS="-lregex")])
  fi
fi

### Check for ZLIB library.

WITH_ZLIB=true
AC_ARG_WITH(zlib,
  [AS_HELP_STRING([--without-zlib], [don't use zlib])],
  with_zlib=$withval, with_zlib=yes)

zlib_lib=
if test "$with_zlib" = yes; then
  zlib_lib="z"
elif test "$with_zlib" != no; then
  zlib_lib="$with_zlib"
fi

ZLIB_LIBS=
WITH_ZLIB=false
if test -n "$zlib_lib"; then
  AC_CHECK_LIB($zlib_lib, gzclearerr, [
      AC_CHECK_HEADERS(zlib.h, [
	WITH_ZLIB=true
        ZLIB_LIBS="-l$zlib_lib"
        LIBS="$ZLIB_LIBS $LIBS"
        AC_DEFINE(HAVE_ZLIB, 1, [Define if ZLIB is available.])])])
fi

if $WITH_ZLIB; then
  ### Check for HDF5 library.

  WITH_HDF5=true
  AC_ARG_WITH(hdf5,
    [AS_HELP_STRING([--without-hdf5], [don't use HDF5])],
    with_hdf5=$withval, with_hdf5=yes)

  hdf5_lib=
  if test "$with_hdf5" = yes; then
    hdf5_lib="hdf5"
  elif test "$with_hdf5" != no; then
    hdf5_lib="$with_hdf5"
  fi

  HDF5_LIBS=
  WITH_HDF5=false
  if test -n "$hdf5_lib"; then
    AC_CHECK_LIB($hdf5_lib, H5Pcreate, [
      AC_CHECK_HEADERS(hdf5.h, [
        WITH_HDF5=true
        HDF5_LIBS="-l$hdf5_lib"
        LIBS="$HDF5_LIBS $LIBS"
        AC_DEFINE(HAVE_HDF5, 1, [Define if HDF5 is available.])
	AC_CHECK_LIB($hdf5_lib, H5Gget_num_objs, [
	  AC_DEFINE(HAVE_H5GGET_NUM_OBJS, 1, [Define if HDF5 has H5Gget_num_objs.])])])])
  fi

  if $WITH_HDF5; then
    true
  else
    warn_hdf5="HDF5 library not found.  Octave will not be able to save or load HDF5 data files."
  fi
else
  warn_zlib="ZLIB library not found.  Octave will not be able to save or load compressed data files or HDF5 files."
fi


# Checks for FFTW header and library.

# subdirectories of libcruft to build if they aren't found on the system:
FFT_DIR="fftpack"
AC_SUBST(FFT_DIR)

# Installed fftw library, if any.
FFTW_LIBS=''
AC_SUBST(FFTW_LIBS)

AC_ARG_WITH(fftw, 
  [AS_HELP_STRING([--without-fftw],
     [use included fftpack instead of installed fftw])],
  with_fftw=$withval, with_fftw=yes)

if test "$with_fftw" = yes; then
  have_fftw3_header=no
  with_fftw3=no
  AC_CHECK_HEADER(fftw3.h, [have_fftw3_header=yes; break])
  if test "$have_fftw3_header" = yes; then
    AC_CHECK_LIB(fftw3, fftw_plan_dft_1d, [FFTW_LIBS="-lfftw3"; with_fftw3=yes])
  fi
fi

if test "$with_fftw" = yes && test "$with_fftw3" = yes; then
  FFT_DIR=''
  AC_DEFINE(HAVE_FFTW3, 1, [Define if the FFTW3 library is used.])
fi

# Checks for GLPK header and library.

AC_ARG_WITH(glpk,
  [AS_HELP_STRING([--without-glpk], [don't use GLPK])],
  with_glpk=$withval, with_glpk=yes)

glpk_lib=
if test "$with_glpk" = yes; then
  glpk_lib="glpk"
elif test "$with_glpk" != no; then
  glpk_lib="$with_glpk"
fi

GLPK_LIBS=
if test -n "$glpk_lib"; then
  AC_CHECK_LIB($glpk_lib, glp_lpx_simplex, [
    AC_CHECK_HEADERS(glpk.h, [
      GLPK_LIBS="-l$glpk_lib"
      AC_DEFINE(HAVE_GLPK, 1, [Define if GLPK is available.])])])
fi
AC_SUBST(GLPK_LIBS)

OCTAVE_IEEE754_DATA_FORMAT

# ----------------------------------------------------------------------

### We need these before trying to find libf2c.

OCTAVE_PROG_AR

AC_PROG_RANLIB

### If we haven't been forced to use a particular Fortran compiler,
### try to find one using any one of several common Un*x Fortran
### compiler names using the AC_PROG_F77 macro.
###
### The configure options --with-f77 or --with-f2c
### force f77 or f2c to be used.  It is also possible to use
### these options to specify the name of the compiler.  For example,
### `--with-f77=g77' says that we are using g77 as the Fortran compiler.

if $use_f77; then
  if test "$with_f77" = yes; then
    F77=f77
  else
    F77="$with_f77"
  fi
  AC_MSG_NOTICE([defining F77 to be $F77])
elif $use_f2c; then
  F77=
  if test "$with_f2c" = yes; then
    F2C=f2c
  else
    F2C="$with_f2c"
  fi
  AC_MSG_NOTICE([defining F2C to be $F2C])
fi

if test "x$FFLAGS" = x; then
  FFLAGS="-O" # override -g -O default by AC_PROG_F77
fi

# the F77 variable, if set, overrides AC_PROG_F77 automatically
AC_PROG_F77

have_fortran_compiler=false
have_f2c=false

if $use_f2c; then
  have_f2c=true
else
  if test -n "$F77"; then
    AC_F77_LIBRARY_LDFLAGS
    AC_F77_DUMMY_MAIN
    AC_F77_WRAPPERS
    case "$canonical_host_type" in
      i[[3456789]]86-*-*)
        if test "$ac_cv_f77_compiler_gnu" = yes; then
	  OCTAVE_F77_FLAG(-mieee-fp)
###          OCTAVE_F77_FLAG(-ffloat-store)
	fi
      ;;
      alpha*-*-*)
        if test "$ac_cv_f77_compiler_gnu" = yes; then
	  OCTAVE_F77_FLAG(-mieee)
	else
	  OCTAVE_F77_FLAG(-ieee)
	  OCTAVE_F77_FLAG(-fpe1)
	fi
      ;;
      powerpc-apple-machten*)
	FFLAGS=
      ;;
    esac
    if test -n "$FFLAGS"; then
      AC_MSG_NOTICE([defining FFLAGS to be $FFLAGS])
    fi
    have_fortran_compiler=true
  else
    AC_CHECK_PROG(F2C, f2c, f2c, [])
    AC_ARG_VAR(F2C, [Fortran to C translator command])
    AC_ARG_VAR(F2CFLAGS, [Fortran to C translator flags])
    if test -n "$F2C"; then
      have_f2c=true
    fi
  fi
fi

f77_rules_frag=/dev/null
if $have_fortran_compiler; then
  f77_rules_frag=Makefrag.f77
  cat << \EOF > $f77_rules_frag

%.c : %.f

%.o : %.f
	$(FC) -c $(ALL_FFLAGS) -o $@ $<

pic/%.o : %.f
	$(FC) -c $(FPICFLAG) $(ALL_FFLAGS) $< -o $@

EOF
elif $have_f2c; then
  AC_DEFINE(HAVE_F2C, 1, [Define if we are using f2c.])

### FIXME -- these shouldn't be fixed names, eh?

  oct_conflib=libconflib.a
  oct_obj_ext=o

  CONFLIB_ARG=
  if AC_TRY_EVAL(ac_compile); then
    $AR $ARFLAGS $oct_conflib conftest.$oct_obj_ext 1>&AS_MESSAGE_LOG_FD()
    if test -n "$RANLIB"; then
      $RANLIB $oct_conflib 1>&AS_MESSAGE_LOG_FD()
    fi
    CONFLIB_ARG="-L. -lconflib"
  fi
  rm -f conftest*
  AC_CHECK_LIB(f2c, f_open, FLIBS=-lf2c, FLIBS=, $CONFLIB_ARG)
  rm -f $oct_conflib

  if test -z "$FLIBS"; then
    AC_CHECK_LIB(F77, d_sin, FLIBS=-lF77, FLIBS=)
    if test -n "$FLIBS"; then
      AC_CHECK_LIB(I77, f_rew, FLIBS="$FLIBS -lI77", FLIBS=, -lF77)
    fi
  fi

  if test -z "$FLIBS"; then
    warn_f2c_no_lib="I found f2c but not libf2c.a, or libF77.a and libI77.a"
    AC_MSG_WARN($warn_f2c_no_lib)
  fi
  f77_rules_frag=Makefrag.f77
  cat << \EOF > $f77_rules_frag

%.c : %.f
	$(F2C) $(F2CFLAGS) < $< > $(@F)

%.o : %.f

EOF
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_ERROR([See the file INSTALL for more information.])
fi

FC=$F77
AC_SUBST(FC)
AC_SUBST_FILE(f77_rules_frag)

OCTAVE_F77_FLAG(-ffloat-store, [
AC_MSG_RESULT([setting F77_FLOAT_STORE_FLAG to -ffloat-store])
F77_FLOAT_STORE_FLAG=-ffloat-store
AC_SUBST(F77_FLOAT_STORE_FLAG)
])

### Checks for BLAS and LAPACK libraries:
# (Build subdirectories of libcruft if they aren't found on the system.)

sinclude(acx_blas.m4)
sinclude(acx_lapack.m4)
ACX_BLAS([], [BLAS_DIR="blas"])
ACX_LAPACK([BLAS_LIBS="$LAPACK_LIBS $BLAS_LIBS"], [LAPACK_DIR="lapack"])
AC_SUBST(BLAS_DIR)
AC_SUBST(LAPACK_DIR)

# Check for AMD library
AMD_LIBS=
AC_SUBST(AMD_LIBS)
AC_CHECK_LIB(amd, amd_postorder, [AMD_LIBS="-lamd"; with_amd=yes],[with_amd=no])

# Check for UMFPACK library.

UMFPACK_LIBS=
AC_SUBST(UMFPACK_LIBS)

AC_ARG_WITH(umfpack,
  [AS_HELP_STRING([--without-umfpack],
     [don't use UMFPACK, disable some sparse functionality])],
  with_umfpack=$withval, with_umfpack=yes)

warn_umfpack="UMFPACK not found.  This will result in some lack of functionality for sparse matrices."
if test "$with_umfpack" = yes && test "$with_amd" = yes; then
  with_umfpack=no
  AC_CHECK_HEADERS([ufsparse/umfpack.h umfpack/umfpack.h umfpack.h], [
    AC_CHECK_LIB(umfpack, umfpack_zi_get_determinant, [
      UMFPACK_LIBS="-lumfpack"; with_umfpack=yes], [
        ## Invalidate the cache.
	$as_unset ac_cv_lib_umfpack_umfpack_zi_get_determinant
	AC_CHECK_LIB(umfpack, umfpack_zi_get_determinant, [
          UMFPACK_LIBS="-lumfpack"; with_umfpack=yes], [

	  ## Invalidate the cache.
	  $as_unset ac_cv_lib_umfpack_umfpack_zi_get_determinant
	  AC_CHECK_LIB(umfpack, umfpack_zi_get_determinant, [
            UMFPACK_LIBS="-lumfpack -lcblas"; with_umfpack=yes], [], $AMD_LIBS -lcblas $BLAS_LIBS)], $AMD_LIBS $BLAS_LIBS $FLIBS)], $AMD_LIBS)

    if test "$with_umfpack" = yes; then
      AC_DEFINE(HAVE_UMFPACK, 1, [Define if the UMFPACK library is used.])
      OLD_LIBS=$LIBS
      LIBS="$LIBS $UMFPACK_LIBS $AMD_LIBS $BLAS_LIBS $FLIBS"
      OCTAVE_UMFPACK_SEPERATE_SPLIT
      LIBS=$OLD_LIBS
      TEXINFO_UMFPACK="@set HAVE_UMFPACK"
      warn_umfpack=
    fi
    break])
fi

AC_SUBST(TEXINFO_UMFPACK)

COLAMD_LIBS=
AC_SUBST(COLAMD_LIBS)

AC_ARG_WITH(colamd,
  [AS_HELP_STRING([--without-colamd],
     [don't use COLAMD, disable some sparse functionality])],
  with_colamd=$withval, with_colamd=yes)

warn_colamd="COLAMD not found. This will result in some lack of functionality for sparse matrices."
if test "$with_colamd" = yes; then
  with_colamd=no
  AC_CHECK_HEADERS([ufsparse/colamd.h colamd/colamd.h colamd.h], [
    AC_CHECK_LIB(colamd, colamd, [COLAMD_LIBS="-lcolamd"; with_colamd=yes])
    if test "$with_colamd" = yes; then
      AC_DEFINE(HAVE_COLAMD, 1, [Define if the COLAMD library is used.])
      TEXINFO_COLAMD="@set HAVE_COLAMD"
      warn_colamd=
    fi
    break])
fi 

AC_SUBST(TEXINFO_COLAMD)

CCOLAMD_LIBS=
AC_SUBST(CCOLAMD_LIBS)

AC_ARG_WITH(ccolamd,
  [AS_HELP_STRING([--without-ccolamd],
     [don't use CCOLAMD, disable some sparse functionality])],
  with_ccolamd=$withval, with_ccolamd=yes)

warn_ccolamd="CCOLAMD not found. This will result in some lack of functionality for sparse matrices."
if test "$with_ccolamd" = yes; then
  with_ccolamd=no
  AC_CHECK_HEADERS([ufsparse/ccolamd.h ccolamd/ccolamd.h ccolamd.h], [
    AC_CHECK_LIB(ccolamd, ccolamd, [CCOLAMD_LIBS="-lccolamd"; with_ccolamd=yes])
    if test "$with_ccolamd" = yes; then
      AC_DEFINE(HAVE_CCOLAMD, 1, [Define if the CCOLAMD library is used.])
      warn_ccolamd=
    fi
    break])
fi 

CHOLMOD_LIBS=
AC_SUBST(CHOLMOD_LIBS)

AC_ARG_WITH(cholmod,
  [AS_HELP_STRING([--without-cholmod],
     [don't use CHOLMOD, disable some sparse functionality])],
  with_cholmod=$withval, with_cholmod=yes)

warn_cholmod="CHOLMOD not found. This will result in some lack of functionality for sparse matrices."
if test "$with_cholmod" = yes && test "$with_colamd" = yes &&
	test "$with_ccolamd" = yes && test "$with_amd" = yes; then
  with_cholmod=no
  AC_CHECK_HEADERS([ufsparse/cholmod.h cholmod/cholmod.h cholmod.h], [
    AC_CHECK_HEADERS([ufsparse/metis.h metis/metis.h metis.h], [
      AC_CHECK_LIB(metis, METIS_NodeND, with_metis=yes, with_metis=no)
      break],
      with_metis=no)

    if test "$with_metis" = yes; then
      AC_DEFINE(HAVE_METIS, 1, [Define if the METIS library is used.])
      AC_CHECK_LIB(cholmod, cholmod_start, [CHOLMOD_LIBS="-lcholmod -lmetis"; 
	with_cholmod=yes], [
        AC_CHECK_LIB(cholmod, cholmod_start, 
	  [CHOLMOD_LIBS="-lcholmod -cblas -lmetis"; with_cholmod=yes], [],
          $AMD_LIBS $COLAMD_LIBS $CCOLAMD_LIBS $BLAS_LIBS $FLIBS -lmetis)],
	$AMD_LIBS $COLAMD_LIBS $CCOLAMD_LIBS $BLAS_LIBS $FLIBS -lmetis)
    else
      AC_CHECK_LIB(cholmod, cholmod_start, [CHOLMOD_LIBS="-lcholmod"; 
	with_cholmod=yes], [
        AC_CHECK_LIB(cholmod, cholmod_start, [CHOLMOD_LIBS="-lcholmod -cblas"; 
	  with_cholmod=yes], [],
          $AMD_LIBS $COLAMD_LIBS $CCOLAMD_LIBS $BLAS_LIBS $FLIBS)],
	$AMD_LIBS $COLAMD_LIBS $CCOLAMD_LIBS $BLAS_LIBS $FLIBS)
    fi

    if test "$with_cholmod" = yes; then
      AC_DEFINE(HAVE_CHOLMOD, 1, [Define if the CHOLMOD library is used.])
      TEXINFO_CHOLMOD="@set HAVE_CHOLMOD"
      warn_cholmod=
    fi
    break])
fi 

AC_SUBST(TEXINFO_CHOLMOD)

CXSPARSE_LIBS=
AC_SUBST(CXSPARSE_LIBS)

AC_ARG_WITH(cxsparse,
  [AS_HELP_STRING([--without-cxsparse],
     [don't use CXSparse, disable some sparse functionality])],
  with_cxsparse=$withval, with_cxsparse=yes)

warn_cxsparse="CXSparse not found. This will result in some lack of functionality for sparse matrices."
if test "$with_cxsparse" = yes; then
  with_cxsparse=no
  AC_CHECK_HEADERS([ufsparse/cs.h cxsparse/cs.h cs.h], [
    AC_CHECK_LIB(cxsparse, cs_di_sqr, [CXSPARSE_LIBS="-lcxsparse"; with_cxsparse=yes])
    if test "$with_cxsparse" = yes; then
      AC_DEFINE(HAVE_CXSPARSE, 1, [Define if the CXSparse library is used.])
      warn_cxsparse=
    fi
    break])
fi

### Handle shared library options.

### Enable creation of static libraries.

AC_ARG_ENABLE(static,
  [AS_HELP_STRING([--enable-static], [create static libraries])],
  [if test "$enableval" = no; then STATIC_LIBS=false;
   else STATIC_LIBS=true; fi],
  STATIC_LIBS=false)
AC_SUBST(STATIC_LIBS)

### Enable creation of shared libraries.  Currently only works with
### gcc on some systems.

AC_ARG_ENABLE(shared,
  [AS_HELP_STRING([--enable-shared],
     [create shared libraries (not all systems)])],
  [if test "$enableval" = no; then SHARED_LIBS=false;
   else SHARED_LIBS=true; fi],
  SHARED_LIBS=true)
AC_SUBST(SHARED_LIBS)

### Enable dynamic linking.  --enable-shared implies this, so
### --enable-dl is only need if you are only building static libraries
### and want to try dynamic linking too (works on some systems, for
### example, OS X and Windows).

AC_ARG_ENABLE(dl,
  [AS_HELP_STRING([--enable-dl],
     [create shared libraries (not all systems)])],
  [if test "$enableval" = no; then ENABLE_DYNAMIC_LINKING=false;
   else ENABLE_DYNAMIC_LINKING=true; fi],
  ENABLE_DYNAMIC_LINKING=true)

if $STATIC_LIBS || $SHARED_LIBS; then
  true
else
  AC_MSG_ERROR([You can't disable building static AND shared libraries!])
fi

AC_ARG_ENABLE(rpath,
  [AS_HELP_STRING([--enable-rpath],
     [override the default link options for rpath; e.g., --enable-rpath='-rpath $(octlibdir)'])],
  [ if test "$enableval" = no; then use_rpath=false;
    else
      use_rpath=true
      if test "$enableval" = yes; then true;
      else enable_rpath_arg="$enableval"; fi
    fi], [use_rpath=true])

DLFCN_DIR=
CPICFLAG=-fPIC
CXXPICFLAG=-fPIC
FPICFLAG=-fPIC
SHLEXT=so
SHLLIB='$(SHLEXT)'
SHLBIN=
SHLEXT_VER='$(SHLEXT).$(version)'
SHLLIB_VER='$(SHLLIB).$(version)'
SHLBIN_VER='$(SHLBIN).$(version)'
SHLLINKEXT=
SH_LD='$(CXX)'
SH_LDFLAGS=-shared
DL_LD='$(SH_LD)'
DL_LDFLAGS='$(SH_LDFLAGS)'
MKOCTFILE_DL_LDFLAGS='$(DL_LDFLAGS)'
SONAME_FLAGS=
RLD_FLAG=
NO_OCT_FILE_STRIP=false
TEMPLATE_AR='$(AR)'
TEMPLATE_ARFLAGS="$ARFLAGS"
library_path_var=LD_LIBRARY_PATH
case "$canonical_host_type" in
  *-*-386bsd* | *-*-openbsd* | *-*-netbsd*)
    SH_LD=ld
    SH_LDFLAGS=-Bshareable
  ;;
  *-*-freebsd*)
    SH_LD='$(CC)'
    SH_LDFLAGS="-shared -Wl,-x"
    RLD_FLAG='-Wl,-rpath -Wl,$(octlibdir)'
  ;;
  alpha*-dec-osf*)
    CPICFLAG=
    CXXPICFLAG=
    FPICFLAG=
    SH_LDFLAGS="-shared -Wl,-expect_unresolved -Wl,'*'"
    RLD_FLAG='-Wl,-rpath -Wl,$(octlibdir)'
  ;;
  *-*-darwin*)
    DL_LDFLAGS='-bundle -bundle_loader $(TOPDIR)/src/octave $(LDFLAGS)'
    MKOCTFILE_DL_LDFLAGS='-bundle -bundle_loader $(bindir)/octave-$(version)$(EXEEXT)'
    SH_LDFLAGS='-dynamiclib -single_module $(LDFLAGS)'
    CXXPICFLAG=
    CPICFLAG=
    FPICFLAG=
    SHLEXT=dylib 
    SHLLIB='$(SHLEXT)'
    SHLEXT_VER='$(version).$(SHLEXT)'
    SHLLIB_VER='$(version).$(SHLLIB)'
    NO_OCT_FILE_STRIP=true
    SONAME_FLAGS='-install_name $(octlibdir)/$@'
    library_path_var=DYLD_LIBRARY_PATH	
  ;;
  *-*-cygwin* | *-*-mingw*)
    DL_LDFLAGS="-shared -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc"
    CXXPICFLAG=
    CPICFLAG=
    FPICFLAG=
    SHLEXT=dll
    SHLLIB=dll.a
    SHLBIN=dll
    SH_LDFLAGS="-shared -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--enable-auto-image-base"
    SHLLINKEXT=.dll
    SONAME_FLAGS='-Wl,--out-implib=$@.a'
    library_path_var=PATH
  ;;
  *-*-linux* | *-*-gnu*)
    MKOCTFILE_DL_LDFLAGS="-shared -Wl,-Bsymbolic"
    SONAME_FLAGS='-Wl,-soname -Wl,$@'
    RLD_FLAG='-Wl,-rpath -Wl,$(octlibdir)'
  ;;
  i[[3456]]86-*-sco3.2v5*)
    SONAME_FLAGS='-Wl,-h -Wl,$@'
    RLD_FLAG=
    SH_LDFLAGS=-G
  ;;
  rs6000-ibm-aix* | powerpc-ibm-aix*)
    CPICFLAG=
    CXXPICFLAG=
    FPICFLAG=
    DLFCN_DIR=dlfcn
  ;;
  hppa*-hp-hpux*)
    if test "$ac_cv_f77_compiler_gnu" = yes; then
      FPICFLAG=-fPIC
    else
      FPICFLAG=+Z
    fi
    SHLEXT=sl
    SH_LDFLAGS="-shared -fPIC"
    RLD_FLAG='-Wl,+b -Wl,$(octlibdir)'
  ;;
  *-sgi-*)
    CPICFLAG=
    CXXPICFLAG=
    FPICFLAG=
    RLD_FLAG='-rpath $(octlibdir)'
  ;;
  sparc-sun-sunos4*)
    if test "$ac_cv_f77_compiler_gnu" = yes; then
      FPICFLAG=-fPIC
    else
      FPICFLAG=-PIC
    fi
    SH_LD=ld
    SH_LDFLAGS="-assert nodefinitions"
    RLD_FLAG='-L$(octlibdir)'
  ;;
  sparc-sun-solaris2* | i386-pc-solaris2*)
    if test "$ac_cv_f77_compiler_gnu" = yes; then
      FPICFLAG=-fPIC
    else
      FPICFLAG=-KPIC
    fi
    if test "$GCC" = yes; then
      CPICFLAG=-fPIC
    else
      CPICFLAG=-KPIC
    fi
    if test "$GXX" = yes; then
      CXXPICFLAG=-fPIC
      SH_LDFLAGS=-shared
    else
      CXXPICFLAG=-KPIC
      SH_LDFLAGS=-G
    fi
    RLD_FLAG='-R $(octlibdir)'
    # Template closures in archive libraries need a different mechanism.
    if test "$GXX" = yes; then
      true
    else
      TEMPLATE_AR='$(CXX)'
      TEMPLATE_ARFLAGS="-xar -o"
    fi
  ;;
esac

if $use_rpath; then
  if test -n "$enable_rpath_arg"; then
    RLD_FLAG="$enable_rpath_arg"
  fi
else
  RLD_FLAG=""
fi

AC_MSG_NOTICE([defining FPICFLAG to be $FPICFLAG])
AC_MSG_NOTICE([defining CPICFLAG to be $CPICFLAG])
AC_MSG_NOTICE([defining CXXPICFLAG to be $CXXPICFLAG])
AC_MSG_NOTICE([defining SHLEXT to be $SHLEXT])
AC_MSG_NOTICE([defining SHLLIB to be $SHLLIB])
AC_MSG_NOTICE([defining SHLBIN to be $SHLBIN])
AC_MSG_NOTICE([defining SHLEXT_VER to be $SHLEXT_VER])
AC_MSG_NOTICE([defining SHLLIB_VER to be $SHLLIB_VER])
AC_MSG_NOTICE([defining SHLBIN_VER to be $SHLBIN_VER])
AC_MSG_NOTICE([defining SHLLINKEXT to be $SHLLINKEXT])
AC_MSG_NOTICE([defining DLFCN_DIR to be $DLFCN_DIR])
AC_MSG_NOTICE([defining SH_LD to be $SH_LD])
AC_MSG_NOTICE([defining SH_LDFLAGS to be $SH_LDFLAGS])
AC_MSG_NOTICE([defining DL_LD to be $DL_LD])
AC_MSG_NOTICE([defining DL_LDFLAGS to be $DL_LDFLAGS])
AC_MSG_NOTICE([defining MKOCTFILE_DL_LDFLAGS to be $MKOCTFILE_DL_LDFLAGS])
AC_MSG_NOTICE([defining SONAME_FLAGS to be $SONAME_FLAGS])
AC_MSG_NOTICE([defining NO_OCT_FILE_STRIP to be $NO_OCT_FILE_STRIP])
AC_MSG_NOTICE([defining RLD_FLAG to be $RLD_FLAG])
AC_MSG_NOTICE([defining TEMPLATE_AR to be $TEMPLATE_AR])
AC_MSG_NOTICE([defining TEMPLATE_ARFLAGS to be $TEMPLATE_ARFLAGS])
AC_MSG_NOTICE([defining library_path_var to be $library_path_var])
AC_SUBST(FPICFLAG)
AC_SUBST(CPICFLAG)
AC_SUBST(CXXPICFLAG)
AC_SUBST(SHLEXT)
AC_SUBST(SHLLIB)
AC_SUBST(SHLBIN)
AC_SUBST(SHLEXT_VER)
AC_SUBST(SHLLIB_VER)
AC_SUBST(SHLBIN_VER)
AC_SUBST(SHLLINKEXT)
AC_SUBST(DLFCN_DIR)
AC_SUBST(SH_LD)
AC_SUBST(SH_LDFLAGS)
AC_SUBST(DL_LD)
AC_SUBST(DL_LDFLAGS)
AC_SUBST(MKOCTFILE_DL_LDFLAGS)
AC_SUBST(SONAME_FLAGS)
AC_SUBST(NO_OCT_FILE_STRIP)
AC_SUBST(RLD_FLAG)
AC_SUBST(TEMPLATE_AR)
AC_SUBST(TEMPLATE_ARFLAGS)
AC_SUBST(library_path_var)

### special checks for odd OS specific things.
###
### I am told that on some SCO systems, the only place to find some
### functions like gethostname and gettimeofday is in libsocket.

AC_CHECK_FUNCS(gethostname, [], [AC_CHECK_LIB(socket, gethostname)])
AC_CHECK_FUNCS(getpwnam, [], [AC_CHECK_LIB(sun, getpwnam)])

case "$canonical_host_type" in
  *-*-cygwin* | *-*-mingw*)
   AC_CHECK_LIB(wsock32, gethostname)
   LIBS="$LIBS -lwsock32"
  ;;
esac

### Type stuff.

AC_TYPE_MODE_T
AC_TYPE_OFF_T
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_TYPE_UID_T
AC_CHECK_TYPES([dev_t, ino_t, nlink_t, nlink_t])
AC_CHECK_TYPES([long long int, unsigned long long int])
AC_CHECK_TYPES([sigset_t, sig_atomic_t], , , [#include <signal.h>])

### How big are ints and how are they oriented?  These could probably
### be eliminated in favor of run-time checks.

AC_CHECK_SIZEOF(short)
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(long)
AC_CHECK_SIZEOF(long long)

### Does the C compiler handle alloca() and const correctly?

AC_FUNC_ALLOCA
AC_C_CONST

### See if we should define NPOS.

OCTAVE_STRING_NPOS

### See if we should use placement delete.

OCTAVE_PLACEMENT_DELETE

### See if we can auto allocate variable sized arrays.

OCTAVE_DYNAMIC_AUTO_ARRAYS

### Checks for header files.

AC_HEADER_STDC
AC_HEADER_DIRENT
AC_HEADER_TIME
AC_HEADER_SYS_WAIT

### C headers

AC_CHECK_HEADERS(assert.h curses.h direct.h dlfcn.h fcntl.h float.h \
  floatingpoint.h grp.h ieeefp.h inttypes.h limits.h memory.h nan.h \
  ncurses.h poll.h pwd.h stdint.h stdlib.h string.h sys/ioctl.h \
  sys/param.h sys/poll.h sys/resource.h sys/select.h sys/stat.h \
  sys/time.h sys/times.h sys/types.h sys/utsname.h termcap.h \
  unistd.h varargs.h)

### C++ headers

AC_LANG_PUSH(C++)
AC_CHECK_HEADERS(sstream)
AC_LANG_POP(C++)

have_termios_h=no
AC_CHECK_HEADERS($TERMIOS_H, have_termios_h=yes)
AC_CHECK_HEADERS(termio.h, have_termio_h=yes, have_termio_h=no)
AC_CHECK_HEADERS(sgtty.h, have_sgtty_h=yes, have_sgtty_h=no)
AC_CHECK_HEADERS(glob.h, have_glob_h=yes, have_glob_h=no)
AC_CHECK_HEADERS(fnmatch.h, have_fnmatch_h=yes, have_fnmatch_h=no)
AC_CHECK_HEADERS(conio.h, have_conio_h=yes, have_conio_h=no)

### I'm told that termios.h is broken on NeXT systems.

case "$canonical_host_type" in
  *-*-nextstep*)
    if test "$have_termios_h" = yes; then
      AC_MSG_WARN([Ignoring termios.h on NeXT systems.])
      have_termios_h=no
    fi
  ;;
esac

if test "$have_termios_h" = yes \
    || test "$have_termio_h" = yes \
    || test "$have_sgtty_h" = yes; then
  true
else
  AC_MSG_WARN([I couldn't find termios.h, termio.h, or sgtty.h!])
fi

LIBGLOB=
AC_SUBST(LIBGLOB)
if test "$have_fnmatch_h" = yes && test "$have_glob_h" = yes; then
  AC_CHECK_FUNCS(fnmatch, have_fnmatch=yes, [
    AC_CHECK_LIB(glob, fnmatch, [have_fnmatch=yes; LIBGLOB=-lglob],
      have_fnmatch=no)])
  AC_CHECK_FUNCS(glob, have_glob=yes, [
    AC_CHECK_LIB(glob, glob, [have_glob=yes; LIBGLOB=-lglob],
      have_glob=no)])

  if test "$have_fnmatch" != yes || test "$have_glob" != yes; then
    AC_MSG_ERROR([You are required to have fnmatch and glob])
  fi
else
  AC_MSG_ERROR([You are required to have fnmatch.h and glob.h])
fi

### Checks for functions and variables.

AC_CHECK_FUNCS(atexit basename bcopy bzero canonicalize_file_name \
  dup2 endgrent endpwent execvp fcntl fork getcwd getegid geteuid \
  getgid getgrent getgrgid getgrnam getpgrp getpid getppid getpwent \
  getpwuid gettimeofday getuid getwd _kbhit kill link localtime_r \
  lstat memmove mkdir mkfifo mkstemp on_exit pipe poll putenv raise \
  readlink rename resolvepath rindex rmdir round select setgrent \
  setpwent setvbuf sigaction siglongjmp sigpending sigprocmask \
  sigsuspend stat strcasecmp strdup strerror strftime stricmp \
  strncasecmp strnicmp strptime strsignal symlink tempnam umask \
  uname unlink usleep vfprintf vsprintf vsnprintf waitpid)

OCTAVE_SMART_PUTENV

### Dynamic linking is now enabled only if we are building shared
### libs and some API for dynamic linking is detected.

LD_CXX='$(CXX)'
LIBDLFCN=
DLFCN_INCFLAGS=
RDYNAMIC_FLAG=
DL_API_MSG=""
dlopen_api=false
shl_load_api=false
loadlibrary_api=false
dyld_api=false

if $SHARED_LIBS || $ENABLE_DYNAMIC_LINKING; then

  ### Check for dyld first since OS X can have a non-standard libdl	

  AC_CHECK_HEADER(mach-o/dyld.h)  
  if test "$ac_cv_header_mach_o_dyld_h" = yes; then
    dyld_api=true
  else 
    AC_CHECK_LIB(dld, shl_load)
    AC_CHECK_FUNCS(shl_load shl_findsym)
    if test "$ac_cv_func_shl_load" = yes \
      && test "$ac_cv_func_shl_findsym" = yes; then
      shl_load_api=true
    else
      AC_CHECK_LIB(wsock32, LoadLibrary)
      AC_CHECK_FUNCS(LoadLibrary)
      if test "$ac_cv_func_loadlibrary" = yes; then
        loadlibrary_api=true
      else
        AC_CHECK_LIB(dl, dlopen)
        AC_CHECK_FUNCS(dlopen dlsym dlerror dlclose)
        if test "$ac_cv_func_dlclose" = yes \
          && test "$ac_cv_func_dlerror" = yes \
          && test "$ac_cv_func_dlopen" = yes \
          && test "$ac_cv_func_dlsym" = yes; then
          dlopen_api=true
        else
	  case "$canonical_host_type" in
	    rs6000-ibm-aix* | powerpc-ibm-aix*)
	      LIBDLFCN="-ldlfcn -ll -lld"
	      DLFCN_INCFLAGS='-I$(top_srcdir)/dlfcn -I$(TOPDIR)/dlfcn'
	      dlopen_api=true
	    ;;
	    i[[3456]]86-*-sco3.2v5*)
	      LD_CXX='LD_RUN_PATH=$LD_RUN_PATH:$(octlibdir) $(CXX)'
	      dlopen_api=true
	    ;;
	  esac
	fi
      fi
    fi
  fi

  ## autoconf test for LoadLibrary appears broken. Bypass for cygwin/mingw 
  if !($dlopen_api || $shl_load_api || $loadlibrary_api || $dyld_api); then
    case "$canonical_host_type" in
      *-*-cygwin* | *-*-mingw*)
       loadlibrary_api=true;
      ;;
    esac
  fi

  if $dlopen_api; then
    DL_API_MSG="(dlopen)"
    AC_DEFINE(HAVE_DLOPEN_API, 1, [Define if your system has dlopen, dlsym, dlerror, and dlclose for dynamic linking])
    OCTAVE_CXX_FLAG(-rdynamic, [RDYNAMIC_FLAG=-rdynamic])
  elif $shl_load_api; then
    DL_API_MSG="(shl_load)"
    AC_DEFINE(HAVE_SHL_LOAD_API, 1, [Define if your system has shl_load and shl_findsym for dynamic linking])
  elif $loadlibrary_api; then
    DL_API_MSG="(LoadLibrary)"
    AC_DEFINE(HAVE_LOADLIBRARY_API, 1, [Define if your system has LoadLibrary for dynamic linking])
  elif $dyld_api; then
    DL_API_MSG="(dyld)"
    AC_DEFINE(HAVE_DYLD_API, 1, [Define if your system has dyld for dynamic linking])
  fi

  if $dlopen_api || $shl_load_api || $loadlibrary_api || $dyld_api; then
    ENABLE_DYNAMIC_LINKING=true
    AC_DEFINE(ENABLE_DYNAMIC_LINKING, 1, [Define if using dynamic linking])
  fi
fi

if $SHARED_LIBS; then
   LIBOCTINTERP=-loctinterp$SHLLINKEXT
   LIBOCTAVE=-loctave$SHLLINKEXT
   LIBCRUFT=-lcruft$SHLLINKEXT
else
  LIBOCTINTERP='$(TOPDIR)/src/liboctinterp.$(LIBEXT)'
  LIBOCTAVE='$(TOPDIR)/liboctave/liboctave.$(LIBEXT)'
  LIBCRUFT='$(TOPDIR)/libcruft/libcruft.$(LIBEXT)'
fi

AC_SUBST(LD_CXX)
AC_SUBST(LIBDLFCN)
AC_SUBST(DLFCN_INCFLAGS)
AC_SUBST(RDYNAMIC_FLAG)
AC_SUBST(ENABLE_DYNAMIC_LINKING)
AC_SUBST(LIBOCTINTERP)
AC_SUBST(LIBOCTAVE)
AC_SUBST(LIBCRUFT)

### There is more than one possible prototype for gettimeofday.  See
### which one (if any) appears in sys/time.h.  These tests are from
### Emacs 19.

AC_MSG_CHECKING(for struct timeval)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#ifdef TIME_WITH_SYS_TIME
#include <sys/time.h>
#include <time.h>
#else
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#else
#include <time.h>
#endif
#endif]], [[static struct timeval x; x.tv_sec = x.tv_usec;]])],
  [AC_MSG_RESULT(yes)
   HAVE_TIMEVAL=yes
   AC_DEFINE(HAVE_TIMEVAL, 1, [Define if struct timeval is defined.])],
  [AC_MSG_RESULT(no)
   HAVE_TIMEVAL=no])

if test "x$HAVE_TIMEVAL" = xyes; then
AC_MSG_CHECKING(whether gettimeofday can't accept two arguments)
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#ifdef TIME_WITH_SYS_TIME
#include <sys/time.h>
#include <time.h>
#else
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#else
#include <time.h>
#endif
#endif]], [[struct timeval time;
  struct timezone dummy;
  gettimeofday (&time, &dummy);]])],
  [AC_MSG_RESULT(no)],
  [AC_MSG_RESULT(yes)
   AC_DEFINE(GETTIMEOFDAY_NO_TZ, 1,
     [Define if your system has a single-arg prototype for gettimeofday.])])
fi

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

### I am told that Inf and NaN don't work on m68k HP sytems, and that
### on SCO systems, isnan and isinf don't work, but they can be
### replaced by something that does.

case "$canonical_host_type" in
  m68k-hp-hpux*)
  ;;
  *-*-sco*)
    AC_MSG_NOTICE([defining SCO to be 1])
    AC_DEFINE(SCO, 1, [Define if using an SCO system.])
    AC_MSG_NOTICE([forcing HAVE_ISINF for SCO])
    AC_DEFINE(HAVE_ISINF, 1, [Define if you have isinf().])
    AC_MSG_NOTICE([forcing HAVE_ISNAN for SCO])
    AC_DEFINE(HAVE_ISNAN, 1, [Define if you have isnan().])
  ;;
  *)
    AC_CHECK_FUNCS(finite isnan isinf copysign signbit)
    AC_CHECK_DECLS(signbit, , , [#include <math.h>])
  ;;
esac

### Check for nonstandard but common math functions that we need.

AC_CHECK_FUNCS(acosh asinh atanh erf erfc exp2 log2)

### Checks for OS specific cruft.

AC_CHECK_MEMBERS([struct stat.st_blksize, struct stat.st_blocks, struct stat.st_rdev])

AC_STRUCT_TM
AC_STRUCT_TIMEZONE
AC_FUNC_CLOSEDIR_VOID

AC_CHECK_MEMBERS(struct group.gr_passwd)

# mkdir takes a single argument on some systems.
OCTAVE_MKDIR_TAKES_ONE_ARG

octave_found_termlib=no
for termlib in ncurses curses termcap terminfo termlib; do
  AC_CHECK_LIB(${termlib}, tputs, [TERMLIBS="${TERMLIBS} -l${termlib}"])
  case "${TERMLIBS}" in
    *-l${termlib}*)
      LIBS="$TERMLIBS $LIBS"
      AC_SUBST(TERMLIBS)
      octave_found_termlib=yes
      break
    ;;
  esac
done

if test "$octave_found_termlib" = no; then
  warn_termlibs="I couldn't find -ltermcap, -lterminfo, -lncurses, -lcurses, o\
r -ltermlib!"
  AC_MSG_WARN($warn_termlibs)
fi

OCTAVE_ENABLE_READLINE

AC_MSG_CHECKING([for struct exception in math.h])
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <math.h>]],
  [[struct exception *x; x->type; x->name;]])],
  [AC_MSG_RESULT(yes)
   AC_DEFINE(EXCEPTION_IN_MATH, 1,
     [Define if your math.h declares struct exception for matherr().])],
  [AC_MSG_RESULT(no)])

### Signal stuff.

AC_TYPE_SIGNAL
AC_CHECK_DECLS([sys_siglist], [], [],
[#include <signal.h>
/* NetBSD declares sys_siglist in unistd.h.  */
#if HAVE_UNISTD_H
# include <unistd.h>
#endif
])
OCTAVE_SIGNAL_CHECK
OCTAVE_REINSTALL_SIGHANDLERS

### A system dependent kluge or two.

AC_CHECK_FUNCS(getrusage times)
case "$canonical_host_type" in
  *-*-cygwin*)
    AC_DEFINE(RUSAGE_TIMES_ONLY, 1, [Define if your struct rusage only has time information.])
  ;;
esac

bsd_gcc_kluge_targets_frag=/dev/null
case "$canonical_host_type" in
  *-*-386bsd* | *-*-openbsd* | *-*-netbsd* | *-*-freebsd*)
    bsd_gcc_kluge_targets_frag=Makefrag.bsd
    cat << \EOF > $bsd_gcc_kluge_targets_frag

lex.o: lex.cc 
	$(CXX) -c $(CPPFLAGS) $(CXXFLAGS_NO_PT_FLAGS) $<

pt-plot.o: pt-plot.cc
	$(CXX) -c $(CPPFLAGS) $(CXXFLAGS_NO_PT_FLAGS) $<

symtab.o: symtab.cc
	$(CXX) -c $(CPPFLAGS) $(CXXFLAGS_NO_PT_FLAGS) $<

toplev.o: toplev.cc
	$(CXX) -c $(CPPFLAGS) $(CXXFLAGS_NO_PT_FLAGS) $<

unwind-prot.o: unwind-prot.cc 
	$(CXX) -c $(CPPFLAGS) $(CXXFLAGS_NO_PT_FLAGS) $<

EOF
  ;;
esac
AC_SUBST_FILE(bsd_gcc_kluge_targets_frag)

### Checks for other programs used for building, testing, installing,
### and running Octave.

AC_PROG_AWK
OCTAVE_PROG_SED
OCTAVE_PROG_PERL
OCTAVE_PROG_PYTHON

OCTAVE_PROG_FLEX
OCTAVE_PROG_BISON

AC_PROG_LN_S

OCTAVE_PROG_NM

AC_PROG_INSTALL
INSTALL_SCRIPT='${INSTALL}'
AC_SUBST(INSTALL_SCRIPT)

OCTAVE_PROG_DESKTOP_FILE_INSTALL

OCTAVE_PROG_GNUPLOT
OCTAVE_PROG_PAGER
OCTAVE_PROG_GPERF

OCTAVE_PROG_GHOSTSCRIPT
OCTAVE_PROG_MAKEINFO
OCTAVE_PROG_TEXI2DVI
OCTAVE_PROG_TEXI2PDF

### Even though we include config.h, we need to have the preprocessor
### defines available in a variable for the octave-bug script.  Use
### UGLY_DEFS for that.

AC_OUTPUT_MAKE_DEFS


dnl Maybe this should really be conditional on "broken sed", or
dnl "broken shell backslash quoting" or somesuch.
dnl
case "$canonical_host_type" in
  *-*-darwin*)
    UGLY_DEFS=`echo $DEFS | sed 's,\\",\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\",g'`
  ;;
  *)
    UGLY_DEFS=`echo $DEFS | sed 's,\\",\\\\\\\\\\\\\\\\\\",g'`
  ;;
esac
AC_MSG_NOTICE([defining UGLY_DEFS to be $UGLY_DEFS])
AC_SUBST(UGLY_DEFS)

### Maybe add -Wall, -W, and -Wshadow to compiler flags now that we're
### done feature testing. 

if test -z "$EXTERN_CFLAGS"; then
  OCTAVE_CC_FLAG(-Wall, [
	WARN_CFLAGS="$WARN_CFLAGS -Wall";
	AC_MSG_RESULT([adding -Wall to WARN_CFLAGS])])
  OCTAVE_CC_FLAG(-W, [
	WARN_CFLAGS="$WARN_CFLAGS -W";
	AC_MSG_RESULT([adding -W to WARN_CFLAGS])])
  OCTAVE_CC_FLAG(-Wshadow, [
	WARN_CFLAGS="$WARN_CFLAGS -Wshadow";
	AC_MSG_RESULT([adding -Wshadow to WARN_CFLAGS])])
fi

if test -z "$EXTERN_CXXFLAGS"; then
  OCTAVE_CXX_FLAG(-Wall, [
    WARN_CXXFLAGS="$WARN_CXXFLAGS -Wall";
    AC_MSG_RESULT([adding -Wall to WARN_CXXFLAGS])])
  OCTAVE_CXX_FLAG(-W, [
    WARN_CXXFLAGS="$WARN_CXXFLAGS -W";
    AC_MSG_RESULT([adding -W to WARN_CXXFLAGS])])
  OCTAVE_CXX_FLAG(-Wshadow, [
    WARN_CXXFLAGS="$WARN_CXXFLAGS -Wshadow";
    AC_MSG_RESULT([adding -Wshadow to WARN_CXXFLAGS])])
  OCTAVE_CXX_FLAG(-Wold-style-cast, [
    WARN_CXXFLAGS="$WARN_CXXFLAGS -Wold-style-cast";
    AC_MSG_RESULT([adding -Wold-style-cast to WARN_CXXFLAGS])])
fi

GCC_PICKY_FLAGS="-Wcast-align -Wcast-qual -Wmissing-prototypes \
  -Wpointer-arith -Wstrict-prototypes -Wwrite-strings"

GXX_PICKY_FLAGS="-Wcast-align -Wcast-qual -Wpointer-arith \
  -Wwrite-strings -Weffc++ -Wenum-clash"

AC_ARG_ENABLE(picky-flags,
  [AS_HELP_STRING([--enable-picky-flags],
     [add extra warning options to CFLAGS, CXXFLAGS, FFLAGS])],
  [if test "$enableval" = no; then
     true
   elif test "$enableval" = yes; then
     if test -z "$EXTERN_CFLAGS"; then
       for flag in $GCC_PICKY_FLAGS; do
	 OCTAVE_CC_FLAG($flag, [
	   WARN_CFLAGS="$WARN_CFLAGS $flag";
	   AC_MSG_RESULT([adding $flag to WARN_CFLAGS])])
       done
     fi
     if test -z "$EXTERN_CXXFLAGS"; then
       for flag in $GXX_PICKY_FLAGS; do
	 OCTAVE_CXX_FLAG($flag, [
	   WARN_CXXFLAGS="$WARN_CXXFLAGS $flag";
	   AC_MSG_RESULT([adding $flag to WARN_CXXFLAGS])])
       done
     fi
   fi], [])

AC_SUBST(WARN_CFLAGS)
AC_SUBST(WARN_CXXFLAGS)

### Run configure in subdirectories.

export CC
export CXX
export F77

AC_CONFIG_SUBDIRS(scripts)

### Some things to add to the bottom of config.h.

AH_BOTTOM([
#if defined (__GNUC__)
#define GCC_ATTR_DEPRECATED __attribute__ ((__deprecated__))
#define GCC_ATTR_NORETURN __attribute__ ((__noreturn__))
#define GCC_ATTR_UNUSED __attribute__ ((__unused__))
#else
#define GCC_ATTR_DEPRECATED
#define GCC_ATTR_NORETURN
#define GCC_ATTR_UNUSED
#endif

#define X_CAST(T, E) (T) (E)

#if defined (CXX_BROKEN_REINTERPRET_CAST)
#define FCN_PTR_CAST(T, E) (T) (E)
#else
#define FCN_PTR_CAST(T, E) reinterpret_cast<T> (E)
#endif

#if defined(HAVE_F2C) && !defined(F77_FUNC)
#  define F77_FUNC(x,X) x ## _
#  define F77_FUNC_(x,X) x ## __
#endif

#if !defined(HAVE_DEV_T)
typedef short dev_t;
#endif

#if !defined(HAVE_INO_T)
typedef unsigned long ino_t;
#endif

#if !defined(HAVE_NLINK_T)
typedef short nlink_t;
#endif

#if !defined(HAVE_SIGSET_T)
typedef int sigset_t;
#endif

#if !defined(HAVE_SIG_ATOMIC_T)
typedef int sig_atomic_t;
#endif

#define OCTAVE_HAVE_POSIX_FILESYSTEM 1

#if defined (__WIN32__) && ! defined (__CYGWIN__)
#define OCTAVE_HAVE_WINDOWS_FILESYSTEM 1
#undef OCTAVE_HAVE_POSIX_FILESYSTEM
#endif

#if defined (__CYGWIN__)
#define OCTAVE_HAVE_WINDOWS_FILESYSTEM 1
#define OCTAVE_HAVE_POSIX_FILESYSTEM 1
#endif

/* Define if we expect to have <windows.h>, Sleep, etc. */
#if defined (__WIN32__) && ! defined (__CYGWIN__)
#define OCTAVE_USE_WINDOWS_API 1
#endif

/* sigsetjmp is a macro, not a function. */
#if defined (sigsetjmp) && defined (HAVE_SIGLONGJMP)
#define OCTAVE_HAVE_SIG_JUMP
#endif

/* Always use vector<T>, since we sometimes allocate large chunks
   of memory and that can cause trouble due to stack size limits.

   Note that using auto_ptr is not appropriate because it uses delete,
   not delete[] and we need the latter to properly handle arrays
   allocated with new[size].

   Use < T > instead of <T> to avoid problems if T is a template type
   (say, foo<int>) and the preprocessor fails to insert a space and
   generates <foo<int>>.

#if defined (HAVE_DYNAMIC_AUTO_ARRAYS)

#define OCTAVE_LOCAL_BUFFER(T, buf, size) \
  T buf[size]

#else

*/

#define OCTAVE_LOCAL_BUFFER(T, buf, size) \
  std::vector< T > buf ## _vector (size); \
  T *buf = &(buf ## _vector[0])

/* #endif */

#if defined (__DECCXX)
#define __USE_STD_IOSTREAM
#endif

#if defined (_UNICOS)
#define F77_USES_CRAY_CALLING_CONVENTION
#endif

#if 0
#define F77_USES_VISUAL_FORTRAN_CALLING_CONVENTION
#endif

#ifdef USE_64_BIT_IDX_T
#define SIZEOF_OCTAVE_IDX_TYPE 8
#else
#define SIZEOF_OCTAVE_IDX_TYPE SIZEOF_INT
#endif

#include "oct-types.h"
])

### Do the substitutions in all the Makefiles.

AC_CONFIG_FILES([Makefile octMakefile Makeconf test/Makefile \
  dlfcn/Makefile doc/Makefile doc/faq/Makefile \
  doc/interpreter/Makefile doc/interpreter/images/Makefile \
  doc/liboctave/Makefile doc/refcard/Makefile emacs/Makefile \
  examples/Makefile liboctave/Makefile liboctave/oct-types.h \
  src/Makefile libcruft/Makefile libcruft/Makerules \
  libcruft/amos/Makefile libcruft/blas/Makefile \
  libcruft/daspk/Makefile libcruft/dasrt/Makefile 
  libcruft/dassl/Makefile libcruft/fftpack/Makefile \
  libcruft/lapack/Makefile libcruft/minpack/Makefile \
  libcruft/misc/Makefile libcruft/odepack/Makefile \
  libcruft/ordered-qz/Makefile libcruft/quadpack/Makefile \
  libcruft/ranlib/Makefile libcruft/slatec-fn/Makefile \
  libcruft/slatec-err/Makefile libcruft/villad/Makefile \
  libcruft/blas-xtra/Makefile libcruft/lapack-xtra/Makefile])
AC_OUTPUT

AC_CONFIG_COMMANDS([default-1],[[chmod +x install-octave]],[[]])

### Print a summary so that important information isn't missed.

if test -z "$F77"; then
  FORT="$F2C $F2CFLAGS"
else
  FORT="$F77 $FFLAGS"
fi

AC_MSG_NOTICE([

Octave is now configured for $canonical_host_type

  Source directory:     $srcdir
  Installation prefix:  $prefix
  C compiler:           $CC $XTRA_CFLAGS $WARN_CFLAGS $CFLAGS
  C++ compiler:         $CXX $XTRA_CXXFLAGS $WARN_CXXFLAGS $CXXFLAGS
  Fortran compiler:     $FORT
  Fortran libraries:    $FLIBS
  BLAS libraries:       $BLAS_LIBS
  FFTW libraries:       $FFTW_LIBS
  GLPK libraries:       $GLPK_LIBS
  UMFPACK libraries:    $UMFPACK_LIBS
  COLAMD libraries:     $COLAMD_LIBS
  CCOLAMD libraries:    $CCOLAMD_LIBS
  CHOLMOD libraries:    $CHOLMOD_LIBS
  CXSPARSE libraries:   $CXSPARSE_LIBS
  HDF5 libraries:       $HDF5_LIBS
  LIBS:                 $LIBS
  Default pager:        $DEFAULT_PAGER
  gnuplot:              $GNUPLOT_BINARY

  Do internal array bounds checking:  $BOUNDS_CHECKING
  Build static libraries:             $STATIC_LIBS
  Build shared libraries:             $SHARED_LIBS
  Dynamic Linking:                    $ENABLE_DYNAMIC_LINKING $DL_API_MSG
  Include support for GNU readline:   $USE_READLINE
  64-bit array dims and indexing:     $USE_64_BIT_IDX_T
])

warn_msg_printed=false

if $ENABLE_DYNAMIC_LINKING; then
  if $SHARED_LIBS; then
    true
  else
    AC_MSG_WARN([You used --enable-dl but not --enable-shared.])
    AC_MSG_WARN([Are you sure that is what you want to do?])
    warn_msg_printed=true
  fi
fi

if test -n "$warn_f2c_and_f77"; then
  AC_MSG_WARN($warn_f2c_and_f77)
  warn_msg_printed=true
fi

if test -n "$gxx_only"; then
  AC_MSG_WARN($gxx_only)
  warn_msg_printed=true
fi

if test -n "$warn_gcc_version"; then
  AC_MSG_WARN($warn_gcc_version)
  warn_msg_printed=true
fi

if test -n "$warn_gcc_only"; then
  AC_MSG_WARN($warn_gcc_only)
  warn_msg_printed=true
fi

if test -n "$warn_f2c_no_lib"; then
  AC_MSG_WARN($warn_f2c_no_lib)
  warn_msg_printed=true
fi

if test -n "$warn_readline"; then
  AC_MSG_WARN($warn_readline)
  warn_msg_printed=true
fi

if test -n "$warn_termlibs"; then
  AC_MSG_WARN($warn_termlibs)
  warn_msg_printed=true
fi

if test -n "$warn_gperf"; then
  AC_MSG_WARN($warn_gperf)
  warn_msg_printed=true
fi

if test -n "$warn_flex"; then
  AC_MSG_WARN($warn_flex)
  warn_msg_printed=true
fi

if test -n "$warn_bison"; then
  AC_MSG_WARN($warn_bison)
  warn_msg_printed=true
fi

if test -n "$warn_less"; then
  AC_MSG_WARN($warn_less)
  warn_msg_printed=true
fi

if test -n "$warn_umfpack"; then
  AC_MSG_WARN($warn_umfpack)
  warn_msg_printed=true
fi

if test -n "$warn_colamd"; then
  AC_MSG_WARN($warn_colamd)
  warn_msg_printed=true
fi

if test -n "$warn_ccolamd"; then
  AC_MSG_WARN($warn_ccolamd)
  warn_msg_printed=true
fi

if test -n "$warn_cholmod"; then
  AC_MSG_WARN($warn_cholmod)
  warn_msg_printed=true
fi

if test -n "$warn_cxsparse"; then
  AC_MSG_WARN($warn_cxsparse)
  warn_msg_printed=true
fi

if test -n "$warn_hdf5"; then
  AC_MSG_WARN($warn_hdf5)
  warn_msg_printed=true
fi

if test -n "$warn_zlib"; then
  AC_MSG_WARN($warn_zlib)
  warn_msg_printed=true
fi

if test -n "$warn_ghostscript"; then
  AC_MSG_WARN($warn_ghostscript)
  warn_msg_printed=true
fi

if test -n "$warn_makeinfo"; then
  AC_MSG_WARN($warn_makeinfo)
  warn_msg_printed=true
fi

if test -n "$warn_texi2dvi"; then
  AC_MSG_WARN($warn_texi2dvi)
  warn_msg_printed=true
fi

if test -n "$warn_texi2pdf"; then
  AC_MSG_WARN($warn_texi2pdf)
  warn_msg_printed=true
fi

if test -n "$warn_64_bit"; then
  AC_MSG_WARN($warn_64_bit)
  warn_msg_printed=true
fi

if test -n "$warn_gnuplot"; then

  ## If you change this text, be sure to also change the corresponding
  ## set of warnings above.

  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.])
  warn_msg_printed=true
fi

if $USE_64_BIT_IDX_T; then
  AC_MSG_WARN([You used the EXPERIMENTAL --enable-64 option.])
  AC_MSG_WARN([Are you sure that is what you want to do?])
  AC_MSG_WARN([])
  AC_MSG_WARN([You must ensure that the Fortran compiler generates])
  AC_MSG_WARN([code with 8 byte signed INTEGER values, and that your])
  AC_MSG_WARN([BLAS and LAPACK libraries are compiled to use 8 byte])
  AC_MSG_WARN([signed integers for array indexing.])
  warn_msg_printed=true
fi

### End of configure.