Merge lp:~mtmiller/ubuntu/wily/octave/fix-build-and-break into lp:ubuntu/wily-proposed/octave

[Mike Miller]

This branch includes two changes necessary for a functional Octave 4.0.0 in wily. The first change fixes a build failure on the armhf architecture using a patch I am proposing for inclusion upstream. The patch disables building the Qt components of Octave when Qt was configured for GLES, as it appears to be on Ubuntu armhf. The second change updates the list of Breaks to the versions currently found in wily (some of which are already good for Octave 4.0, some of which will need to be rebuilt).

I've done a test build of the qt-requires-opengl.patch in my PPA (https://launchpad.net/~mtmiller/+archive/ubuntu/octave/+packages). The armhf build hasn't completed yet but it at least got past the point where the error appeared in 4.0.0-3.

[Sebastien Bacher (seb128)]

Seems like the patch has been merged in https://launchpad.net/ubuntu/+source/octave/4.0.0-3ubuntu1, can you please resubmit the other change if it still applies? thanks

review: Approve

[Mike Miller (mtmiller)]

Thanks for your review anyway. It's easier for folks with upload rights to take care of these changes, looks like both of my changes have been taken care of by others now. Thanks for your hard work!

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2015-07-18 14:20:22 +0000
+++ .pc/applied-patches	2015-08-02 19:51:25 +0000
@@ -9,3 +9,4 @@
 hdf5-mkoctfile.patch
 xbackslash-texinfo.patch
 dont-use-included-texinfo-texmfcnf.patch
+qt-requires-opengl.patch

=== added directory '.pc/qt-requires-opengl.patch'
=== added file '.pc/qt-requires-opengl.patch/configure.ac'
--- .pc/qt-requires-opengl.patch/configure.ac	1970-01-01 00:00:00 +0000
+++ .pc/qt-requires-opengl.patch/configure.ac	2015-08-02 19:51:25 +0000
@@ -0,0 +1,3228 @@
+dnl Process this file with autoconf to produce a configure script.
+dnl
+dnl Copyright (C) 1993-2015 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 3 of the License, 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, see
+### <http://www.gnu.org/licenses/>.
+
+AC_PREREQ([2.63])
+AC_INIT([GNU Octave], [4.0.0], [http://octave.org/bugs.html], [octave])
+
+dnl Note that the version number is duplicated here and in AC_INIT
+dnl because AC_INIT requires it to be static, not computed from
+dnl shell variables.
+OCTAVE_MAJOR_VERSION=4
+OCTAVE_MINOR_VERSION=0
+OCTAVE_PATCH_VERSION=0
+
+dnl PACKAGE_VERSION is set by the AC_INIT VERSION arg
+OCTAVE_VERSION="$PACKAGE_VERSION"
+
+OCTAVE_COPYRIGHT="Copyright (C) 2015 John W. Eaton and others."
+
+OCTAVE_RELEASE_DATE="2015-05-26"
+
+## The "API version" is used as a way of checking that interfaces in the
+## liboctave and libinterp libraries haven't changed in a backwardly
+## incompatible way when loading .oct files.  A better way to do that is
+## with library versioning, but not all systems support that.
+## NOTE: This macro will be removed in a future version of Octave.  If
+## you insist on checking for features using a version number, use the
+## OCTAVE_MAJOR_VERSION, OCTAVE_MINOR_VERSION, and
+## OCTAVE_PATCH_VERSION macros instead.
+## FIXME: Since we also set libtool versions for liboctave and
+## libinterp, perhaps we should be computing the "api version" from
+## those versions numbers in some way instead of setting it
+## independently here.
+OCTAVE_API_VERSION="api-v50+"
+
+AC_SUBST(OCTAVE_MAJOR_VERSION)
+AC_SUBST(OCTAVE_MINOR_VERSION)
+AC_SUBST(OCTAVE_PATCH_VERSION)
+AC_SUBST(OCTAVE_VERSION)
+AC_SUBST(OCTAVE_COPYRIGHT)
+AC_SUBST(OCTAVE_RELEASE_DATE)
+AC_SUBST(OCTAVE_API_VERSION)
+
+dnl FIXME: We should auto-insert the Mercurial changeset ID into the
+dnl        AC_REVISION field whenever configure.ac is modified.
+dnl AC_REVISION($Revision: 1.603 $)
+AC_CONFIG_SRCDIR([libinterp/octave.cc])
+AC_CONFIG_HEADERS([config.h:config.in.h])
+AC_CONFIG_AUX_DIR([build-aux])
+AC_CONFIG_MACRO_DIR([m4])
+
+AM_INIT_AUTOMAKE([1.11 foreign -Wno-portability -Wno-override tar-ustar subdir-objects])
+
+## Add the option to enable silent rules and make silent rules the
+## default behavior.  Available since Automake 1.11 and included by
+## default starting with Automake 1.13.
+AM_SILENT_RULES([yes])
+
+OCTAVE_CANONICAL_HOST
+
+AC_DEFINE(OCTAVE_SOURCE, 1, [Define to 1 if this is Octave.])
+
+AC_USE_SYSTEM_EXTENSIONS
+
+### Make configure args available for other uses.
+
+config_opts=$ac_configure_args
+AC_SUBST(config_opts)
+
+### Set default file locations
+
+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],
+  '$(libdir)/octave/$(version)/oct/$(canonical_host_type)')
+OCTAVE_SET_DEFAULT([localoctfiledir],
+  '$(libdir)/octave/site/oct/$(canonical_host_type)')
+OCTAVE_SET_DEFAULT([localapioctfiledir],
+  '$(libdir)/octave/site/oct/$(api_version)/$(canonical_host_type)')
+OCTAVE_SET_DEFAULT([localveroctfiledir],
+  '$(libdir)/octave/$(version)/site/oct/$(canonical_host_type)')
+OCTAVE_SET_DEFAULT([octincludedir], '$(includedir)/octave-$(version)/octave')
+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([octetcdir], '$(datadir)/octave/$(version)/etc')
+OCTAVE_SET_DEFAULT([octlocaledir], '$(datadir)/octave/$(version)/locale')
+OCTAVE_SET_DEFAULT([doc_cache_file], '$(octetcdir)/doc-cache')
+OCTAVE_SET_DEFAULT([octtestsdir], '$(octetcdir)/tests')
+OCTAVE_SET_DEFAULT([texi_macros_file], '$(octetcdir)/macros.texi')
+OCTAVE_SET_DEFAULT([imagedir], '$(datadir)/octave/$(version)/imagelib')
+OCTAVE_SET_DEFAULT([octdatadir], '$(datadir)/octave/$(version)/data')
+OCTAVE_SET_DEFAULT([man1dir], '$(mandir)/man1')
+OCTAVE_SET_DEFAULT([man1ext], '.1')
+OCTAVE_SET_DEFAULT([infofile], '$(infodir)/octave.info')
+
+### Check for programs used in building, installing, and running Octave.
+
+## Programs used in configuring Octave.
+## Find pkg-config executable (sets $PKG_CONFIG)
+PKG_PROG_PKG_CONFIG
+
+## Programs used in Makefiles.
+AC_PROG_AWK
+AC_PROG_GREP
+OCTAVE_PROG_FIND
+OCTAVE_PROG_SED
+OCTAVE_PROG_PERL
+
+## Programs used to build parts of Octave.
+OCTAVE_PROG_GPERF
+
+OCTAVE_PROG_FLEX
+AC_SUBST([LEX_OUTPUT_ROOT], [lex.octave_])
+
+OCTAVE_PROG_BISON
+
+OCTAVE_PROG_MAKEINFO
+OCTAVE_PROG_TEXI2DVI
+OCTAVE_PROG_TEXI2PDF
+
+## Programs used when installing Octave.
+AC_PROG_LN_S
+AC_PROG_MKDIR_P
+
+AC_PROG_INSTALL
+INSTALL_SCRIPT='${INSTALL}'
+AC_SUBST(INSTALL_SCRIPT)
+
+OCTAVE_PROG_DESKTOP_FILE_INSTALL
+
+## Programs used when running Octave
+OCTAVE_PROG_GHOSTSCRIPT
+OCTAVE_PROG_GNUPLOT
+OCTAVE_PROG_PAGER
+OCTAVE_PROG_PYTHON
+
+## Programs used to generate icons file formats.
+OCTAVE_PROG_ICOTOOL
+OCTAVE_PROG_RSVG_CONVERT
+AM_CONDITIONAL([AMCOND_HAVE_ICON_TOOLS],
+  [test -n "$ICOTOOL" && test -n "$RSVG_CONVERT"])
+
+### Default terminal font for the GUI
+case $host_os in
+  mingw* | msdosmsvc)
+    DEFAULT_TERMINAL_FONT="Lucida Console"
+  ;;
+  *)
+    DEFAULT_TERMINAL_FONT="Courier"
+  ;;
+esac
+DEFAULT_TERMINAL_FONT_SIZE=10
+AC_SUBST(DEFAULT_TERMINAL_FONT)
+AC_SUBST(DEFAULT_TERMINAL_FONT_SIZE)
+
+### 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 $host_os in
+      mingw* | msdosmsvc)
+        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 be the path separator for your system, as a string.])
+
+### Define the path to the shell on the host system.  Most systems will
+### ensure /bin/sh is the default shell so this can be safely ignored by
+### almost everyone.  However, when building for Android, for example,
+### this will need to be set.
+SHELL_PATH=/bin/sh
+AC_ARG_WITH([shell],
+  [AS_HELP_STRING([--with-shell=SHELL],
+    [use SHELL as the shell interpreter (default: /bin/sh)])])
+case $with_shell in
+  no)
+    AC_MSG_ERROR([A shell interpreter is required])
+  ;;
+  yes | "")
+  ;;
+  *)
+    SHELL_PATH=$with_shell
+  ;;
+esac
+AC_DEFINE_UNQUOTED([SHELL_PATH], ["$SHELL_PATH"],
+  [Define this to be the path to the shell command interpreter.])
+
+### Enable bounds checking on element references within Octave's array and
+### matrix classes.  This slows down some operations a bit, so it is turned off
+### by default.
+
+BOUNDS_CHECKING=no
+AC_ARG_ENABLE([bounds-check],
+  [AS_HELP_STRING([--enable-bounds-check],
+    [enable bounds checking for indexing in internal array classes])],
+  [if test "$enableval" = yes; then BOUNDS_CHECKING=yes; fi], [])
+if test $BOUNDS_CHECKING = yes; then
+  AC_DEFINE(BOUNDS_CHECKING, 1, [Define to 1 to use internal bounds checking.])
+fi
+
+### Use atomic operations for internal reference counting.  This is required
+### for thread-safe behavior (Qt Handles) but incurs a significant slowdown.
+### Enabled by default until a higher performing solution can be found.
+
+USE_ATOMIC_REFCOUNT=yes
+AC_ARG_ENABLE([atomic-refcount],
+  [AS_HELP_STRING([--disable-atomic-refcount],
+    [Do not use atomic operations for internal reference counting.  This option is required for thread-safe behavior as used in the GUI's Qt plotting toolkit.  Performance for CLI-only builds is improved by disabling this feature.])],
+  [if test "$enableval" = no; then USE_ATOMIC_REFCOUNT=no; fi], [])
+if test $USE_ATOMIC_REFCOUNT = yes; then
+  AC_DEFINE(USE_ATOMIC_REFCOUNT, 1,
+    [Define to 1 to use atomic operations for reference counting.])
+fi
+
+### Disable running Make in the doc directory.
+### This is useful, for example, when building Octave on systems without TeX.
+
+DOCDIR=doc
+AC_ARG_ENABLE([docs],
+  [AS_HELP_STRING([--disable-docs], [don't build documentation files])],
+  [if test "$enableval" = no; then
+     DOCDIR=
+     warn_docs="building documentation disabled; make dist will fail"
+     OCTAVE_CONFIGURE_WARNING([warn_docs])
+   fi],
+  [])
+AC_SUBST(DOCDIR)
+
+### If possible, use a 64-bit integer type for array dimensions and indexing.
+
+USE_64_BIT_IDX_T=no
+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=yes; fi], [])
+if test $USE_64_BIT_IDX_T = yes; then
+  AC_CHECK_SIZEOF([void *])
+  AC_CHECK_SIZEOF([int])
+  AC_CHECK_SIZEOF([long])
+  AC_CHECK_SIZEOF([int64_t])
+  if test $ac_cv_sizeof_void_p -eq 8; then
+    OCTAVE_IDX_TYPE=int64_t
+  else
+    warn_64_bit="pointers are not 64-bits wide; disabling 64-bit features"
+    OCTAVE_CONFIGURE_WARNING([warn_64_bit])
+    USE_64_BIT_IDX_T=no
+  fi
+fi
+AC_SUBST(OCTAVE_IDX_TYPE)
+AC_DEFINE_UNQUOTED(OCTAVE_IDX_TYPE, [$OCTAVE_IDX_TYPE],
+  [Define to the type of octave_idx_type (64 or 32 bit signed integer).])
+if test $USE_64_BIT_IDX_T = yes; then
+  AC_DEFINE(USE_64_BIT_IDX_T, 1,
+    [Define to 1 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 to 1 if your version of GNU libc has buggy inline assembly code for math functions like exp.])
+
+### Determine which C++ compiler to use (we expect to find g++).
+
+AC_PROG_CXX
+AC_PROG_CXXCPP
+
+### Determine which C compiler to use (we expect to find gcc).
+
+AC_PROG_CC
+AC_PROG_CPP
+AC_PROG_GCC_TRADITIONAL
+
+## Save and restore CFLAGS and CXXFLAGS globally.  These variables
+## are for users, so we shouldn't be touching them.  Instead, we should
+## set the corresponding AM_ flags (currently by way of the XTRA_ variables).
+## However, for the duration of the configure script, we may set CFLAGS
+## and CXXFLAGS so that subsequent tests succeed.  Temporary settings
+## like this are currently done for pthreads and openmp, for example.
+original_octave_configure_CFLAGS="$CFLAGS"
+original_octave_configure_CXXFLAGS="$CXXFLAGS"
+
+## Check for MSVC
+have_msvc=no
+case $host_os in
+  msdosmsvc)
+    have_msvc=yes
+  ;;
+  mingw*)
+    AC_MSG_CHECKING([for MSVC compiler])
+    AC_PREPROC_IFELSE([AC_LANG_SOURCE([[
+        #ifndef _MSC_VER
+        #error "Not MSVC compiler"
+        #endif
+        ]])],
+      have_msvc=yes, have_msvc=no)
+    AC_MSG_RESULT([$have_msvc])
+  ;;
+esac
+
+### gnulib initialization: part 1
+### Must take place immediately after a compiler is determined
+
+gl_EARLY
+
+### Check version number when using gcc.
+
+GCC_VERSION=
+if test "$GCC" = yes; then
+  AC_MSG_CHECKING([C compiler version number])
+  gcc_version=`$CC -v 2>&1 | $GREP "^.*gcc version" | \
+    $SED -e 's/^.*g.. version *//' -e 's/cygnus-//' -e 's/egcs-//' -e 's/ .*//'`
+
+  AX_COMPARE_VERSION([$gcc_version], [lt], [3],
+    [warn_gcc_version="gcc version $gcc_version is likely to cause problems"
+     OCTAVE_CONFIGURE_WARNING([warn_gcc_version])])
+
+  GCC_VERSION=$gcc_version
+  AC_MSG_RESULT([$GCC_VERSION])
+fi
+AC_SUBST(GCC_VERSION)
+
+### Check version number when using g++ .
+### It might be different from the gcc version number.
+
+GXX_VERSION=
+if test "$GXX" = yes; then
+  AC_MSG_CHECKING([C++ compiler version number])
+  gxx_version=`$CXX -v 2>&1 | $GREP "^.*g.. version" | \
+    $SED -e 's/^.*g.. version *//' -e 's/cygnus-//' -e 's/egcs-//' -e 's/ .*//'`
+
+  AX_COMPARE_VERSION([$gxx_version], [lt], [4.1],
+    [warn_gxx_version="g++ version $gxx_version is likely to cause problems"
+     OCTAVE_CONFIGURE_WARNING([warn_gxx_version])])
+
+  GXX_VERSION=$gxx_version
+  AC_MSG_RESULT([$GXX_VERSION])
+fi
+AC_SUBST(GXX_VERSION)
+
+OCTAVE_CHECK_BROKEN_STL_ALGO_H
+AM_CONDITIONAL([AMCOND_HAVE_BROKEN_STL_ALGO_H],
+  [test $octave_cv_broken_stl_algo_h = yes])
+
+if test $octave_cv_broken_stl_algo_h = yes; then
+  warn_stl_algo_h="Found nth_element broken in g++ $GXX_VERSION.  Attempting to repair by using local patched version of bits/stl_algo.h."
+  OCTAVE_CONFIGURE_WARNING([warn_stl_algo_h])
+fi
+
+### Determine the compiler flag necessary to create dependencies
+
+## Assume GCC.
+INCLUDE_DEPS=yes
+DEPEND_FLAGS="-M"
+DEPEND_EXTRA_SED_PATTERN=""
+if test "$GCC" != yes; then
+  case $canonical_host_type in
+    sparc-sun-solaris2* | i386-pc-solaris2*)
+      DEPEND_FLAGS="-xM1"
+      DEPEND_EXTRA_SED_PATTERN="-e '/\/opt\/SUNWspro/d'"
+    ;;
+    *-*-msdosmsvc)
+    ;;
+    *-*-mingw*)
+      if test $have_msvc = no; then
+        INCLUDE_DEPS=no
+      fi
+    ;;
+    *)
+      INCLUDE_DEPS=no
+    ;;
+  esac
+fi
+AC_SUBST(INCLUDE_DEPS)
+AC_SUBST(DEPEND_FLAGS)
+AC_SUBST(DEPEND_EXTRA_SED_PATTERN)
+
+### Check for pthread library
+
+AX_PTHREAD
+## Include pthread libs and flags early in case other tests need them.
+## They seem to be required for the OpenGL tests on Debian systems.
+LIBS="$PTHREAD_LIBS $LIBS"
+XTRA_CFLAGS="$XTRA_CFLAGS $PTHREAD_CFLAGS"
+XTRA_CXXFLAGS="$XTRA_CXXFLAGS $PTHREAD_CFLAGS"
+## Set these for any other tests that may require them.  They will be
+## reset before output files are generated.
+CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"
+
+### Test whether the compiler supports OpenMP.  This is enabled by default
+### now to allow the option of using OpenMP in loadable modules.
+
+USE_OPENMP=no
+check_for_openmp=yes
+AC_ARG_ENABLE([openmp],
+  [AS_HELP_STRING([--disable-openmp],
+    [disable OpenMP SMP multi-threading])],
+  [if test "$enableval" = no; then check_for_openmp=no; fi], [])
+if test $check_for_openmp = yes; then
+  AC_LANG_PUSH(C)
+  AX_OPENMP([XTRA_CFLAGS="$XTRA_CFLAGS $OPENMP_CFLAGS"; USE_OPENMP=yes], [])
+  AC_LANG_POP(C)
+  AC_LANG_PUSH(C++)
+  AX_OPENMP([XTRA_CXXFLAGS="$XTRA_CXXFLAGS $OPENMP_CXXFLAGS"; USE_OPENMP=yes], [])
+  AC_LANG_POP(C++)
+fi
+dnl Define here since it is skipped if the first argument to
+dnl AX_OPENMP is not empty.
+if test $USE_OPENMP = yes; then
+  AC_DEFINE(HAVE_OPENMP, 1, [Define if OpenMP is enabled])
+fi
+## Set these for any other tests that may require them.  They will be
+## reset before output files are generated.
+CFLAGS="$CFLAGS $OPENMP_CFLAGS"
+CXXFLAGS="$CXXFLAGS $OPENMP_CXXFLAGS"
+
+### When compiling math for x87, problems may arise in some code comparing
+### floating-point intermediate results.  The root cause is the extra precision
+### (~80 bits) of x87 co-processor registers versus the IEEE standard 64 bits.
+### Generally, storing the result in a local volatile variable forces a
+### truncation back to 64 bits, but it also degrades performance.
+### However, this performance degradation is very minimal, if indeed measurable.
+### Therefore, it has been enabled for all platforms and compilers.
+### Reported bugs indicate that --enable-float-truncate is required for MinGW
+### and Cygwin platforms and for GCC compilers >= 5.0.  It should not be
+### necessary for non-x87 targets or when using modern SSE math.
+ac_float_truncate=volatile
+AC_ARG_ENABLE([float-truncate],
+  [AS_HELP_STRING([--disable-float-truncate],
+    [truncate intermediate FP results])],
+  [if test "$enableval" = no; then
+     ac_float_truncate=
+   fi],
+  [])
+
+AC_DEFINE_UNQUOTED(FLOAT_TRUNCATE, [$ac_float_truncate],
+  [Define to volatile if you need to truncate intermediate FP results.])
+
+### Determine extra CFLAGS that may be necessary for Octave.
+
+## On Intel systems with gcc, we may need to compile with -mieee-fp
+## 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])])
+    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])])
+    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)
+
+### 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)'
+  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)])
+
+
+### Look for math library.  If found, this will add -lm to LIBS.
+
+dnl Keep this check before the check for the Fortran compiler,
+dnl in case -lm is needed to compile Fortran programs.
+AC_CHECK_LIB(m, sin)
+
+### Determine the Fortran compiler and how to invoke it
+
+## Default FFLAGS is -O.
+if test -z "$FFLAGS"; then
+  FFLAGS="-O"
+fi
+
+## Prefer gfortran, but the user's F77 environment variable will override.
+AC_PROG_F77([gfortran])
+if test -z "$F77"; then
+  ## No gfortran found, search for any other installed compiler.
+  AC_PROG_F77
+fi
+if test "$F77" = g77; then
+  AC_MSG_ERROR([g77 is not a supported Fortran compiler.  Select another compiler by setting the environment variable F77 and re-running configure.])
+fi
+
+AC_MSG_CHECKING([whether a usable Fortran compiler was found])
+if test -n "$F77"; then
+  AC_MSG_RESULT(yes)
+else
+  AC_MSG_RESULT(no)
+  AC_MSG_ERROR([A Fortran compiler is required])
+fi
+
+## Determine calling conventions for Fortran compiler
+AC_F77_LIBRARY_LDFLAGS
+AC_F77_DUMMY_MAIN
+AC_F77_WRAPPERS
+
+F77_TOLOWER=yes
+F77_APPEND_UNDERSCORE=yes
+F77_APPEND_EXTRA_UNDERSCORE=yes
+
+case $ac_cv_f77_mangling in
+  "upper case") F77_TOLOWER=no ;;
+esac
+case $ac_cv_f77_mangling in
+  "no underscore") F77_APPEND_UNDERSCORE=no ;;
+esac
+case $ac_cv_f77_mangling in
+  "no extra underscore") F77_APPEND_EXTRA_UNDERSCORE=no ;;
+esac
+
+case $canonical_host_type in
+  i[[3456789]]86-*-*)
+    if test $ac_cv_f77_compiler_gnu = yes; then
+      OCTAVE_F77_FLAG([-mieee-fp])
+    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
+
+AC_SUBST(F77_TOLOWER)
+AC_SUBST(F77_APPEND_UNDERSCORE)
+AC_SUBST(F77_APPEND_EXTRA_UNDERSCORE)
+
+if test -z "$F77"; then
+  AC_MSG_ERROR([in order to build Octave, you must have a compatible Fortran compiler or wrapper script for f2c that functions as a Fortran compiler installed and in your path.  See the file INSTALL for more information.])
+fi
+
+OCTAVE_CHECK_FUNC_FORTRAN_ISNAN
+F77_ISNAN_MACRO=
+if test $octave_cv_func_fortran_isnan = no; then
+  AC_MSG_NOTICE([substituting ISNAN(X) with X.NE.X in Fortran sources])
+  F77_ISNAN_MACRO="s|ISNAN(\(@<:@^)@:>@*\))|(\1.NE.\1)|"
+fi
+AC_SUBST(F77_ISNAN_MACRO)
+
+OCTAVE_CHECK_SIZEOF_FORTRAN_INTEGER
+if test $octave_cv_sizeof_fortran_integer = no; then
+  if test $USE_64_BIT_IDX_T = yes; then
+    case $F77 in
+      *gfortran*)
+        case $F77_INTEGER_8_FLAG in
+          *-fdefault-integer-8*)
+          ;;
+          *)
+            case $FFLAGS in
+              *-fdefault-integer-8*)
+                AC_MSG_NOTICE([setting -fdefault-integer-8 in F77_INTEGER_8_FLAG instead of FFLAGS])
+                FFLAGS=`echo $FFLAGS | $SED 's/-fdefault-integer-8//g'`
+                F77_INTEGER_8_FLAG="-fdefault-integer-8"
+              ;;
+              *)
+                AC_MSG_NOTICE([adding -fdefault-integer-8 to F77_INTEGER_8_FLAG])
+                F77_INTEGER_8_FLAG="-fdefault-integer-8"
+                ## Invalidate the cache and try again.
+                $as_unset octave_cv_sizeof_fortran_integer
+              ;;
+            esac
+          ;;
+        esac
+      ;;
+    esac
+    if test -z "$octave_cv_sizeof_fortran_integer"; then
+      OCTAVE_CHECK_SIZEOF_FORTRAN_INTEGER
+    fi
+    if test $octave_cv_sizeof_fortran_integer = no; then
+      AC_MSG_ERROR([in order to build Octave with 64-bit indexing support your Fortran compiler must have an option for setting the default integer size to 8 bytes.  See the file INSTALL for more information.])
+    fi
+  else
+    AC_MSG_ERROR([your Fortran compiler must have an option to make integers the same size as octave_idx_type ($OCTAVE_IDX_TYPE).  See the file INSTALL for more information.])
+  fi
+fi
+AC_SUBST(F77_INTEGER_8_FLAG)
+
+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)
+])
+
+### Check for the Qhull library
+
+OCTAVE_CHECK_LIB(qhull, QHull,
+  [Qhull library not found.  This will result in loss of functionality of some geometry functions.],
+  [libqhull/libqhull.h qhull/libqhull.h libqhull.h qhull/qhull.h qhull.h],
+  [qh_qhull], [], [],
+  [warn_qhull=
+  OCTAVE_CHECK_QHULL_VERSION
+  OCTAVE_CHECK_LIB_QHULL_OK(
+    [AC_DEFINE(HAVE_QHULL, 1, [Define to 1 if Qhull is available.])],
+    [warn_qhull="Qhull library found, but does not seem to work properly.  This will result in loss of functionality of some geometry functions.  Please try recompiling the library with -fno-strict-aliasing."])])
+
+### Check for PCRE regex library.
+
+PCRE_LIBS=
+
+pcre_fail_msg="to build Octave, you must have the PCRE library and header files installed"
+
+AC_CHECK_HEADERS([pcre.h pcre/pcre.h])
+
+AC_CACHE_CHECK([whether pcre.h defines the macros we need],
+  [ac_cv_pcre_h_macros_present],
+  [AC_EGREP_CPP([PCRE_HAS_MACROS_WE_NEED], [
+    #if defined (HAVE_PCRE_H)
+    # include <pcre.h>
+    #elif defined (HAVE_PCRE_PCRE_H)
+    # include <pcre/pcre.h>
+    #error "NO PCRE HEADER"
+    #endif
+    #if defined (PCRE_INFO_NAMECOUNT) \
+      && defined (PCRE_INFO_NAMEENTRYSIZE) \
+      && defined (PCRE_INFO_NAMETABLE)
+      PCRE_HAS_MACROS_WE_NEED
+    #endif],
+    ac_cv_pcre_h_macros_present=yes, ac_cv_pcre_h_macros_present=no)])
+
+if test $ac_cv_pcre_h_macros_present = yes; then
+  ## check for pcre-config, and if so, get build variables
+  AC_CHECK_PROG(HAVE_PCRE_CONFIG, pcre-config, [yes], [no])
+  if test $HAVE_PCRE_CONFIG = yes; then
+    PCRE_CPPFLAGS=`pcre-config --cflags`
+    PCRE_LIBS=`pcre-config --libs`
+  else
+    PCRE_LIBS="-lpcre"
+  fi
+  save_LIBS="$LIBS"
+  LIBS="$PCRE_LIBS $LIBS"
+  AC_CHECK_FUNCS([pcre_compile],
+    [AC_SUBST(PCRE_CPPFLAGS)
+     AC_SUBST(PCRE_LIBS)],
+    [AC_MSG_ERROR([$pcre_fail_msg])])
+  LIBS="$save_LIBS"
+else
+  AC_MSG_ERROR([$pcre_fail_msg])
+fi
+
+### Check for ZLIB library.
+
+OCTAVE_CHECK_LIB(z, ZLIB,
+  [ZLIB library not found.  Octave will not be able to save or load compressed data files or HDF5 files.],
+  [zlib.h], [gzclearerr])
+
+### Also define HAVE_ZLIB if libz is found.
+if test -z "$warn_z"; then
+  AC_DEFINE(HAVE_ZLIB, 1, [Define to 1 if ZLIB is available.])
+fi
+
+ ### Check for the LLVM library
+
+build_jit=no
+AC_ARG_ENABLE([jit],
+  [AS_HELP_STRING([--enable-jit],
+    [(EXPERIMENTAL) enable JIT compiler])],
+  [if test "$enableval" = yes; then
+     build_jit=yes
+   fi],
+  [])
+
+LLVM_CXXFLAGS=
+LLVM_CPPFLAGS=
+LLVM_LDFLAGS=
+LLVM_LIBS=
+
+if test $build_jit = yes; then
+
+  ## Find llvm-config program from environment variable or by searching
+  AC_ARG_VAR([LLVM_CONFIG], [path to llvm-config utility])
+  AC_CHECK_PROG([LLVM_CONFIG], llvm-config, llvm-config, [])
+
+  if test -z "$LLVM_CONFIG"; then
+    warn_llvm="llvm-config utility not found.  JIT compiler is disabled."
+  else
+    dnl Preset warning message in case compile fails
+    warn_llvm="LLVM was not found or is to old.  JIT compiler is disabled."
+
+    save_CPPFLAGS="$CPPFLAGS"
+    save_CXXFLAGS="$CXXFLAGS"
+    save_LDFLAGS="$LDFLAGS"
+
+    ## Use -isystem if available because we don't want to see warnings in LLVM
+    LLVM_INCLUDE_FLAG=-I
+    OCTAVE_CC_FLAG([-isystem .], [
+      LLVM_INCLUDE_FLAG=-isystem
+      AC_MSG_NOTICE([using -isystem for LLVM headers])])
+
+    dnl Use -isystem so we don't get warnings from llvm headers
+    LLVM_CPPFLAGS="$LLVM_INCLUDE_FLAG `$LLVM_CONFIG --includedir`"
+    LLVM_CXXFLAGS=
+    LLVM_LDFLAGS="-L`$LLVM_CONFIG --libdir`"
+
+
+    LDFLAGS="$LDFLAGS $LLVM_LDFLAGS"
+    LLVM_SO=LLVM-`$LLVM_CONFIG --version`
+    AC_CHECK_LIB([$LLVM_SO], [LLVMBuildAdd], [LLVM_LIBS="-l$LLVM_SO"], [LLVM_LIBS=`$LLVM_CONFIG --libs`])
+
+    dnl
+    dnl Define some extra flags that LLVM requires in order to include headers.
+    dnl Ideally we should get these from llvm-config, but llvm-config isn't
+    dnl very helpful.
+    dnl
+    CPPFLAGS="-D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS $LLVM_CPPFLAGS $CPPFLAGS"
+    CXXFLAGS="$LLVM_CXXFLAGS $CXXFLAGS"
+    AC_LANG_PUSH(C++)
+    AC_CHECK_HEADER([llvm/Support/TargetSelect.h], [warn_llvm=""])
+
+    have_function_h=no
+    AC_CHECK_HEADERS([llvm/IR/Function.h llvm/Function.h],
+                     [have_function_h=yes; break])
+    if test $have_function_h = no; then
+      warn_llvm="Missing LLVM file Function.h.  JIT compiler is disabled."
+    fi
+    have_irbuilder_h=no
+    AC_CHECK_HEADERS([llvm/Support/IRBuilder.h llvm/IR/IRBuilder.h \
+                      llvm/IRBuilder.h], [have_irbuilder_h=yes; break])
+    if test $have_irbuilder_h = no; then
+      warn_llvm="Missing LLVM file IRBuilder.h.  JIT compiler is disabled."
+    fi
+    have_llvm_data_h=no
+    AC_CHECK_HEADERS([llvm/Target/TargetData.h llvm/IR/DataLayout.h \
+                      llvm/DataLayout.h], [have_llvm_data_h=yes; break])
+    if test $have_llvm_data_h = no; then
+      warn_llvm="Missing LLVM file TargetData.h.  JIT compiler is disabled."
+    fi
+
+    AC_CHECK_HEADERS([llvm/IR/Verifier.h])
+
+    OCTAVE_LLVM_FUNCTION_ADDATTRIBUTE_API
+    OCTAVE_LLVM_FUNCTION_ADDFNATTR_API
+    OCTAVE_LLVM_CALLINST_ADDATTRIBUTE_API
+    OCTAVE_LLVM_RAW_FD_OSTREAM_API
+    OCTAVE_LLVM_LEGACY_PASSMANAGER_API
+    AC_LANG_POP(C++)
+    CPPFLAGS="$save_CPPFLAGS"
+    CXXFLAGS="$save_CXXFLAGS"
+    LDFLAGS="$save_LDFLAGS"
+  fi
+
+  if test -z "$warn_llvm"; then
+    AC_DEFINE(HAVE_LLVM, 1, [Define to 1 if LLVM is available.])
+  else
+    build_jit=no
+    LLVM_CPPFLAGS=
+    LLVM_CXXFLAGS=
+    LLVM_LDFLAGS=
+    LLVM_LIBS=
+    OCTAVE_CONFIGURE_WARNING([warn_llvm])
+  fi
+dnl FIXME: Re-instate when JIT is enabled by default
+dnl else
+dnl   ## JIT build disabled
+dnl   warn_llvm="JIT compiler disabled, some performance loss for loops"
+dnl   OCTAVE_CONFIGURE_WARNING([warn_llvm])
+fi
+
+AC_SUBST(LLVM_CPPFLAGS)
+AC_SUBST(LLVM_CXXFLAGS)
+AC_SUBST(LLVM_LDFLAGS)
+AC_SUBST(LLVM_LIBS)
+AM_CONDITIONAL([AMCOND_HAVE_LLVM], [test -z "$warn_llvm"])
+
+### Check for HDF5 library.
+
+save_CPPFLAGS="$CPPFLAGS"
+save_LIBS="$LIBS"
+CPPFLAGS="$Z_CPPFLAGS $CPPFLAGS"
+LIBS="$Z_LDFLAGS $Z_LIBS $LIBS"
+OCTAVE_CHECK_LIB(hdf5, HDF5,
+  [HDF5 library not found.  Octave will not be able to save or load HDF5 data files.],
+  [hdf5.h], [H5Gget_num_objs], [], [],
+  [warn_hdf5=
+   OCTAVE_CHECK_HDF5_HAS_VER_16_API
+   AC_DEFINE(HAVE_HDF5, 1,
+     [Define to 1 if HDF5 is available and newer than version 1.6.])
+   if test $have_msvc = yes; then
+     OCTAVE_CHECK_LIB_HDF5_DLL
+   fi
+  ])
+CPPFLAGS="$save_CPPFLAGS"
+LIBS="$save_LIBS"
+
+### Check for FFTW library.  Default to Fortran FFTPACK if it is not available.
+
+## Check for FFTW header and library.
+OCTAVE_CHECK_LIB(fftw3, FFTW3,
+  [FFTW3 library not found.  The slower FFTPACK library will be used instead.],
+  [fftw3.h], [fftw_plan_dft_1d])
+
+OCTAVE_CHECK_LIB(fftw3f, FFTW3F,
+  [FFTW3F library not found.  The slower FFTPACK library will be used instead.],
+  [fftw3.h], [fftwf_plan_dft_1d])
+
+## Check command line for the option to disable multi-threaded FFTW
+build_fftw_threads=yes
+AC_ARG_ENABLE([fftw-threads],
+  [AS_HELP_STRING([--disable-fftw-threads],
+    [disable Multi-threaded FFTW])],
+  [if test "$enableval" = no; then
+     build_fftw_threads=no
+   fi],
+  [])
+
+## Octave is currently unable to use FFTW unless
+## both float and double versions are available.
+
+AM_CONDITIONAL([AMCOND_HAVE_FFTW],
+  [test -n "$FFTW3_LIBS" && test -n "$FFTW3F_LIBS"])
+
+if test -n "$FFTW3_LIBS" && test -n "$FFTW3F_LIBS"; then
+  AC_DEFINE(HAVE_FFTW, 1, [Define if you have both FFTW3 and FFTW3F libraries.])
+else
+  ## --without-fftw3 given, or one of the FFTW3 libs not installed.
+  ## Don't check for FFTW threads as this is now pointless.
+  build_fftw_threads=no
+fi
+
+## Check for the multithreaded FFTW library.
+## Fallback to singlethreaded if not found or disabled
+if test $build_fftw_threads = yes; then
+  OCTAVE_CHECK_FFTW_THREADS(fftw3, fftw_plan_with_nthreads)
+  OCTAVE_CHECK_FFTW_THREADS(fftw3f, fftwf_plan_with_nthreads)
+fi
+
+## Subdirectory of liboctave/cruft to build if FFTW is not found.
+FFT_DIR="fftpack"
+AC_SUBST(FFT_DIR)
+
+### Check for GLPK library and header.
+
+save_CPPFLAGS="$CPPFLAGS"
+save_LIBS="$LIBS"
+CPPFLAGS="$Z_CPPFLAGS $CPPFLAGS"
+LIBS="$Z_LDFLAGS $Z_LIBS $LIBS"
+OCTAVE_CHECK_LIB(glpk, GLPK,
+  [GLPK library not found.  The glpk function for solving linear programs will be disabled.],
+  [glpk/glpk.h glpk.h], [glp_simplex], [], [],
+  [warn_glpk=
+   OCTAVE_CHECK_LIB_GLPK_OK(
+    [AC_DEFINE(HAVE_GLPK, 1, [Define to 1 if GLPK is available.])],
+    [warn_glpk="GLPK library found, but does not seem to work properly -- disabling glpk function"])])
+LIBS="$save_LIBS"
+CPPFLAGS="$save_CPPFLAGS"
+
+### Checks for cURL header and library.
+
+save_CPPFLAGS="$CPPFLAGS"
+save_LIBS="$LIBS"
+CPPFLAGS="$Z_CPPFLAGS $CPPFLAGS"
+LIBS="$Z_LDFLAGS $Z_LIBS $LIBS"
+OCTAVE_CHECK_LIB(curl, cURL,
+  [cURL library not found.  The ftp objects, urlread and urlwrite functions will be disabled.],
+  [curl/curl.h], [curl_easy_escape])
+if test -z "$warn_curl"; then
+  ## Additional check on cURL library that was found
+  AC_CACHE_CHECK([for CURLOPT_DIRLISTONLY in curl/curl.h],
+    [octave_cv_curl_has_curlopt_dirlistonly],
+    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+      #include <curl/curl.h>
+      ]], [[
+      curl_easy_setopt ((CURL*)NULL, CURLOPT_DIRLISTONLY, 0);
+      ]])],
+      [octave_cv_curl_has_curlopt_dirlistonly=yes],
+      [octave_cv_curl_has_curlopt_dirlistonly=no])
+    ])
+  if test $octave_cv_curl_has_curlopt_dirlistonly = no; then
+    AC_DEFINE(CURLOPT_DIRLISTONLY, CURLOPT_FTPLISTONLY,
+      [Define to the legacy option name if using an older version of cURL.])
+  fi
+fi
+LIBS="$save_LIBS"
+CPPFLAGS="$save_CPPFLAGS"
+
+### Check for sndfile
+
+warn_sndfile="sndfile library fails tests.  The audioinfo, audioread and audiowrite functions for reading and writing audio files will not be fully functional."
+
+check_sndfile=no
+AC_ARG_WITH([sndfile],
+  [AS_HELP_STRING([--without-sndfile],
+    [don't use sndfile library, disable audio file I/O])],
+  [if test x"$withval" = x"no"; then
+     warn_sndfile="--without-sndfile specified.  The audioinfo, audioread and audiowrite functions for reading and writing audio files will not be fully functional."
+   else
+     check_sndfile=yes
+   fi],
+  [check_sndfile=yes])
+
+if test $check_sndfile = yes; then
+  PKG_CHECK_EXISTS([sndfile], [
+    SNDFILE_CPPFLAGS=`$PKG_CONFIG --cflags-only-I sndfile`
+    SNDFILE_LDFLAGS=`$PKG_CONFIG --libs-only-L sndfile`
+    SNDFILE_LIBS=`$PKG_CONFIG --libs-only-l sndfile`
+    OCTAVE_CHECK_LIB_SNDFILE_OK([warn_sndfile=])
+  ])
+fi
+
+if test -z "$warn_sndfile"; then
+  AC_DEFINE(HAVE_SNDFILE, 1, [Define to 1 if sndfile is available.])
+else
+  SNDFILE_CPPFLAGS=
+  SNDFILE_LDFLAGS=
+  SNDFILE_LIBS=
+fi
+
+AC_SUBST(SNDFILE_CPPFLAGS)
+AC_SUBST(SNDFILE_LDFLAGS)
+AC_SUBST(SNDFILE_LIBS)
+
+### Check for PortAudio
+
+warn_portaudio="PortAudio library fails tests.  The audioplayer, audiorecorder classes and audiodevinfo function for audio playback and recording will not be fully functional."
+
+check_portaudio=no
+AC_ARG_WITH([portaudio],
+  [AS_HELP_STRING([--without-portaudio],
+    [don't use PortAudio library, disable audio playback and recording])],
+  [if test x"$withval" = x"no"; then
+     warn_portaudio="--without-portaudio specified.  The audioplayer, audiorecorder classes and audiodevinfo function for audio playback and recording will not be fully functional."
+   else
+     check_portaudio=yes
+   fi],
+  [check_portaudio=yes])
+
+if test $check_portaudio = yes; then
+  PKG_CHECK_EXISTS([portaudio-2.0 >= 19], [
+    PORTAUDIO_CPPFLAGS=`$PKG_CONFIG --cflags-only-I portaudio-2.0`
+    PORTAUDIO_LDFLAGS=`$PKG_CONFIG --libs-only-L portaudio-2.0`
+    PORTAUDIO_LIBS=`$PKG_CONFIG --libs-only-l portaudio-2.0`
+    warn_portaudio=
+  ])
+fi
+
+if test -z "$warn_portaudio"; then
+  AC_DEFINE(HAVE_PORTAUDIO, 1, [Define to 1 if PortAudio is available.])
+else
+  PORTAUDIO_CPPFLAGS=
+  PORTAUDIO_LDFLAGS=
+  PORTAUDIO_LIBS=
+fi
+AC_SUBST(PORTAUDIO_CPPFLAGS)
+AC_SUBST(PORTAUDIO_LDFLAGS)
+AC_SUBST(PORTAUDIO_LIBS)
+
+### Check for either of Graphics/ImageMagick++ libraries
+
+AC_ARG_WITH([magick],
+  [AS_HELP_STRING([--with-magick=LIB],
+    [select library to use for image I/O (options: GraphicsMagick(default) or ImageMagick)])],
+  [magick="$withval"],
+  [magick="GraphicsMagick"])
+
+warn_magick="$magick++ library not found.  The imread function for reading image files will not be fully functional."
+
+MAGICK_CPPFLAGS=
+MAGICK_LDFLAGS=
+MAGICK_LIBS=
+
+PKG_CHECK_EXISTS([$magick++], [
+  ## Make sure we only get -I, -L, and -l flags.  Some Graphics/ImageMagick++
+  ## packages add extra flags that are useful when building
+  ## Graphics/ImageMagick++ extentions.  These extra flags break the
+  ## Octave build.
+  MAGICK_CPPFLAGS=`$PKG_CONFIG --cflags-only-I $magick++`
+  MAGICK_LDFLAGS=`$PKG_CONFIG --libs-only-L $magick++`
+  MAGICK_LIBS=`$PKG_CONFIG --libs-only-l $magick++`
+
+  warn_magick="$magick++ library fails tests.  The imread function for reading image files will not be fully functional."
+
+  save_CPPFLAGS="$CPPFLAGS"
+  save_LIBS="$LIBS"
+  CPPFLAGS="$MAGICK_CPPFLAGS $CPPFLAGS"
+  LIBS="$MAGICK_LDFLAGS $MAGICK_LIBS $LIBS"
+  AC_LANG_PUSH(C++)
+  AC_CHECK_HEADER([Magick++.h], [
+    AC_CACHE_CHECK([for Magick::ColorRGB in Magick++.h],
+      [octave_cv_func_magick_colorrgb],
+      [AC_PREPROC_IFELSE([AC_LANG_SOURCE([[
+        #include <Magick++.h>
+        ]], [[
+        Magick::ColorRGB c;
+        ]])],
+        octave_cv_func_magick_colorrgb=yes,
+        octave_cv_func_magick_colorrgb=no)
+      ])
+    if test $octave_cv_func_magick_colorrgb = yes; then
+      warn_magick=
+    fi
+  ])
+  AC_LANG_POP(C++)
+  CPPFLAGS="$save_CPPFLAGS"
+  LIBS="$save_LIBS"
+
+  AC_CHECK_FUNCS([setlocale], [],
+                 [warn_magick="$magick++ requires setlocale function.  The imread function for reading image files will not be fully functional."])
+])
+
+if test -z "$warn_magick"; then
+  AC_DEFINE(HAVE_MAGICK, 1,
+    [Define to 1 if Graphics/ImageMagick++ is available.])
+else
+  MAGICK_CPPFLAGS=
+  MAGICK_LDFLAGS=
+  MAGICK_LIBS=
+fi
+AC_SUBST(MAGICK_CPPFLAGS)
+AC_SUBST(MAGICK_LDFLAGS)
+AC_SUBST(MAGICK_LIBS)
+
+### Check for X11 libraries
+
+AC_PATH_X
+if test "$have_x" = yes; then
+  AC_DEFINE(HAVE_X_WINDOWS, 1, [Define to 1 if you have X11.])
+
+  if test "$x_includes" != "NONE"; then
+    X11_INCFLAGS="$x_includes"
+  fi
+  AC_SUBST(X11_INCFLAGS)
+
+  if test -z "$x_libraries"; then
+    AC_CHECK_LIB([X11], XrmInitialize, [X11_LIBS="-lX11"], [X11_LIBS=])
+  elif test $x_libraries != "NONE"; then
+    AC_CHECK_LIB([X11], XrmInitialize,
+      [X11_LIBS="-L$x_libraries -lX11"], [X11_LIBS=], "-L$x_libraries")
+  fi
+  AC_SUBST(X11_LIBS)
+fi
+
+### Check for the Carbon framework on MacOSX systems
+OCTAVE_HAVE_FRAMEWORK([Carbon],
+  [[#include <Carbon/Carbon.h>]], [[CGMainDisplayID ()]],
+  [have_framework_carbon=yes], [have_framework_carbon=no])
+if test $have_framework_carbon = yes; then
+  AC_DEFINE(HAVE_FRAMEWORK_CARBON, 1,
+    [Define to 1 if framework CARBON is available.])
+  CARBON_LIBS="-Wl,-framework -Wl,Carbon"
+  AC_MSG_NOTICE([adding -Wl,-framework -Wl,Carbon to CARBON_LIBS])
+  AC_SUBST(CARBON_LIBS)
+fi
+
+### Check for list of libraries needed for native graphics renderer.
+
+native_graphics=yes
+warn_freetype=""
+
+check_opengl=no
+AC_ARG_WITH([opengl],
+  [AS_HELP_STRING([--without-opengl],
+    [don't use OpenGL libraries, disable native graphics])],
+  [if test x"$withval" = x"no"; then
+     native_graphics=no
+     warn_opengl="--without-opengl specified.  Native graphics will be disabled."
+     OCTAVE_CONFIGURE_WARNING([warn_opengl])
+   else
+     check_opengl=yes
+   fi],
+  [check_opengl=yes])
+
+## Check for OpenGL library
+if test $check_opengl = yes; then
+  OCTAVE_CHECK_LIB_OPENGL
+fi
+
+FLTK_CPPFLAGS=
+FLTK_LDFLAGS=
+FLTK_LIBS=
+
+if test -z "$OPENGL_LIBS"; then
+  if test $check_opengl = yes; then
+    native_graphics=no
+    warn_fltk_opengl="OpenGL libs (GL and GLU) not found.  Native graphics will be disabled."
+    OCTAVE_CONFIGURE_WARNING([warn_fltk_opengl])
+  fi
+fi
+
+if test -n "$OPENGL_LIBS"; then
+  AC_DEFINE(HAVE_OPENGL, 1, [Define to 1 if OpenGL is available.])
+
+  ## Check for FreeType 2 library
+
+  PKG_CHECK_MODULES([FT2], [freetype2], [
+    min_ft2_version=9.03
+    AC_MSG_CHECKING([for FreeType2 version >= $min_ft2_version])
+    $PKG_CONFIG freetype2 --atleast-version=$min_ft2_version
+    ac_status=$?
+    if test $ac_status = 0; then
+      AC_MSG_RESULT(yes)
+      AC_DEFINE(HAVE_FREETYPE, 1, [Define to 1 if you have Freetype library.])
+      save_LIBS="$LIBS"
+      LIBS="$FT2_LIBS $LIBS"
+      AC_CHECK_FUNCS([FT_Reference_Face])
+      LIBS="$save_LIBS"
+    else
+      AC_MSG_RESULT(no)
+      warn_freetype="FreeType library >= 9.03 not found.  Native graphics will be disabled."
+    fi])
+
+  if test -n "$warn_freetype"; then
+    native_graphics=no
+    OCTAVE_CONFIGURE_WARNING([warn_freetype])
+  else
+    FT2_CPPFLAGS="$FT2_CFLAGS"
+  fi
+
+  ## Check for fontconfig library
+
+  warn_fontconfig=""
+  if test $native_graphics = yes; then
+    PKG_CHECK_MODULES(FONTCONFIG, [fontconfig],
+      [have_fontconfig=yes
+       OPENGL_LIBS="$FONTCONFIG_LIBS $OPENGL_LIBS"
+       AC_DEFINE(HAVE_FONTCONFIG, 1, [Define to 1 if fontconfig is present.])],
+      [have_fontconfig=no
+       warn_fontconfig="Fontconfig library not found.  Native graphics will be disabled."])
+  fi
+
+  if test -n "$warn_fontconfig"; then
+    native_graphics=no
+    OCTAVE_CONFIGURE_WARNING([warn_fontconfig])
+  else
+    FONTCONFIG_CPPFLAGS="$FONTCONFIG_CFLAGS"
+  fi
+
+  ## Check for Xft library (when using X11)
+
+  warn_xft=""
+  if test $native_graphics = yes && test "$have_x" = yes; then
+    PKG_CHECK_MODULES(XFT, [xft],
+      [AC_DEFINE(HAVE_XFT, 1, [Define to 1 if Xft is present.])],
+      [warn_xft="Xft library not found.  Native graphics will be disabled."])
+  fi
+
+  if test -n "$warn_xft"; then
+    native_graphics=no
+    OCTAVE_CONFIGURE_WARNING([warn_xft])
+  fi
+
+  ## Check for FLTK (www.fltk.org) library
+
+  check_fltk=no
+  AC_ARG_WITH([fltk],
+    [AS_HELP_STRING([--without-fltk],
+      [don't use FLTK libraries, disable native graphics])],
+    [if test x"$withval" = x"no"; then
+       native_graphics=no
+       warn_fltk="--without-fltk specified.  Native graphics will be disabled."
+       OCTAVE_CONFIGURE_WARNING([warn_fltk])
+     else
+       check_fltk=yes
+     fi],
+    [check_fltk=yes])
+
+  if test $check_fltk = yes; then
+    AC_ARG_WITH([fltk-prefix],
+      [AS_HELP_STRING([--with-fltk-prefix=PFX],
+        [prefix where FLTK is installed (optional)])],
+      [fltk_prefix="$withval"],
+      [fltk_prefix=""])
+
+    AC_ARG_WITH([fltk-exec-prefix],
+      [AS_HELP_STRING([--with-fltk-exec-prefix=PFX],
+        [exec prefix where FLTK is installed (optional)])],
+      [fltk_exec_prefix="$withval"],
+      [fltk_exec_prefix=""])
+
+    if test x"$fltk_exec_prefix" != x""; then
+      fltk_args="$fltk_args --exec-prefix=$fltk_exec_prefix"
+      if test "x${FLTK_CONFIG+set}" != xset ; then
+        FLTK_CONFIG="$fltk_exec_prefix/bin/fltk-config"
+      fi
+    fi
+
+    if test x"$fltk_prefix" != x""; then
+      fltk_args="$fltk_args --prefix=$fltk_prefix"
+      if test x${FLTK_CONFIG+set} != xset ; then
+        FLTK_CONFIG="$fltk_prefix/bin/fltk-config"
+      fi
+    fi
+
+    AC_PATH_PROG([FLTK_CONFIG], [fltk-config], [no])
+
+    warn_fltk_config=""
+    warn_fltk_opengl=""
+
+    if test "$FLTK_CONFIG" = no; then
+      native_graphics=no
+      warn_fltk_config="FLTK config script not found.  Native graphics will be disabled."
+      OCTAVE_CONFIGURE_WARNING([warn_fltk_config])
+    else
+      FLTK_CPPFLAGS=`$FLTK_CONFIG $fltkconf_args --use-gl --cflags`
+      FLTK_LDFLAGS=`$FLTK_CONFIG $fltkconf_args --use-gl --ldflags`
+
+      case $host_os in
+        mingw*)
+          FLTK_LDFLAGS=`echo $FLTK_LDFLAGS | $SED -e 's/-mwindows//g'`
+        ;;
+      esac
+
+      AC_CACHE_CHECK([for OpenGL support in FLTK],
+        [octave_cv_fltk_opengl_support],
+        [save_CPPFLAGS="$CPPFLAGS"
+        CPPFLAGS="$CFLAGS $FLTK_CPPFLAGS"
+        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+          #include <FL/gl.h>
+          ]], [[
+          int nothing = 0;
+          ]])],
+          octave_cv_fltk_opengl_support=no,
+          octave_cv_fltk_opengl_support=yes)
+        CPPFLAGS="$save_CPPFLAGS"
+        ])
+      if test $octave_cv_fltk_opengl_support = no; then
+        warn_fltk_opengl="FLTK does not have OpenGL support.  Native graphics will be disabled."
+      else
+        AC_DEFINE(HAVE_FLTK, 1, [Define to 1 if FLTK is available.])
+      fi
+
+      if test -n "$warn_fltk_opengl"; then
+        native_graphics=no
+        OCTAVE_CONFIGURE_WARNING([warn_fltk_opengl])
+      fi
+    fi
+  fi
+fi
+
+AC_SUBST(FLTK_CPPFLAGS)
+AC_SUBST(FLTK_LDFLAGS)
+AC_SUBST(FLTK_LIBS)
+
+## Check for gl2ps which is required for printing with OpenGL graphics
+if test $native_graphics = yes; then
+  AC_CHECK_HEADERS([gl2ps.h],
+    [GL2PS_LIBS="-lgl2ps"],
+    [warn_gl2ps="gl2ps library not found.  OpenGL printing is disabled."
+     OCTAVE_CONFIGURE_WARNING([warn_gl2ps])])
+fi
+
+AC_SUBST(GL2PS_LIBS)
+
+if test -n "$OPENGL_LIBS"; then
+  ## Check for OSMesa which is needed for offscreen rendering with OpenGL
+  ## FIXME: Check for version >= 9.0.0
+  OCTAVE_CHECK_LIB(OSMesa, OSMesa,
+    [OSMesa library not found.  Offscreen rendering with OpenGL will be disabled.],
+    [osmesa.h GL/osmesa.h], [OSMesaCreateContext])
+fi
+
+### Start determination of shared vs. static libraries
+
+## 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_PROG_AR
+
+ifdef([LT_INIT], [], [
+  errprint([error: you must have libtool 2.2.2 or a more recent version
+])
+  m4exit([1])])
+
+LT_PREREQ([2.2.2])
+LT_INIT([disable-static dlopen win32-dll])
+
+if test $enable_shared = yes; then
+  SHARED_LIBS=yes
+else
+  SHARED_LIBS=no
+fi
+
+if test $enable_static = yes; then
+  STATIC_LIBS=yes
+else
+  STATIC_LIBS=no
+fi
+
+XTRA_CRUFT_SH_LDFLAGS=
+if test $have_msvc = yes; then
+  FLIBS="$FLIBS -lkernel32"
+  XTRA_CRUFT_SH_LDFLAGS="-Wl,cruft/cruft.def"
+fi
+AC_SUBST(XTRA_CRUFT_SH_LDFLAGS)
+
+### Check for BLAS and LAPACK libraries:
+
+## Need to adjust FFLAGS to include correct integer size.
+save_FFLAGS="$FFLAGS"
+FFLAGS="$FFLAGS $F77_INTEGER_8_FLAG"
+
+AX_BLAS_WITH_F77_FUNC([:], [:],
+  [ax_blas_ok=yes
+  AC_MSG_CHECKING([BLAS can be called from Fortran])
+  AC_MSG_RESULT([yes assumed for cross compilation])])
+AX_LAPACK([:], [:])
+
+## Restore FFLAGS.
+FFLAGS="$save_FFLAGS"
+
+## If necessary, try again with -ff2c in FFLAGS
+if test $ax_blas_ok = no; then
+  save_FFLAGS="$FFLAGS"
+  FFLAGS="-ff2c $FFLAGS $F77_INTEGER_8_FLAG"
+
+  AX_BLAS_WITH_F77_FUNC([:], [:])
+  AX_LAPACK([:], [:])
+
+  ## Restore FFLAGS, with -ff2c if that was helpful
+
+  if test $ax_blas_ok = yes; then
+    FFLAGS="-ff2c $save_FFLAGS"
+  else
+    FFLAGS="$save_FFLAGS"
+  fi
+fi
+
+## On OSX, try again with a wrapper library (without -ff2c!)
+if test $ax_blas_ok = no; then
+  case $host_os in
+    darwin*)
+      ## test if wrapper functions help
+      octave_blaswrap_save_CFLAGS="$CFLAGS"
+      CFLAGS="$CFLAGS -DUSE_BLASWRAP"
+      AC_LANG_PUSH(C)
+      AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
+          #include "liboctave/cruft/misc/blaswrap.c"
+        ]])],
+        [mv conftest.$ac_objext blaswrap.$ac_objext
+         octave_blaswrap_save_BLAS_LIBS="$BLAS_LIBS"
+         BLAS_LIBS="blaswrap.$ac_objext -framework vecLib"
+
+         save_FFLAGS="$FFLAGS"
+         FFLAGS="$FFLAGS $F77_INTEGER_8_FLAG"
+
+         AX_BLAS_WITH_F77_FUNC([:], [:])
+         AX_LAPACK([:], [:])
+
+         ## Restore FFLAGS.
+         FFLAGS="$save_FFLAGS"
+
+         ## remove temp file
+         rm -f blaswrap.$ac_objext],
+        [AC_MSG_FAILURE([cannot compile liboctave/cruft/misc/blaswrap.c])])
+      AC_LANG_POP(C)
+      CFLAGS="$octave_blaswrap_save_CFLAGS"
+
+      if test $ax_blas_ok = no; then
+        BLAS_LIBS="$octave_blaswrap_save_BLAS_LIBS"
+      else
+        ## wrapper in cruft, remove from BLAS_LIBS
+        BLAS_LIBS=`echo $BLAS_LIBS | $SED -e 's/blaswrap.[[^ ]]* //g'`
+        AC_DEFINE(USE_BLASWRAP, 1,
+          [Define to 1 if BLAS functions need to be wrapped (potentially needed for 64-bit OSX only).])
+      fi
+    ;;
+  esac
+fi
+
+if test $ax_blas_ok = no; then
+  if test $USE_64_BIT_IDX_T = yes && test "$ax_blas_integer_size_ok" = no; then
+    ## Attempt to be more informative.
+    AC_MSG_ERROR([BLAS doesn't seem to support 64-bit integers.  This is incompatible with --enable-64.])
+  else
+    AC_MSG_ERROR([A BLAS library was detected but found incompatible with your Fortran 77 compiler settings.])
+  fi
+fi
+
+if test $ax_blas_ok = no || test $ax_lapack_ok = no; then
+  AC_MSG_ERROR([BLAS and LAPACK libraries are required])
+fi
+
+### Check for the qrupdate library
+
+## No need to adjust FFLAGS because only link is attempted.
+## Must supply proper LIBS, however.
+save_LIBS="$LIBS"
+LIBS="$LAPACK_LIBS $BLAS_LIBS $FLIBS $LIBS"
+OCTAVE_CHECK_LIB(qrupdate, qrupdate,
+  [qrupdate not found.  The QR & Cholesky updating functions will be slow.],
+  [],
+  [sqr1up],
+  [Fortran 77], [don't use qrupdate, disable QR & Cholesky updating functions])
+
+## Additional check to see if qrupdate lib found supports LU updates
+if test -z "$warn_qrupdate"; then
+  AC_CACHE_CHECK([for slup1up in $QRUPDATE_LIBS],
+    [octave_cv_func_slup1up],
+    [LIBS="$LIBS $QRUPDATE_LIBS"
+    AC_LANG_PUSH([Fortran 77])
+    AC_LINK_IFELSE([AC_LANG_CALL([], [slup1up])],
+      octave_cv_func_slup1up=yes, octave_cv_func_slup1up=no)
+    AC_LANG_POP([Fortran 77])
+  ])
+  if test $octave_cv_func_slup1up = yes; then
+    AC_DEFINE(HAVE_QRUPDATE_LUU, 1, [Define to 1 if qrupdate supports LU updates.])
+  fi
+fi
+LIBS="$save_LIBS"
+
+if test $USE_64_BIT_IDX_T = yes; then
+  CHOLMOD_TAG="_l_"
+  CXSPARSE_TAG="_dl_"
+  UMFPACK_TAG="_zl_"
+else
+  CHOLMOD_TAG="_"
+  CXSPARSE_TAG="_di_"
+  UMFPACK_TAG="_zi_"
+fi
+
+### Check for AMD library
+
+OCTAVE_CHECK_LIB(amd, AMD,
+  [AMD library not found.  This will result in some lack of functionality for sparse matrices.],
+  [suitesparse/amd.h ufsparse/amd.h amd/amd.h amd.h],
+  [amd_postorder],
+  [], [don't use AMD library, disable some sparse matrix functionality])
+
+### Check for CAMD library
+
+OCTAVE_CHECK_LIB(camd, CAMD,
+  [CAMD library not found.  This will result in some lack of functionality for sparse matrices.],
+  [suitesparse/camd.h ufsparse/camd.h camd/camd.h camd.h],
+  [camd_postorder],
+  [], [don't use CAMD library, disable some sparse matrix functionality])
+
+### Check for COLAMD library
+
+OCTAVE_CHECK_LIB(colamd, COLAMD,
+  [COLAMD library not found.  This will result in some lack of functionality for sparse matrices.],
+  [suitesparse/colamd.h ufsparse/colamd.h colamd/colamd.h colamd.h],
+  [colamd],
+  [], [don't use COLAMD library, disable some sparse matrix functionality])
+
+### Check for CCOLAMD library
+
+OCTAVE_CHECK_LIB(ccolamd, CCOLAMD,
+  [CCOLAMD library not found.  This will result in some lack of functionality for sparse matrices.],
+  [suitesparse/ccolamd.h ufsparse/ccolamd.h ccolamd/ccolamd.h ccolamd.h],
+  [ccolamd],
+  [], [don't use CCOLAMD library, disable some sparse matrix functionality])
+
+### Check for CHOLMOD library.
+### If your cholmod library requires cblas, then you will need to
+### configure with --with-cholmod="-lcholmod -lcblas".
+
+save_LIBS="$LIBS"
+LIBS="$COLAMD_LDFLAGS $COLAMD_LIBS $AMD_LDFLAGS $AMD_LIBS $LAPACK_LIBS $BLAS_LIBS $FLIBS $LIBS"
+OCTAVE_CHECK_LIB(cholmod, CHOLMOD,
+  [CHOLMOD library not found.  This will result in some lack of functionality for sparse matrices.],
+  [suitesparse/cholmod.h ufsparse/cholmod.h cholmod/cholmod.h cholmod.h],
+  [cholmod${CHOLMOD_TAG}start],
+  [], [don't use CHOLMOD library, disable some sparse matrix functionality])
+LIBS="$save_LIBS"
+
+### Check for CXSparse library
+
+OCTAVE_CHECK_LIB(cxsparse, CXSparse,
+  [CXSparse library not found.  This will result in some lack of functionality for sparse matrices.],
+  [suitesparse/cs.h ufsparse/cs.h cxsparse/cs.h cs.h],
+  [cs${CXSPARSE_TAG}sqr],
+  [C++], [don't use CXSparse library, disable some sparse matrix functionality])
+
+### Check for UMFPACK library.
+
+save_LIBS="$LIBS"
+save_CPPFLAGS="$CPPFLAGS"
+LIBS="$AMD_LDFLAGS $AMD_LIBS $BLAS_LIBS $FLIBS $LIBS"
+CPPFLAGS="$AMD_CPPFLAGS $CPPFLAGS"
+OCTAVE_CHECK_LIB([umfpack], UMFPACK,
+  [UMFPACK not found.  This will result in some lack of functionality for sparse matrices.],
+  [suitesparse/umfpack.h ufsparse/umfpack.h umfpack/umfpack.h umfpack.h],
+  [umfpack${UMFPACK_TAG}get_determinant],
+  [], [don't use UMFPACK, disable some sparse matrix functionality])
+CPPFLAGS="$save_CPPFLAGS"
+LIBS="$save_LIBS"
+
+if test -z "$UMFPACK_LIBS"; then
+  ## Invalidate the cache and try again with -lcblas.
+  $as_unset ac_cv_lib_umfpack_umfpack${UMFPACK_TAG}get_determinant
+  $as_unset octave_cv_lib_umfpack
+  save_LIBS="$LIBS"
+  LIBS="-lcblas $AMD_LDFLAGS $AMD_LIBS $BLAS_LIBS $FLIBS $LIBS"
+  OCTAVE_CHECK_LIB([umfpack], UMFPACK,
+    [UMFPACK not found.  This will result in some lack of functionality for sparse matrices.],
+    [suitesparse/umfpack.h ufsparse/umfpack.h umfpack/umfpack.h umfpack.h],
+    [umfpack${UMFPACK_TAG}get_determinant],
+    [], [don't use UMFPACK, disable some sparse matrix functionality])
+  if test -n "$UMFPACK_LIBS"; then
+    UMFPACK_LIBS="$UMFPACK_LIBS -lcblas"
+  fi
+  LIBS="$save_LIBS"
+fi
+
+## Test features of the installed UMFPACK library
+
+if test -n "$UMFPACK_LIBS"; then
+  ## SuiteSparse >= 4.0 needs additional link library for SuiteSparse_time()
+  save_CPPFLAGS="$CPPFLAGS"
+  save_LIBS="$LIBS";
+  CPPFLAGS="$UMFPACK_CPPFLAGS $AMD_CPPFLAGS $CPPFLAGS"
+  LIBS="$UMFPACK_LIBS $AMD_LDFLAGS $AMD_LIBS $BLAS_LIBS $FLIBS $LIBS"
+  xtra_libs=
+  OCTAVE_UMFPACK_NEED_SUITESPARSE_TIME
+  if test $octave_cv_umfpack_need_suitesparse_time = yes; then
+    AC_CHECK_LIB([rt], [clock_gettime], [xtra_libs="-lrt"], [xtra_libs=])
+    ## FIXME: This library list is only accurate for Linux, Mac OS X.
+    ##        Possibly need other library names for MinGW, Cygwin.
+    AC_SEARCH_LIBS([SuiteSparse_time],
+                   [suitesparseconfig SuiteSparse],
+                   [], [], [$xtra_libs])
+    case $ac_cv_search_SuiteSparse_time in
+      -l*)
+        UMFPACK_LIBS="$UMFPACK_LIBS $ac_cv_search_SuiteSparse_time"
+      ;;
+      no)
+        UMFPACK_LIBS=
+        AC_MSG_WARN([UMFPACK library found but is missing SuiteSparse_time functionality.])
+        AC_MSG_WARN([UMFPACK library will be disabled.])
+      ;;
+    esac
+  fi
+  LIBS="$save_LIBS"
+  CPPFLAGS="$save_CPPFLAGS"
+
+  ## Check for UMFPACK separately split complex matrix and RHS.
+  if test -n "$UMFPACK_LIBS"; then
+    save_CPPFLAGS="$CPPFLAGS"
+    save_LIBS="$LIBS";
+    CPPFLAGS="$UMFPACK_CPPFLAGS $AMD_CPPFLAGS $CPPFLAGS"
+    LIBS="$UMFPACK_LIBS $CHOLMOD_LDFLAGS $CHOLMOD_LIBS $AMD_LDFLAGS $AMD_LIBS $COLAMD_LDFLAGS $COLAMD_LIBS $LAPACK_LIBS $BLAS_LIBS $FLIBS $LIBS $xtra_libs"
+    OCTAVE_UMFPACK_SEPARATE_SPLIT
+    LIBS="$save_LIBS"
+    CPPFLAGS="$save_CPPFLAGS"
+  fi
+fi
+
+### Check for ARPACK library.
+
+save_LIBS="$LIBS"
+LIBS="$LAPACK_LIBS $BLAS_LIBS $FLIBS $LIBS"
+OCTAVE_CHECK_LIB([arpack], ARPACK,
+  [ARPACK not found.  The eigs function will be disabled.],
+  [],
+  [dseupd],
+  [Fortran 77], [don't use the ARPACK library, disable eigs function],
+  [warn_arpack=
+   OCTAVE_CHECK_LIB_ARPACK_OK(
+     [AC_DEFINE(HAVE_ARPACK, 1, [Define to 1 if ARPACK is available.])],
+     [warn_arpack="ARPACK library found, but does not seem to work properly -- disabling eigs function"])])
+LIBS="$save_LIBS"
+
+### Check for readline library.
+
+OCTAVE_ENABLE_READLINE
+
+### 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([--disable-dl],
+    [disable loading of dynamically linked modules])],
+  [case $enableval in
+     yes) ENABLE_DYNAMIC_LINKING=yes ;;
+     no) ENABLE_DYNAMIC_LINKING=no ;;
+     *) AC_MSG_ERROR([bad value $enableval for --enable-dl]) ;;
+   esac],
+  [ENABLE_DYNAMIC_LINKING=no])
+
+if test $STATIC_LIBS = no && test $SHARED_LIBS = no; then
+  AC_MSG_ERROR([You can't disable building both static AND shared libraries!])
+fi
+
+CPICFLAG=-fPIC
+CXXPICFLAG=-fPIC
+FPICFLAG=-fPIC
+SHLEXT=so
+SHLLIB='$(SHLEXT)'
+SHLBIN=
+SHLEXT_VER='$(SHLEXT).$(version)'
+SHLLIB_VER='$(SHLLIB).$(version)'
+SHLBIN_VER='$(SHLBIN).$(version)'
+SHLLINKEXT=
+LIBPRE=lib
+SHLPRE=lib
+SHLLIBPRE=lib
+SHLBINPRE=lib
+SH_LD='$(CXX)'
+SH_LDFLAGS=-shared
+DL_LD='$(SH_LD)'
+DL_LDFLAGS='$(SH_LDFLAGS)'
+MKOCTFILE_DL_LDFLAGS='$(DL_LDFLAGS)'
+SONAME_FLAGS=
+NO_OCT_FILE_STRIP=false
+TEMPLATE_AR='$(AR)'
+TEMPLATE_ARFLAGS="$ARFLAGS"
+CRUFT_DLL_DEFS=
+OCTAVE_DLL_DEFS=
+OCTINTERP_DLL_DEFS=
+OCTGUI_DLL_DEFS=
+OCTGRAPHICS_DLL_DEFS=
+library_path_var=LD_LIBRARY_PATH
+ldpreloadsep=" "
+case $canonical_host_type in
+  *-*-386bsd* | *-*-netbsd*)
+    SH_LD=ld
+    SH_LDFLAGS=-Bshareable
+  ;;
+  *-*-openbsd*)
+    SH_LDFLAGS='-shared -fPIC'
+  ;;
+  *-*-freebsd*)
+    SH_LDFLAGS="-shared -Wl,-x"
+  ;;
+  alpha*-dec-osf*)
+    CPICFLAG=
+    CXXPICFLAG=
+    FPICFLAG=
+    SH_LDFLAGS="-shared -Wl,-expect_unresolved -Wl,'*'"
+  ;;
+  *-*-darwin*)
+    DL_LDFLAGS='-bundle -bundle_loader $(top_builddir)/libinterp/octave $(LDFLAGS)'
+    MKOCTFILE_DL_LDFLAGS='-bundle -bundle_loader $(bindir)/octave-$(version)$(EXEEXT)'
+    SH_LDFLAGS='-dynamiclib -single_module $(LDFLAGS)'
+    case $canonical_host_type in
+      powerpc-*)
+        CXXPICFLAG=
+        CPICFLAG=
+        FPICFLAG=
+      ;;
+    esac
+    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*)
+    CPICFLAG=
+    CXXPICFLAG=
+    FPICFLAG=
+    LIBPRE=lib
+    SHLPRE=cyg
+    SHLBINPRE=cyg
+    SHLEXT=dll
+    SHLLIB=dll.a
+    SHLBIN=dll
+    DL_LDFLAGS="-shared -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc"
+    SH_LDFLAGS="-shared -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--enable-auto-image-base"
+    SONAME_FLAGS='-Wl,--out-implib=$(patsubst $(SHLPRE)%,$(LIBPRE)%,$@).a'
+    ldpreloadsep=":"
+  ;;
+  *-*-mingw*)
+    if test $have_msvc = yes; then
+      DL_LDFLAGS="-shared"
+      CPICFLAG=
+      CXXPICFLAG=
+      FPICFLAG=
+      SHLEXT=dll
+      SHLLIB=lib
+      SHLBIN=dll
+      LIBPRE=
+      SHLPRE=
+      SHLLIBPRE=
+      SHLBINPRE=
+      SH_LDFLAGS="-shared"
+      if test -n "`echo $CFLAGS | $GREP -e '-g'`" || test -n "`echo $CXXFLAGS | $GREP -e '-g'`"; then
+        DL_LDFLAGS="$DL_LDFLAGS -g"
+        SH_LDFLAGS="$SH_LDFLAGS -g"
+      fi
+      NO_OCT_FILE_STRIP=true
+      library_path_var=PATH
+      ## Extra compilation flags.
+      CRUFT_DLL_DEFS="-DCRUFT_DLL"
+      OCTAVE_DLL_DEFS="-DOCTAVE_DLL"
+      OCTINTERP_DLL_DEFS="-DOCTINTERP_DLL"
+      OCTGUI_DLL_DEFS="-DOCTGUI_DLL"
+      OCTGRAPHICS_DLL_DEFS="-DOCTGRAPHICS_DLL"
+    else
+      CPICFLAG=
+      CXXPICFLAG=
+      FPICFLAG=
+      SHLEXT=dll
+      SHLLIB=dll.a
+      SHLBIN=dll
+      DL_LDFLAGS="-shared -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc"
+      SH_LDFLAGS="-shared -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--enable-auto-image-base"
+      SONAME_FLAGS='-Wl,--out-implib=$@.a'
+      library_path_var=PATH
+    fi
+  ;;
+
+  *-*-msdosmsvc)
+    DL_LDFLAGS="-shared"
+    CPICFLAG=
+    CXXPICFLAG=
+    FPICFLAG=
+    SHLEXT=dll
+    SHLLIB=lib
+    SHLBIN=dll
+    LIBPRE=
+    SHLPRE=
+    SHLLIBPRE=
+    SHLBINPRE=
+    SH_LDFLAGS="-shared"
+    if test -n "`echo $CFLAGS | $GREP -e '-g'`" || test -n "`echo $CXXFLAGS | $GREP -e '-g'`"; then
+      DL_LDFLAGS="$DL_LDFLAGS -g"
+      SH_LDFLAGS="$SH_LDFLAGS -g"
+    fi
+    NO_OCT_FILE_STRIP=true
+    library_path_var=PATH
+    ## Extra compilation flags.
+    CRUFT_DLL_DEFS="-DCRUFT_DLL"
+    OCTAVE_DLL_DEFS="-DOCTAVE_DLL"
+    OCTGUI_DLL_DEFS="-DOCTGUI_DLL"
+    OCTGRAPHICS_DLL_DEFS="-DOCTGRAPHICS_DLL"
+  ;;
+  *-*-linux* | *-*-gnu*)
+    MKOCTFILE_DL_LDFLAGS="-shared -Wl,-Bsymbolic"
+    SONAME_FLAGS='-Wl,-soname -Wl,$@'
+  ;;
+  i[[3456]]86-*-sco3.2v5*)
+    SONAME_FLAGS='-Wl,-h -Wl,$@'
+    SH_LDFLAGS=-G
+  ;;
+  rs6000-ibm-aix* | powerpc-ibm-aix*)
+    CPICFLAG=
+    CXXPICFLAG=
+    FPICFLAG=
+    library_path_var=LIBPATH
+  ;;
+  hppa*-hp-hpux*)
+    if test $ac_cv_f77_compiler_gnu = yes; then
+      FPICFLAG=-fPIC
+    else
+      FPICFLAG=+Z
+    fi
+    SHLEXT=sl
+    SH_LDFLAGS="-shared -fPIC"
+    library_path_var=SHLIB_PATH
+  ;;
+  ia64*-hp-hpux*)
+    if test $ac_cv_f77_compiler_gnu = yes; then
+      FPICFLAG=-fPIC
+    else
+      FPICFLAG=+Z
+    fi
+    SH_LDFLAGS="-shared -fPIC"
+  ;;
+  *-sgi-*)
+    CPICFLAG=
+    CXXPICFLAG=
+    FPICFLAG=
+  ;;
+  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"
+  ;;
+  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
+    ## Template closures in archive libraries need a different mechanism.
+    if test "$GXX" != yes; then
+      TEMPLATE_AR='$(CXX)'
+      TEMPLATE_ARFLAGS="-xar -o"
+    fi
+  ;;
+esac
+
+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 LIBPRE to be $LIBPRE])
+AC_MSG_NOTICE([defining SHLPRE to be $SHLPRE])
+AC_MSG_NOTICE([defining SHLLIBPRE to be $SHLLIBPRE])
+AC_MSG_NOTICE([defining SHLBINPRE to be $SHLBINPRE])
+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 TEMPLATE_AR to be $TEMPLATE_AR])
+AC_MSG_NOTICE([defining TEMPLATE_ARFLAGS to be $TEMPLATE_ARFLAGS])
+AC_MSG_NOTICE([defining CRUFT_DLL_DEFS to be $CRUFT_DLL_DEFS])
+AC_MSG_NOTICE([defining OCTAVE_DLL_DEFS to be $OCTAVE_DLL_DEFS])
+AC_MSG_NOTICE([defining OCTINTERP_DLL_DEFS to be $OCTINTERP_DLL_DEFS])
+AC_MSG_NOTICE([defining OCTGUI_DLL_DEFS to be $OCTGUI_DLL_DEFS])
+AC_MSG_NOTICE([defining OCTGRAPHICS_DLL_DEFS to be $OCTGRAPHICS_DLL_DEFS])
+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(LIBPRE)
+AC_SUBST(SHLPRE)
+AC_SUBST(SHLLIBPRE)
+AC_SUBST(SHLBINPRE)
+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(TEMPLATE_AR)
+AC_SUBST(TEMPLATE_ARFLAGS)
+AC_SUBST(CRUFT_DLL_DEFS)
+AC_SUBST(OCTAVE_DLL_DEFS)
+AC_SUBST(OCTINTERP_DLL_DEFS)
+AC_SUBST(OCTGUI_DLL_DEFS)
+AC_SUBST(OCTGRAPHICS_DLL_DEFS)
+AC_SUBST(library_path_var)
+AC_SUBST(ldpreloadsep)
+
+### More configure argument checking related to linking
+
+AC_ARG_ENABLE([no-undefined],
+  [AS_HELP_STRING([--disable-no-undefined],
+    [don't pass -no-undefined to libtool when linking Octave and its shared libraries])],
+  [case $enableval in
+     yes) NO_UNDEFINED_LDFLAG="-no-undefined" ;;
+     no)  NO_UNDEFINED_LDFLAG="" ;;
+     *) AC_MSG_ERROR([bad value $enableval for --disable-no-undefined]) ;;
+   esac],
+  [NO_UNDEFINED_LDFLAG="-no-undefined"])
+AC_SUBST(NO_UNDEFINED_LDFLAG)
+
+AC_ARG_ENABLE([link-all-dependencies],
+  [AS_HELP_STRING([--enable-link-all-dependencies],
+    [link Octave and its shared libraries with all dependencies, not just those immediately referenced (should not be needed on most systems)])],
+  [case $enableval in
+     yes) link_all_deps=yes ;;
+     no)  link_all_deps=no ;;
+     *) AC_MSG_ERROR([bad value $enableval for --enable-link-all-depenencies])
+     ;;
+   esac],
+  [link_all_deps=no])
+AM_CONDITIONAL([AMCOND_LINK_ALL_DEPS], [test $link_all_deps = yes])
+
+## Dynamic linking is now enabled only if we are building shared
+## libs and some API for dynamic linking has been detected.
+
+## FIXME: A lot of the following duplicates the functionality of
+## code generated by the dlopen option for LT_INIT.
+
+LD_CXX='$(CXX)'
+RDYNAMIC_FLAG=
+DL_API_MSG=""
+dlopen_api=no
+shl_load_api=no
+loadlibrary_api=no
+dyld_api=no
+
+if test $SHARED_LIBS = yes || test $ENABLE_DYNAMIC_LINKING = yes; then
+
+  case $lt_cv_dlopen in
+    dlopen)
+      dlopen_api=yes
+      DL_API_MSG="(dlopen)"
+      AC_DEFINE(HAVE_DLOPEN_API, 1,
+        [Define to 1 if your system has dlopen, dlsym, dlerror, and dlclose for dynamic linking.])
+      OCTAVE_CXX_FLAG([-rdynamic], [RDYNAMIC_FLAG=-rdynamic])
+    ;;
+    shl_load)
+      shl_load_api=yes
+      DL_API_MSG="(shl_load)"
+      AC_DEFINE(HAVE_SHL_LOAD_API, 1,
+        [Define to 1 if your system has shl_load and shl_findsym for dynamic linking.])
+    ;;
+    LoadLibrary)
+      loadlibrary_api=yes
+      DL_API_MSG="(LoadLibrary)"
+      AC_DEFINE(HAVE_LOADLIBRARY_API, 1,
+        [Define to 1 if your system has LoadLibrary for dynamic linking.])
+    ;;
+    dyld)
+      dyld_api=yes
+      DL_API_MSG="(dyld)"
+      AC_DEFINE(HAVE_DYLD_API, 1,
+        [Define to 1 if your system has dyld for dynamic linking.])
+    ;;
+  esac
+
+  DL_LIBS="$lt_cv_dlopen_libs"
+  AC_SUBST(DL_LIBS)
+
+  ## Disable dynamic linking if capability is not present.
+  if test $dlopen_api = yes \
+      || test $shl_load_api = yes \
+      || test $loadlibrary_api = yes \
+      || test $dyld_api = yes; then
+    # some form of dynamic linking present
+    ENABLE_DYNAMIC_LINKING=yes
+  else
+    ENABLE_DYNAMIC_LINKING=no
+  fi
+fi
+
+if test $ENABLE_DYNAMIC_LINKING = yes; then
+  AC_DEFINE(ENABLE_DYNAMIC_LINKING, 1, [Define to 1 if using dynamic linking.])
+fi
+
+AM_CONDITIONAL([AMCOND_ENABLE_DYNAMIC_LINKING],
+  [test $ENABLE_DYNAMIC_LINKING = yes])
+
+if test $SHARED_LIBS = yes; then
+  LIBOCTINTERP="-loctinterp$SHLLINKEXT"
+  LIBOCTAVE="-loctave$SHLLINKEXT"
+else
+  LIBOCTINTERP='$(top_builddir)/libinterp/liboctinterp.$(LIBEXT)'
+  LIBOCTAVE='$(top_builddir)/liboctave/liboctave.$(LIBEXT)'
+fi
+
+AC_SUBST(LD_CXX)
+AC_SUBST(RDYNAMIC_FLAG)
+AC_SUBST(ENABLE_DYNAMIC_LINKING)
+AC_SUBST(LIBOCTINTERP)
+AC_SUBST(LIBOCTAVE)
+
+
+if test "$cross_compiling" = yes && test -n "$ac_tool_prefix"; then
+  CROSS_TOOL_PREFIX="$ac_tool_prefix"
+  MKOCTFILE_AR='$(shell echo $(AR) | $(SED) "s,$(CROSS_TOOL_PREFIX),,")'
+  MKOCTFILE_CC='$(shell echo $(CC) | $(SED) "s,$(CROSS_TOOL_PREFIX),,")'
+  MKOCTFILE_CXX='$(shell echo $(CXX) | $(SED) "s,$(CROSS_TOOL_PREFIX),,")'
+  MKOCTFILE_DL_LD='$(shell echo $(DL_LD) | $(SED) "s,$(CROSS_TOOL_PREFIX),,")'
+  MKOCTFILE_F77='$(shell echo $(F77) | $(SED) "s,$(CROSS_TOOL_PREFIX),,")'
+  MKOCTFILE_LD_CXX='$(shell echo $(LD_CXX) | $(SED) "s,$(CROSS_TOOL_PREFIX),,")'
+  MKOCTFILE_RANLIB='$(shell echo $(RANLIB) | $(SED) "s,$(CROSS_TOOL_PREFIX),,")'
+else
+  MKOCTFILE_AR="$AR"
+  MKOCTFILE_CC="$CC"
+  MKOCTFILE_CXX="$CXX"
+  MKOCTFILE_DL_LD="$DL_LD"
+  MKOCTFILE_F77="$F77"
+  MKOCTFILE_LD_CXX="$LD_CXX"
+  MKOCTFILE_RANLIB="$RANLIB"
+fi
+AC_MSG_NOTICE([defining CROSS_TOOL_PREFIX to be $CROSS_TOOL_PREFIX])
+AC_MSG_NOTICE([defining MKOCTFILE_AR to be $MKOCTFILE_AR])
+AC_MSG_NOTICE([defining MKOCTFILE_CC to be $MKOCTFILE_CC])
+AC_MSG_NOTICE([defining MKOCTFILE_CXX to be $MKOCTFILE_CXX])
+AC_MSG_NOTICE([defining MKOCTFILE_DL_LD to be $MKOCTFILE_DL_LD])
+AC_MSG_NOTICE([defining MKOCTFILE_F77 to be $MKOCTFILE_F77])
+AC_MSG_NOTICE([defining MKOCTFILE_LD_CXX to be $MKOCTFILE_LD_CXX])
+AC_MSG_NOTICE([defining MKOCTFILE_RANLIB to be $MKOCTFILE_RANLIB])
+AC_SUBST(CROSS_TOOL_PREFIX)
+AC_SUBST(MKOCTFILE_AR)
+AC_SUBST(MKOCTFILE_CC)
+AC_SUBST(MKOCTFILE_CXX)
+AC_SUBST(MKOCTFILE_DL_LD)
+AC_SUBST(MKOCTFILE_F77)
+AC_SUBST(MKOCTFILE_LD_CXX)
+AC_SUBST(MKOCTFILE_RANLIB)
+
+### Check for existence of various libraries
+
+## OS-specific test for dirent, opendir.
+case $host_os in
+  mingw*)
+    if test $have_msvc = yes; then
+      AC_CHECK_LIB([dirent], [opendir])
+      LIBS="$LIBS -ladvapi32 -lgdi32 -lws2_32 -luser32 -lkernel32"
+    else
+      LIBS="$LIBS -lgdi32 -lws2_32 -luser32 -lkernel32"
+    fi
+    LIBS="$LIBS -lgdi32 -lws2_32 -luser32 -lkernel32"
+  ;;
+  msdosmsvc)
+    AC_CHECK_LIB([dirent], [opendir])
+    LIBS="$LIBS -ladvapi32 -lgdi32 -lws2_32 -luser32 -lkernel32"
+  ;;
+esac
+
+## Find a termlib to use.
+OCTAVE_CHECK_LIB_TERMLIB
+
+### Checks for header files.
+
+AC_HEADER_DIRENT
+AC_HEADER_SYS_WAIT
+
+## C headers
+
+dnl Use multiple AC_CHECKs to avoid line continuations '\' in list
+AC_CHECK_HEADERS([curses.h direct.h dlfcn.h floatingpoint.h fpu_control.h])
+AC_CHECK_HEADERS([grp.h ieeefp.h inttypes.h locale.h memory.h ncurses.h])
+AC_CHECK_HEADERS([poll.h pthread.h pwd.h sunmath.h sys/ioctl.h])
+AC_CHECK_HEADERS([sys/param.h sys/poll.h sys/resource.h])
+AC_CHECK_HEADERS([sys/select.h termcap.h])
+
+## C++ headers
+
+AC_LANG_PUSH(C++)
+
+AC_CHECK_HEADERS([sstream])
+OCTAVE_UNORDERED_MAP_HEADERS
+
+AC_LANG_POP(C++)
+
+## Find a termio header to include.
+
+AC_CHECK_HEADERS([termios.h], have_termios_h=yes, have_termios_h=no)
+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([fnmatch.h], have_fnmatch_h=yes, have_fnmatch_h=no)
+AC_CHECK_HEADERS([conio.h], have_conio_h=yes, have_conio_h=no)
+
+if test $have_termios_h != yes \
+    && test $have_termio_h != yes \
+    && test $have_sgtty_h != yes; then
+  AC_MSG_WARN([I couldn't find termios.h, termio.h, or sgtty.h!])
+fi
+
+## For MSVC compilers, avoid #define of min/max from windows.h header
+if test $have_msvc = yes; then
+  AC_DEFINE(NOMINMAX, 1, [Define to 1 if you want to avoid min/max macro definition in Windows headers.])
+fi
+
+### Determine types and size of types.
+
+AC_TYPE_INT64_T
+AC_TYPE_MODE_T
+AC_TYPE_OFF_T
+AC_TYPE_PID_T
+AC_TYPE_SIZE_T
+AC_TYPE_SSIZE_T
+AC_TYPE_UID_T
+AC_TYPE_UINT64_T
+AC_CHECK_TYPES([dev_t, ino_t])
+AC_CHECK_TYPES([long long int, unsigned long long int])
+AC_CHECK_TYPES([ptrdiff_t])
+
+## 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])
+## Check for long double type (for 64-bit integers)
+AC_CHECK_SIZEOF([long double])
+
+### Check structures and existence of necessary members
+
+AC_CHECK_MEMBERS([struct stat.st_blksize, struct stat.st_blocks,
+                  struct stat.st_rdev])
+AC_CHECK_MEMBERS([struct group.gr_passwd])
+
+AC_STRUCT_TIMEZONE
+
+### Check compiler characteristics.
+
+## Does compiler have support for new friend template declarations?
+OCTAVE_CXX_NEW_FRIEND_TEMPLATE_DECL
+
+## Does reinterpret_cast fail for function pointers?
+OCTAVE_CXX_BROKEN_REINTERPRET_CAST
+
+## Check if C++ compiler allows placement delete.
+OCTAVE_CXX_PLACEMENT_DELETE
+
+## Check if C++ compiler can auto allocate variable sized arrays.
+OCTAVE_CXX_DYNAMIC_AUTO_ARRAYS
+
+## Check that C compiler and libraries support IEEE754 data format.
+OCTAVE_IEEE754_DATA_FORMAT
+
+## Is C++ runtime library ISO compliant?
+OCTAVE_CXX_ISO_COMPLIANT_LIBRARY
+
+## Are bit_and, bit_or, and bit_xor defined as templated operators?
+OCTAVE_CXX_BITWISE_OP_TEMPLATES
+
+## Can complex class set components independently?
+OCTAVE_CXX_COMPLEX_SETTERS
+
+## Are there functions to access real/imag parts of numbers via references?
+OCTAVE_CXX_COMPLEX_REFERENCE_ACCESSORS
+
+## Check if fast integer arithmetics based on bit tricks is available.
+OCTAVE_FAST_INT_OPS
+
+## Does the C compiler handle alloca() and const correctly?
+AC_FUNC_ALLOCA
+
+## Does the C compiler support Automake subdir-objects option?
+AM_PROG_CC_C_O
+
+### gnulib initialization: part 2
+### After all include and path modifications have taken place
+### and at the same priority level as function checks.
+
+gl_INIT
+
+### Checks for functions and variables.
+
+dnl These checks define/undefine HAVE_FUNCNAME in config.h.
+dnl Code tests HAVE_FUNCNAME and either uses function or provides workaround.
+dnl Use multiple AC_CHECKs to avoid line continuations '\' in list
+AC_CHECK_FUNCS([ctermid dup2])
+AC_CHECK_FUNCS([endgrent endpwent execvp expm1 expm1f fork])
+AC_CHECK_FUNCS([getegid geteuid getgid getgrent getgrgid getgrnam])
+AC_CHECK_FUNCS([getpgrp getpid getppid getpwent getpwuid getuid])
+AC_CHECK_FUNCS([isascii kill])
+AC_CHECK_FUNCS([lgamma lgammaf lgamma_r lgammaf_r])
+AC_CHECK_FUNCS([log1p log1pf pipe])
+AC_CHECK_FUNCS([realpath resolvepath roundl])
+AC_CHECK_FUNCS([select setgrent setpwent siglongjmp strsignal])
+AC_CHECK_FUNCS([tcgetattr tcsetattr tgammaf toascii])
+AC_CHECK_FUNCS([umask waitpid])
+AC_CHECK_FUNCS([_kbhit])
+
+dnl There are no workarounds in the code for missing these functions.
+AC_CHECK_FUNCS([modf pow sqrt sqrtf], [],
+               [AC_MSG_ERROR([Missing function required to build Octave])])
+
+## exp2, round, tgamma function checks
+AC_LANG_PUSH(C++)
+AC_CHECK_DECLS([exp2, round, tgamma], [], [], [[#include <cmath>]])
+AC_CHECK_FUNCS([exp2 round tgamma])
+AH_VERBATIM([Z_FUNCS_AND_DECLS], [
+#if defined (__cplusplus)
+extern "C" {
+#endif
+#if HAVE_EXP2 && ! HAVE_DECL_EXP2
+double exp2 (double);
+#endif
+#if HAVE_ROUND && ! HAVE_DECL_ROUND
+double round (double);
+#endif
+#if HAVE_TGAMMA && ! HAVE_DECL_TGAMMA
+double tgamma (double);
+#endif
+#if defined (__cplusplus)
+}
+#endif
+])
+AC_LANG_POP(C++)
+
+## Look in <cmath> for the IEEE functions isnan, isinf, isfinite that we need.
+
+OCTAVE_CHECK_FUNC_CMATH(isnan)
+OCTAVE_CHECK_FUNC_CMATH(isinf)
+OCTAVE_CHECK_FUNC_CMATH(isfinite)
+OCTAVE_CHECK_FUNC_CMATH(signbit)
+
+## Check for Inf and NaN functions
+
+case $canonical_host_type in
+  m68k-hp-hpux*)
+    ## I am told that Inf and NaN don't work on m68k HP sytems.
+  ;;
+  *)
+    AC_CHECK_FUNCS([finite isnan isinf signbit])
+    AC_CHECK_FUNCS([_finite _isnan])
+    AC_CHECK_DECLS([signbit], , , [#include <math.h>])
+  ;;
+esac
+
+## Check for nonstandard, but common math functions, that we need.
+
+dnl Use multiple AC_CHECKs to avoid line continuations '\' in list
+AC_CHECK_FUNCS([acosh acoshf asinh asinhf atanh atanhf cbrt cbrtf])
+AC_CHECK_FUNCS([erf erff erfc erfcf exp2f hypotf _hypotf log2 log2f])
+
+## Check for math defines such as M_LN2 in math.h
+AC_CACHE_CHECK([for MATH DEFINES in math.h],
+  [octave_cv_header_math_defines],
+  [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+    #include <math.h>
+    ]], [[
+    double x = M_LN2;]])],
+    octave_cv_header_math_defines=yes,
+    octave_cv_header_math_defines=no)
+  ])
+
+if test $octave_cv_header_math_defines = no; then
+  ## Check again and try defining _USE_MATH_DEFINES
+  AC_CACHE_CHECK([whether _USE_MATH_DEFINES needs to be defined],
+    [octave_cv_header__use_math_defines],
+    [save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$CPPFLAGS -D_USE_MATH_DEFINES"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+      #include <math.h>
+      ]], [[
+      double x = M_LN2;]])],
+      octave_cv_header__use_math_defines=yes,
+      octave_cv_header__use_math_defines=no)
+    CPPFLAGS="$save_CPPFLAGS"
+    ])
+  if test $octave_cv_header__use_math_defines = yes; then
+    octave_cv_header_math_defines=yes
+    AC_DEFINE(_USE_MATH_DEFINES, 1,
+      [Define to 1 if _USE_MATH_DEFINES is required to get math constants like M_LN2.])
+    CPPFLAGS="$CPPFLAGS -D_USE_MATH_DEFINES"
+  fi
+fi
+
+if test $octave_cv_header_math_defines = yes; then
+  AC_DEFINE(HAVE_MATH_DEFINES, 1,
+    [Define to 1 if defines such as M_PI are available in math.h])
+else
+  AC_MSG_ERROR([MATH DEFINES in math.h such as M_PI are required to build Octave])
+fi
+
+## Windows-specific tests for extra #defines
+case $host_os in
+  msdosmsvc | mingw*)
+    AC_MSG_CHECKING([for required _WIN32_WINNT])
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <windows.h>
+        #if _WIN32_WINNT < 0x0403
+        #error "Wrong version"
+        #endif
+        ]], [])],
+      [AC_MSG_RESULT([none])],
+      [AC_DEFINE(_WIN32_WINNT, 0x0403,
+        [Define to 0x0403 to access InitializeCriticalSectionAndSpinCount.])
+       AC_MSG_RESULT([0x0403])])
+  ;;
+esac
+
+## Windows-specific use of functions
+case $host_os in
+  msdosmsvc | mingw*)
+    AC_CHECK_FUNCS([setvbuf], [],
+                   [AC_MSG_ERROR([Missing function required to build Octave])])
+  ;;
+esac
+
+## Cygwin kluge for getrusage.
+AC_CHECK_FUNCS([getrusage])
+case $host_os in
+  cygwin*)
+    AC_DEFINE(RUSAGE_TIMES_ONLY, 1,
+      [Define to 1 if your struct rusage only has time information.])
+  ;;
+esac
+
+## Check for CGDisplayBitsPerPixel function on Mac OSX systems with Carbon
+if test $have_framework_carbon = yes; then
+  OCTAVE_CARBON_CGDISPLAYBITSPERPIXEL
+fi
+
+AC_CHECK_FUNCS([getpwnam], [], [AC_CHECK_LIB([sun], [getpwnam])])
+
+AC_FUNC_CLOSEDIR_VOID
+
+## Check return type of matherr()
+AC_CACHE_CHECK([for struct exception in math.h],
+  [octave_cv_func_matherr_type],
+  [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+      #include <math.h>
+      ]], [[
+      struct exception *x;
+      x->type;
+      x->name;
+      ]])],
+    octave_cv_func_matherr_type=yes,
+    octave_cv_func_matherr_type=no)
+  ])
+if test $octave_cv_func_matherr_type = yes; then
+  AC_DEFINE(EXCEPTION_IN_MATH, 1,
+    [Define to 1 if math.h declares struct exception for matherr().])
+fi
+
+## Signal stuff.
+
+AC_CHECK_DECLS([sys_siglist], [], [],
+[[#include <signal.h>
+/* NetBSD declares sys_siglist in unistd.h.  */
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+]])
+
+### Need to disable building documentation if either gnuplot or
+### makeinfo are missing.  Skip this warning if building docs was
+### disabled with a configure option.
+
+if test -n "$DOCDIR"; then
+  if test -n "$warn_gnuplot"; then
+    DOCDIR=
+    warn_docs_gnuplot="building documentation disabled because gnuplot was not found; make dist will fail"
+    OCTAVE_CONFIGURE_WARNING([warn_docs_gnuplot])
+  fi
+  if test -n "$warn_makeinfo"; then
+    DOCDIR=
+    warn_docs_makeinfo="building documentation disabled because makeinfo was not found; make dist will fail"
+    OCTAVE_CONFIGURE_WARNING([warn_docs_makeinfo])
+  fi
+fi
+AM_CONDITIONAL([AMCOND_BUILD_DOCS], [test -n "$DOCDIR"])
+
+### Maybe add -Wall, -W, and -Wshadow to compiler flags now that we're
+### done feature testing.
+
+GCC_EXTRA_FLAGS="-Wall -W -Wshadow -Wformat -Wpointer-arith -Wmissing-prototypes -Wstrict-prototypes -Wwrite-strings -Wcast-align -Wcast-qual"
+
+GXX_EXTRA_FLAGS="-Wall -W -Wshadow -Wold-style-cast -Wformat -Wpointer-arith -Wwrite-strings -Wcast-align -Wcast-qual"
+
+try_extra_warning_flags=yes
+
+AC_ARG_ENABLE([extra-warning-flags],
+  [AS_HELP_STRING([--disable-extra-warning-flags],
+    [don't add -Wall, -W, -Wshadow, and -Wold-style-cast options to CFLAGS and CXXFLAGS])],
+  [if test "$enableval" = no; then
+     try_extra_warning_flags=no
+   fi],
+  [])
+
+if test $try_extra_warning_flags = yes; then
+  for flag in $GCC_EXTRA_FLAGS; do
+    OCTAVE_CC_FLAG([$flag], [
+      WARN_CFLAGS="$WARN_CFLAGS $flag";
+      AC_MSG_RESULT([adding $flag to WARN_CFLAGS])])
+  done
+  for flag in $GXX_EXTRA_FLAGS; do
+    OCTAVE_CXX_FLAG([$flag], [
+      WARN_CXXFLAGS="$WARN_CXXFLAGS $flag";
+      AC_MSG_RESULT([adding $flag to WARN_CXXFLAGS])])
+  done
+fi
+
+GCC_STRICT_FLAGS="-Wconversion"
+
+GXX_STRICT_FLAGS="-Wconversion -Weffc++"
+
+try_strict_warning_flags=no
+
+AC_ARG_ENABLE([strict-warning-flags],
+  [AS_HELP_STRING([--enable-strict-warning-flags],
+    [add extra strict warning options to CFLAGS and CXXFLAGS])],
+  [if test "$enableval" = yes; then
+     try_strict_warning_flags=yes
+   fi],
+  [])
+
+if test $try_strict_warning_flags = yes; then
+  for flag in $GCC_STRICT_FLAGS; do
+    OCTAVE_CC_FLAG([$flag], [
+      WARN_CFLAGS="$WARN_CFLAGS $flag";
+      AC_MSG_RESULT([adding $flag to WARN_CFLAGS])])
+  done
+  for flag in $GXX_STRICT_FLAGS; do
+    OCTAVE_CXX_FLAG([$flag], [
+      WARN_CXXFLAGS="$WARN_CXXFLAGS $flag";
+      AC_MSG_RESULT([adding $flag to WARN_CXXFLAGS])])
+  done
+fi
+
+AC_SUBST(WARN_CFLAGS)
+AC_SUBST(WARN_CXXFLAGS)
+
+### Check for Java.
+
+build_java=yes
+AC_ARG_ENABLE([java],
+  [AS_HELP_STRING([--disable-java],
+    [disable Java interface])],
+  [if test "$enableval" = no; then
+     build_java=no
+   fi],
+  [])
+
+AC_ARG_WITH([java-homedir],
+  [AS_HELP_STRING([--with-java-homedir=DIR],
+    [Java JDK directory in DIR])],
+  [JAVA_HOMEDIR="$withval"])
+
+AC_ARG_WITH([java-includedir],
+  [AS_HELP_STRING([--with-java-includedir=DIR],
+    [look for java include file <jni.h> in DIR])],
+  [JAVA_CPPFLAGS="$withval"], [JAVA_CPPFLAGS=""])
+
+AC_ARG_WITH([java-libdir],
+  [AS_HELP_STRING([--with-java-libdir=DIR],
+    [look for java library libjvm in DIR])],
+  [JAVA_LDPATH="$withval"], [JAVA_LDPATH=""])
+
+## Grab JAVA_HOME from environment variable if it exists
+AC_ARG_VAR([JAVA_HOME], [path to Java JDK installation])
+## But --with-java-homedir option overrides environment variable
+if test -n "$JAVA_HOMEDIR"; then
+  JAVA_HOME=$JAVA_HOMEDIR
+fi
+JAVA=
+JAVAC=
+JAR=
+JAVA_LIBS=
+
+## Fake loop so that "break" can be used to skip code blocks.
+warn_java=""
+while test $build_java = yes
+do
+  ## Unset build_java.  Variable is set only if all configuration tests pass.
+  build_java=no
+
+  ## Warn if JAVA_HOME is unset.  It is *strongly* advised to specify JAVA_HOME.
+  if test -z "$JAVA_HOME"; then
+    warn_java_home="JAVA_HOME environment variable not initialized.  Auto-detection will proceed but is unreliable."
+    OCTAVE_CONFIGURE_WARNING([warn_java_home])
+  fi
+
+  ## Search for a viable Java executable.
+  if test -z "$JAVA_HOME"; then
+    JAVA_PATH="$PATH"
+  else
+    JAVA_PATH="${JAVA_HOME}$PATH_SEPARATOR${JAVA_HOME}/jre/bin$PATH_SEPARATOR${JAVA_HOME}/bin$PATH_SEPARATOR${JAVA_HOME}/../bin$PATH_SEPARATOR${PATH}"
+  fi
+  AC_PATH_PROG(JAVA, java, [], [$JAVA_PATH])
+
+  if test -z "$JAVA"; then
+    warn_java="No Java executable found.  Octave will not be able to call Java methods."
+    break
+  fi
+
+  if test -z "$JAVA_HOME"; then
+    ## Find JAVA_HOME for JRE by running java and querying properties.
+    JAVA_TMP_HOME=`"$JAVA" -classpath ${srcdir}/build-aux OctJavaQry JAVA_HOME`
+    ## Strip directory back to top-level installation dir (JAVA_HOME for JDK).
+    JAVA_HOME=`echo $JAVA_TMP_HOME | $SED -e 's|[[/\\]]bin[[/\\]]\?$||' | $SED -e 's|[[/\\]]jre[[/\\]]\?$||'`
+  fi
+
+  case $build_os in
+    mingw* | msdosmsvc)
+      ## Under Win32 platform, we want JAVA_HOME to be in MSYS format, that is
+      ## without colon and backslashes, as it is also used as path separator.
+      ## Use quoted paths as Java may be installed in a path with whitespaces
+      ## (e.g. C:\Program Files\Java\...).
+      if test -n "$JAVA_HOME"; then
+        JAVA_HOME=`cd "$JAVA_HOME" && pwd`
+      fi
+    ;;
+  esac
+
+  ## Amend search path for JAVAC and JAR.
+  if test -z "$JAVA_HOME"; then
+    JAVA_PATH="$PATH"
+  else
+    JAVA_PATH="${JAVA_HOME}$PATH_SEPARATOR${JAVA_HOME}/bin$PATH_SEPARATOR${JAVA_HOME}/../bin$PATH_SEPARATOR${PATH}"
+  fi
+
+  AC_PATH_PROG(JAVAC, javac, [], [$JAVA_PATH])
+  AC_PATH_PROG(JAR, jar, [], [$JAVA_PATH])
+
+  if test -z "$JAVAC" || test -z "$JAR"; then
+    warn_java="No javac compiler or jar executable found.  Octave will not be able to call Java methods."
+    break
+  fi
+
+  ## Check Java version is recent enough.
+  AC_MSG_CHECKING([for Java version])
+  java_version=[`"$JAVA" -version 2>&1 | $SED -n -e 's/^[^ ]* version[^0-9"]*"\([^"]*\)"/\1/p'`]
+  AC_MSG_RESULT([$java_version])
+  java_major=[`echo $java_version | $SED -e 's/^\([0-9][0-9]*\)\.\([0-9][0-9]*\)\..*$/\1/'`]
+  java_minor=[`echo $java_version | $SED -e 's/^\([0-9][0-9]*\)\.\([0-9][0-9]*\)\..*$/\2/'`]
+  if test $java_major -ge 1 && test $java_minor -ge 5; then
+    :  # Version is ok.  Do nothing.
+  else
+    warn_java="Java version is too old (< 1.5).  Octave will not be able to call Java methods."
+    break
+  fi
+
+  ## At this point Win32 systems have enough configuration data.
+  ## We assume that all appropriate variables (e.g. INCLUDE and LIB) already
+  ## contain the required paths to compile and link against JDK.
+  case $host_os in
+    msdosmsvc)
+      build_java=yes
+      JAVA_LIBS=-ladvapi32
+      AC_DEFINE(HAVE_JAVA, 1,
+        [Define to 1 if Java is available and is at least version 1.5])
+      break
+    ;;
+    mingw* | cygwin*)
+      build_java=yes
+      JAVA_LIBS=-ladvapi32
+      if test $have_msvc = no; then
+        if test -n "$JAVA_CPPFLAGS"; then
+          JAVA_CPPFLAGS="-I\"${JAVA_CPPFLAGS}\" -I\"${JAVA_CPPFLAGS}/win32\""
+        else
+          JAVA_CPPFLAGS="-I\"${JAVA_HOME}/include\" -I\"${JAVA_HOME}/include/win32\""
+        fi
+        LDFLAGS="$LDFLAGS -Wl,--export-all-symbols"
+      fi
+      AC_DEFINE(HAVE_JAVA, 1,
+        [Define to 1 if Java is available and is at least version 1.5])
+      break
+    ;;
+  esac
+
+  ## Determine which library file name to search for.
+  case $host_os in
+    darwin*)
+      jvmlib=libjvm.dylib
+    ;;
+    *)
+      jvmlib=libjvm.so
+    ;;
+  esac
+
+  AC_MSG_CHECKING([for $jvmlib])
+
+  if test -z "$JAVA_LDPATH"; then
+    ## Run Java to try and determine library path to libjvm.so.
+    JAVA_TMP_LDPATH=`$JAVA -classpath ${srcdir}/build-aux OctJavaQry JAVA_LDPATH`
+    JAVA_TMP_LDPATH=`echo $JAVA_TMP_LDPATH | $SED -e "s/${PATH_SEPARATOR}/ /g"`
+    for dir in $JAVA_TMP_LDPATH; do
+      if test -f "$dir/$jvmlib"; then
+        JAVA_LDPATH=$dir
+        break
+      fi
+    done
+  fi
+
+  if test -z "$JAVA_LDPATH"; then
+    ## Nothing found.  Try Java again using bootpath argument.
+    JAVA_TMP_LDPATH=`$JAVA -classpath ${srcdir}/build-aux OctJavaQry JAVA_BOOTPATH`
+    JAVA_TMP_LDPATH="${JAVA_TMP_LDPATH} ${JAVA_TMP_LDPATH}/client ${JAVA_TMP_LDPATH}/server"
+    for dir in $JAVA_TMP_LDPATH; do
+      if test -f "$dir/$jvmlib"; then
+        JAVA_LDPATH=$dir
+        break
+      fi
+    done
+  fi
+
+  if test -z "$JAVA_LDPATH"; then
+    ## Java failed to find it's own library path.  Guess wildly.
+    JAVA_TMP_LDPATH=`ls -d $JAVA_HOME/jre/lib/*/client`
+    JAVA_TMP_LDPATH="${JAVA_TMP_LDPATH} `ls -d $JAVA_HOME/jre/lib/*/server`"
+    ## Add some paths that might work on Macs.
+    JAVA_TMP_LDPATH="${JAVA_TMP_LDPATH} ${JAVA_HOME}/../Libraries ${JAVA_HOME}/Libraries"
+    ## Add some paths that might work on MinGW
+    JAVA_TMP_LDPATH="${JAVA_TMP_LDPATH} ${JAVA_HOME}/bin/client ${JAVA_HOME}/bin/server"
+    for dir in $JAVA_TMP_LDPATH; do
+      if test -f "$dir/$jvmlib"; then
+        JAVA_LDPATH=$dir
+        break
+      fi
+    done
+  fi
+
+  ## Verify value passed in option --with-java-libdir
+  if test -n "$JAVA_LDPATH"; then
+    if test -f "${JAVA_LDPATH}/$jvmlib"; then
+      :  # libjvm found
+    else
+      JAVA_LDPATH=""
+    fi
+  fi
+
+  if test -z "$JAVA_LDPATH"; then
+    AC_MSG_RESULT([not found])
+    warn_java="Library $jvmlib not found.  Octave will not be able to call Java methods."
+    break
+  else
+    AC_MSG_RESULT([$JAVA_LDPATH])
+  fi
+
+  AC_MSG_CHECKING([for include file <jni.h>])
+
+  ## Java and JVM found.  Set up flags.
+  case $host_os in
+    darwin*)
+      ## Sneak the -framework flag into mkoctfile via LDFLAGS
+      LDFLAGS="$LDFLAGS -framework JavaVM"
+      ## According to: http://developer.apple.com/unix/crossplatform.html
+      ## one must explicitly set the include path.
+      ## Unfortunately, the include path keeps moving around.
+      if test -n "$JAVA_CPPFLAGS"; then
+        JAVA_CPPFLAGS="-I${JAVA_CPPFLAGS}"
+      else
+        JAVA_CPPFLAGS="-I${JAVA_HOME}/include -I/System/Library/Frameworks/JavaVM.framework/Home/include -I/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK/Headers -I/System/Library/Frameworks/JavaVM.framework/Versions/Current/Headers"
+      fi
+      JAVA_LIBS="-framework JavaVM"
+    ;;
+    *)
+      if test -n "$JAVA_CPPFLAGS"; then
+        JAVA_CPPFLAGS="-I${JAVA_CPPFLAGS} -I${JAVA_CPPFLAGS}/linux"
+      else
+        JAVA_CPPFLAGS="-I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux"
+      fi
+    ;;
+  esac
+
+  ## Verify jni.h include file exists.
+  JNI_PATH=`echo $JAVA_CPPFLAGS | $SED -e 's/-I//g'`
+  have_jni=no
+  for dir in $JNI_PATH; do
+    if test -f "${dir}/jni.h"; then have_jni=yes; break; fi
+  done
+  if test $have_jni = yes; then
+    AC_MSG_RESULT([$dir])
+  else
+    AC_MSG_RESULT([not found])
+    warn_java="Include file <jni.h> not found.  Octave will not be able to call Java methods."
+    break
+  fi
+
+  ## Passed all configuration tests.  A workable Java installation was found.
+  build_java=yes
+  AC_DEFINE(HAVE_JAVA, 1,
+    [Define to 1 if Java is available and is at least version 1.5])
+  break
+done
+if test -n "$warn_java"; then
+  OCTAVE_CONFIGURE_WARNING([warn_java])
+fi
+
+AM_CONDITIONAL([AMCOND_HAVE_JAVA], [test $build_java = yes])
+AC_SUBST(JAVA)
+AC_SUBST(JAVAC)
+AC_SUBST(JAR)
+AC_SUBST(JAVA_CPPFLAGS)
+AC_SUBST(JAVA_LIBS)
+AC_DEFINE_UNQUOTED([JAVA_HOME], ["$JAVA_HOME"], [Java home (top-level installation dir)])
+AC_DEFINE_UNQUOTED([JAVA_LDPATH], ["$JAVA_LDPATH"], [Java library path (libjvm)])
+
+### GUI/Qt related tests.
+
+QT_CPPFLAGS=
+QT_LDFLAGS=
+QT_LIBS=
+win32_terminal=no
+build_gui=yes
+AC_ARG_ENABLE([gui],
+  [AS_HELP_STRING([--disable-gui], [don't build the GUI])],
+  [if test "$enableval" = no; then build_gui=no; fi], [])
+
+if test -z "$OPENGL_LIBS"; then
+  build_gui=no
+  if test $check_opengl = yes; then
+    warn_gui="OpenGL libs (GL and GLU) not found -- disabling GUI"
+  else
+    warn_gui="--without-opengl was specified -- disabling GUI"
+  fi
+  OCTAVE_CONFIGURE_WARNING([warn_gui])
+fi
+
+if test $build_gui = yes; then
+
+  warn_gui=""
+  ## Check for Qt libraries
+  QT_MODULES="QtCore QtGui QtNetwork QtOpenGL"
+  PKG_CHECK_MODULES(QT, [$QT_MODULES],
+    [],
+    [warn_gui="Qt libraries not found -- disabling GUI"
+     build_gui=no])
+
+  if test $build_gui = yes; then
+    ## Retrieve Qt compilation and linker flags
+    QT_CPPFLAGS="`$PKG_CONFIG --cflags-only-I $QT_MODULES`"
+    QT_LDFLAGS="`$PKG_CONFIG --libs-only-L $QT_MODULES`"
+    QT_LIBS="`$PKG_CONFIG --libs-only-l $QT_MODULES`"
+
+    case $host_os in
+      *darwin*)
+        ## Qt might be installed in framework
+        if test -z "$QT_LIBS"; then
+          QT_LDFLAGS="`$PKG_CONFIG --libs-only-other $QT_MODULES | tr ' ' '\n' | $GREP -e '-F' | uniq | tr '\n' ' '`"
+          QT_LIBS="`$PKG_CONFIG --libs-only-other $QT_MODULES | tr ' ' '\n' | $GREP -v -e '-F' | uniq | tr '\n' ' '`"
+          ## Enabling link_all_deps works around libtool's imperfect handling
+          ## of the -F flag
+          AM_CONDITIONAL([AMCOND_LINK_ALL_DEPS],
+                         [test $link_all_deps = yes || test -n "$QT_LDFLAGS"])
+        fi
+      ;;
+    esac
+
+    ## Check for Qt4
+    if ! `$PKG_CONFIG --atleast-version=4.0.0 QtCore`; then
+      warn_gui="Qt >= 4.0.0 not found -- disabling GUI"
+      build_gui=no
+    fi
+  fi
+
+  if test $build_gui = yes; then
+    AC_CHECK_TOOLS(MOC, [moc-qt4 moc])
+    AC_CHECK_TOOLS(UIC, [uic-qt4 uic])
+    AC_CHECK_TOOLS(RCC, [rcc-qt4 rcc])
+    AC_CHECK_TOOLS(LRELEASE, [lrelease-qt4 lrelease])
+    if test -n "$MOC" && test -n "$UIC" && test -n "$RCC" && test -n "$LRELEASE"; then
+      AC_DEFINE(HAVE_QT, 1,
+        [Define to 1 if Qt is available (libraries, developer header files, utility programs (moc, uic, rcc, and lrelease))])
+    else
+      warn_gui="Qt utility programs moc, uic, rcc, and lrelease not found -- disabling GUI"
+      build_gui=no
+    fi
+  fi
+
+  if test $build_gui = yes; then
+    OCTAVE_CHECK_FUNC_QABSTRACTITEMMODEL_BEGINRESETMODEL
+    if test $octave_cv_func_qabstractitemmodel_beginresetmodel = no; then
+      warn_gui="QAbstractItemModel::beginResetModel() not found -- disabling GUI"
+      build_gui=no
+    fi
+  fi
+
+  if test $build_gui = yes; then
+    OCTAVE_CHECK_QFONT_MONOSPACE
+    OCTAVE_CHECK_QFONT_FORCE_INTEGER_METRICS
+    OCTAVE_CHECK_FUNC_SETPLACEHOLDERTEXT
+    OCTAVE_CHECK_FUNC_QTABWIDGET_SETMOVABLE
+    OCTAVE_CHECK_FUNC_QSCI_FINDSELECTION
+  fi
+
+  if test $build_gui = yes; then
+    ## Check for Qscintilla library which is used in the GUI editor.
+    AC_CACHE_CHECK([whether Qscintilla library is installed],
+      [octave_cv_lib_qscintilla],
+      [save_CPPFLAGS="$CPPFLAGS"
+      save_LDFLAGS="$LDFLAGS"
+      save_LIBS="$LIBS"
+      CPPFLAGS="$QT_CPPFLAGS $CPPFLAGS"
+      LDFLAGS="$QT_LDFLAGS $LDFLAGS"
+      LIBS="$QT_LIBS -lqscintilla2"
+      AC_LANG_PUSH(C++)
+      AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+        #include <Qsci/qscilexersql.h>
+        ]], [[
+        QsciLexerSQL sqlLexer(0);
+        ]])],
+        octave_cv_lib_qscintilla=yes,
+        octave_cv_lib_qscintilla=no)
+      CPPFLAGS="$save_CPPFLAGS"
+      LDFLAGS="$save_LDFLAGS"
+      LIBS="$save_LIBS"
+      AC_LANG_POP([C++])
+    ])
+    if test $octave_cv_lib_qscintilla = no; then
+      warn_gui_editor="Qscintilla library not found -- disabling built-in GUI editor"
+      OCTAVE_CONFIGURE_WARNING([warn_gui_editor])
+    else
+      ## Let's assume Qscintilla library is at the same location as
+      ## other regular Qt libraries.
+      QT_LIBS="$QT_LIBS -lqscintilla2"
+      OCTAVE_CHECK_VERSION_2_6_0
+      AC_DEFINE(HAVE_QSCINTILLA, 1,
+        [Define to 1 if the QScintilla library and header files are available])
+
+      save_CPPFLAGS="$CPPFLAGS"
+      CPPFLAGS="$QT_CPPFLAGS $CPPFLAGS"
+      AC_LANG_PUSH(C++)
+      AC_CHECK_HEADERS([Qsci/qscilexeroctave.h Qsci/qscilexermatlab.h])
+      AC_LANG_POP(C++)
+      CPPFLAGS="$save_CPPFLAGS"
+    fi
+
+    AC_CHECK_FUNCS([setlocale], [],
+      [warn_gui="setlocale not found -- disabling GUI"
+       build_gui=no])
+
+    if test $build_gui = yes; then
+      case $host_os in
+        mingw* | msdosmsvc*)
+          AC_CHECK_FUNCS([setvbuf], [win32_terminal=yes],
+            [warn_gui="setvbuf not found -- disabling GUI"
+             build_gui=no])
+        ;;
+        *)
+          AC_CHECK_HEADERS([pty.h libutil.h util.h])
+          AC_SEARCH_LIBS([openpty], [util],
+            [AC_DEFINE(HAVE_OPENPTY, [], [Define whether openpty exists])])
+          AC_CHECK_FUNCS([chmod chown ftruncate mmap munmap], [],
+            [AC_MSG_ERROR([At least one of chmod, chown, ftruncate, mmap, and munmap not found -- disabling GUI])
+             build_gui=no])
+        ;;
+      esac
+    fi
+  fi
+
+  if test -n "$warn_gui"; then
+    OCTAVE_CONFIGURE_WARNING([warn_gui])
+  fi
+fi
+
+AM_CONDITIONAL([AMCOND_BUILD_GUI], [test $build_gui = yes])
+AM_CONDITIONAL([AMCOND_HAVE_QSCINTILLA],
+               [test "$octave_cv_lib_qscintilla" = yes])
+AM_CONDITIONAL([WIN32_TERMINAL], [test $win32_terminal = yes])
+AC_SUBST(QT_CPPFLAGS)
+AC_SUBST(QT_LDFLAGS)
+AC_SUBST(QT_LIBS)
+
+# do we want to create cross-mkoctfile etc ?
+cross_tools=no
+AC_ARG_ENABLE([cross-tools],
+  [AS_HELP_STRING([--enable-cross-tools],
+    [build cross tools (mkoctfile, octave-config) if cross compiling])],
+  [if test "$enableval" = yes; then cross_tools=yes; fi])
+
+if test "$cross_tools" = yes; then
+  if test "$cross_compiling" = no; then
+    AC_MSG_WARN([ignoring --enable-cross-tools when not cross compiling])
+    cross_tools=no
+  fi
+fi
+AM_CONDITIONAL([AMCOND_CROSS_TOOLS], [test $cross_tools = yes])
+
+
+### Decide whether or not to install build logs with Octave.
+
+install_build_logs=no
+AC_ARG_ENABLE([install-build-logs],
+  [AS_HELP_STRING([--enable-install-build-logs],
+    [install build logs (e.g. config.log) with Octave])],
+  [if test "$enableval" = yes; then install_build_logs=yes; fi])
+AM_CONDITIONAL([AMCOND_INSTALL_BUILD_LOGS], [test $install_build_logs = yes])
+
+CFLAGS="$original_octave_configure_CFLAGS"
+CXXFLAGS="$original_octave_configure_CXXFLAGS"
+
+AH_BOTTOM([#include "oct-conf-post.h"])
+
+### Make all AC_DEFINES available to testif feature of test.m function.
+### This must reside at the bottom of configure.ac after all AC_DEFINES
+### have been made.
+
+AC_OUTPUT_MAKE_DEFS
+
+### Do the substitutions in all the Makefiles.
+
+AC_SUBST(ac_config_files)
+AC_SUBST(ac_config_headers)
+
+AC_CONFIG_FILES([
+  oct-conf-post.h:oct-conf-post.in.h
+  Makefile
+  doc/Makefile
+  doc/doxyhtml/Makefile
+  doc/doxyhtml/Doxyfile
+  doc/interpreter/Makefile
+  doc/liboctave/Makefile
+  doc/refcard/Makefile
+  etc/icons/Makefile
+  examples/Makefile
+  examples/code/Makefile
+  examples/data/Makefile
+  libgnu/Makefile
+  libgui/Makefile
+  libinterp/Makefile
+  liboctave/Makefile
+  liboctave/cruft/mkf77def
+  scripts/Makefile
+  src/Makefile
+  test/Makefile])
+
+AC_OUTPUT
+
+### Print a summary so that important information isn't missed.
+
+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:            $F77 $FFLAGS
+  Fortran libraries:           $FLIBS
+  Lex libraries:               $LEXLIB
+  LIBS:                        $LIBS
+
+  AMD CPPFLAGS:                $AMD_CPPFLAGS
+  AMD LDFLAGS:                 $AMD_LDFLAGS
+  AMD libraries:               $AMD_LIBS
+  ARPACK CPPFLAGS:             $ARPACK_CPPFLAGS
+  ARPACK LDFLAGS:              $ARPACK_LDFLAGS
+  ARPACK libraries:            $ARPACK_LIBS
+  BLAS libraries:              $BLAS_LIBS
+  CAMD CPPFLAGS:               $CAMD_CPPFLAGS
+  CAMD LDFLAGS:                $CAMD_LDFLAGS
+  CAMD libraries:              $CAMD_LIBS
+  CARBON libraries:            $CARBON_LIBS
+  CCOLAMD CPPFLAGS:            $CCOLAMD_CPPFLAGS
+  CCOLAMD LDFLAGS:             $CCOLAMD_LDFLAGS
+  CCOLAMD libraries:           $CCOLAMD_LIBS
+  CHOLMOD CPPFLAGS:            $CHOLMOD_CPPFLAGS
+  CHOLMOD LDFLAGS:             $CHOLMOD_LDFLAGS
+  CHOLMOD libraries:           $CHOLMOD_LIBS
+  COLAMD CPPFLAGS:             $COLAMD_CPPFLAGS
+  COLAMD LDFLAGS:              $COLAMD_LDFLAGS
+  COLAMD libraries:            $COLAMD_LIBS
+  CURL CPPFLAGS:               $CURL_CPPFLAGS
+  CURL LDFLAGS:                $CURL_LDFLAGS
+  CURL libraries:              $CURL_LIBS
+  CXSPARSE CPPFLAGS:           $CXSPARSE_CPPFLAGS
+  CXSPARSE LDFLAGS:            $CXSPARSE_LDFLAGS
+  CXSPARSE libraries:          $CXSPARSE_LIBS
+  DL libraries:                $DL_LIBS
+  FFTW3 CPPFLAGS:              $FFTW3_CPPFLAGS
+  FFTW3 LDFLAGS:               $FFTW3_LDFLAGS
+  FFTW3 libraries:             $FFTW3_LIBS
+  FFTW3F CPPFLAGS:             $FFTW3F_CPPFLAGS
+  FFTW3F LDFLAGS:              $FFTW3F_LDFLAGS
+  FFTW3F libraries:            $FFTW3F_LIBS
+  FLTK CPPFLAGS:               $FLTK_CPPFLAGS
+  FLTK LDFLAGS:                $FLTK_LDFLAGS
+  FLTK libraries:              $FLTK_LIBS
+  fontconfig CPPFLAGS:         $FONTCONFIG_CPPFLAGS
+  fontconfig libraries:        $FONTCONFIG_LIBS
+  FreeType2 CPPFLAGS:          $FT2_CPPFLAGS
+  FreeType2 libraries:         $FT2_LIBS
+  GLPK CPPFLAGS:               $GLPK_CPPFLAGS
+  GLPK LDFLAGS:                $GLPK_LDFLAGS
+  GLPK libraries:              $GLPK_LIBS
+  HDF5 CPPFLAGS:               $HDF5_CPPFLAGS
+  HDF5 LDFLAGS:                $HDF5_LDFLAGS
+  HDF5 libraries:              $HDF5_LIBS
+  Java home:                   $JAVA_HOME
+  Java JVM path:               $JAVA_LDPATH
+  Java CPPFLAGS:               $JAVA_CPPFLAGS
+  Java libraries:              $JAVA_LIBS
+  LAPACK libraries:            $LAPACK_LIBS
+  LLVM CPPFLAGS:               $LLVM_CPPFLAGS
+  LLVM LDFLAGS:                $LLVM_LDFLAGS
+  LLVM libraries:              $LLVM_LIBS
+  Magick++ CPPFLAGS:           $MAGICK_CPPFLAGS
+  Magick++ LDFLAGS:            $MAGICK_LDFLAGS
+  Magick++ libraries:          $MAGICK_LIBS
+  OPENGL libraries:            $OPENGL_LIBS
+  OSMesa CPPFLAGS:             $OSMESA_CPPFLAGS
+  OSMesa LDFLAGS:              $OSMESA_LDFLAGS
+  OSMesa libraries:            $OSMESA_LIBS
+  PCRE CPPFLAGS:               $PCRE_CPPFLAGS
+  PCRE libraries:              $PCRE_LIBS
+  PortAudio CPPFLAGS:          $PORTAUDIO_CPPFLAGS
+  PortAudio LDFLAGS:           $PORTAUDIO_LDFLAGS
+  PortAudio libraries:         $PORTAUDIO_LIBS
+  PTHREAD flags:               $PTHREAD_CFLAGS
+  PTHREAD libraries:           $PTHREAD_LIBS
+  QHULL CPPFLAGS:              $QHULL_CPPFLAGS
+  QHULL LDFLAGS:               $QHULL_LDFLAGS
+  QHULL libraries:             $QHULL_LIBS
+  QRUPDATE CPPFLAGS:           $QRUPDATE_CPPFLAGS
+  QRUPDATE LDFLAGS:            $QRUPDATE_LDFLAGS
+  QRUPDATE libraries:          $QRUPDATE_LIBS
+  Qt CPPFLAGS:                 $QT_CPPFLAGS
+  Qt LDFLAGS:                  $QT_LDFLAGS
+  Qt libraries:                $QT_LIBS
+  READLINE libraries:          $READLINE_LIBS
+  Sndfile CPPFLAGS:            $SNDFILE_CPPFLAGS
+  Sndfile LDFLAGS:             $SNDFILE_LDFLAGS
+  Sndfile libraries:           $SNDFILE_LIBS
+  TERM libraries:              $TERM_LIBS
+  UMFPACK CPPFLAGS:            $UMFPACK_CPPFLAGS
+  UMFPACK LDFLAGS:             $UMFPACK_LDFLAGS
+  UMFPACK libraries:           $UMFPACK_LIBS
+  X11 include flags:           $X11_INCFLAGS
+  X11 libraries:               $X11_LIBS
+  Z CPPFLAGS:                  $Z_CPPFLAGS
+  Z LDFLAGS:                   $Z_LDFLAGS
+  Z libraries:                 $Z_LIBS
+
+  Default pager:               $DEFAULT_PAGER
+  gnuplot:                     $GNUPLOT
+
+  Build Octave GUI:                   $build_gui
+  JIT compiler for loops:             $build_jit
+  Build Java interface:               $build_java
+  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
+  OpenMP SMP multithreading:          $USE_OPENMP
+  Build cross tools:                  $cross_tools
+])
+
+warn_msg_printed=false
+
+OCTAVE_CONFIGURE_WARNING_SUMMARY
+
+if test $ENABLE_DYNAMIC_LINKING = yes; then
+  if test $SHARED_LIBS = no; then
+    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 $USE_64_BIT_IDX_T = yes; then
+  AC_MSG_WARN([])
+  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([Your Fortran compiler must have an option to generate])
+  AC_MSG_WARN([code with 8 byte signed INTEGER values.  This option])
+  AC_MSG_WARN([should be specified in the F77_INTEGER_8_FLAG variable])
+  AC_MSG_WARN([Make.  This should work automatically for gfortran.  If])
+  AC_MSG_WARN([you use another compiler, you will need to set this])
+  AC_MSG_WARN([variable on the configure command line.  You must also])
+  AC_MSG_WARN([compile the ARPACK, BLAS, LAPACK, QRUPDATE, and SuiteSparse])
+  AC_MSG_WARN([libraries to use 8 byte signed integers for array indexing.])
+  AC_MSG_WARN([])
+  warn_msg_printed=true
+fi
+
+if test $native_graphics != yes; then
+  AC_MSG_WARN([])
+  AC_MSG_WARN([I didn't find the necessary libraries to compile native])
+  AC_MSG_WARN([graphics.  It isn't necessary to have native graphics,])
+  AC_MSG_WARN([but you will need to have gnuplot installed or you won't])
+  AC_MSG_WARN([be able to use any of Octave's plotting commands])
+  AC_MSG_WARN([])
+  warn_msg_printed=true
+fi
+
+if test -n "$warn_gnuplot"; then
+  if test $native_graphics = yes; then
+    AC_MSG_WARN([])
+    AC_MSG_WARN([I didn't find gnuplot.  Plotting commands will use the])
+    AC_MSG_WARN([native graphics toolkit.])
+  else
+    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.])
+  fi
+  AC_MSG_WARN([])
+  AC_MSG_WARN([If gnuplot is installed, but isn't in your path, you can])
+  AC_MSG_WARN([tell Octave where to find it by using the gnuplot_binary])
+  AC_MSG_WARN([function.  For example,])
+  AC_MSG_WARN([])
+  AC_MSG_WARN([gnuplot_binary ("/full/path/and/name/of/gnuplot/binary")])
+  AC_MSG_WARN([])
+  AC_MSG_WARN([at the Octave prompt.])
+  AC_MSG_WARN([])
+  AC_MSG_WARN([Setting default value to $GNUPLOT])
+  AC_MSG_WARN([])
+
+  warn_msg_printed=true
+fi
+
+if test $USE_ATOMIC_REFCOUNT = no; then
+  AC_MSG_WARN([])
+  AC_MSG_WARN([atomic reference counting disabled.])
+  AC_MSG_WARN([This feature allows access to Octave data safely from])
+  AC_MSG_WARN([another thread, and is required when using the GUI's Qt toolkit])
+  AC_MSG_WARN([for plotting.])
+  AC_MSG_WARN([])
+fi
+
+if $warn_msg_printed; then
+  AC_MSG_NOTICE([])
+  AC_MSG_NOTICE([NOTE: Libraries or auxiliary programs may be skipped if they are])
+  AC_MSG_NOTICE([NOTE: not found OR if they are missing required features on your])
+  AC_MSG_NOTICE([NOTE: system. ])
+fi
+
+### End of configure.

=== added directory '.pc/qt-requires-opengl.patch/m4'
=== added file '.pc/qt-requires-opengl.patch/m4/acinclude.m4'
--- .pc/qt-requires-opengl.patch/m4/acinclude.m4	1970-01-01 00:00:00 +0000
+++ .pc/qt-requires-opengl.patch/m4/acinclude.m4	2015-08-02 19:51:25 +0000
@@ -0,0 +1,2448 @@
+dnl aclocal.m4 -- extra macros for configuring Octave
+dnl
+dnl Copyright (C) 1995-2015 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 3 of the License, or (at
+dnl your option) any 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, see
+dnl <http://www.gnu.org/licenses/>.
+dnl
+dnl
+dnl Copyright (C) 2008 - 2009 Free Software Foundation, Inc.
+dnl
+dnl If needed, define the m4_ifblank and m4_ifnblank macros from autoconf 2.64
+dnl This allows us to run with earlier Autoconfs as well.
+dnl FIXME: these should go away once Autoconf 2.64 is required or ubiquitous.
+dnl
+ifdef([m4_ifblank],[],[
+m4_define([m4_ifblank],
+[m4_if(m4_translit([[$1]],  [ ][	][
+]), [], [$2], [$3])])])
+dnl
+ifdef([m4_ifnblank],[],[
+m4_define([m4_ifnblank],
+[m4_if(m4_translit([[$1]],  [ ][	][
+]), [], [$3], [$2])])])
+dnl
+dnl ----------------------------------------------------------------------
+dnl
+
+dnl
+dnl Alphabetical list of macros in the OCTAVE_ namespace
+dnl
+
+dnl
+dnl Check if the Carbon Framework defines CGDisplayBitsPerPixel.
+dnl
+AC_DEFUN([OCTAVE_CARBON_CGDISPLAYBITSPERPIXEL], [
+  AC_CACHE_CHECK([whether CGDisplayBitsPerPixel is defined in the Carbon Framework],
+    [octave_cv_func_carbon_cgdisplaybitsperpixel],
+    [AC_LANG_PUSH(C++)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <Carbon/Carbon.h>
+        ]], [[
+        CGDirectDisplayID display = CGMainDisplayID ();
+        size_t depth = CGDisplayBitsPerPixel (display);
+      ]])],
+      octave_cv_func_carbon_cgdisplaybitsperpixel=yes,
+      octave_cv_func_carbon_cgdisplaybitsperpixel=no)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_func_carbon_cgdisplaybitsperpixel = yes; then
+    AC_DEFINE(HAVE_CARBON_CGDISPLAYBITSPERPIXEL, 1,
+      [Define to 1 if Carbon Framework has CGDisplayBitsPerPixel.])
+  fi
+])
+dnl
+dnl Check if C compiler handles FLAG command line option.  If two
+dnl arguments are specified, execute the second arg as shell commands.
+dnl Otherwise, add FLAG to CFLAGS if the compiler accepts the flag.
+dnl
+AC_DEFUN([OCTAVE_CC_FLAG], [
+  ac_safe=`echo "$1" | $SED 'y% ./+-:=%___p___%'`
+  AC_MSG_CHECKING([whether ${CC-cc} accepts $1])
+  AC_CACHE_VAL([octave_cv_cc_flag_$ac_safe],
+    [AC_LANG_PUSH(C)
+    ac_octave_save_CFLAGS="$CFLAGS"
+    CFLAGS="$CFLAGS $1"
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
+      [eval "octave_cv_cc_flag_$ac_safe=yes"],
+      [eval "octave_cv_cc_flag_$ac_safe=no"])
+    CFLAGS="$ac_octave_save_CFLAGS"
+    AC_LANG_POP(C)
+  ])
+  if eval "test \"`echo '$octave_cv_cc_flag_'$ac_safe`\" = yes"; then
+    AC_MSG_RESULT([yes])
+    ifelse([$2], ,
+      [CFLAGS="$CFLAGS $1"
+      AC_MSG_RESULT([adding $1 to CFLAGS])], [$2])
+  else
+    AC_MSG_RESULT([no])
+    ifelse([$3], , , [$3])
+  fi
+])
+dnl
+dnl Check for broken stl_algo.h header file in gcc versions 4.8.0, 4.8.1, 4.8.2
+dnl which leads to failures in nth_element.
+dnl
+AC_DEFUN([OCTAVE_CHECK_BROKEN_STL_ALGO_H], [
+  AC_CACHE_CHECK([whether stl_algo.h is broken],
+    [octave_cv_broken_stl_algo_h],
+    [AC_LANG_PUSH(C++)
+    AC_RUN_IFELSE([AC_LANG_PROGRAM([[
+// Based on code from a GCC test program.
+
+// Copyright (C) 2013 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
+// any later version.
+
+// This library 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 library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 25.3.2 [lib.alg.nth.element]
+
+// { dg-options "-std=gnu++11" }
+
+#include <algorithm>
+#include <vector>
+      ]], [[
+std::vector<int> v (7);
+
+v[0] = 207089;
+v[1] = 202585;
+v[2] = 180067;
+v[3] = 157549;
+v[4] = 211592;
+v[5] = 216096;
+v[6] = 207089;
+
+std::nth_element (v.begin (), v.begin () + 3, v.end ());
+
+return v[3] == 207089 ? 0 : 1;
+    ]])],
+    octave_cv_broken_stl_algo_h=no,
+    octave_cv_broken_stl_algo_h=yes,
+    [case "$GXX_VERSION" in
+       *4.8.2*)
+         octave_cv_broken_stl_algo_h=yes
+       ;;
+       *)
+         octave_cv_broken_stl_algo_h=no
+       ;;
+     esac
+    ])
+    AC_LANG_POP(C++)
+  ])
+  if test "$GXX" = yes; then
+    if test $octave_cv_broken_stl_algo_h = yes; then
+      case "$GXX_VERSION" in
+        4.8.[[012]])
+        ;;
+        *)
+          octave_cv_broken_stl_algo_h=no
+          warn_stl_algo_h="UNEXPECTED: found nth_element broken in g++ $GXX_VERSION.  Refusing to fix except for g++ 4.8.0, 4.8.1, or 4.8.2.  You appear to have g++ $GXX_VERSION."
+          OCTAVE_CONFIGURE_WARNING([warn_stl_algo_h])
+        ;;
+      esac
+    else
+      case "$GXX_VERSION" in
+        4.8.2)
+          warn_stl_algo_h="UNEXPECTED: found nth_element working in g++ 4.8.2.  Has it been patched on your system?"
+          OCTAVE_CONFIGURE_WARNING([warn_stl_algo_h])
+        ;;
+      esac
+    fi
+  else
+    octave_cv_broken_stl_algo_h=no
+    warn_stl_algo_h="UNEXPECTED: nth_element test failed.  Refusing to fix except for g++ 4.8.2."
+    OCTAVE_CONFIGURE_WARNING([warn_stl_algo_h])
+  fi
+])
+dnl
+dnl Check whether the FFTW library supports multi-threading. This macro
+dnl should be called once per FFTW precision passing in the library
+dnl variant (e.g. "fftw3") and a function in the thread support API
+dnl (e.g. "fftw_plan_with_nthreads"). Depending on how FFTW was built,
+dnl the thread functions could be compiled into the main FFTW library or
+dnl could be a separate add-on library that is passed to the linker
+dnl ahead of the main FFTW library.
+dnl
+AC_DEFUN([OCTAVE_CHECK_FFTW_THREADS], [
+  ac_octave_save_CPPFLAGS="$CPPFLAGS"
+  ac_octave_save_LDFLAGS="$LDFLAGS"
+  ac_octave_save_LIBS="$LIBS"
+  CPPFLAGS="$m4_toupper([$1])_CPPFLAGS $CPPFLAGS"
+  LDFLAGS="$m4_toupper([$1])_LDFLAGS $LDFLAGS"
+  LIBS="$m4_toupper([$1])_LIBS $LIBS"
+  AC_CACHE_CHECK([for $1 multi-threading support],
+    [octave_cv_[$1]_threads_lib],
+    [AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+      #include <fftw3.h>
+      ]], [[
+      $2 (2);
+      ]])],
+      [octave_cv_[$1]_threads_lib=yes],
+      [LIBS="-l[$1]_threads $LIBS"
+      AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+        #include <fftw3.h>
+        ]], [[
+        $2 (2);
+        ]])],
+        [octave_cv_[$1]_threads_lib="-l[$1]_threads"],
+        [octave_cv_[$1]_threads_lib=no])
+    ])
+  ])
+  case $octave_cv_[$1]_threads_lib in
+    -l*)
+      m4_toupper([$1])_LIBS="$octave_cv_[$1]_threads_lib $m4_toupper([$1])_LIBS"
+      ;;
+    no)
+      AC_MSG_WARN([No $1 multi-threading support found.])
+      AC_MSG_WARN([The single-threaded library will be used instead.])
+      ;;
+  esac
+  if test $octave_cv_[$1]_threads_lib != no; then
+    AC_DEFINE([HAVE_]m4_toupper([$1])[_THREADS], 1,
+      [Define to 1 if ]m4_toupper([$1])[ has multi-threading support.])
+  fi
+  CPPFLAGS="$ac_octave_save_CPPFLAGS"
+  LDFLAGS="$ac_octave_save_LDFLAGS"
+  LIBS="$ac_octave_save_LIBS"
+])
+dnl
+dnl Check whether a math mapper function is available in <cmath>.
+dnl Will define HAVE_CMATH_FUNC if there is a double variant and
+dnl HAVE_CMATH_FUNCF if there is a float variant.
+dnl Currently capable of checking for functions with single
+dnl argument and returning bool/int/real.
+dnl
+AC_DEFUN([OCTAVE_CHECK_FUNC_CMATH], [
+  ac_safe=`echo "$1" | $SED 'y% ./+-:=%___p___%'`
+
+  AC_CACHE_CHECK([for std::$1 in <cmath>],
+    [octave_cv_func_cmath_$ac_safe],
+    [AC_LANG_PUSH(C++)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <cmath>
+        void take_func (bool (*func) (double x));
+        void take_func (int (*func) (double x));
+        void take_func (double (*func) (double x));
+        ]], [[
+        take_func(std::$1);
+        ]])],
+      [eval "octave_cv_func_cmath_$ac_safe=yes"],
+      [eval "octave_cv_func_cmath_$ac_safe=no"])
+    AC_LANG_POP(C++)
+  ])
+  if eval "test \"`echo '$octave_cv_func_cmath_'$ac_safe`\" = yes"; then
+    AC_DEFINE(AS_TR_CPP([[HAVE_CMATH_][$1]]), 1,
+      [Define to 1 if <cmath> provides $1.])
+  fi
+
+  AC_CACHE_CHECK([for std::$1 (float variant) in <cmath>],
+    [octave_cv_func_cmath_f$ac_safe],
+    [AC_LANG_PUSH(C++)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <cmath>
+        void take_func (bool (*func) (float x));
+        void take_func (int (*func) (float x));
+        void take_func (float (*func) (float x));
+        ]], [[
+        take_func(std::$1);
+        ]])],
+      [eval "octave_cv_func_cmath_f$ac_safe=yes"],
+      [eval "octave_cv_func_cmath_f$ac_safe=no"])
+    AC_LANG_POP(C++)
+  ])
+  if eval "test \"`echo '$octave_cv_func_cmath_f'$ac_safe`\" = yes"; then
+    AC_DEFINE(AS_TR_CPP([[HAVE_CMATH_][$1][F]]), 1,
+      [Define to 1 if <cmath> provides float variant of $1.])
+  fi
+])
+dnl
+dnl Check whether Qscintilla has version 2.6.0 or later
+dnl FIXME: This test uses a version number.  It potentially could
+dnl        be re-written to actually call the function, but is it worth it?
+dnl
+AC_DEFUN([OCTAVE_CHECK_VERSION_2_6_0], [
+  AC_CACHE_CHECK([whether Qscintilla has version 2.6.0 or later],
+    [octave_cv_version_2_6_0],
+    [AC_LANG_PUSH(C++)
+    ac_octave_save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$QT_CPPFLAGS $CPPFLAGS"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <Qsci/qsciglobal.h>
+        ]], [[
+        #if QSCINTILLA_VERSION < 0x020600
+        #error Old FindFirst function found.
+        #endif
+        ]])],
+      octave_cv_version_2_6_0=yes,
+      octave_cv_version_2_6_0=no)
+    CPPFLAGS="$ac_octave_save_CPPFLAGS"
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_version_2_6_0 = yes; then
+    AC_DEFINE(HAVE_QSCI_VERSION_2_6_0, 1,
+      [Define to 1 if Qscintilla is of Version 2.6.0 or later.])
+  fi
+])
+dnl
+dnl Check if Fortran compiler has the intrinsic function ISNAN.
+dnl
+AC_DEFUN([OCTAVE_CHECK_FUNC_FORTRAN_ISNAN], [
+  AC_CACHE_CHECK([whether $F77 has the intrinsic function ISNAN],
+    [octave_cv_func_fortran_isnan],
+    [AC_LANG_PUSH(Fortran 77)
+    AC_COMPILE_IFELSE([[
+      program foo
+      implicit none
+      real x
+      double precision y
+      if (isnan(x)) then
+        print *, 'x is NaN'
+      end if
+      if (isnan(y)) then
+        print *, 'y is NaN'
+      end if
+      end program
+      ]],
+      octave_cv_func_fortran_isnan=yes, octave_cv_func_fortran_isnan=no)
+    AC_LANG_POP(Fortran 77)
+  ])
+])
+dnl
+dnl Check if function gluTessCallback is called with "(...)".
+dnl
+AC_DEFUN([OCTAVE_CHECK_FUNC_GLUTESSCALLBACK_THREEDOTS], [
+  AC_CACHE_CHECK([whether gluTessCallback is called with "(...)"],
+    [octave_cv_func_glutesscallback_threedots],
+    [AC_LANG_PUSH(C++)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #ifdef HAVE_GL_GLU_H
+        # include <GL/glu.h>
+        #elif defined HAVE_OPENGL_GLU_H || defined HAVE_FRAMEWORK_OPENGL
+        # include <OpenGL/glu.h>
+        #endif
+        ]], [[
+        GLvoid (*func)(...);
+        gluTessCallback(0, 0, func);
+        ]])],
+      octave_cv_func_glutesscallback_threedots=yes,
+      octave_cv_func_glutesscallback_threedots=no)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_func_glutesscallback_threedots = yes; then
+    AC_DEFINE(HAVE_GLUTESSCALLBACK_THREEDOTS, 1,
+      [Define to 1 if gluTessCallback is called with (...).])
+  fi
+])
+dnl
+dnl Check whether Qt provides QFont::Monospace
+dnl
+AC_DEFUN([OCTAVE_CHECK_QFONT_MONOSPACE], [
+  AC_CACHE_CHECK([whether Qt provides QFont::Monospace],
+    [octave_cv_decl_qfont_monospace],
+    [AC_LANG_PUSH(C++)
+    ac_octave_save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$QT_CPPFLAGS $CPPFLAGS"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <QFont>
+        ]], [[
+        QFont::StyleHint hint = QFont::Monospace;
+        ]])],
+      octave_cv_decl_qfont_monospace=yes,
+      octave_cv_decl_qfont_monospace=no)
+    CPPFLAGS="$ac_octave_save_CPPFLAGS"
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_decl_qfont_monospace = yes; then
+    AC_DEFINE(HAVE_QFONT_MONOSPACE, 1,
+      [Define to 1 if Qt provides QFont::Monospace.])
+  fi
+])
+dnl
+dnl Check whether Qt provides QFont::ForceIntegerMetrics
+dnl
+AC_DEFUN([OCTAVE_CHECK_QFONT_FORCE_INTEGER_METRICS], [
+  AC_CACHE_CHECK([whether Qt provides QFont::ForceIntegerMetrics],
+    [octave_cv_decl_qfont_force_integer_metrics],
+    [AC_LANG_PUSH(C++)
+    ac_octave_save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$QT_CPPFLAGS $CPPFLAGS"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <QFont>
+        ]], [[
+        QFont::StyleStrategy strategy = QFont::ForceIntegerMetrics;
+        ]])],
+      octave_cv_decl_qfont_force_integer_metrics=yes,
+      octave_cv_decl_qfont_force_integer_metrics=no)
+    CPPFLAGS="$ac_octave_save_CPPFLAGS"
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_decl_qfont_force_integer_metrics = yes; then
+    AC_DEFINE(HAVE_QFONT_FORCE_INTEGER_METRICS, 1,
+      [Define to 1 if Qt provides QFont::ForceIntegerMetrics.])
+  fi
+])
+dnl
+dnl Check whether Qscintilla SetPlaceholderText function exists.
+dnl FIXME: This test uses a version number.  It potentially could
+dnl        be re-written to actually call the function, but is it worth it?
+dnl
+AC_DEFUN([OCTAVE_CHECK_FUNC_SETPLACEHOLDERTEXT], [
+  AC_CACHE_CHECK([whether Qt has SetPlaceholderText function],
+    [octave_cv_func_setplaceholdertext],
+    [AC_LANG_PUSH(C++)
+    ac_octave_save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$QT_CPPFLAGS $CPPFLAGS"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <Qt/qglobal.h>
+        ]], [[
+        #if QT_VERSION < 0x040700
+        #error No SetPlacholderText function available.
+        #endif
+        ]])],
+      octave_cv_func_setplaceholdertext=yes,
+      octave_cv_func_setplaceholdertext=no)
+    CPPFLAGS="$ac_octave_save_CPPFLAGS"
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_func_setplaceholdertext = yes; then
+    AC_DEFINE(HAVE_SETPLACEHOLDERTEXT, 1,
+      [Define to 1 if you have the Qt SetPlaceholderText function.])
+  fi
+])
+dnl
+dnl Check whether the Qt QAbstractItemModel::beginResetModel() function exists.
+dnl Also checks for QAbstractItemModel::endResetModel().  These are two of the
+dnl newest Qt functions that the Octave GUI depends on, added in Qt 4.6.
+dnl
+AC_DEFUN([OCTAVE_CHECK_FUNC_QABSTRACTITEMMODEL_BEGINRESETMODEL], [
+  AC_CACHE_CHECK([whether Qt has the QAbstractItemModel::beginResetModel() function],
+    [octave_cv_func_qabstractitemmodel_beginresetmodel],
+    [AC_LANG_PUSH(C++)
+    ac_octave_save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$QT_CPPFLAGS $CPPFLAGS"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <QAbstractItemModel>
+        class item_model : public QAbstractItemModel
+        {
+        public:
+          item_model (QObject *parent = 0) : QAbstractItemModel (parent) {}
+          ~item_model () {}
+          QModelIndex index (int, int, const QModelIndex& m) const { return m; }
+          QModelIndex parent (const QModelIndex& m) const { return m; }
+          int columnCount (const QModelIndex&) const { return 0; }
+          int rowCount (const QModelIndex&) const { return 0; }
+          QVariant data (const QModelIndex&, int) const { return QVariant(); }
+          void update_model ()
+          {
+            this->beginResetModel ();
+            this->endResetModel ();
+          }
+        };
+        ]], [[
+        item_model model;
+        model.update_model ();
+        ]])],
+      octave_cv_func_qabstractitemmodel_beginresetmodel=yes,
+      octave_cv_func_qabstractitemmodel_beginresetmodel=no)
+    CPPFLAGS="$ac_octave_save_CPPFLAGS"
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_func_qabstractitemmodel_beginresetmodel = yes; then
+    AC_DEFINE(HAVE_QABSTRACTITEMMODEL_BEGINRESETMODEL, 1,
+      [Define to 1 if Qt has the QAbstractItemModel::beginResetModel() function.])
+  fi
+])
+dnl
+dnl Check whether the Qt QTabWidget::setMovable() function exists.
+dnl This function was added in Qt 4.5.
+dnl
+AC_DEFUN([OCTAVE_CHECK_FUNC_QTABWIDGET_SETMOVABLE], [
+  AC_CACHE_CHECK([whether Qt has the QTabWidget::setMovable() function],
+    [octave_cv_func_qtabwidget_setmovable],
+    [AC_LANG_PUSH(C++)
+    ac_octave_save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$QT_CPPFLAGS $CPPFLAGS"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <QTabWidget>
+        class tab_widget : public QTabWidget
+        {
+        public:
+          tab_widget (QWidget *parent = 0) : QTabWidget (parent) { this->setMovable (true); }
+          ~tab_widget () {}
+        };
+        ]], [[
+        tab_widget tw;
+        ]])],
+      octave_cv_func_qtabwidget_setmovable=yes,
+      octave_cv_func_qtabwidget_setmovable=no)
+    CPPFLAGS="$ac_octave_save_CPPFLAGS"
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_func_qtabwidget_setmovable = yes; then
+    AC_DEFINE(HAVE_QTABWIDGET_SETMOVABLE, 1,
+      [Define to 1 if Qt has the QTabWidget::setMovable() function.])
+  fi
+])
+dnl
+dnl Check whether the QsciScintilla::findFirstInSelection () function exists.
+dnl This function was added in QScintilla 2.7.
+dnl
+AC_DEFUN([OCTAVE_CHECK_FUNC_QSCI_FINDSELECTION], [
+  AC_CACHE_CHECK([whether QSci has the QsciScintilla::findFirstInSelection () function],
+    [octave_cv_func_qsci_findfirstinselection],
+    [AC_LANG_PUSH(C++)
+    ac_octave_save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$QT_CPPFLAGS $CPPFLAGS"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <Qsci/qsciscintilla.h>
+        class qsci : public QsciScintilla
+        {
+        public:
+          qsci (QWidget *parent = 0) : QsciScintilla (parent)
+          { this->findFirstInSelection (QString ("x"),true,true,true,true,true); }
+          ~qsci () {}
+        };
+        ]], [[
+        qsci edit;
+        ]])],
+      octave_cv_func_qsci_findfirstinselection=yes,
+      octave_cv_func_qsci_findfirstinselection=no)
+    CPPFLAGS="$ac_octave_save_CPPFLAGS"
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_func_qsci_findfirstinselection = yes; then
+    AC_DEFINE(HAVE_QSCI_FINDSELECTION, 1,
+      [Define to 1 if Qsci has the QsciScintilla::findFirstInSelection () function.])
+  fi
+])
+dnl
+dnl Check whether HDF5 library has version 1.6 API functions.
+dnl
+AC_DEFUN([OCTAVE_CHECK_HDF5_HAS_VER_16_API], [
+  AC_CACHE_CHECK([whether HDF5 library has enforced version 1.6 API],
+    [octave_cv_hdf5_has_ver_16_api],
+    [AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+      #include <hdf5.h>
+      ]], [[
+      H5Eset_auto (0, 0);
+      ]])],
+      octave_cv_hdf5_has_ver_16_api=yes,
+      octave_cv_hdf5_has_ver_16_api=no)
+  ])
+  if test $octave_cv_hdf5_has_ver_16_api != yes; then
+    AC_DEFINE(HAVE_HDF5_18, 1, [Define to 1 if >=HDF5-1.8 is available.])
+  fi
+])
+dnl
+dnl Usage:
+dnl OCTAVE_CHECK_LIB(LIBRARY, DOC-NAME, WARN-MSG, HEADER, FUNC,
+dnl                  LANG, DOC-STRING, EXTRA-CHECK)
+dnl
+AC_DEFUN([OCTAVE_CHECK_LIB], [
+  AC_ARG_WITH([$1-includedir],
+    [AS_HELP_STRING([--with-$1-includedir=DIR],
+      [look for $2 include files in DIR])],
+    [m4_toupper([$1])_CPPFLAGS="-I$withval"])
+  AC_SUBST(m4_toupper([$1])_CPPFLAGS)
+
+  AC_ARG_WITH([$1-libdir],
+    [AS_HELP_STRING([--with-$1-libdir=DIR],
+      [look for $2 libraries in DIR])],
+    [m4_toupper([$1])_LDFLAGS="-L$withval"])
+  AC_SUBST(m4_toupper([$1])_LDFLAGS)
+
+  AC_ARG_WITH([$1],
+    [m4_ifblank([$7],
+      [AS_HELP_STRING([--without-$1], [don't use $2 library])],
+      [AS_HELP_STRING([--without-$1], [$7])])],
+    with_$1=$withval, with_$1=yes)
+
+  m4_toupper([$1])_LIBS=
+  case $with_$1 in
+    no)
+      m4_toupper([$1])_LIBS=
+    ;;
+    yes | "")
+      m4_toupper([$1])_LIBS="-l$1"
+    ;;
+    -* | */* | *.a | *.so | *.so.* | *.o)
+      m4_toupper([$1])_LIBS="$with_$1"
+    ;;
+    *)
+      m4_toupper([$1])_LIBS="-l$with_$1"
+    ;;
+  esac
+
+  warn_$1="$3"
+  m4_set_add([summary_warning_list], [warn_$1])
+
+  if test -n "$m4_toupper([$1])_LIBS"; then
+    ac_octave_save_CPPFLAGS="$CPPFLAGS"
+    ac_octave_save_LDFLAGS="$LDFLAGS"
+    ac_octave_save_LIBS="$LIBS"
+    CPPFLAGS="$m4_toupper([$1])_CPPFLAGS $CPPFLAGS"
+    LDFLAGS="$m4_toupper([$1])_LDFLAGS $LDFLAGS"
+    LIBS="$m4_toupper([$1])_LIBS $LIBS"
+    m4_ifnblank([$6], [AC_LANG_PUSH($6)])
+    ac_octave_$1_check_for_lib=no
+    m4_ifblank([$4], [ac_octave_$1_check_for_lib=yes],
+               [AC_CHECK_HEADERS([$4], [ac_octave_$1_check_for_lib=yes; break])])
+    if test $ac_octave_$1_check_for_lib = yes; then
+      AC_CACHE_CHECK([for $5 in $m4_toupper([$1])_LIBS],
+        [octave_cv_lib_$1],
+        [AC_LINK_IFELSE([AC_LANG_CALL([], [$5])],
+          [octave_cv_lib_$1=yes], [octave_cv_lib_$1=no])
+      ])
+      if test "$octave_cv_lib_$1" = yes; then
+        m4_ifblank([$8], [
+          warn_$1=
+          AC_DEFINE([HAVE_]m4_toupper([$1]), 1,
+            [Define to 1 if $2 is available.])], [$8])
+      fi
+    fi
+    m4_ifnblank([$6], [AC_LANG_POP($6)])
+    CPPFLAGS="$ac_octave_save_CPPFLAGS"
+    LDFLAGS="$ac_octave_save_LDFLAGS"
+    LIBS="$ac_octave_save_LIBS"
+  fi
+
+  AC_SUBST(m4_toupper([$1])_LIBS)
+  if test -n "$warn_$1"; then
+    AC_MSG_WARN([$warn_$1])
+    m4_toupper([$1])_LIBS=
+  fi
+])
+dnl
+dnl Check whether ARPACK works (does not crash).
+dnl
+dnl Using a pure Fortran program doesn't seem to crash when linked
+dnl with the buggy ARPACK library but the C++ program does.  Maybe it
+dnl is the memory allocation that exposes the bug and using statically
+dnl allocated arrays in Fortran does not?
+dnl
+dnl FIXME: it would be nice to avoid the duplication of F77 macros
+dnl and typedefs here and in the f77-fcn.h header file.
+dnl
+AC_DEFUN([OCTAVE_CHECK_LIB_ARPACK_OK], [
+  AC_CACHE_CHECK([whether the arpack library works],
+    [octave_cv_lib_arpack_ok],
+    [AC_LANG_PUSH(C++)
+    AC_RUN_IFELSE([AC_LANG_PROGRAM([[
+
+#include <cfloat>
+
+#include <stdint.h>
+
+typedef OCTAVE_IDX_TYPE octave_idx_type;
+typedef int F77_RET_T;
+
+#define F77_CHAR_ARG2(x, l) x
+#define F77_CONST_CHAR_ARG2(x, l) F77_CHAR_ARG2 (x, l)
+
+#define F77_CHAR_ARG_LEN(l) , l
+
+#define F77_CONST_CHAR_ARG_DECL const char *
+#define F77_CHAR_ARG_LEN_DECL , long
+
+extern "C"
+{
+  F77_RET_T
+  F77_FUNC (dnaupd, DNAUPD) (octave_idx_type&,
+                             F77_CONST_CHAR_ARG_DECL,
+                             const octave_idx_type&,
+                             F77_CONST_CHAR_ARG_DECL,
+                             octave_idx_type&, const double&,
+                             double*, const octave_idx_type&, double*,
+                             const octave_idx_type&, octave_idx_type*,
+                             octave_idx_type*, double*, double*,
+                             const octave_idx_type&, octave_idx_type&
+                             F77_CHAR_ARG_LEN_DECL
+                             F77_CHAR_ARG_LEN_DECL);
+
+  F77_RET_T
+  F77_FUNC (dneupd, DNEUPD) (const octave_idx_type&,
+                             F77_CONST_CHAR_ARG_DECL,
+                             octave_idx_type*, double*, double*,
+                             double*, const octave_idx_type&, const double&,
+                             const double&, double*,
+                             F77_CONST_CHAR_ARG_DECL,
+                             const octave_idx_type&,
+                             F77_CONST_CHAR_ARG_DECL,
+                             octave_idx_type&, const double&, double*,
+                             const octave_idx_type&, double*,
+                             const octave_idx_type&, octave_idx_type*,
+                             octave_idx_type*, double*, double*,
+                             const octave_idx_type&, octave_idx_type&
+                             F77_CHAR_ARG_LEN_DECL
+                             F77_CHAR_ARG_LEN_DECL
+                             F77_CHAR_ARG_LEN_DECL);
+
+  F77_RET_T
+  F77_FUNC (dgemv, DGEMV) (F77_CONST_CHAR_ARG_DECL,
+                           const octave_idx_type&, const octave_idx_type&,
+                           const double&, const double*,
+                           const octave_idx_type&, const double*,
+                           const octave_idx_type&, const double&, double*,
+                           const octave_idx_type&
+                           F77_CHAR_ARG_LEN_DECL);
+}
+
+void
+doit (void)
+{
+  // Based on function EigsRealNonSymmetricMatrix from liboctave/eigs-base.cc.
+
+  // Problem matrix.  See bug #31479
+  octave_idx_type n = 4;
+  double *m = new double [n * n];
+  m[0] = 1, m[4] = 0, m[8]  = 0, m[12] = -1;
+  m[1] = 0, m[5] = 1, m[9]  = 0, m[13] = 0;
+  m[2] = 0, m[6] = 0, m[10] = 1, m[14] = 0;
+  m[3] = 0, m[7] = 0, m[11] = 2, m[15] = 1;
+
+  double *resid = new double [4];
+
+  resid[0] = 0.960966;
+  resid[1] = 0.741195;
+  resid[2] = 0.150143;
+  resid[3] = 0.868067;
+
+  octave_idx_type *ip = new octave_idx_type [11];
+
+  ip[0] = 1;   // ishift
+  ip[1] = 0;   // ip[1] not referenced
+  ip[2] = 300; // mxiter, maximum number of iterations
+  ip[3] = 1;   // NB blocksize in recurrence
+  ip[4] = 0;   // nconv, number of Ritz values that satisfy convergence
+  ip[5] = 0;   // ip[5] not referenced
+  ip[6] = 1;   // mode
+  ip[7] = 0;   // ip[7] to ip[10] are return values
+  ip[8] = 0;
+  ip[9] = 0;
+  ip[10] = 0;
+
+  octave_idx_type *ipntr = new octave_idx_type [14];
+
+  octave_idx_type k = 1;
+  octave_idx_type p = 3;
+  octave_idx_type lwork = 3 * p * (p + 2);
+
+  double *v = new double [n * (p + 1)];
+  double *workl = new double [lwork + 1];
+  double *workd = new double [3 * n + 1];
+
+  octave_idx_type ido = 0;
+  octave_idx_type info = 0;
+
+  double tol = DBL_EPSILON;
+
+  do
+    {
+      F77_FUNC (dnaupd, DNAUPD) (ido, F77_CONST_CHAR_ARG2 ("I", 1),
+                                 n, F77_CONST_CHAR_ARG2 ("LM", 2),
+                                 k, tol, resid, p, v, n, ip, ipntr,
+                                 workd, workl, lwork, info
+                                 F77_CHAR_ARG_LEN (1)
+                                 F77_CHAR_ARG_LEN (2));
+
+      if (ido == -1 || ido == 1 || ido == 2)
+        {
+          double *x = workd + ipntr[0] - 1;
+          double *y = workd + ipntr[1] - 1;
+
+          F77_FUNC (dgemv, DGEMV) (F77_CONST_CHAR_ARG2 ("N", 1),
+                                   n, n, 1.0, m, n, x, 1, 0.0, y, 1
+                                   F77_CHAR_ARG_LEN (1));
+        }
+      else
+        {
+          if (info < 0)
+            {
+              return;  // Error
+            }
+
+          break;
+        }
+    }
+  while (1);
+
+  octave_idx_type *sel = new octave_idx_type [p];
+
+  // In Octave, the dimensions of dr and di are k+1, but k+2 avoids segfault
+  double *dr = new double [k + 1];
+  double *di = new double [k + 1];
+  double *workev = new double [3 * p];
+
+  for (octave_idx_type i = 0; i < k + 1; i++)
+    dr[i] = di[i] = 0.;
+
+  octave_idx_type rvec = 1;
+
+  double sigmar = 0.0;
+  double sigmai = 0.0;
+
+  // In Octave, this is n*(k+1), but n*(k+2) avoids segfault
+  double *z = new double [n * (k + 1)];
+
+  F77_FUNC (dneupd, DNEUPD) (rvec, F77_CONST_CHAR_ARG2 ("A", 1),
+                             sel, dr, di, z, n, sigmar, sigmai, workev,
+                             F77_CONST_CHAR_ARG2 ("I", 1), n,
+                             F77_CONST_CHAR_ARG2 ("LM", 2), k, tol,
+                             resid, p, v, n, ip, ipntr, workd,
+                             workl, lwork, info
+                             F77_CHAR_ARG_LEN (1)
+                             F77_CHAR_ARG_LEN (1)
+                             F77_CHAR_ARG_LEN (2));
+}
+
+]], [[
+
+  for (int i = 0; i < 10; i++)
+    doit ();
+    ]])],
+    octave_cv_lib_arpack_ok=yes,
+    octave_cv_lib_arpack_ok=no,
+    octave_cv_lib_arpack_ok=yes)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_lib_arpack_ok = yes; then
+    $1
+    :
+  else
+    $2
+    :
+  fi
+])
+dnl
+dnl Check whether GLPK provides the latest API functions required
+dnl for the glpk function. The glp_iptcp structure was introduced
+dnl in GLPK version 4.38.
+dnl
+AC_DEFUN([OCTAVE_CHECK_LIB_GLPK_OK], [
+  AC_CACHE_CHECK([whether the glpk library has glp_interior(glp_prob*, glp_iptcp*)],
+    [octave_cv_lib_glpk_ok],
+    [AC_LANG_PUSH(C++)
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+        extern "C"
+        {
+        #if defined (HAVE_GLPK_GLPK_H)
+        #include <glpk/glpk.h>
+        #else
+        #include <glpk.h>
+        #endif
+        }
+        ]], [[
+        glp_prob *lp = glp_create_prob ();
+        glp_iptcp iptcp;
+        glp_init_iptcp (&iptcp);
+        int retval = glp_interior (lp, &iptcp);
+        ]])],
+      octave_cv_lib_glpk_ok=yes,
+      octave_cv_lib_glpk_ok=no)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_lib_glpk_ok = yes; then
+    $1
+    :
+  else
+    $2
+    :
+  fi
+])
+dnl
+dnl Check whether using HDF5 DLL under Windows.  This is done by
+dnl testing for a data symbol in the HDF5 library, which would
+dnl require the definition of _HDF5USEDL_ under MSVC compiler.
+dnl
+AC_DEFUN([OCTAVE_CHECK_LIB_HDF5_DLL], [
+  AC_CACHE_CHECK([if _HDF5USEDLL_ needs to be defined],
+    [octave_cv_lib_hdf5_dll],
+    [AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+        #include <hdf5.h>
+        ]], [[
+        hid_t x = H5T_NATIVE_DOUBLE;
+        return x
+      ]])],
+      [octave_cv_lib_hdf5_dll=no],
+      [save_CFLAGS="$CFLAGS"
+      CFLAGS="$CFLAGS -DWIN32 -D_HDF5USEDLL_"
+      save_LIBS="$LIBS"
+      LIBS="$HDF5_LIBS $LIBS"
+      AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+          #include <hdf5.h>
+          ]], [[
+          hid_t x = H5T_NATIVE_DOUBLE;
+          return x
+        ]])],
+        octave_cv_lib_hdf5_dll=yes,
+        octave_cv_lib_hdf5_dll=no)
+      CFLAGS="$save_CFLAGS"
+      LIBS="$save_LIBS"
+    ])
+  ])
+  if test $octave_cv_lib_hdf5_dll = yes; then
+    AC_DEFINE(_HDF5USEDLL_, 1, [Define to 1 if using HDF5 dll (Win32).])
+  fi
+])
+dnl
+dnl Check for OpenGL.  If found, define OPENGL_LIBS.
+dnl
+dnl FIXME: The following tests should probably check for the
+dnl libraries separately.
+dnl
+dnl FIXME: Should we allow a way to specify a directory for OpenGL
+dnl libraries and header files?
+dnl
+AC_DEFUN([OCTAVE_CHECK_LIB_OPENGL], [
+  OPENGL_LIBS=
+
+  ## On MacOSX systems the OpenGL framework can be used
+  OCTAVE_HAVE_FRAMEWORK(OpenGL, [[
+    #include <OpenGL/gl.h>
+    #include <OpenGL/glu.h>
+    ]], [[
+    GLint par; glGetIntegerv (GL_VIEWPORT, &par);
+    ]],
+    have_framework_opengl=yes, have_framework_opengl=no)
+
+  if test $have_framework_opengl = yes; then
+    AC_DEFINE(HAVE_FRAMEWORK_OPENGL, 1,
+      [Define to 1 if framework OPENGL is available.])
+    OPENGL_LIBS="-Wl,-framework -Wl,OpenGL"
+    AC_MSG_NOTICE([adding -Wl,-framework -Wl,OpenGL to OPENGL_LIBS])
+    OCTAVE_CHECK_FUNC_GLUTESSCALLBACK_THREEDOTS
+  else
+    case $canonical_host_type in
+      *-*-mingw32* | *-*-msdosmsvc)
+        AC_CHECK_HEADERS([windows.h])
+      ;;
+    esac
+    have_opengl_incs=no
+    AC_CHECK_HEADERS([GL/gl.h OpenGL/gl.h],
+      [AC_CHECK_HEADERS([GL/glu.h OpenGL/glu.h],
+        [have_opengl_incs=yes; break], [], [
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#endif
+      ])
+      break
+      ], [], [
+#ifdef HAVE_WINDOWS_H
+# include <windows.h>
+#endif
+    ])
+
+    if test $have_opengl_incs = yes; then
+      AC_CHECK_HEADERS([GL/glext.h OpenGL/glext.h], [], [], [
+#ifdef HAVE_WINDOWS_H
+# include <windows.h>
+#endif
+#if defined (HAVE_GL_GL_H)
+# include <GL/gl.h>
+#elif defined (HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+      ])
+      case $canonical_host_type in
+        *-*-mingw32* | *-*-msdosmsvc)
+          save_LIBS="$LIBS"
+          LIBS="$LIBS -lopengl32"
+          AC_MSG_CHECKING([for glEnable in -lopengl32])
+          AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+            #if HAVE_WINDOWS_H
+            # include <windows.h>
+            #endif
+            #if defined (HAVE_GL_GL_H)
+            # include <GL/gl.h>
+            #elif defined (HAVE_OPENGL_GL_H)
+            # include <OpenGL/gl.h>
+            #endif
+            ]], [[
+            glEnable(GL_SMOOTH);
+            ]])], [OPENGL_LIBS="-lopengl32 -lglu32"])
+
+          LIBS="$save_LIBS"
+          if test "x$OPENGL_LIBS" != "x"; then
+            AC_MSG_RESULT([yes])
+          else
+            AC_MSG_RESULT([no])
+          fi
+          ;;
+        *)
+          ## Non-Mac, Non-Windows systems use this check
+          AC_CHECK_LIB([GL], [glEnable], [OPENGL_LIBS="-lGL -lGLU"])
+          ;;
+      esac
+    fi
+  fi
+  AC_SUBST(OPENGL_LIBS)
+])
+dnl
+dnl Check whether Qhull works (does not crash).
+dnl
+AC_DEFUN([OCTAVE_CHECK_LIB_QHULL_OK], [
+  AC_CACHE_CHECK([whether the qhull library works],
+    [octave_cv_lib_qhull_ok],
+    [AC_RUN_IFELSE([AC_LANG_PROGRAM([[
+        #include <stdio.h>
+        #if defined (HAVE_LIBQHULL_LIBQHULL_H)
+        # include <libqhull/libqhull.h>
+        # include <libqhull/qset.h>
+        # include <libqhull/geom.h>
+        # include <libqhull/poly.h>
+        # include <libqhull/io.h>
+        #elif defined (HAVE_QHULL_LIBQHULL_H) || defined (HAVE_QHULL_QHULL_H)
+        # if defined (HAVE_QHULL_LIBQHULL_H)
+        #  include <qhull/libqhull.h>
+        # else
+        #  include <qhull/qhull.h>
+        # endif
+        # include <qhull/qset.h>
+        # include <qhull/geom.h>
+        # include <qhull/poly.h>
+        # include <qhull/io.h>
+        #elif defined (HAVE_LIBQHULL_H) || defined (HAVE_QHULL_H)
+        # if defined (HAVE_LIBQHULL_H)
+        #  include <libqhull.h>
+        # else
+        #  include <qhull.h>
+        # endif
+        # include <qset.h>
+        # include <geom.h>
+        # include <poly.h>
+        # include <io.h>
+        #endif
+        #ifdef NEED_QHULL_VERSION
+          char *qh_version = "version";
+        #endif
+        ]], [[
+        int dim = 2;
+        int n = 4;
+        coordT points[8] = { -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5 };
+        boolT ismalloc = 0;
+        return qh_new_qhull (dim, n, points, ismalloc, "qhull ", 0, stderr);
+      ]])],
+      octave_cv_lib_qhull_ok=yes,
+      octave_cv_lib_qhull_ok=no,
+      octave_cv_lib_qhull_ok=yes)
+  ])
+  if test $octave_cv_lib_qhull_ok = yes; then
+    $1
+    :
+  else
+    $2
+    :
+  fi
+])
+dnl 
+dnl Check whether sndfile library is modern enough to include things like Ogg
+dnl
+AC_DEFUN([OCTAVE_CHECK_LIB_SNDFILE_OK], [
+  AC_CACHE_CHECK([whether sndfile library is modern enough],
+    [octave_cv_lib_sndfile_ok],
+    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <sndfile.h>
+        ]], [[
+        int x = SF_FORMAT_OGG;
+      ]])],
+      octave_cv_lib_sndfile_ok=yes,
+      octave_cv_lib_sndfile_ok=no)
+  ])
+  if test $octave_cv_lib_sndfile_ok = yes; then
+    $1
+    :
+  else
+    $2
+    :
+  fi
+])
+dnl
+dnl Find a suitable termlib to use.
+dnl
+AC_DEFUN([OCTAVE_CHECK_LIB_TERMLIB], [
+  TERM_LIBS=
+  ac_octave_save_LIBS="$LIBS"
+  AC_SEARCH_LIBS([tputs],
+                 [ncurses curses termcap terminfo termlib],
+                 [], [])
+  LIBS="$ac_octave_save_LIBS"
+  case "$ac_cv_search_tputs" in
+    -l*)
+      TERM_LIBS="$ac_cv_search_tputs"
+    ;;
+    no)
+      warn_termlibs="I couldn't find -ltermcap, -lterminfo, -lncurses, -lcurses, or -ltermlib!"
+      AC_MSG_WARN([$warn_termlibs])
+    ;;
+  esac
+
+dnl  Old code (9/9/2012).  Delete when new code is definitely proven.
+dnl
+dnl  for _termlib in ncurses curses termcap terminfo termlib; do
+dnl    AC_CHECK_LIB([${_termlib}], [tputs], [
+dnl      TERM_LIBS="-l${termlib}"
+dnl      octave_cv_lib_found_termlib=yes
+dnl      break])
+dnl  done
+
+  AC_SUBST(TERM_LIBS)
+])
+dnl
+dnl Check for the Qhull version.
+dnl
+AC_DEFUN([OCTAVE_CHECK_QHULL_VERSION], [
+  AC_CACHE_CHECK([for qh_version in $QHULL_LIBS],
+    [octave_cv_lib_qhull_version],
+    [AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+        #include <stdio.h>
+        #if defined (HAVE_LIBQHULL_LIBQHULL_H)
+        # include <libqhull/libqhull.h>
+        # include <libqhull/qset.h>
+        # include <libqhull/geom.h>
+        # include <libqhull/poly.h>
+        # include <libqhull/io.h>
+        #elif defined (HAVE_QHULL_LIBQHULL_H) || defined (HAVE_QHULL_QHULL_H)
+        # if defined (HAVE_QHULL_LIBQHULL_H)
+        #  include <qhull/libqhull.h>
+        # else
+        #  include <qhull/qhull.h>
+        # endif
+        # include <qhull/qset.h>
+        # include <qhull/geom.h>
+        # include <qhull/poly.h>
+        # include <qhull/io.h>
+        #elif defined (HAVE_LIBQHULL_H) || defined (HAVE_QHULL_H)
+        # if defined (HAVE_LIBQHULL_H)
+        #  include <libqhull.h>
+        # else
+        #  include <qhull.h>
+        # endif
+        # include <qset.h>
+        # include <geom.h>
+        # include <poly.h>
+        # include <io.h>
+        #endif
+        ]], [[
+        const char *tmp = qh_version;
+      ]])],
+      octave_cv_lib_qhull_version=yes, octave_cv_lib_qhull_version=no)
+  ])
+  if test $octave_cv_lib_qhull_version = no; then
+    AC_DEFINE(NEED_QHULL_VERSION, 1,
+      [Define to 1 if the Qhull library needs a qh_version variable defined.])
+  fi
+])
+dnl
+dnl Check if the default Fortran INTEGER is 64 bits wide.
+dnl
+AC_DEFUN([OCTAVE_CHECK_SIZEOF_FORTRAN_INTEGER], [
+  AC_CACHE_CHECK([whether $F77 generates correct size integers],
+    [octave_cv_sizeof_fortran_integer],
+    [ac_octave_save_FFLAGS="$FFLAGS"
+    FFLAGS="$FFLAGS $F77_INTEGER_8_FLAG"
+    AC_LANG_PUSH(Fortran 77)
+    AC_COMPILE_IFELSE([[
+      subroutine foo(n, in, out)
+      integer n, in(n), out(n)
+      integer i
+      do 10 i = 1, n
+        out(i) = in(i)
+   10 continue
+      return
+      end
+      ]],
+      [mv conftest.$ac_objext fintsize.$ac_objext
+      ac_octave_save_LIBS="$LIBS"
+      LIBS="fintsize.$ac_objext $[]_AC_LANG_PREFIX[]LIBS"
+      AC_LANG_PUSH(C)
+      AC_RUN_IFELSE([AC_LANG_PROGRAM([[
+          #include <assert.h>
+          #include <stdint.h>
+          ]], [[
+          #ifdef USE_64_BIT_IDX_T
+            typedef int64_t octave_idx_type;
+          #else
+            typedef int octave_idx_type;
+          #endif
+          octave_idx_type n = 2;
+          octave_idx_type in[2];
+          octave_idx_type out[2];
+          in[0] = 13;
+          in[0] = 42;
+          F77_FUNC(foo,FOO) (&n, &in, &out);
+          assert (in[0] == out[0] && in[1] == out[1]);
+        ]])],
+        octave_cv_sizeof_fortran_integer=yes,
+        octave_cv_sizeof_fortran_integer=no,
+        octave_cv_sizeof_fortran_integer=yes)
+      AC_LANG_POP(C)
+      LIBS="$ac_octave_save_LIBS"
+      rm -f conftest.$ac_objext fintsize.$ac_objext],
+      [rm -f conftest.$ac_objext
+      AC_MSG_FAILURE([cannot compile a simple Fortran program])
+      octave_cv_sizeof_fortran_integer=no])
+    AC_LANG_POP(Fortran 77)
+    FFLAGS="$ac_octave_save_FFLAGS"
+  ])
+])
+dnl
+dnl Add warning to final summary.
+dnl
+AC_DEFUN([OCTAVE_CONFIGURE_WARNING], [
+  AC_MSG_WARN([$][$1])
+  m4_set_add([summary_warning_list], [$1])
+])
+dnl
+dnl Print final summary.
+dnl
+AC_DEFUN([OCTAVE_CONFIGURE_WARNING_SUMMARY], [
+  m4_set_foreach([summary_warning_list], [elt], [
+    if test -n "[$]elt"; then
+      AC_MSG_WARN([$]elt)
+      warn_msg_printed=true
+    fi])
+])
+dnl
+dnl Check if the C++ library has the bit_and, bit_or, and bit_xor
+dnl templates defined.
+dnl
+AC_DEFUN([OCTAVE_CXX_BITWISE_OP_TEMPLATES], [
+  AC_CACHE_CHECK([whether bit_and, bit_or, bit_xor are defined in the C++ library],
+    [octave_cv_cxx_bitwise_op_templates],
+    [AC_LANG_PUSH(C++)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <functional>
+        ]], [[
+        int x = 0;
+        int y = 1;
+        int z1 = std::bit_and<int>() (x, y);
+        int z2 = std::bit_or<int>() (x, y);
+        int z3 = std::bit_xor<int>() (x, y);
+      ]])],
+      octave_cv_cxx_bitwise_op_templates=yes,
+      octave_cv_cxx_bitwise_op_templates=no)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_cxx_bitwise_op_templates = yes; then
+    AC_DEFINE(HAVE_CXX_BITWISE_OP_TEMPLATES, 1,
+      [Define to 1 if C++ library has templated bitwise operators.])
+  fi
+])
+dnl
+dnl Check if C++ reinterpret cast works for function pointers.
+dnl
+AC_DEFUN([OCTAVE_CXX_BROKEN_REINTERPRET_CAST],
+  [AC_REQUIRE([AC_PROG_CXX])
+  AC_CACHE_CHECK([for broken C++ reinterpret_cast],
+    [octave_cv_cxx_broken_reinterpret_cast],
+    [AC_LANG_PUSH(C++)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <cmath> ]], [[
+        typedef double (*fptr) (double);
+        fptr psin = sin;
+        void *vptr = reinterpret_cast<void *> (psin);
+        psin = reinterpret_cast<fptr> (vptr);
+      ]])],
+      octave_cv_cxx_broken_reinterpret_cast=no,
+      octave_cv_cxx_broken_reinterpret_cast=yes)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_cxx_broken_reinterpret_cast = yes; then
+    AC_DEFINE(CXX_BROKEN_REINTERPRET_CAST, 1,
+      [Define to 1 if C++ reinterpret_cast fails for function pointers.])
+  fi
+])
+dnl
+dnl Check if the C++ library has functions to access real and imaginary
+dnl parts of complex numbers independently via references.
+dnl
+AC_DEFUN([OCTAVE_CXX_COMPLEX_REFERENCE_ACCESSORS], [
+  AC_CACHE_CHECK([whether complex class can reference components independently],
+    [octave_cv_cxx_complex_reference_accessors],
+    [AC_LANG_PUSH(C++)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <complex>
+        ]], [[
+        std::complex<double> x;
+        x.real () = 1.0;
+        x.imag () = 1.0;
+      ]])],
+      octave_cv_cxx_complex_reference_accessors=yes,
+      octave_cv_cxx_complex_reference_accessors=no)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_cxx_complex_reference_accessors = yes; then
+    AC_DEFINE(HAVE_CXX_COMPLEX_REFERENCE_ACCESSORS, 1,
+      [Define to 1 if C++ complex class has T& real (void) and T& imag (void) methods.])
+  fi
+])
+dnl
+dnl Check if the C++ library has functions to set real and imaginary
+dnl parts of complex numbers independently.
+dnl
+AC_DEFUN([OCTAVE_CXX_COMPLEX_SETTERS], [
+  AC_CACHE_CHECK([whether complex class can set components independently],
+    [octave_cv_cxx_complex_setters],
+    [AC_LANG_PUSH(C++)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <complex>
+        ]], [[
+        std::complex<double> x;
+        x.real (1.0);
+        x.imag (2.0);
+      ]])],
+      octave_cv_cxx_complex_setters=yes, octave_cv_cxx_complex_setters=no)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_cxx_complex_setters = yes; then
+    AC_DEFINE(HAVE_CXX_COMPLEX_SETTERS, 1,
+      [Define to 1 if C++ complex class has void real (T) and void imag (T) methods.])
+  fi
+])
+dnl
+dnl Check if the compiler supports dynamic auto arrays.
+dnl
+AC_DEFUN([OCTAVE_CXX_DYNAMIC_AUTO_ARRAYS], [
+  AC_CACHE_CHECK([whether C++ supports dynamic auto arrays],
+    [octave_cv_cxx_dynamic_auto_arrays],
+    [AC_LANG_PUSH(C++)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[
+        void test(char *);
+        int length();
+        char x[length()];
+        test(x);
+      ]])],
+      octave_cv_cxx_dynamic_auto_arrays=yes,
+      octave_cv_cxx_dynamic_auto_arrays=no)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_cxx_dynamic_auto_arrays = yes; then
+    AC_DEFINE(HAVE_DYNAMIC_AUTO_ARRAYS, 1,
+      [Define to 1 if C++ supports dynamic auto arrays.])
+  fi
+])
+dnl
+dnl Check if C++ compiler handles FLAG command line option.  If two
+dnl arguments are specified, execute the second arg as shell commands.
+dnl Otherwise, add FLAG to CXXFLAGS if the compiler accepts the flag.
+dnl
+AC_DEFUN([OCTAVE_CXX_FLAG], [
+  ac_safe=`echo "$1" | $SED 'y%./+-:=%__p___%'`
+  AC_MSG_CHECKING([whether ${CXX-g++} accepts $1])
+  AC_CACHE_VAL([octave_cv_cxx_flag_$ac_safe],
+    [AC_LANG_PUSH(C++)
+    ac_octave_save_CXXFLAGS="$CXXFLAGS"
+    CXXFLAGS="$CXXFLAGS $1"
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
+      eval "octave_cv_cxx_flag_$ac_safe=yes",
+      eval "octave_cv_cxx_flag_$ac_safe=no")
+    CXXFLAGS="$ac_octave_save_CXXFLAGS"
+    AC_LANG_POP(C++)
+  ])
+  if eval "test \"`echo '$octave_cv_cxx_flag_'$ac_safe`\" = yes"; then
+    AC_MSG_RESULT([yes])
+    ifelse([$2], ,
+      [CXXFLAGS="$CXXFLAGS $1"
+      AC_MSG_RESULT([adding $1 to CXXFLAGS])], [$2])
+  else
+    AC_MSG_RESULT([no])
+    ifelse([$3], , , [$3])
+  fi
+])
+dnl
+dnl Check if the C++ library is ISO compliant.
+dnl FIXME: This is obviously very simplistic, and trivially fooled.
+dnl
+AC_DEFUN([OCTAVE_CXX_ISO_COMPLIANT_LIBRARY], [
+  AC_REQUIRE([AC_PROG_CXX])
+  AC_MSG_CHECKING([if C++ library is ISO compliant])
+  AC_CACHE_VAL([octave_cv_cxx_iso_compliant_library],
+    [AC_LANG_PUSH(C++)
+    rm -f conftest.h
+    ## Omitting cwctype for now, since it is broken with gcc-3.0.x and
+    ## possibly other versions...
+    for inc in algorithm bitset cassert cctype cerrno cfloat ciso646 \
+        climits clocale cmath complex csetjmp csignal cstdarg cstddef \
+        cstdio cstdlib cstring ctime cwchar deque exception \
+        fstream functional iomanip ios iosfwd iostream istream iterator \
+        limits list locale map memory new numeric ostream queue set \
+        sstream stack stdexcept streambuf string strstream typeinfo \
+        utility valarray vector; do
+      echo "#include <$inc>" >> conftest.h
+    done
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+        #include "conftest.h"
+        ]], [[
+        std::bitset<50> flags;
+        flags.set();
+        int digits = std::numeric_limits<unsigned long>::digits;
+        digits = 0;
+      ]])],
+      octave_cv_cxx_iso_compliant_library=yes,
+      octave_cv_cxx_iso_compliant_library=no)
+    AC_LANG_POP(C++)
+  ])
+  AC_MSG_RESULT([$octave_cv_cxx_iso_compliant_library])
+  if test $octave_cv_cxx_iso_compliant_library = yes; then
+    AC_DEFINE(CXX_ISO_COMPLIANT_LIBRARY, 1,
+      [Define to 1 if your C++ runtime library is ISO compliant.])
+  fi
+])
+dnl
+dnl Check if C++ compiler needs the new friend template declaration
+dnl syntax.
+dnl
+AC_DEFUN([OCTAVE_CXX_NEW_FRIEND_TEMPLATE_DECL], [
+  AC_REQUIRE([AC_PROG_CXX])
+  AC_MSG_CHECKING([for C++ support for new friend template declaration])
+  AC_CACHE_VAL([octave_cv_cxx_new_friend_template_decl],
+    [AC_LANG_PUSH(C++)
+    rm -f conftest.h
+    cat > conftest.h <<EOB
+       struct A {
+         friend int operator== (const A&, const A&);
+         A (int) { }
+       };
+
+       template <class T> int
+       operator== (const T&, const T&)
+       {
+         return 0;
+       }
+EOB
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+        #include "conftest.h"
+        ]], [[
+        A a (1);
+        return a == A(1);
+      ]])],
+      octave_cv_cxx_new_friend_template_decl=no,
+      octave_cv_cxx_new_friend_template_decl=yes)
+    AC_LANG_POP(C++)
+  ])
+  AC_MSG_RESULT([$octave_cv_cxx_new_friend_template_decl])
+  if test $octave_cv_cxx_new_friend_template_decl = yes; then
+    AC_DEFINE(CXX_NEW_FRIEND_TEMPLATE_DECL, 1,
+      [Define to 1 if your compiler supports `<>' stuff for template friends.])
+  fi
+])
+dnl
+dnl Check if the compiler supports placement delete.
+dnl
+AC_DEFUN([OCTAVE_CXX_PLACEMENT_DELETE], [
+  AC_CACHE_CHECK([whether <new> defines placement delete operator],
+    [octave_cv_cxx_placement_delete],
+    [AC_LANG_PUSH(C++)
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+        #include <new>
+        ]], [[
+        operator delete((void *)0, (void *)0);
+      ]])],
+      octave_cv_cxx_placement_delete=yes,
+      octave_cv_cxx_placement_delete=no)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_cxx_placement_delete = yes; then
+    AC_DEFINE(HAVE_PLACEMENT_DELETE, 1,
+      [Define to 1 if C++ supports operator delete(void *, void *).])
+  fi
+])
+dnl
+dnl Allow the user disable support for command line editing using GNU
+dnl readline.
+dnl
+AC_DEFUN([OCTAVE_ENABLE_READLINE], [
+  USE_READLINE=yes
+  READLINE_LIBS=
+  AC_ARG_ENABLE([readline],
+    [AS_HELP_STRING([--disable-readline],
+      [do not use readline library])],
+    [if test "$enableval" = no; then
+       USE_READLINE=no
+       warn_readline="command editing and history features require GNU Readline"
+     fi])
+  if test $USE_READLINE = yes; then
+    dnl RHEL 5 and older systems require termlib set before enabling readline
+    AC_REQUIRE([OCTAVE_CHECK_LIB_TERMLIB])
+    ac_octave_save_LIBS="$LIBS"
+    LIBS="$TERM_LIBS"
+    AC_CHECK_LIB([readline], [rl_set_keyboard_input_timeout],
+      [READLINE_LIBS="-lreadline"
+      AC_DEFINE(USE_READLINE, 1, [Define to 1 to use the readline library.])
+      ],
+      [AC_MSG_WARN([I need GNU Readline 4.2 or later])
+      AC_MSG_ERROR([this is fatal unless you specify --disable-readline])
+    ])
+    LIBS="$ac_octave_save_LIBS"
+  fi
+  AC_SUBST(READLINE_LIBS)
+])
+dnl
+dnl Check if Fortran compiler handles FLAG command line option.  If
+dnl two arguments are specified, execute the second arg as shell
+dnl commands.  Otherwise, add FLAG to FFLAGS if the compiler accepts
+dnl the flag.
+dnl
+AC_DEFUN([OCTAVE_F77_FLAG], [
+  ac_safe=`echo "$1" | $SED 'y%./+-:=%__p___%'`
+  AC_MSG_CHECKING([whether ${F77-g77} accepts $1])
+  AC_CACHE_VAL([octave_cv_f77_flag_$ac_safe], [
+    AC_LANG_PUSH(Fortran 77)
+    ac_octave_save_FFLAGS="$FFLAGS"
+    FFLAGS="$FFLAGS $1"
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
+      eval "octave_cv_f77_flag_$ac_safe=yes",
+      eval "octave_cv_f77_flag_$ac_safe=no")
+    FFLAGS="$ac_octave_save_FFLAGS"
+    AC_LANG_POP(Fortran 77)
+  ])
+  if eval "test \"`echo '$octave_cv_f77_flag_'$ac_safe`\" = yes"; then
+    AC_MSG_RESULT([yes])
+    ifelse([$2], ,
+      [FFLAGS="$FFLAGS $1"
+      AC_MSG_RESULT([adding $1 to FFLAGS])], [$2])
+  else
+    AC_MSG_RESULT([no])
+    ifelse([$3], , , [$3])
+  fi
+])
+dnl
+dnl Check whether fast signed integer arithmetics using bit tricks
+dnl can be used in oct-inttypes.h.  Defines HAVE_FAST_INT_OPS if
+dnl the following conditions hold:
+dnl 1. Signed numbers are represented by twos complement
+dnl    (see <http://en.wikipedia.org/wiki/Two%27s_complement>)
+dnl 2. static_cast to unsigned int counterpart works like interpreting
+dnl    the signed bit pattern as unsigned (and is thus zero-cost).
+dnl 3. Signed addition and subtraction yield the same bit results as unsigned.
+dnl    (We use casts to prevent optimization interference, so there is no
+dnl     need for things like -ftrapv).
+dnl 4. Bit operations on signed integers work like on unsigned integers,
+dnl    except for the shifts.  Shifts are arithmetic.
+dnl
+AC_DEFUN([OCTAVE_FAST_INT_OPS], [
+  AC_CACHE_CHECK([whether fast integer arithmetics is usable],
+    [octave_cv_fast_int_ops],
+    [AC_LANG_PUSH(C++)
+    AC_RUN_IFELSE([AC_LANG_PROGRAM([[
+        #include <limits>
+        template<class UT, class ST>
+        static bool
+        do_test (UT, ST)
+        {
+          volatile ST s = std::numeric_limits<ST>::min () / 3;
+          volatile UT u = static_cast<UT> (s);
+          if (*(reinterpret_cast<volatile ST *> (&u)) != s) return true;
+
+          u = 0; u = ~u;
+          if (*(reinterpret_cast<volatile ST *> (&u)) != -1) return true;
+
+          ST sx, sy;
+          sx = std::numeric_limits<ST>::max () / 2 + 1;
+          sy = std::numeric_limits<ST>::max () / 2 + 2;
+          if (static_cast<ST> (static_cast<UT> (sx) + static_cast<UT> (sy))
+              != std::numeric_limits<ST>::min () + 1) return true;
+          if (static_cast<ST> (static_cast<UT> (sx) - static_cast<UT> (sy))
+              != -1) return true;
+
+          if ((sx & sy) != (static_cast<UT> (sx) & static_cast<UT> (sy)))
+            return true;
+          if ((sx | sy) != (static_cast<UT> (sx) | static_cast<UT> (sy)))
+            return true;
+          if ((sx ^ sy) != (static_cast<UT> (sx) ^ static_cast<UT> (sy)))
+            return true;
+          if ((-1 >> 1) != -1) return true;
+          return false;
+        }
+
+        #define DO_TEST(T) \
+          if (do_test (static_cast<unsigned T> (0), static_cast<signed T> (0)))\
+            return sizeof (T);
+
+        ]],[[
+
+        DO_TEST(char)
+        DO_TEST(short)
+        DO_TEST(int)
+        DO_TEST(long)
+        #if (defined(HAVE_LONG_LONG_INT) && defined(HAVE_UNSIGNED_LONG_LONG_INT))
+          DO_TEST(long long)
+        #endif
+      ]])],
+      octave_cv_fast_int_ops=yes,
+      octave_cv_fast_int_ops=no,
+      octave_cv_fast_int_ops=yes)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_fast_int_ops = yes; then
+    AC_DEFINE(HAVE_FAST_INT_OPS, 1,
+      [Define to 1 if signed integers use two's complement.])
+  fi
+])
+dnl
+dnl Check to see if the compiler and the linker can handle the flags
+dnl "-framework $1" for the given prologue $2 and the given body $3 of
+dnl a source file.  Arguments 2 and 3 optionally can also be empty.
+dnl Add options (lower case letters $1) "--with-framework-$1" and
+dnl "--without-framework-$1".  If this test is successful then perform
+dnl $4, otherwise do $5.
+dnl
+AC_DEFUN([OCTAVE_HAVE_FRAMEWORK], [
+  AC_MSG_CHECKING([whether ${LD-ld} accepts -framework $1])
+  AC_CACHE_VAL([octave_cv_framework_$1],
+    [ac_octave_save_LDFLAGS="$LDFLAGS"
+    LDFLAGS="$LDFLAGS -framework $1"
+    AC_LANG_PUSH(C++)
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([$2], [$3])],
+      eval "octave_cv_framework_$1=yes",
+      eval "octave_cv_framework_$1=no")
+    AC_LANG_POP(C++)
+    LDFLAGS="$ac_octave_save_LDFLAGS"
+  ])
+  if test "$octave_cv_framework_$1" = yes; then
+    AC_MSG_RESULT([yes])
+    AC_ARG_WITH(framework-m4_tolower($1),
+      [AS_HELP_STRING([--without-framework-m4_tolower($1)],
+        [don't use framework $1])],
+         with_have_framework=$withval, with_have_framework=yes)
+    if test "$with_have_framework" = yes; then
+      [$4]
+      :
+    else
+      AC_MSG_NOTICE([framework rejected by --without-framework-m4_tolower($1)])
+      [$5]
+    fi
+  else
+    AC_MSG_RESULT([no])
+    [$5]
+  fi
+])
+dnl
+dnl Figure out the hardware-vendor-os info.
+dnl
+AC_DEFUN([OCTAVE_CANONICAL_HOST], [
+  AC_CANONICAL_HOST
+  if test -z "$host"; then
+    host=unknown-unknown-unknown
+    AC_MSG_WARN([configuring Octave for unknown system type])
+  fi
+  canonical_host_type=$host
+  AC_SUBST(canonical_host_type)
+  if test -z "$host_cpu"; then
+    host_cpu=unknown
+  fi
+  if test -z "$host_vendor"; then
+    host_vendor=unknown
+  fi
+  if test -z "$host_os"; then
+    host_os=unknown
+  fi
+])
+dnl
+dnl Check for IEEE 754 data format.
+dnl
+AC_DEFUN([OCTAVE_IEEE754_DATA_FORMAT], [
+  AC_MSG_CHECKING([for IEEE 754 data format])
+  AC_CACHE_VAL([octave_cv_ieee754_data_format],
+    [AC_RUN_IFELSE([AC_LANG_SOURCE([[
+        int
+        main (void)
+        {
+          typedef union { unsigned char c[8]; double d; } ieeebytes;
+
+          ieeebytes l = {0x1c, 0xbc, 0x6e, 0xf2, 0x54, 0x8b, 0x11, 0x43};
+          ieeebytes b = {0x43, 0x11, 0x8b, 0x54, 0xf2, 0x6e, 0xbc, 0x1c};
+
+          return l.d != 1234567891234567.0 && b.d != 1234567891234567.0;
+        }
+      ]])],
+      octave_cv_ieee754_data_format=yes,
+      octave_cv_ieee754_data_format=no,
+      octave_cv_ieee754_data_format=yes)
+  ])
+  if test "$cross_compiling" = yes; then
+    AC_MSG_RESULT([$octave_cv_ieee754_data_format assumed for cross compilation])
+  else
+    AC_MSG_RESULT([$octave_cv_ieee754_data_format])
+  fi
+  if test $octave_cv_ieee754_data_format = yes; then
+    AC_DEFINE(HAVE_IEEE754_DATA_FORMAT, 1,
+      [Define to 1 if your system uses IEEE 754 data format.])
+  else
+    ## If the format is unknown, then you will probably not have a
+    ## useful system, so we will abort here.  Anyone wishing to
+    ## experiment with building Octave on a system without IEEE
+    ## floating point should be capable of removing this check and
+    ## the one in the octave_ieee_init function in liboctave/lo-ieee.cc.
+    AC_MSG_ERROR([IEEE 754 data format required for building Octave])
+  fi
+])
+dnl
+dnl Check for CallInst::addAttribute API
+dnl
+AC_DEFUN([OCTAVE_LLVM_CALLINST_ADDATTRIBUTE_API], [
+  AC_CACHE_CHECK([check LLVM::CallInst::addAttribute arg type is llvm::Attributes],
+    [octave_cv_callinst_addattribute_arg_is_attributes],
+    [AC_LANG_PUSH(C++)
+      AC_COMPILE_IFELSE(
+        [AC_LANG_PROGRAM([[
+#ifdef HAVE_LLVM_IR_FUNCTION_H
+          #include <llvm/IR/Instructions.h>
+          #include <llvm/IR/Attributes.h>
+#else
+          #include <llvm/Instructions.h>
+          #include <llvm/Attributes.h>
+#endif
+          ]], [[
+          llvm::CallInst *callinst;
+          llvm::AttrBuilder attr_builder;
+          attr_builder.addAttribute(llvm::Attributes::StructRet);
+          llvm::Attributes attrs = llvm::Attributes::get(llvm::getGlobalContext(), attr_builder);
+          callinst->addAttribute (1, attrs);
+        ]])],
+        octave_cv_callinst_addattribute_arg_is_attributes=yes,
+        octave_cv_callinst_addattribute_arg_is_attributes=no)
+    AC_LANG_POP(C++)
+  ])
+  if test $octave_cv_callinst_addattribute_arg_is_attributes = yes; then
+    AC_DEFINE(CALLINST_ADDATTRIBUTE_ARG_IS_ATTRIBUTES, 1,
+      [Define to 1 if llvm::CallInst:addAttribute arg type is llvm::Attributes.])
+  fi
+])
+dnl
+dnl Check for Function::addAttribute API
+dnl
+AC_DEFUN([OCTAVE_LLVM_FUNCTION_ADDATTRIBUTE_API], [
+  AC_CACHE_CHECK([check llvm::Function::addAttribute arg type is llvm::Attributes],
+    [octave_cv_function_addattribute_arg_is_attributes],
+    [AC_LANG_PUSH(C++)
+      AC_COMPILE_IFELSE(
+        [AC_LANG_PROGRAM([[
+#ifdef HAVE_LLVM_IR_FUNCTION_H
+          #include <llvm/IR/Function.h>
+          #include <llvm/IR/Attributes.h>
+          #include <llvm/IR/LLVMContext.h>
+#else
+          #include <llvm/Function.h>
+          #include <llvm/Attributes.h>