[svn-r23577] Bring revisions 22708:22730 from trunk to revise_chunks.

h5committested.

1 files changed, 0 insertions, 4540 deletions

diff --git a/configure.in b/configure.in
deleted file mode 100644
index 7e4c9e9..0000000
--- a/configure.in
+++ /dev/null
@@ -1,4540 +0,0 @@
-dnl Process this file with autoconf to produce configure.
-dnl
-dnl Copyright by The HDF Group.
-dnl Copyright by the Board of Trustees of the University of Illinois.
-dnl All rights reserved.
-dnl
-dnl This file is part of HDF5.  The full HDF5 copyright notice, including
-dnl terms governing use, modification, and redistribution, is contained in
-dnl the files COPYING and Copyright.html.  COPYING can be found at the root
-dnl of the source code distribution tree; Copyright.html can be found at the
-dnl root level of an installed copy of the electronic HDF5 document set and
-dnl is linked from the top-level documents page.  It can also be found at
-dnl http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have
-dnl access to either file, you may request a copy from help@hdfgroup.org.
-
-dnl ----------------------------------------------------------------------
-dnl Initialize configure.
-dnl
-AC_REVISION($Id$)
-AC_PREREQ([2.53])
-
-dnl AC_INIT takes the name of the package, the version number, and an
-dnl email address to report bugs. AC_CONFIG_SRCDIR takes a unique file
-dnl as its argument.
-dnl
-dnl NOTE: Don't forget to change the version number here when we do a
-dnl release!!!
-dnl
-AC_INIT([HDF5], [1.9.127-FA_a5], [help@hdfgroup.org])
-AC_CONFIG_SRCDIR([src/H5.c])
-AM_CONFIG_HEADER([src/H5config.h])
-
-AC_CONFIG_AUX_DIR([bin])
-AC_CONFIG_MACRO_DIR([m4])
-
-dnl AM_INIT_AUTOMAKE takes a list of options that should be applied to
-dnl every Makefile.am when automake is run.
-AM_INIT_AUTOMAKE([foreign])
-AM_SILENT_RULES([yes])
-
-dnl AM_MAINTAINER_MODE turns off "rebuild rules" that contain dependencies
-dnl for Makefiles, configure, src/H5config.h, etc.  If AM_MAINTAINER_MODE
-dnl is *not* included here, these files will be rebuilt if out of date.
-dnl This is a problem because if users try to build on a machine with
-dnl the wrong versions of autoconf and automake, these files will be
-dnl rebuilt with the wrong versions and bad things can happen.
-dnl Also, CVS doesn't preserve dependencies between timestamps, so
-dnl Makefiles will often think rebuilding needs to occur when it doesn't.
-dnl Developers should './configure --enable-maintainer-mode' to turn on
-dnl rebuild rules.
-AM_MAINTAINER_MODE
-
-dnl Run post processing on files created by configure.
-dnl src/H5pubconf.h:
-dnl Generate src/H5pubconf.h from src/H5config.h by prepending H5_ to all
-dnl macro names. This avoid name conflict between HDF5 macro names and those
-dnl generated by another software package that uses the HDF5 library.
-dnl src/libhdf5.settings:
-dnl Remove all lines begun with "#" which are generated by CONDITIONAL's of
-dnl configure.
-AC_OUTPUT_COMMANDS([
-  echo "creating src/H5pubconf.h"
-  sed 's/#define /#define H5_/' <src/H5config.h |\
-    sed 's/#undef /#undef H5_/' >pubconf
-  if test ! -f src/H5pubconf.h; then
-    /bin/mv -f pubconf src/H5pubconf.h
-  elif (diff pubconf src/H5pubconf.h >/dev/null); then
-    rm -f pubconf
-    echo "src/H5pubconf.h is unchanged"
-  else
-    /bin/mv -f pubconf src/H5pubconf.h
-  fi
-  echo "Post process src/libhdf5.settings"
-  sed '/^#/d' < src/libhdf5.settings > libhdf5.settings.TMP
-  cp libhdf5.settings.TMP src/libhdf5.settings
-  rm -f libhdf5.settings.TMP
-])
-
-dnl It's possible to configure for a host other than the one on which
-dnl configure is currently running by using the --host=foo flag.
-dnl For machines on which HDF5 is often configured, it can be convenient
-dnl to specify the name of the machine rather than its canonical type.
-case $host_alias in
-  redstorm)
-    host_alias=x86_64-redstorm-linux-gnu
-    ;;
-esac
-
-AC_CANONICAL_HOST
-AC_SUBST([CPPFLAGS])
-
-dnl H5_CFLAGS (and company) are for CFLAGS that should be used on HDF5, but
-dnl not exported to h5cc (or h5fc, etc.)
-AC_SUBST([H5_CFLAGS])
-AC_SUBST([H5_CPPFLAGS])
-AC_SUBST([H5_FCFLAGS])
-AC_SUBST([H5_CXXFLAGS])
-AC_SUBST([H5_LDFLAGS])
-
-dnl AM_CFLAGS (and company) are for CFLAGS that should be used on HDF5,
-dnl and WILL be exported to h5cc (or h5fc, etc) if set by configure.
-AC_SUBST([AM_CFLAGS])
-AC_SUBST([AM_FCFLAGS])
-AC_SUBST([AM_CXXFLAGS])
-AC_SUBST([AM_CPPFLAGS])
-AC_SUBST([AM_LDFLAGS])
-
-dnl Make sure flags are set to something (otherwise macros may set them later).
-AM_CFLAGS="${AM_CFLAGS}"
-AM_CXXFLAGS="${AM_CXXFLAGS}"
-AM_FCFLAGS="${AM_FCFLAGS}"
-AM_CPPFLAGS="${AM_CPPFLAGS}"
-AM_LDFLAGS="${AM_LDFLAGS}"
-CFLAGS="${CFLAGS}"
-CXXFLAGS="${CXXFLAGS}"
-FCFLAGS="${FCFLAGS}"
-CPPFLAGS="${CPPFLAGS}"
-LDFLAGS="${LDFLAGS}"
-
-dnl Configure may need to alter any of the *FLAGS variables in order for
-dnl various checks to work correctly. Save the user's value here so it
-dnl can be restored once all configure checks are complete.
-saved_user_CFLAGS="$CFLAGS"
-saved_user_CXXFLAGS="$CXXFLAGS"
-saved_user_FCFLAGS="$FCFLAGS"
-saved_user_LDFLAGS="$LDFLAGS"
-saved_user_CPPFLAGS="$CPPFLAGS"
-
-dnl Different compilers may need default libraries. They are specified in
-dnl the config/* files, so we put this statement here so that it'll be
-dnl set by the code which follows...
-dnl
-DEFAULT_LIBS=""
-
-dnl Support F9X variable to define Fortran compiler if FC variable is
-dnl not used.  This should be deprecated in the future.
-if test "x" = "x$FC"; then
-  FC=${F9X}
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set prefix default (install directory) to a directory in the build area.
-dnl This allows multiple src-dir builds within one host.
-AC_PREFIX_DEFAULT([`pwd`/hdf5])
-
-dnl ----------------------------------------------------------------------
-dnl Dump all shell variables values.
-dnl
-AC_MSG_CHECKING([shell variables initial values])
-set >&AS_MESSAGE_LOG_FD
-AC_MSG_RESULT([done])
-
-dnl Define all symbol variables used for configure summary.
-dnl EXTERNAL_FILTERS equals all external filters. Default none.
-dnl MPE: whether MPE option is enabled. Default no.
-dnl STATIC_EXEC: whether static-exec is enabled. Default no.
-dnl HDF_FORTRAN: whether Fortran is enabled. Default no.
-dnl HDF_FORTRAN2003: whether Fortran 2003 is enabled. Default no.
-dnl FC: Fortran compiler.
-dnl HDF_CXX: whether C++ is enabled. Default no.
-dnl CXX: C++ compiler.
-dnl HDF5_HL: whether high-level library is enabled. Default is yes.
-dnl GPFS: whether gpfs is enabled. Default no.
-dnl LARGEFILE: whether largefile support is enabled. Default yes.
-dnl INSTRUMENT: whether INSTRUMENT is enabled. No default set here.
-dnl CODESTACK: whether CODESTACK is enabled. Default no.
-dnl HAVE_DMALLOC: whether system has dmalloc support. Default no.
-dnl DIRECT_VFD: whether DIRECT_VFD is enabled. Default no.
-dnl THREADSAFE: whether THREADSAFE is enabled. Default no.
-dnl STATIC_SHARED: whether static and/or shared libraries are requested.
-dnl enable_shared: whether shared lib is enabled.
-dnl enable_static: whether static lib is enabled.
-dnl UNAME_INFO: System information.
-
-AC_SUBST(EXTERNAL_FILTERS)
-AC_SUBST(MPE) MPE=no
-AC_SUBST(STATIC_EXEC) STATIC_EXEC=no
-AC_SUBST(HDF_FORTRAN) HDF_FORTRAN=no
-AC_SUBST(HDF_FORTRAN2003) HDF_FORTRAN2003=no
-AC_SUBST(FC) HDF_FORTRAN=no
-AC_SUBST(FC2003) HDF_FORTRAN2003=no
-AC_SUBST(HDF_CXX) HDF_CXX=no
-AC_SUBST(CXX) HDF_CXX=no
-AC_SUBST(HDF5_HL) HDF5_HL=yes
-AC_SUBST(GPFS) GPFS=no
-AC_SUBST(LARGEFILE) LARGEFILE=yes
-AC_SUBST(INSTRUMENT)
-AC_SUBST(CODESTACK) CODESTACK=no
-AC_SUBST(HAVE_DMALLOC) HAVE_DMALLOC=no
-AC_SUBST(DIRECT_VFD) DIRECT_VFD=no
-AC_SUBST(THREADSAFE) THREADSAFE=no
-AC_SUBST(STATIC_SHARED)
-AC_SUBST(enable_shared)
-AC_SUBST(enable_static)
-AC_SUBST(UNAME_INFO) UNAME_INFO=`uname -a`
-
-dnl ----------------------------------------------------------------------
-dnl Some platforms have broken basename, and/or xargs programs. Check
-dnl that it actually does what it's supposed to do. Catch this early
-dnl since configure relies upon them heavily and there's no use continuing
-dnl if it's broken.
-dnl
-
-dnl Avoid depending upon Character Ranges.
-dnl These are defined by autoconf.
-dnl as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-dnl as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-
-AC_MSG_CHECKING([if basename works])
-BASENAME_TEST="`basename /foo/bar/baz/qux/basename_works`"
-if test $BASENAME_TEST != "basename_works"; then
-  AC_MSG_ERROR([basename program doesn't work])
-else
-  AC_MSG_RESULT([yes])
-fi
-
-AC_MSG_CHECKING([if xargs works])
-XARGS_TEST="`echo /foo/bar/baz/qux/xargs_works | xargs basename`"
-if test $XARGS_TEST != "xargs_works"; then
-  AC_MSG_ERROR([xargs program doesn't work])
-else
-  AC_MSG_RESULT([yes])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Check that the cache file was build on the same host as what we're
-dnl running on now.
-dnl
-AC_CACHE_CHECK([for cached host], [hdf5_cv_host], [hdf5_cv_host="none"]);
-if test $hdf5_cv_host = "none"; then
-  hdf5_cv_host=$host
-elif test $hdf5_cv_host != $host; then
-  echo "The config.cache file was generated on $hdf5_cv_host but"
-  echo "this is $host.  Please remove that file and try again."
-  AC_MSG_ERROR(config.cache file is invalid)
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Source any special files that we need.  These files normally aren't
-dnl present but can be used by the maintainers to fine tune things like
-dnl turning on debug or profiling flags for the compiler.  The search order
-dnl is:
-dnl
-dnl	CPU-VENDOR-OS
-dnl	VENDOR-OS
-dnl	CPU-OS
-dnl	CPU-VENDOR
-dnl	OS
-dnl	VENDOR
-dnl	CPU
-dnl
-dnl If the `OS' ends with a version number then remove it. For instance,
-dnl `freebsd3.1' would become `freebsd'
-
-case $host_os in
-  aix*)
-    host_os_novers=aix
-    ;;
-  freebsd*)
-    host_os_novers=freebsd
-    ;;
-  irix5.*)
-    host_os_novers=irix5.x
-    ;;
-  irix6.*)
-    host_os_novers=irix6.x
-    ;;
-  osf4.*)
-    host_os_novers=osf4.x
-    ;;
-  osf5.*)
-    host_os_novers=osf5.x
-    ;;
-  solaris2.*)
-    host_os_novers=solaris2.x
-    ;;
-  *)
-    host_os_novers=$host_os
-    ;;
-esac
-
-host_config="none"
-for f in $host_cpu-$host_vendor-$host_os \
-         $host_cpu-$host_vendor-$host_os_novers \
-         $host_vendor-$host_os \
-         $host_vendor-$host_os_novers \
-         $host_cpu-$host_os \
-         $host_cpu-$host_os_novers \
-         $host_cpu-$host_vendor \
-         $host_os \
-         $host_os_novers \
-         $host_vendor \
-         $host_cpu ; do
-  AC_MSG_CHECKING([for config $f])
-  if test -f "$srcdir/config/$f"; then
-    host_config=$srcdir/config/$f
-    AC_MSG_RESULT([found])
-    break
-  fi
-  AC_MSG_RESULT([no])
-done
-if test "X$host_config" != "Xnone"; then
-  CC_BASENAME="`echo $CC | cut -f1 -d' ' | xargs basename 2>/dev/null`"
-  . $host_config
-fi
-
-dnl Source any special site-specific file
-hname="`hostname`"
-while test -n "$hname"; do
-  file=$srcdir/config/site-specific/host-$hname
-  AC_MSG_CHECKING([for config $file])
-  if test -f "$file"; then
-    . $file
-    AC_MSG_RESULT([found])
-    break
-  fi
-  AC_MSG_RESULT([no])
-  hname_tmp=$hname
-  hname="`echo $hname | cut -d. -f2-99`"
-  test "$hname_tmp" = "$hname" && break
-done
-
-dnl ----------------------------------------------------------------------
-dnl Some built-in configure checks can only see CFLAGS (not AM_CFLAGS), so
-dnl we need to add this in so configure works as intended. We will need to
-dnl reset this value at the end of configure, to preserve the user's settings.
-CFLAGS="${AM_CFLAGS} ${CFLAGS}"
-FCFLAGS="${AM_FCFLAGS} ${FCFLAGS}"
-CXXFLAGS="${AM_CXXFLAGS} ${CXXFLAGS}"
-CPPFLAGS="${AM_CPPFLAGS} ${CPPFLAGS}"
-LDFLAGS="${AM_LDFLAGS} ${LDFLAGS}"
-
-dnl ----------------------------------------------------------------------
-dnl Enable dependency tracking unless the configure options or a
-dnl site-specific file told us not to.  This prevents configure from
-dnl silently disabling dependencies for some compilers.
-dnl
-if test -z "${enable_dependency_tracking}"; then
-  enable_dependency_tracking="yes"
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Check for programs.
-dnl
-AC_PROG_CC
-CC_BASENAME="`echo $CC | cut -f1 -d' ' | xargs basename 2>/dev/null`"
-
-dnl ----------------------------------------------------------------------------
-dnl Configure disallows unsupported combinations of options. However, users
-dnl may want to override and build with unsupported combinations for their
-dnl own use. They can use the --enable-unsupported configure flag, which
-dnl ignores any errors from configure due to incompatible flags.
-AC_MSG_CHECKING([if unsupported combinations of configure options are allowed])
-AC_ARG_ENABLE([unsupported],
-              [AC_HELP_STRING([--enable-unsupported],
-                              [Allow unsupported combinations of configure options])],
-              [ALLOW_UNSUPPORTED=$enableval])
-
-case "X-$ALLOW_UNSUPPORTED" in 
-  X-|X-no)
-    AC_MSG_RESULT([no])
-    ;;
-  X-yes)
-    AC_MSG_RESULT([yes])
-    ;;
-  *)
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Check if they would like the Fortran interface compiled
-dnl
-AC_SUBST([HDF5_INTERFACES]) HDF5_INTERFACES=""
-AC_MSG_CHECKING([if Fortran interface enabled])
-AC_ARG_ENABLE([fortran],
-              [AC_HELP_STRING([--enable-fortran],
-                              [Compile the Fortran 77/90/95 interface [default=no]])],
-              [HDF_FORTRAN=$enableval])
-
-if test "X$HDF_FORTRAN" = "Xyes"; then
-  echo "yes"
-else
-  echo "no"
-fi
-
-
-dnl ----------------------------------------------------------------------
-dnl Check if they would like the Fortran 2003 interface compiled
-dnl
-AC_MSG_CHECKING([if Fortran 2003 interface enabled])
-AC_ARG_ENABLE([fortran2003],
-              [AC_HELP_STRING([--enable-fortran2003],
-                              [Compile the Fortran 2003 interface, must also specify --enable-fortran [default=no]])],
-              [HDF_FORTRAN2003=$enableval])
-
-dnl ----------------------------------------------------------------------
-dnl Check to make sure --enable-fortran is present if --enable-fortran2003 
-dnl was specified
-
-if test "X$HDF_FORTRAN2003" = "Xyes" && test "X$HDF_FORTRAN" = "Xno"; then
-  echo "no"
-  AC_MSG_ERROR([--enable-fortran must be used with --enable-fortran2003])
-else
-  echo "yes"
-fi
-
-HAVE_SIZEOF="no"
-FORTRAN_DEFAULT_REALisDBLE="no"
-
-if test "X$HDF_FORTRAN" = "Xyes"; then
-
-  AC_SUBST(FC) HDF_FORTRAN=yes
-  AC_SUBST([HAVE_FORTRAN_2003])
-		
-  HDF5_INTERFACES="$HDF5_INTERFACES fortran"
-
-  dnl --------------------------------------------------------------------
-  dnl Default for FORTRAN 2003 compliant compilers
-  dnl
-  HAVE_FORTRAN_2003="no"
-  HAVE_F2003_REQUIREMENTS="no"
-
-  dnl --------------------------------------------------------------------
-  dnl HDF5 integer variables for the H5fortran_types.f90 file.
-  dnl
-  AC_SUBST([R_LARGE])
-  AC_SUBST([R_INTEGER])
-  AC_SUBST([HADDR_T])
-  AC_SUBST([HSIZE_T])
-  AC_SUBST([HSSIZE_T])
-  AC_SUBST([HID_T])
-  AC_SUBST([SIZE_T])
-  AC_SUBST([OBJECT_NAMELEN_DEFAULT_F])
-
-  dnl --------------------------------------------------------------------
-  dnl General Fortran flags
-  dnl
-  AM_FCFLAGS="${AM_FCFLAGS} ${FFLAGS}"
-  FCFLAGS="${FCFLAGS} ${FFLAGS}"
-
-  dnl --------------------------------------------------------------------
-  dnl Fortran source extention
-  dnl
-  AC_FC_SRCEXT([f90])
-
-  AC_SUBST([F9XSUFFIXFLAG])
-  AC_SUBST([FSEARCH_DIRS])
-
-  dnl --------------------------------------------------------------------
-  dnl Check for a Fortran 9X compiler and how to include modules.
-  dnl 
-  AC_PROG_FC([f90 pgf90 slf90 f95 g95 xlf95 efc ifort ftn],)
-  AC_F9X_MODS
-
-  dnl It seems that libtool (as of Libtool 1.5.14) is trying to
-  dnl configure itself for Fortran 77.
-  dnl Tell it that our F77 compiler is $FC (actually a F9X compiler)
-  F77=$FC
-
-  dnl Change to the Fortran 90 language
-  AC_LANG_PUSH(Fortran)
-
-  dnl --------------------------------------------------------------------
-  dnl Define wrappers for the C compiler to use Fortran function names
-  dnl
-  AC_FC_WRAPPERS
-
-  dnl --------------------------------------------------------------------
-  dnl See if the compiler will support the "-I." option
-  dnl
-  dnl  AM_FCFLAGS_saved=$AM_FCFLAGS
-  dnl  AM_FCFLAGS="${AM_FCFLAGS} -I."
-
-  dnl  AC_MSG_CHECKING(if compiler supports -I. option)
-  dnl  AC_TRY_FCOMPILE([
-  dnl      program conftest
-  dnl      end
-  dnl  ], AC_MSG_RESULT(yes),
-  dnl     AC_MSG_RESULT(no)
-  dnl     AM_FCFLAGS="$AM_FCFLAGS_saved")
-
-  dnl --------------------------------------------------------------------
-  dnl See if the fortran compiler supports the intrinsic function "SIZEOF"
-
-  AC_MSG_CHECKING([if Fortran compiler supports intrinsic SIZEOF])
-  AC_TRY_RUN([ 
-   PROGRAM main
-     i = sizeof(x)
-   END PROGRAM
-  ], [AC_MSG_RESULT(yes)
-     	HAVE_SIZEOF="yes"],
-       AC_MSG_RESULT(no))
-
-  dnl Check to see if -r8 was specified to determine if we need to
-  dnl compile the DOUBLE PRECISION interfaces.
-
-  AC_MSG_CHECKING([if Fortran default REAL is DOUBLE PRECISION])
-  
-  AC_TRY_RUN([
-     MODULE type_mod
-       INTERFACE h5t	
-         MODULE PROCEDURE h5t_real
-         MODULE PROCEDURE h5t_dble
-       END INTERFACE
-     CONTAINS
-       SUBROUTINE h5t_real(r)
-         REAL :: r
-       END SUBROUTINE h5t_real
-       SUBROUTINE h5t_dble(d)
-         DOUBLE PRECISION :: d
-       END SUBROUTINE h5t_dble
-     END MODULE type_mod
-     PROGRAM main
-       USE type_mod
-       REAL :: r
-       DOUBLE PRECISION :: d
-       CALL h5t(r)
-       CALL h5t(d)
-     END PROGRAM main
-                  ],
-   AC_MSG_RESULT(no), 
-   [AC_MSG_RESULT(yes) 
-       FORTRAN_DEFAULT_REALisDBLE="yes"])
-
-  if test "X$HDF_FORTRAN2003" = "Xyes"; then
-
-    dnl Checking if the compiler supports the required Fortran 2003 features and
-    dnl disable Fortran 2003 if it does not.
-
-    AC_MSG_CHECKING([if Fortran compiler version compatible with Fortran 2003 HDF])
-    HAVE_FORTRAN_2003="no"
-	
-    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[
-
-	USE iso_c_binding
-	IMPLICIT NONE
-	TYPE(C_PTR) :: ptr
-	TYPE(C_FUNPTR) :: funptr
-	CHARACTER(LEN=80, KIND=c_char), TARGET :: ichr
-
-	ptr = C_LOC(ichr(1:1))
-
-        ])], 
-        [AC_MSG_RESULT(yes) 
-        HAVE_F2003_REQUIREMENTS=[yes]],
-        [AC_MSG_RESULT(no)])
-
-    if test "X$HAVE_F2003_REQUIREMENTS" = "Xno"; then
-    dnl  echo $HAVE_FORTRAN_2003
-      AC_MSG_ERROR([Fortran compiler lacks required Fortran 2003 features; unsupported Fortran 2003 compiler, remove --enable-fortran2003])
-    else
-      HAVE_FORTRAN_2003="yes"
-    dnl  echo $HAVE_FORTRAN_2003
-    fi
-
-  fi
-else
-  FC="no"
-fi
-
-dnl Change back to the C language
-AC_LANG_POP(Fortran)
-
-AM_CONDITIONAL([FORTRAN_HAVE_SIZEOF], [test "X$HAVE_SIZEOF" = "Xyes"])
-AM_CONDITIONAL([FORTRAN_2003_CONDITIONAL_F], [test "X$HAVE_FORTRAN_2003" = "Xyes"])
-AM_CONDITIONAL([FORTRAN_DEFAULT_REALisDBLE_F], [test "X$FORTRAN_DEFAULT_REALisDBLE" = "Xyes"])
-
-dnl ----------------------------------------------------------------------
-dnl Check if they would like the C++ interface compiled
-dnl
-dnl We need to check for a C++ compiler unconditionally, since
-dnl AC_PROG_CXX defines some macros that Automake 1.9.x uses and will
-dnl miss even if c++ is not enabled.
-  AC_PROG_CXX
-  AC_PROG_CXXCPP	dnl this is checked for when AC_HEADER_STDC is done
-
-AC_MSG_CHECKING([if c++ interface enabled])
-
-AC_ARG_ENABLE([cxx],
-              [AC_HELP_STRING([--enable-cxx],
-                              [Compile the C++ interface [default=no]])],
-              [HDF_CXX=$enableval])
-
-if test "X$HDF_CXX" = "Xyes"; then
-  echo "yes"
-  HDF5_INTERFACES="$HDF5_INTERFACES c++"
-
-  dnl Change to the C++ language
-  AC_LANG_PUSH(C++)
-
-  AC_MSG_CHECKING([if $CXX needs old style header files in includes])
-  AC_TRY_RUN([
-#include <iostream>
-
-int main(void) { return 0; }
-  ], [
-    echo no
-  ], [
-    echo yes
-    CXXFLAGS="${CXXFLAGS} -DOLD_HEADER_FILENAME"
-    AM_CXXFLAGS="${AM_CXXFLAGS} -DOLD_HEADER_FILENAME"
-  ])
-
-  AC_MSG_CHECKING([if $CXX can handle namespaces])
-  AC_TRY_RUN([
-namespace H5 {
-int fnord;
-}
-
-int main(void) {
-   using namespace H5;
-   fnord = 37;
-   return 0;
-} 
-  ], [
-     echo yes
-  ], [
-     echo no
-     CXXFLAGS="${CXXFLAGS} -DH5_NO_NAMESPACE"
-     AM_CXXFLAGS="${AM_CXXFLAGS} -DH5_NO_NAMESPACE"
-  ])
-
-  AC_MSG_CHECKING([if $CXX supports std])
-  AC_TRY_RUN([
-#include <string>
-
-using namespace std;
-
-int main(void) {
-   string myString("testing namespace std");
-   return 0;
-}
-  ], [
-     echo yes
-  ], [
-     echo no
-     CXXFLAGS="${CXXFLAGS} -DH5_NO_STD"
-     AM_CXXFLAGS="${AM_CXXFLAGS} -DH5_NO_STD"
-  ])
-
-  AC_MSG_CHECKING([if $CXX supports bool types])
-  AC_TRY_RUN([
-int main(void) {
-   bool flag;
-   return 0;
-}
-  ], [
-     echo yes
-  ], [
-     echo no
-     CXXFLAGS="${CXXFLAGS} -DBOOL_NOTDEFINED"
-     AM_CXXFLAGS="${AM_CXXFLAGS} -DBOOL_NOTDEFINED"
-  ])
-
-  AC_MSG_CHECKING([if $CXX has offsetof extension])
-    AC_TRY_COMPILE([
-  #include <stdio.h>
-  #include <stddef.h>
-    ],[
-    struct index_st
-    {
-      unsigned char type;
-      unsigned char num;
-      unsigned int len;
-    };
-    typedef struct index_st index_t;
-    int x,y;
-    x = offsetof(struct index_st, len);
-    y = offsetof(index_t, num)
-    ],
-    AC_DEFINE([CXX_HAVE_OFFSETOF], [1],
-    [Define if C++ compiler recognizes offsetof])
-    AC_MSG_RESULT([yes]),
-    AC_MSG_RESULT([no]))
-
-  AC_MSG_CHECKING([if $CXX can handle static cast])
-  AC_TRY_RUN([
-int main(void) {
-   float test_float;
-   int test_int;
-   test_float = 37.0;
-   test_int = static_cast <int> (test_float);
-   return 0;
-}
-  ], [
-    echo yes
-  ], [
-    echo no
-    CXXFLAGS="${CXXFLAGS} -DNO_STATIC_CAST"
-    AM_CXXFLAGS="${AM_CXXFLAGS} -DNO_STATIC_CAST"
-  ])
-else
-  echo "no"
-  CXX="no"
-fi
-
-dnl Change back to the C language
-AC_LANG_POP(C++)
-
-dnl ----------------------------------------------------------------------
-dnl Check if they have Perl installed on their system. We only need Perl
-dnl if they're using a GNU compiler.
-dnl
-AC_SUBST([PERL]) PERL=""
-if test "X$GCC" = "Xyes"; then
-  AC_CHECK_PROGS([PERL], [perl],, [$PATH])
-fi
-
-
-dnl ----------------------------------------------------------------------
-dnl Check which archiving tool to use. This needs to be done before
-dnl the AM_PROG_LIBTOOL macro.
-dnl
-
-if test -z "$AR"; then
-  AC_CHECK_PROGS([AR], [ar xar], [:], [$PATH])
-fi
-AC_SUBST([AR])
-
-dnl Export the AR macro so that it will be placed in the libtool file
-dnl correctly.
-export AR
-
-AC_PROG_MAKE_SET
-AC_PROG_INSTALL
-
-
-dnl ----------------------------------------------------------------------
-dnl Check that the tr utility is working properly.
-
-AC_PATH_PROG(TR, tr)
-
-TR_TEST=`echo Test | ${TR} ${as_cr_letters}"," ${as_cr_LETTERS}" "`
-if test "X${TR_TEST}" != "XTEST"; then
-  AC_MSG_ERROR([tr program doesn't work])
-fi
-
-
-dnl ----------------------------------------------------------------------
-dnl Check that time can be used with srcdir.  This is okay on most systems,
-dnl but seems to cause problems on Cygwin.
-dnl The solution on Cygwin is not to record execution time for tests.
-AC_MSG_CHECKING([if srcdir= and time commands work together])
-
-AC_SUBST([TIME])
-TIME=time
-TIME_TEST=`foo="bar" ${TIME} echo 'baz' 2> /dev/null | grep baz`
-
-if test "X${TIME_TEST}" = "Xbaz"; then
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-  TIME=
-fi
-
-
-dnl The following variables are used to distinguish between building a
-dnl serial and parallel library.
-dnl
-dnl    HAVE_PARALLEL	-- defined in H5config.h if we are building
-dnl			   a parallel library even if configure wasn't
-dnl			   able to find some header file or library that
-dnl			   might be required. This is defined if the
-dnl			   compiler looks like a parallel compiler (e.g.,
-dnl			   mpicc or mpcc) or if the user explicitly states
-dnl			   that a parallel library is being built by supplying
-dnl			   the `--enable-parallel' configure switch.
-dnl
-dnl    PARALLEL		-- This variable is set to a non-null value if
-dnl			   configure thinks we're compiling a parallel
-dnl			   version of the library.
-dnl
-dnl    RUNSERIAL	-- This is a command which will be prepended to
-dnl			   the executable name to run the executable using
-dnl			   a single process. For serial versions of the
-dnl			   library this will normally be empty. For parallel
-dnl			   versions it might be something like `mpiexec -n 1'.
-dnl			   The value of this variable is substituted in *.in
-dnl			   files.
-dnl
-dnl    RUNPARALLEL	-- This is a command which will be prepended to
-dnl			   the executable name to run the executable on
-dnl			   multiple processors. For the serial library the
-dnl			   value will normally be the empty string. For
-dnl			   parallel library it should be something like
-dnl			   "mpiexec -n \$\${NPROCS:=6}" where NPROCS will
-dnl			   eventually contain the number of processors on which
-dnl			   to run the executable (the double dollarsigns are to
-dnl			   protect the expansion until make executes the
-dnl			   command).  The value of this variable is
-dnl			   substituted in *.in files.
-dnl
-AC_SUBST([PARALLEL])
-AC_SUBST([RUNSERIAL])
-AC_SUBST([RUNPARALLEL])
-AC_SUBST([TESTPARALLEL])
-
-dnl ----------------------------------------------------------------------
-dnl If the compiler is obviously a parallel compiler then we're building
-dnl a parallel version of hdf5 and should define HAVE_PARALLEL. Furthermore,
-dnl the name of the compiler might tell us how to run the resulting
-dnl executable. For `mpicc' the executable should be run with `mpiexec' from
-dnl the same directory as mpicc if it exists.
-dnl
-case "$CC_BASENAME" in
-  mpicc)
-    dnl The mpich compiler. Use mpiexec from the same directory if it
-    dnl exists.
-    PARALLEL=mpicc
-    AC_MSG_CHECKING([for mpiexec])
-
-    dnl Find the path where mpicc is located.
-    cmd="`echo $CC | cut -f1 -d' '`"
-    if (echo $cmd | grep / >/dev/null); then
-      path="`echo $cmd | sed 's/\(.*\)\/.*$/\1/'`"
-    else
-      for path in `echo $PATH | ${TR} ":" " "`; do
-        if test -x $path/$cmd; then
-          break
-        fi
-      done
-    fi
-
-    dnl Is there an mpiexec at that path?
-    if test -x $path/mpiexec; then
-      AC_MSG_RESULT([$path/mpiexec])
-      RUNSERIAL="${RUNSERIAL:-none}"
-
-      if test -z "$RUNPARALLEL"; then
-        RUNPARALLEL="$path/mpiexec -n \$\${NPROCS:=6}"
-      fi
-    else
-      AC_MSG_RESULT([none])
-    fi
-    ;;
-
-  mpcc|mpcc_r)
-    dnl The IBM compiler
-    PARALLEL="$CC_BASENAME"
-    ;;
-
-  *)
-    dnl Probably not a parallel compiler, but if `--enable-parallel'
-    dnl is defined below then we're still building a parallel hdf5.
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl If the Fortran compiler is obviously a parallel compiler then we're
-dnl building a parallel version of hdf5 and should define HAVE_PARALLEL.
-dnl Furthermore, the name of the compiler might tell us how to run the
-dnl resulting executable. For `mpif90' the executable should be run with
-dnl `mpiexec' from the same directory as mpif90 if it exists.
-dnl
-
-if test "X$HDF_FORTRAN" = "Xyes" ; then
-  dnl Change to the Fortran 90 language
-  AC_LANG_PUSH(Fortran)
-
-  case "$FC" in
-    *mpif90*)
-      dnl The Fortran mpich compiler. Use mpiexec from the same directory
-      dnl if it exists.
-      PARALLEL=mpif90
-      AC_MSG_CHECKING([for mpiexec])
-
-      dnl Find the path where mpif90 is located.
-      cmd=`echo $FC |cut -f1 -d' '`
-      if (echo $cmd |grep / >/dev/null); then
-        path="`echo $cmd |sed 's/\(.*\)\/.*$/\1/'`"
-      else
-        for path in `echo $PATH | ${TR} ":" " "`; do
-          if test -x $path/$cmd; then
-            break;
-          fi
-        done
-      fi
-
-      dnl Is there an mpiexec at that path?
-      if test -x $path/mpiexec; then
-        AC_MSG_RESULT([$path/mpiexec])
-        RUNSERIAL="${RUNSERIAL:-none}"
-
-        if test -z "$RUNPARALLEL"; then
-          RUNPARALLEL="$path/mpiexec -n \$\${NPROCS:=6}"
-        fi
-      else
-        AC_MSG_RESULT([none])
-      fi
-      ;;
-
-    *mpxlf* | *mpxlf_r* | *mpxlf90* | *mpxlf90_r* | *mpxlf95* | *mpxlf95_r*)
-      dnl The IBM compiler
-      PARALLEL="$FC"
-      ;;
-
-    *)
-      dnl Probably not a parallel compiler, but if `--enable-parallel'
-      dnl is defined below then we're still building a parallel hdf5.
-      ;;
-  esac
-
-  dnl Change to the C language
-  AC_LANG_POP(Fortran)
-fi
-
-dnl -----------------------------------------------------------------------------
-dnl If shared libraries are being used with parallel, disable them, unless the 
-dnl user explicity enables them via the '--enable-shared' option.
-
-if test "X${enable_shared}" = "X" -a "X${enable_parallel}" = "Xyes"; then
-    echo '    shared libraries disabled in parallel'
-    enable_shared="no"
-elif test "X${enable_shared}" = "Xyes" -a "X${enable_parallel}" = "Xyes"; then
-    echo '    shared libraries explicitly enabled by user'
-elif test "X${enable_shared}" = "X" -a "X${PARALLEL}" != "X"; then
-    echo '    shared libraries disabled when a parallel compiler is being used'
-    enable_shared="no"
-elif test "X${enable_shared}" = "Xyes" -a "X${PARALLEL}" != "X"; then
-    echo '    shared libraries explicitly enabled by user'
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Fortran libraries are not currently supported on Mac. Disable them.
-dnl this is overridable with '--enable-unsupported'.
-dnl
-AC_SUBST([H5_FORTRAN_SHARED])
-H5_FORTRAN_SHARED="no"
-if test "X${HDF_FORTRAN}" = "Xyes" && test "X${enable_shared}" != "Xno"; then
-  AC_MSG_CHECKING([if shared Fortran libraries are supported])
-  H5_FORTRAN_SHARED="yes"
-
-  dnl Disable fortran shared libraries on Mac. (MAM - 03/30/11)
-  
-  case "`uname`" in
-    Darwin*)
-    H5_FORTRAN_SHARED="no"
-    CHECK_WARN="Shared Fortran libraries not currently supported on Mac."
-      ;;
-  esac
-
-  dnl Report results of check(s)
-  
-  if test "X${H5_FORTRAN_SHARED}" = "Xno"; then
-    AC_MSG_RESULT([no])
-    AC_MSG_WARN([$CHECK_WARN])
-    if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
-      AC_MSG_WARN([Disabling shared Fortran libraries.])
-      AC_MSG_WARN([To override this behavior, please use --enable-unsupported configure option.])
-        if test "X${enable_static}" = "Xno"; then
-          AC_MSG_ERROR([both static and shared Fortran libraries are disabled])
-        fi
-    else
-      AC_MSG_WARN([Allowing unsupported Fortran shared libraries due to use of --enable-unsupported flag])
-      H5_FORTRAN_SHARED="yes"
-    fi
-  else
-    AC_MSG_RESULT([yes])
-  fi
-fi
-
-AM_CONDITIONAL([FORTRAN_SHARED_CONDITIONAL], [test "X$H5_FORTRAN_SHARED" = "Xyes"])
-
-dnl ----------------------------------------------------------------------
-dnl Disable C++ shared libraries if +DD64 flag is detected.
-dnl
-AC_SUBST([H5_CXX_SHARED])
-H5_CXX_SHARED="no"
-if test "X${HDF_CXX}" = "Xyes" && test "X${enable_shared}" != "Xno"; then
-  AC_MSG_CHECKING([if shared C++ libraries are supported])
-  H5_CXX_SHARED="yes"
-
-  dnl Disable C++ shared libraries if DD64 flag is being used.
-  
-  if (echo dummy ${CXX} ${CXXLD} ${CFLAGS} ${CXXFLAGS} ${LDFLAGS} | grep 'DD64') > /dev/null; then
-    H5_CXX_SHARED="no"
-    CHECK_WARN="Shared C++ libraries not currently supported with +DD64 flag."
-  fi
-
-  dnl Report results of check(s)
-  
-  if test "X${H5_CXX_SHARED}" = "Xno"; then
-    AC_MSG_RESULT([no])
-    AC_MSG_WARN([$CHECK_WARN])
-    if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
-      AC_MSG_WARN([Disabling shared C++ libraries.])
-      AC_MSG_WARN([To override this behavior, please use --enable-unsupported configure option.])
-      if test "X${enable_static}" = "Xno"; then
-        AC_MSG_ERROR([both static and shared C++ libraries are disabled])
-      fi
-    else
-      AC_MSG_WARN([Allowing unsupported C++ shared librares due to use of --enable-unsupported flag])
-    fi
-  else
-    AC_MSG_RESULT([yes])
-  fi
-fi
-
-AM_CONDITIONAL([CXX_SHARED_CONDITIONAL], [test "X$H5_CXX_SHARED" = "Xyes"])
-
-dnl ----------------------------------------------------------------------
-dnl pgcc version 6.0x have optimization (-O, -O2 or -O3) problem.  Detect
-dnl these versions and add option "-Mx,28,0x8" to the compiler to avoid
-dnl the problem if optimization is enabled.
-dnl
-
-if (${CC-cc} -V 2>&1 | grep '^pgcc 6.0') > /dev/null && test "X$enable_production" = "Xyes"; then
-    echo 'adding compiler flag to avoid optimization problem in pgcc'
-    CC="${CC-cc} -Mx,28,0x8"
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Shared libraries are not currently supported under Cygwin, so configure
-dnl disables them unless --enable-unsupported has been supplied by the user.
-
-if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
-  case "`uname`" in
-    CYGWIN*)
-      if test "X${enable_shared}" = "Xyes"; then
-        echo '    warning: shared libraries are not supported on Cygwin!'
-        echo '    disabling shared libraries'
-        echo '    use --enable-unsupported to override this warning and keep shared libraries enabled'
-      fi
-      enable_shared="no"
-      ;;
-  esac
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Windows won't create DLLs without the following macro.
-dnl
-AC_LIBTOOL_WIN32_DLL
-
-dnl ----------------------------------------------------------------------
-dnl Create libtool.  If shared/static libraries are going to be enabled
-dnl or disabled, it should happen before these macros.
-AC_LIBTOOL_DLOPEN
-AM_PROG_LIBTOOL
-
-dnl ----------------------------------------------------------------------
-dnl Check if we should install only statically linked executables.
-dnl   This check needs to occur after libtool is initialized because
-dnl   we check a libtool cache value and may issue a warning based 
-dnl   on its result.
-AC_MSG_CHECKING([if we should install only statically linked executables])
-AC_ARG_ENABLE([static_exec],
-              [AC_HELP_STRING([--enable-static-exec],
-                              [Install only statically linked executables
-                               [default=no]])],
-              [STATIC_EXEC=$enableval])
-
-if test "X$STATIC_EXEC" = "Xyes"; then
-  echo "yes"
-  dnl Issue a warning if -static flag is not supported.
-  if test "X$lt_cv_prog_compiler_static_works" = "Xno"; then
-      echo "    warning: -static flag not supported on this system; executable won't statically link shared system libraries."
-  fi
-  LT_STATIC_EXEC="-all-static"
-else
-  echo "no"
-  LT_STATIC_EXEC=""
-fi
-
-AC_SUBST([LT_STATIC_EXEC])
-
-dnl Fix up the INSTALL macro if it's a relative path. We want the
-dnl full-path to the binary instead.
-case "$INSTALL" in
-  *install-sh*)
-    INSTALL='\${top_srcdir}/bin/install-sh -c'
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Some users have reported problems with libtool's use of '-Wl,-rpath' to
-dnl link shared libraries in nondefault directories. Allow users to
-dnl disable embedding the rpath information in the executables and to
-dnl instead solely rely on the information in LD_LIBRARY_PATH.
-AC_MSG_CHECKING([if -Wl,-rpath should be used to link shared libs in nondefault directories])
-AC_ARG_ENABLE([sharedlib-rpath],
-              [AC_HELP_STRING([--disable-sharedlib-rpath],
-               [Disable use of the '=Wl,-rpath' linker option])],
-              [RPATH=$enableval])
-
-case "X-$RPATH" in
-  X-no)
-    AC_MSG_RESULT([no])
-    runpath_var=
-    hardcode_libdir_flag_spec=
-    hardcode_libdir_flag_spec_ld=
-    ;;
-  X-|X-yes)
-    AC_MSG_RESULT([yes])
-    ;;
-  *)
-    AC_MSG_RESULT([error])
-    AC_MSG_ERROR([\'$enableval\' is not a valid rpath type])
-    ;;
-esac
-
-AC_MSG_CHECKING([make])
-
-dnl ----------------------------------------------------------------------
-dnl Sometimes makes think the `.PATH:' appearing before the first rule
-dnl with an action should override the `all' default target. So we have
-dnl to decide what the proper syntax is.
-dnl
-AC_MSG_CHECKING([how make searches directories])
-while true; do #for break
-  # The most common method is `VPATH=DIR1 DIR2 ...'
-  cat >maketest <<EOF
-VPATH=$srcdir/config $srcdir/src $srcdir/bin
-.c.o:
-	cp $< H5.o
-
-foo: H5.o
-	rm -f H5.o
-	@echo works
-EOF
-
-  if (${MAKE-make} -f maketest foo) >/dev/null 2>&1; then
-    SEARCH_RULE='VPATH='
-    SEARCH_SEP=' '
-    AC_MSG_RESULT([VPATH=DIR1 DIR2 ...])
-    break
-  fi
-
-  dnl The second most common method is like above except with the
-  dnl directories separated by colons.
-  cat >maketest <<EOF
-VPATH=$srcdir/config:$srcdir/src:$srcdir/bin
-.c.o:
-	cp $< H5.o
-
-foo: H5.o
-	rm -f H5.o
-	@echo works
-EOF
-
-  if (${MAKE-make} -f maketest foo) >/dev/null 2>&1; then
-    SEARCH_RULE='VPATH='
-    SEARCH_SEP=':'
-    AC_MSG_RESULT([VPATH=DIR1:DIR2:...])
-    break
-  fi
-
-  dnl pmake uses the construct `.PATH: DIR1 DIR2
-  cat >maketest <<EOF
-.PATH: $srcdir/config $srcdir/src $srcdir/bin
-.c.o:
-	cp $< H5.o
-
-foo: H5.o
-	rm -f H5.o
-	@echo works
-EOF
-
-  if (MAKE= ${MAKE-make} -f maketest foo) >/dev/null 2>&1; then
-    SEARCH_RULE='.PATH: '
-    SEARCH_SEP=' '
-    AC_MSG_RESULT([.PATH: DIR1 DIR2 ...])
-    break
-  fi
-
-  dnl No way for make to search directories
-  SEARCH_RULE='## SEARCH DISABLED: '
-  SEARCH_SEP=' '
-  AC_MSG_RESULT([it doesn't])
-  if test ! -f configure; then
-    AC_MSG_ERROR([${MAKE-make} requires the build and source directories to be the same])
-  fi
-  break
-done
-rm maketest
-
-dnl ----------------------------------------------------------------------
-dnl pmake will throw an error if variables are undefined in a Makefile.
-dnl These errors can be changed to warnings using the -V flag.
-dnl
-AC_SUBST(AM_MAKEFLAGS) AM_MAKEFLAGS=""
-
-dnl Don't run test if MAKE is defined but is the empty string
-if test -n "${MAKE-make}"; then 
-
-  AC_MSG_CHECKING([whether make will build with undefined variables])
-
-  cat >maketest <<EOF
-foo: \$(UNDEFINED) \$(UNDEFINED2)
-	@echo \$(UNDEFINED3) works
-EOF
-
-  if (${MAKE-make} -f maketest foo) >/dev/null 2>&1; then
-    AC_MSG_RESULT([yes])
-  else
-    AC_MSG_RESULT([no, setting -V flag])
-    AM_MAKEFLAGS="\-V"
-  fi
-
-  rm maketest
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Production flags?  Save the value in $CONFIG_MODE so we have it for
-dnl the record.
-dnl
-AC_MSG_CHECKING(for production mode)
-AC_ARG_ENABLE(production,
-              [AC_HELP_STRING([--enable-production],
-                              [Determines how to run the compiler.])])
-
-case "X-$enable_production" in
-  X-yes)
-    enable_production="yes"
-    AC_MSG_RESULT([production])
-    CONFIG_MODE=production
-    H5_CFLAGS="$H5_CFLAGS $PROD_CFLAGS"
-    H5_CPPFLAGS="$H5_CPPFLAGS $PROD_CPPFLAGS"
-    H5_CXXFLAGS="$H5_CXXFLAGS $PROD_CXXFLAGS"
-    H5_FCFLAGS="$H5_FCFLAGS $PROD_FCFLAGS"
-    ;;
-  X-|X-no)
-    enable_production="no"
-    AC_MSG_RESULT([development])
-    CONFIG_MODE=development
-    H5_CFLAGS="$H5_CFLAGS $DEBUG_CFLAGS"
-    H5_CPPFLAGS="$H5_CPPFLAGS $DEBUG_CPPFLAGS"
-    H5_CXXFLAGS="$H5_CXXFLAGS $DEBUG_CXXFLAGS"
-    H5_FCFLAGS="$H5_FCFLAGS $DEBUG_FCFLAGS"
-    ;;
-  X-pg|X-profile)
-    enable_production="profile"
-    AC_MSG_RESULT([profile])
-    CONFIG_MODE=profile
-    H5_CFLAGS="$H5_CFLAGS $PROFILE_CFLAGS"
-    H5_CPPFLAGS="$H5_CPPFLAGS $PROFILE_CPPFLAGS"
-    H5_CXXFLAGS="$H5_CXXFLAGS $PROFILE_CXXFLAGS"
-    H5_FCFLAGS="$H5_FCFLAGS $PROFILE_FCFLAGS"
-    ;;
-  *)
-    enable_production="user-defined"
-    AC_MSG_RESULT([user-defined])
-    CONFIG_MODE="$enableval"
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Check for system libraries.
-dnl
-AC_CHECK_LIB([m], [ceil])
-
-if test "`uname`" = "SunOS" -o "`uname -sr`" = "HP-UX B.11.00"; then
-  dnl ...for Solaris
-  AC_CHECK_LIB([socket], [socket])
-  AC_CHECK_LIB([nsl], [xdr_int])
-fi
-
-dnl AC_CHECK_LIB([coug], [main])		dnl ...for ASCI/Red
-
-dnl ----------------------------------------------------------------------
-dnl Check for system header files.
-dnl
-AC_HEADER_STDC
-AC_HEADER_TIME
-
-dnl ----------------------------------------------------------------------
-dnl Check for these two functions before the time headers are checked
-dnl for, otherwise they are not detected correctly on Solaris (the
-dnl configure test will fail due to multiply-defined symbols).
-dnl
-AC_CHECK_FUNCS(difftime)
-AC_CHECK_FUNCS(gettimeofday, [have_gettime="yes"], [have_gettime="no"])
-AC_SEARCH_LIBS([clock_gettime], [rt posix4])
-AC_CHECK_FUNCS([clock_gettime],[have_clock_gettime="yes"],[have_clock_gettime="no"])
-
-dnl Unix
-AC_CHECK_HEADERS([sys/resource.h sys/time.h unistd.h sys/ioctl.h sys/stat.h])
-AC_CHECK_HEADERS([sys/socket.h sys/types.h])
-AC_CHECK_HEADERS([stddef.h setjmp.h features.h])
-AC_CHECK_HEADERS([stdint.h], [C9x=yes])
-
-dnl Darwin
-AC_CHECK_HEADERS([mach/mach_time.h])
-
-dnl Windows
-case "`uname`" in
-  CYGWIN*)
-    AC_CHECK_HEADERS([io.h sys/timeb.h])
-    ;;
-  MINGW*)
-    AC_CHECK_HEADERS([io.h winsock2.h sys/timeb.h])
-    AC_HAVE_LIBRARY([ws2_32])
-    ;;
-  *)
-    AC_CHECK_HEADERS([io.h winsock2.h sys/timeb.h])
-    ;;
-esac
-
-case "$host" in
-  alpha*-dec*-osf*)
-    dnl The <sys/sysinfo.h> and <sys/proc.h> are needed on the DEC
-    dnl Alpha to turn off UAC fixing. We do *not* attempt to
-    dnl locate these files on other systems because there are too
-    dnl many problems with including them.
-    AC_CHECK_HEADERS([sys/sysinfo.h sys/proc.h])
-    ;;
-  mips*-sgi*-irix*)
-    dnl The <sys/fpu.h> is needed on the SGI machines to turn off
-    dnl denormalized floating-point values going to zero.  We do *not*
-    dnl attempt to dnl locate these files on other systems because there
-    dnl may be problems with including them.
-    AC_CHECK_HEADERS([sys/fpu.h])
-    AC_CHECK_FUNCS([get_fpc_csr])
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Some platforms require that all symbols are resolved when a library
-dnl is linked. We can use the -no-undefined flag to tell libtool that
-dnl it will be able to build shared libraries on these architectures,
-dnl as it will not do so by default.
-dnl
-if test "X${enable_shared}" = "Xyes"; then
-  AC_MSG_CHECKING([if libtool needs -no-undefined flag to build shared libraries])
-  case "`uname`" in
-    CYGWIN*|MINGW*|AIX*)
-      dnl Add in the -no-undefined flag to LDFLAGS for libtool.
-      AC_MSG_RESULT([yes])
-      H5_LDFLAGS="$H5_LDFLAGS -no-undefined"
-      ;;
-    *)
-      dnl Don't add in anything.
-      AC_MSG_RESULT([no])
-      ;;
-  esac
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Test for Largefile support.
-dnl
-AC_MSG_CHECKING([if configure should try to set up large file support])
-
-AC_ARG_ENABLE([largefile],
-           [AC_HELP_STRING([--disable-largefile],
-                           [omit support for large files])])
-
-dnl If largefile support is enabled, then set up appropriate compiler options.
-if test "$enable_largefile" != no; then
-  AC_MSG_RESULT(yes)
-
-  dnl Check for needed compiler options. This check is pulled drectly 
-  dnl from autoconf's AC_SYS_LARGEFILE macro, as of Autoconf v2.65.
-  AC_CACHE_CHECK([for special C compiler options needed for large files],
-    ac_cv_sys_largefile_CC,
-    [ac_cv_sys_largefile_CC=no
-     if test "$GCC" != yes; then
-       ac_save_CC=$CC
-       while :; do
-     # IRIX 6.2 and later do not support large files by default,
-     # so use the C compiler's -n32 option if that helps.
-     AC_LANG_CONFTEST([AC_LANG_PROGRAM([_AC_SYS_LARGEFILE_TEST_INCLUDES])])
-     AC_COMPILE_IFELSE([], [break])
-     CC="$CC -n32"
-     AC_COMPILE_IFELSE([], [ac_cv_sys_largefile_CC=' -n32'; break])
-     break
-       done
-       CC=$ac_save_CC
-       rm -f conftest.$ac_ext
-    fi])
-  if test "$ac_cv_sys_largefile_CC" != no; then
-    CC=$CC$ac_cv_sys_largefile_CC
-  fi
-
-  dnl Use the macro _AC_SYS_LARGEFILE_MACRO_VALUE to test defines
-  dnl that might need to be set for largefile support to behave 
-  dnl correctly. This macro is defined in acsite.m4 and overrides
-  dnl the version provided by Autoconf (as of v2.65). The custom
-  dnl macro additionally adds the appropriate defines to AM_CPPFLAGS 
-  dnl so that later configure checks have them visible. 
-
-  dnl Check for _FILE_OFFSET_BITS
-  _AC_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, 64,
-    ac_cv_sys_file_offset_bits,
-    [Number of bits in a file offset, on hosts where this is settable.],
-    [_AC_SYS_LARGEFILE_TEST_INCLUDES])
-
-  dnl Check for _LARGE_FILES
-  if test $ac_cv_sys_file_offset_bits = unknown; then
-    _AC_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1,
-      ac_cv_sys_large_files,
-      [Define for large files, on AIX-style hosts.],
-      [_AC_SYS_LARGEFILE_TEST_INCLUDES])
-  fi
-
-  dnl Now actually test to see if we can create large files after we've
-  dnl checked for any needed defines.
-  AC_MSG_CHECKING([if large (64-bit) files are supported on this system.])
-  AC_CACHE_VAL([hdf5_cv_have_lfs],
-    [AC_TRY_RUN([
-      #include <stdio.h>
-      #include <unistd.h>
-      #include <stdlib.h>
-      #include <fcntl.h>
-      #define BIG_FILE (off_t)0x80000000UL 
-      int main(void) {
-        int fd;
-        if ((fd=open("test.conf", O_RDWR|O_TRUNC|O_CREAT, 0666)) < 0) exit(1);
-        if (lseek(fd, BIG_FILE, SEEK_SET)!=BIG_FILE) exit(1);
-        if (5!=write(fd, "hello", (size_t)5)) exit(1);
-        if (lseek(fd, 2*BIG_FILE, SEEK_SET) != 2*BIG_FILE) exit(1);
-        if (5!=write(fd, "hello", (size_t)5)) exit(1);
-        if (unlink("test.conf") < 0) exit(1);
-        exit(0);
-      }
-    ],[hdf5_cv_have_lfs=yes],[hdf5_cv_have_lfs=no],)])
-
-  if test "X${hdf5_cv_have_lfs}" = "Xyes"; then
-    AC_MSG_RESULT([yes])
-    LARGEFILE="yes"
-  fi 
-  if test "X${hdf5_cv_have_lfs}" = "Xno"; then
-    AC_MSG_RESULT([no])
-    LARGEFILE="no"
-  fi 
-
-else
-  LARGEFILE="no"
-  AC_MSG_RESULT(no)
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Add necessary defines for Linux Systems.
-dnl
-case "$host_cpu-$host_vendor-$host_os" in
-  *linux*)
-    dnl If largefile support is enabled, then make available various
-    dnl LFS-related routines using the following _LARGEFILE*_SOURCE macros.
-    if test "X$LARGEFILE" != "Xno"; then
-        AM_CPPFLAGS="-D_LARGEFILE64_SOURCE -D_LARGEFILE_SOURCE $AM_CPPFLAGS"
-    fi
-
-    dnl Add POSIX support on Linux systems, so <features.h> defines
-    dnl __USE_POSIX, which is required to get the prototype for fdopen
-    dnl defined correctly in <stdio.h>. 
-    dnl This flag was removed from h5cc as of 2009-10-17 when it was found
-    dnl that the flag broke compiling netCDF-4 code with h5cc, but kept in 
-    dnl H5_CPPFLAGS because fdopen and HDfdopen fail without it. HDfdopen
-    dnl is used only by H5_debug_mask which is used only when debugging in
-    dnl H5_init_library (all in H5.c).  When the flag was removed this was
-    dnl the only compile failure noted.
-    dnl This was originally defined as _POSIX_SOURCE which was updated to
-    dnl _POSIX_C_SOURCE=199506L to expose a greater amount of POSIX
-    dnl functionality so clock_gettime and CLOCK_MONOTONIC are defined
-    dnl correctly.
-    dnl POSIX feature information can be found in the gcc manual at:
-    dnl http://www.gnu.org/s/libc/manual/html_node/Feature-Test-Macros.html
-    H5_CPPFLAGS="-D_POSIX_C_SOURCE=199506L $H5_CPPFLAGS"
-
-    dnl Also add BSD support on Linux systems, so <features.h> defines
-    dnl __USE_BSD, which is required to get the prototype for strdup
-    dnl defined correctly in <string.h> and snprintf & vsnprintf defined
-    dnl correctly in <stdio.h>
-    dnl Linking to the bsd-compat library is required as per the gcc manual:
-    dnl http://www.gnu.org/s/libc/manual/html_node/Feature-Test-Macros.html
-    dnl however, we do not do this since it breaks the big test on some 
-    dnl older platforms.
-    AM_CPPFLAGS="-D_BSD_SOURCE $AM_CPPFLAGS"
-    ;;
-esac
-
-dnl Need to add the AM_ and H5_ into CPFLAGS/CPPFLAGS to make them visible 
-dnl for configure checks.
-dnl Note: Both will be restored by the end of configure.
-CPPFLAGS="$H5_CPPFLAGS $AM_CPPFLAGS $CPPFLAGS"
-CFLAGS="$H5_CFLAGS $AM_CFLAGS $CFLAGS"
-
-AC_TRY_COMPILE([#include <sys/types.h>],
-               [off64_t n = 0;],
-               [AC_CHECK_FUNCS([lseek64 fseeko64 ftello64 ftruncate64])],
-               [AC_MSG_RESULT([skipping test for lseek64(), fseeko64 , ftello64, ftruncate64() because off64_t is not defined])])
-AC_CHECK_FUNCS(fseeko ftello)
-AC_TRY_COMPILE([
-#include <sys/types.h>
-#include <sys/stat.h>],
-[struct stat64 sb;],
-[AC_CHECK_FUNCS([stat64 fstat64])],
-[AC_MSG_RESULT([skipping test for stat64() and fstat64()])])
-
-dnl ----------------------------------------------------------------------
-dnl Data types and their sizes.
-dnl
-AC_TYPE_OFF_T
-AC_CHECK_TYPE([size_t], [unsigned long])
-AC_CHECK_TYPE([ssize_t], [long])
-AC_CHECK_TYPE([ptrdiff_t], [long])
-AC_C_BIGENDIAN
-AC_CHECK_SIZEOF([char], [1])
-AC_CHECK_SIZEOF([short], [2])
-AC_CHECK_SIZEOF([int], [4])
-AC_CHECK_SIZEOF([unsigned], [4])
-AC_CHECK_SIZEOF([long], [4])
-AC_CHECK_SIZEOF([long long], [8])
-AC_CHECK_SIZEOF([__int64], [8])
-AC_CHECK_SIZEOF([float], [4])
-AC_CHECK_SIZEOF([double], [8])
-AC_CHECK_SIZEOF([long double], [8])
-
-dnl Checkpoint the cache
-AC_CACHE_SAVE
-
-dnl Posix.1g types (C9x)
-cat >>confdefs.h <<\EOF
-#include <sys/types.h>
-EOF
-
-if test "X$C9x" = "Xyes"; then
-  cat >>confdefs.h <<\EOF
-#include <stdint.h>
-EOF
-fi
-
-AC_CHECK_SIZEOF(        int8_t, [1])
-AC_CHECK_SIZEOF(       uint8_t, [1])
-AC_CHECK_SIZEOF(  int_least8_t, [1])
-AC_CHECK_SIZEOF( uint_least8_t, [1])
-AC_CHECK_SIZEOF(   int_fast8_t, [1])
-AC_CHECK_SIZEOF(  uint_fast8_t, [1])
-
-AC_CHECK_SIZEOF(       int16_t, [2])
-AC_CHECK_SIZEOF(      uint16_t, [2])
-AC_CHECK_SIZEOF( int_least16_t, [2])
-AC_CHECK_SIZEOF(uint_least16_t, [2])
-AC_CHECK_SIZEOF(  int_fast16_t, [2])
-AC_CHECK_SIZEOF( uint_fast16_t, [2])
-
-AC_CHECK_SIZEOF(       int32_t, [4])
-AC_CHECK_SIZEOF(      uint32_t, [4])
-AC_CHECK_SIZEOF( int_least32_t, [4])
-AC_CHECK_SIZEOF(uint_least32_t, [4])
-AC_CHECK_SIZEOF(  int_fast32_t, [4])
-AC_CHECK_SIZEOF( uint_fast32_t, [4])
-
-AC_CHECK_SIZEOF(       int64_t, [8])
-AC_CHECK_SIZEOF(      uint64_t, [8])
-AC_CHECK_SIZEOF( int_least64_t, [8])
-AC_CHECK_SIZEOF(uint_least64_t, [8])
-AC_CHECK_SIZEOF(  int_fast64_t, [8])
-AC_CHECK_SIZEOF( uint_fast64_t, [8])
-
-AC_CHECK_SIZEOF([size_t], [4])
-AC_CHECK_SIZEOF([ssize_t], [4])
-AC_CHECK_SIZEOF([ptrdiff_t], [4])
-
-cat >>confdefs.h <<\EOF
-#include <sys/types.h> /*for off_t definition*/
-EOF
-AC_CHECK_SIZEOF([off_t], [4])
-AC_CHECK_SIZEOF([off64_t], [8])
-
-dnl Checkpoint the cache
-AC_CACHE_SAVE
-
-dnl ----------------------------------------------------------------------
-dnl Check if the dev_t type is a scalar type (must come after the check for
-dnl sys/types.h)
-AC_MSG_CHECKING([if dev_t is scalar])
-AC_TRY_COMPILE([
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-  ],
-  [dev_t d1, d2; if(d1==d2) return 0;],
-  AC_DEFINE([DEV_T_IS_SCALAR], [1],
-            [Define if `dev_t' is a scalar])
-  AC_MSG_RESULT(yes),
-  AC_MSG_RESULT(no)
-)
-
-dnl ----------------------------------------------------------------------
-dnl Fake --with-xxx option to allow us to create a help message for the
-dnl following --with-xxx options which can take either a =DIR or =INC,LIB
-dnl specifier.
-dnl
-AC_ARG_WITH([fnord],
-  [
- For the following --with-xxx options, you can specify where the header
- files and libraries are in two different ways:
-
-    --with-xxx=INC,LIB - Specify individually the include directory and
-                         library directory separated by a comma
-    --with-xxx=DIR     - Specify only the directory which contains the
-                         include/ and lib/ subdirectories
-  ])
-
-dnl ----------------------------------------------------------------------
-dnl Is the dmalloc present? It has a header file `dmalloc.h' and a library
-dnl `-ldmalloc' and their locations might be specified with the `--with-dmalloc'
-dnl command-line switch. The value is an include path and/or a library path.
-dnl If the library path is specified then it must be preceded by a comma.
-dnl
-AC_ARG_WITH([dmalloc],
-            [AC_HELP_STRING([--with-dmalloc=DIR],
-                            [Use dmalloc memory debugging aid [default=no]])],,
-            withval=no)
-
-case $withval in
-  yes)
-    HAVE_DMALLOC="yes"
-    AC_CHECK_HEADERS(dmalloc.h)
-    AC_CHECK_LIB(dmalloc, dmalloc_shutdown,, unset HAVE_DMALLOC)
-
-    if test -z "$HAVE_DMALLOC" -a -n "$HDF5_CONFIG_ABORT"; then
-      AC_MSG_ERROR(couldn't find dmalloc library)
-    fi
-    ;;
-  no)
-    HAVE_DMALLOC="no"
-    AC_MSG_CHECKING(for dmalloc library)
-    AC_MSG_RESULT(suppressed)
-    ;;
-  *)
-    HAVE_DMALLOC="yes"
-    case "$withval" in
-      *,*)
-        dmalloc_inc="`echo $withval |cut -f1 -d,`"
-        dmalloc_lib="`echo $withval |cut -f2 -d, -s`"
-        ;;
-      *)
-        if test -n "$withval"; then
-          dmalloc_inc="$withval/include"
-          dmalloc_lib="$withval/lib"
-        fi
-        ;;
-    esac
-
-    dnl Trying to include -I/usr/include and -L/usr/lib is redundant and
-    dnl can mess some compilers up.
-    if test "X$dmalloc_inc" = "X/usr/include"; then
-      dmalloc_inc=""
-    fi
-    if test "X$dmalloc_lib" = "X/usr/lib"; then
-      dmalloc_lib=""
-    fi
-
-    saved_CPPFLAGS="$CPPFLAGS"
-    saved_AM_CPPFLAGS="$AM_CPPFLAGS"
-    saved_LDFLAGS="$LDFLAGS"
-    saved_AM_LDFLAGS="$AM_LDFLAGS"
-
-    if test -n "$dmalloc_inc"; then
-      CPPFLAGS="$CPPFLAGS -I$dmalloc_inc"
-      AM_CPPFLAGS="$AM_CPPFLAGS -I$dmalloc_inc"
-    fi
-
-    AC_CHECK_HEADERS(dmalloc.h,,CPPFLAGS="$saved_CPPFLAGS"; AM_CPPFLAGS="$saved_AM_CPPFLAGS")
-
-    if test -n "$dmalloc_lib"; then
-      LDFLAGS="$LDFLAGS -L$dmalloc_lib"
-      AM_LDFLAGS="$AM_LDFLAGS -L$dmalloc_lib"
-    fi
-
-    AC_CHECK_LIB(dmalloc, dmalloc_shutdown,, LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset HAVE_DMALLOC)
-
-    if test -z "$HAVE_DMALLOC" -a -n "$HDF5_CONFIG_ABORT"; then
-      AC_MSG_ERROR(couldn't find dmalloc library)
-    fi
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Is the GNU zlib present? It has a header file `zlib.h' and a library
-dnl `-lz' and their locations might be specified with the `--with-zlib'
-dnl command-line switch. The value is an include path and/or a library path.
-dnl If the library path is specified then it must be preceded by a comma.
-dnl
-AC_SUBST(USE_FILTER_DEFLATE) USE_FILTER_DEFLATE="no"
-AC_ARG_WITH([zlib],
-            [AC_HELP_STRING([--with-zlib=DIR],
-                            [Use zlib library for external deflate I/O
-                             filter [default=yes]])],,
-            withval=yes)
-
-case $withval in
-  yes)
-    HAVE_ZLIB="yes"
-    AC_CHECK_HEADERS([zlib.h], [HAVE_ZLIB_H="yes"])
-    AC_CHECK_LIB([z], [compress2],, [unset HAVE_ZLIB])
-    AC_CHECK_FUNC([compress2], [HAVE_COMPRESS2="yes"])
-
-    if test -z "$HAVE_ZLIB" -a -n "$HDF5_CONFIG_ABORT"; then
-      AC_MSG_ERROR([couldn't find zlib library])
-    fi
-    ;;
-  no)
-    HAVE_ZLIB="no"
-    AC_MSG_CHECKING([for GNU zlib])
-    AC_MSG_RESULT([suppressed])
-    ;;
-  *)
-    HAVE_ZLIB="yes"
-    case "$withval" in
-      *,*)
-        zlib_inc="`echo $withval |cut -f1 -d,`"
-        zlib_lib="`echo $withval |cut -f2 -d, -s`"
-        ;;
-      *)
-        if test -n "$withval"; then
-          zlib_inc="$withval/include"
-          zlib_lib="$withval/lib"
-        fi
-        ;;
-    esac
-
-    dnl Trying to include -I/usr/include and -L/usr/lib is redundant and
-    dnl can mess some compilers up.
-    if test "X$zlib_inc" = "X/usr/include"; then
-      zlib_inc=""
-    fi
-    if test "X$zlib_lib" = "X/usr/lib"; then
-      zlib_lib=""
-    fi
-
-    saved_CPPFLAGS="$CPPFLAGS"
-    saved_AM_CPPFLAGS="$AM_CPPFLAGS"
-    saved_LDFLAGS="$LDFLAGS"
-    saved_AM_LDFLAGS="$AM_LDFLAGS"
-
-    if test -n "$zlib_inc"; then
-      CPPFLAGS="$CPPFLAGS -I$zlib_inc"
-      AM_CPPFLAGS="$AM_CPPFLAGS -I$zlib_inc"
-    fi
-
-    AC_CHECK_HEADERS([zlib.h],
-                     [HAVE_ZLIB_H="yes"],
-                     [CPPFLAGS="$saved_CPPFLAGS"; AM_CPPFLAGS="$saved_AM_CPPFLAGS"])
-
-    if test -n "$zlib_lib"; then
-      LDFLAGS="$LDFLAGS -L$zlib_lib"
-      AM_LDFLAGS="$AM_LDFLAGS -L$zlib_lib"
-    fi
-
-    AC_CHECK_LIB([z], [compress2],,
-                 [LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset HAVE_ZLIB])
-    AC_CHECK_FUNC([compress2], [HAVE_COMPRESS2="yes"])
-
-    if test -z "$HAVE_ZLIB" -a -n "$HDF5_CONFIG_ABORT"; then
-      AC_MSG_ERROR([couldn't find zlib library])
-    fi
-    ;;
-esac
-
-if test "x$HAVE_ZLIB" = "xyes" -a "x$HAVE_ZLIB_H" = "xyes" -a "x$HAVE_COMPRESS2" = "xyes"; then
-    AC_DEFINE([HAVE_FILTER_DEFLATE], [1], [Define if support for deflate (zlib) filter is enabled])
-    USE_FILTER_DEFLATE="yes"
-
-    dnl Add "deflate" to external filter list
-    if test "X$EXTERNAL_FILTERS" != "X"; then
-        EXTERNAL_FILTERS="${EXTERNAL_FILTERS},"
-    fi
-    EXTERNAL_FILTERS="${EXTERNAL_FILTERS}deflate(zlib)"
-fi
-
-
-dnl ----------------------------------------------------------------------
-dnl Is the szlib present? It has a header file `szlib.h' and a library
-dnl `-lsz' and their locations might be specified with the `--with-szlib'
-dnl command-line switch. The value is an include path and/or a library path.
-dnl If the library path is specified then it must be preceded by a comma.
-dnl
-AC_SUBST(USE_FILTER_SZIP) USE_FILTER_SZIP="no"
-AC_ARG_WITH([szlib],
-            [AC_HELP_STRING([--with-szlib=DIR],
-                            [Use szlib library for external szlib I/O
-                             filter [default=no]])],,
-            withval=no)
-
-case $withval in
-  yes)
-    HAVE_SZLIB="yes"
-    AC_CHECK_HEADERS([szlib.h], [HAVE_SZLIB_H="yes"])
-    AC_CHECK_LIB([sz], [SZ_BufftoBuffCompress],, [unset HAVE_SZLIB])
-
-    if test -z "$HAVE_SZLIB" -a -n "$HDF5_CONFIG_ABORT"; then
-      AC_MSG_ERROR([couldn't find szlib library])
-    fi
-    ;;
-  no)
-    HAVE_SZLIB="no"
-    AC_MSG_CHECKING([for szlib])
-    AC_MSG_RESULT([suppressed])
-    ;;
-  *)
-    HAVE_SZLIB="yes"
-    case "$withval" in
-      *,*)
-        szlib_inc="`echo $withval |cut -f1 -d,`"
-        szlib_lib="`echo $withval |cut -f2 -d, -s`"
-        ;;
-      *)
-        if test -n "$withval"; then
-          szlib_inc="$withval/include"
-          szlib_lib="$withval/lib"
-        fi
-        ;;
-    esac
-    
-    dnl Trying to include -I/usr/include and -L/usr/lib is redundant and
-    dnl can mess some compilers up.
-    if test "X$szlib_inc" = "X/usr/include"; then
-      szlib_inc=""
-    fi 
-    if test "X$szlib_lib" = "X/usr/lib"; then
-      szlib_lib=""
-    fi
-    
-    saved_CPPFLAGS="$CPPFLAGS"
-    saved_AM_CPPFLAGS="$AM_CPPFLAGS"
-    saved_LDFLAGS="$LDFLAGS"
-    saved_AM_LDFLAGS="$AM_LDFLAGS"
-    
-    if test -n "$szlib_inc"; then
-      CPPFLAGS="$CPPFLAGS -I$szlib_inc"
-      AM_CPPFLAGS="$AM_CPPFLAGS -I$szlib_inc"
-    fi
-    
-    AC_CHECK_HEADERS([szlib.h],
-                     [HAVE_SZLIB_H="yes"],
-                     [CPPFLAGS="$saved_CPPFLAGS"; AM_CPPFLAGS="$saved_AM_CPPFLAGS"])
-
-    if test -n "$szlib_lib"; then
-      LDFLAGS="$LDFLAGS -L$szlib_lib"
-      AM_LDFLAGS="$AM_LDFLAGS -L$szlib_lib"
-    fi
-    
-    AC_CHECK_LIB([sz], [SZ_BufftoBuffCompress],,
-                 [LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset HAVE_SZLIB])
-
-    if test -z "$HAVE_SZLIB" -a -n "$HDF5_CONFIG_ABORT"; then
-      AC_MSG_ERROR([couldn't find szlib library])
-    fi
-    ;;
-esac
-
-if test "x$HAVE_SZLIB" = "xyes" -a "x$HAVE_SZLIB_H" = "xyes"; then
-    dnl SZLIB library is available.  Check if it can encode
-    AC_MSG_CHECKING([for szlib encoder])
-
-    dnl Set LD_LIBRARY_PATH so encoder test can find the library and run.
-    dnl Also add LL_PATH substitution to Makefiles so they can use the 
-    dnl path as well, for testing examples.
-    if test -z "$LD_LIBRARY_PATH"; then
-    export LD_LIBRARY_PATH="$szlib_lib"
-    else
-    export LD_LIBRARY_PATH="$szlib_lib:$LD_LIBRARY_PATH"
-    fi
-
-    AC_SUBST([LL_PATH]) LL_PATH="$LD_LIBRARY_PATH"
-    
-    AC_CACHE_VAL([hdf5_cv_szlib_can_encode],
-        [AC_TRY_RUN([
-        #include <szlib.h>
-        
-        int main(void)
-        {       
-                /* SZ_encoder_enabled returns 1 if encoder is present */
-            if(SZ_encoder_enabled() == 1)
-                exit(0);
-            else
-                exit(1);
-        }
-        ], [hdf5_cv_szlib_can_encode=yes], [hdf5_cv_szlib_can_encode=no],)])
-    
-    AC_DEFINE(HAVE_FILTER_SZIP, 1, 
-            [Define if support for szip filter is enabled])
-    USE_FILTER_SZIP="yes"
-    
-    if test ${hdf5_cv_szlib_can_encode} = "yes"; then
-        AC_MSG_RESULT([yes])
-    fi 
-    if test ${hdf5_cv_szlib_can_encode} = "no"; then
-        AC_MSG_RESULT([no])
-    fi 
-    
-    dnl Add "szip" to external filter list
-    if test ${hdf5_cv_szlib_can_encode} = "yes"; then
-        if test "X$EXTERNAL_FILTERS" != "X"; then
-            EXTERNAL_FILTERS="${EXTERNAL_FILTERS},"
-        fi
-        EXTERNAL_FILTERS="${EXTERNAL_FILTERS}szip(encoder)"
-    fi 
-    if test ${hdf5_cv_szlib_can_encode} = "no"; then
-        if test "X$EXTERNAL_FILTERS" != "X"; then
-            EXTERNAL_FILTERS="${EXTERNAL_FILTERS},"
-        fi
-        EXTERNAL_FILTERS="${EXTERNAL_FILTERS}szip(no encoder)"
-    fi
-
-fi
-
-AM_CONDITIONAL([BUILD_SHARED_SZIP_CONDITIONAL], [test "X$USE_FILTER_SZIP" = "Xyes" && test "X$LL_PATH" != "X"])
-
-dnl Checkpoint the cache
-AC_CACHE_SAVE
-
-dnl ----------------------------------------------------------------------
-dnl Is the Pthreads library present?  It has a header file `pthread.h' and
-dnl a library `-lpthread' and their locations might be specified with the
-dnl `--with-pthread' command-line switch.  The value is an include path
-dnl and/or a library path.  If the library path is specified then it must
-dnl be preceded by a comma.
-dnl
-AC_SUBST([PTHREAD]) PTHREAD=yes
-AC_ARG_WITH([pthread],
-            [AC_HELP_STRING([--with-pthread=DIR],
-                            [Use the Pthreads library [default=no]])],,
-            withval=no)
-
-case "$withval" in
-  yes)
-    AC_CHECK_HEADERS([pthread.h])
-    AC_CHECK_LIB([pthread], [pthread_self],, [unset PTHREAD])
-    ;;
-  no)
-    AC_MSG_CHECKING([for pthread])
-    AC_MSG_RESULT([suppressed])
-    unset PTHREAD
-    ;;
-  *)
-    case "$withval" in
-      *,*)
-        pthread_inc="`echo $withval | cut -f1 -d,`"
-        pthread_lib="`echo $withval | cut -f2 -d, -s`"
-        ;;
-      *)
-        if test -n "$withval"; then
-          pthread_inc="$withval/include"
-          pthread_lib="$withval/lib"
-        fi
-        ;;
-    esac
-
-    dnl Trying to include -I/usr/include and -L/usr/lib is redundant and
-    dnl can mess some compilers up.
-    if test "X$pthread_inc" = "X/usr/include"; then
-      pthread_inc=""
-    fi
-    if test "X$pthread_lib" = "X/usr/lib"; then
-      pthread_lib=""
-    fi
-
-    if test -n "$pthread_inc"; then
-      saved_CPPFLAGS="$CPPFLAGS"
-      saved_AM_CPPFLAGS="$AM_CPPFLAGS"
-      CPPFLAGS="$CPPFLAGS -I$pthread_inc"
-      AM_CPPFLAGS="$AM_CPPFLAGS -I$pthread_inc"
-      AC_CHECK_HEADERS([pthread.h],, [CPPFLAGS="$saved_CPPFLAGS"; AM_CPPFLAGS="$saved_AM_CPPFLAGS"; unset PTHREAD])
-    else
-      AC_CHECK_HEADERS([pthread.h],, [unset PTHREAD])
-    fi
-
-    if test -n "$pthread_lib"; then
-      saved_LDFLAGS="$LDFLAGS"
-      saved_AM_LDFLAGS="$AM_LDFLAGS"
-      LDFLAGS="$LDFLAGS -L$pthread_lib"
-      AM_LDFLAGS="$AM_LDFLAGS -L$pthread_lib"
-      AC_CHECK_LIB([pthread], [pthread_self],,
-                   [LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset PTHREAD])
-
-    else
-      AC_CHECK_LIB([pthread], [pthread_self],, [unset PTHREAD])
-    fi
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Enable thread-safe version of library.  It requires Pthreads support.
-dnl
-AC_MSG_CHECKING([for thread safe support])
-AC_ARG_ENABLE([threadsafe],
-              [AC_HELP_STRING([--enable-threadsafe],
-                              [Enable thread safe capability])],
-              THREADSAFE=$enableval)
-
-case "X-$THREADSAFE" in
-  X-|X-no)
-    AC_MSG_RESULT([no])
-    ;;
-  X-yes)
-    dnl Check that we can link a simple Pthread program.
-    AC_TRY_LINK(, [pthread_self()],
-                [AC_MSG_RESULT([yes]); THREADSAFE=yes],
-                [AC_MSG_ERROR([needed pthread library not available])])
-    ;;
-  *)
-    AC_MSG_RESULT([error])
-    AC_MSG_ERROR([\'$enableval\' is not a valid threadsafe type])
-    ;;
-esac
-
-if test "X$THREADSAFE" = "Xyes"; then
-  AC_DEFINE([HAVE_THREADSAFE], [1], [Define if we have thread safe support])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Check for MONOTONIC_TIMER support (used in clock_gettime).  This has
-dnl to be done after any POSIX/BSD defines to ensure that the test gets
-dnl the correct POSIX level on linux.
-AC_CHECK_DECL(CLOCK_MONOTONIC,[have_clock_monotonic="yes"],[have_clock_monotonic="no"],[[#include <time.h>]])
-
-dnl ----------------------------------------------------------------------
-dnl How does one figure out the local time zone?  Anyone know of a
-dnl Posix way to do this?
-dnl
-
-dnl First check if `struct tm' has a `tm_gmtoff' member.
-AC_MSG_CHECKING([for tm_gmtoff in struct tm])
-AC_TRY_COMPILE([
-#include <sys/time.h>
-#include <time.h>], [struct tm tm; tm.tm_gmtoff=0;],
-AC_DEFINE([HAVE_TM_GMTOFF], [1],
-          [Define if `tm_gmtoff' is a member of `struct tm'])
-AC_MSG_RESULT([yes]),
-AC_MSG_RESULT([no]))
-
-dnl check if `struct tm' has a `__tm_gmtoff' member.
-AC_MSG_CHECKING([for __tm_gmtoff in struct tm])
-AC_TRY_COMPILE([
-#include <sys/time.h>
-#include <time.h>], [struct tm tm; tm.__tm_gmtoff=0;],
-AC_DEFINE([HAVE___TM_GMTOFF], [1],
-          [Define if `__tm_gmtoff' is a member of `struct tm'])
-AC_MSG_RESULT([yes]),
-AC_MSG_RESULT([no]))
-
-dnl Check whether the global variable `timezone' is defined.
-AC_MSG_CHECKING([for global timezone variable])
-
-case "`uname`" in
-  CYGWIN*)
-    AC_MSG_RESULT([disabled in CYGWIN])
-    ;;
-  *)
-    AC_TRY_LINK([
-    #include <sys/time.h>
-    #include <time.h>], [timezone=0;],
-    AC_DEFINE([HAVE_TIMEZONE], [1],
-              [Define if `timezone' is a global variable])
-    AC_MSG_RESULT([yes]),
-    AC_MSG_RESULT([no]))
-    ;;
-esac
-
-dnl Check whether `struct timezone' is defined.
-AC_STRUCT_TIMEZONE
-AC_MSG_CHECKING([for struct timezone])
-AC_TRY_COMPILE([
-#include <sys/types.h>
-#include <sys/time.h>
-#include <time.h>], [struct timezone tz; tz.tz_minuteswest=0;],
-AC_DEFINE([HAVE_STRUCT_TIMEZONE], [1],
-          [Define if `struct timezone' is defined])
-have_struct_tz="yes"
-AC_MSG_RESULT([yes]),
-AC_MSG_RESULT([no]))
-
-dnl If gettimeofday() is going to be used, make sure it uses the timezone struct
-
-if test "$have_gettime" = "yes" -a "$have_struct_tz" = "yes"; then
-   AC_MSG_CHECKING(whether gettimeofday() gives timezone)
-   AC_CACHE_VAL([hdf5_cv_gettimeofday_tz],
-       [AC_TRY_RUN([
-          #include <time.h>
-          #include <sys/time.h>
-          int main(void)
-          {
-             struct timeval tv;
-             struct timezone tz;
-             tz.tz_minuteswest = 7777;  /* Initialize to an unreasonable number */
-             tz.tz_dsttime = 7;
-             gettimeofday(&tv, &tz);
-                /* Check whether the function returned any value at all */
-             if(tz.tz_minuteswest == 7777 && tz.tz_dsttime == 7)
-                exit(1);
-             else exit (0);
-          }], [hdf5_cv_gettimeofday_tz=yes], [hdf5_cv_gettimeofday_tz=no],)])
-
-   if test ${hdf5_cv_gettimeofday_tz} = "yes"; then
-      AC_MSG_RESULT([yes])
-      AC_DEFINE([GETTIMEOFDAY_GIVES_TZ], [1],
-                [Define if gettimeofday() populates the tz pointer passed in])
-   else
-      AC_MSG_RESULT([no])
-   fi
-fi 
-
-dnl ----------------------------------------------------------------------
-dnl Does the struct stat have the st_blocks field?  This field is not Posix.
-dnl
-AC_MSG_CHECKING([for st_blocks in struct stat])
-AC_TRY_COMPILE([
-#include <sys/stat.h>],[struct stat sb; sb.st_blocks=0;],
-AC_DEFINE([HAVE_STAT_ST_BLOCKS], [1],
-          [Define if `struct stat' has the `st_blocks' field])
-AC_MSG_RESULT([yes]),
-AC_MSG_RESULT([no]))
-
-dnl ----------------------------------------------------------------------
-dnl How do we figure out the width of a tty in characters?
-dnl
-AC_CHECK_FUNCS(_getvideoconfig gettextinfo GetConsoleScreenBufferInfo)
-AC_CHECK_FUNCS(_scrsize ioctl)
-
-AC_MSG_CHECKING([for struct videoconfig])
-AC_TRY_COMPILE(,[struct videoconfig w; w.numtextcols=0;],
-AC_DEFINE([HAVE_STRUCT_VIDEOCONFIG], [1],
-          [Define if `struct videoconfig' is defined])
-AC_MSG_RESULT([yes]),
-AC_MSG_RESULT([no]))
-
-AC_MSG_CHECKING([for struct text_info])
-AC_TRY_COMPILE(, [struct text_info w; w.screenwidth=0;],
-AC_DEFINE([HAVE_STRUCT_TEXT_INFO], [1],
-          [Define if `struct text_info' is defined])
-AC_MSG_RESULT([yes]),
-AC_MSG_RESULT([no]))
-
-AC_MSG_CHECKING([for TIOCGWINSZ])
-AC_TRY_COMPILE([#include <sys/ioctl.h>],[int w=TIOCGWINSZ;],
-AC_DEFINE([HAVE_TIOCGWINSZ], [1],
-          [Define if the ioctl TIOGWINSZ is defined])
-AC_MSG_RESULT([yes]),
-AC_MSG_RESULT([no]))
-
-AC_MSG_CHECKING([for TIOCGETD])
-AC_TRY_COMPILE([#include <sys/ioctl.h>],[int w=TIOCGETD;],
-AC_DEFINE([HAVE_TIOCGETD], [1],
-          [Define if the ioctl TIOCGETD is defined])
-AC_MSG_RESULT([yes]),
-AC_MSG_RESULT([no]))
-
-
-dnl ----------------------------------------------------------------------
-dnl Check for functions.
-dnl
-AC_CHECK_FUNCS(alarm BSDgettimeofday fork frexpf frexpl)
-AC_CHECK_FUNCS(gethostname getpwuid getrusage lstat)
-AC_CHECK_FUNCS(rand_r random setsysinfo)
-AC_CHECK_FUNCS(signal longjmp setjmp siglongjmp sigsetjmp sigprocmask)
-AC_CHECK_FUNCS(snprintf srandom strdup symlink system)
-AC_CHECK_FUNCS(tmpfile vasprintf waitpid)
-
-dnl Check for vsnprintf() separately, so we can detect situations where it
-dnl doesn't return the correct size for formatted strings that are too large
-dnl for the buffer provided
-AC_CHECK_FUNCS(vsnprintf,
-
-    dnl Check if vsnprintf() returns correct size for strings that don't fit
-    dnl into the size allowed.  If vsnprintf() works correctly on this platform,
-    dnl it should return a value of 42 for the test below
-    dnl
-    dnl Note that vsnprintf fails in two different ways:
-    dnl         - In IRIX64, calls to vnsprintf() with a formatted string that
-    dnl                 is larger than the buffer size allowed incorrectly
-    dnl                 return the size of the buffer minus one.
-    dnl         - In HP/UX, calls to vsnprintf() with a formatted string that
-    dnl                 is larger than the buffer size allowed incorrectly
-    dnl                 return (-1)
-    AC_MSG_CHECKING([if vsnprintf returns correct value])
-
-    AC_CACHE_VAL([hdf5_cv_vsnprintf_works],
-        AC_TRY_RUN([
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-
-int test_vsnprintf(const char *fmt,...)
-{
-    va_list     ap;
-    char *s = malloc(16);
-    int ret;
-
-    va_start(ap, fmt);
-    ret=vsnprintf(s,16,"%s",ap);
-    va_end(ap);
-
-    return(ret!=42 ? 1 : 0);
-}
-
-int main(void)
-{
-    exit(test_vsnprintf("%s","A string that is longer than 16 characters"));
-}
-   ],[hdf5_cv_vsnprintf_works=yes],[hdf5_cv_vsnprintf_works=no],))
-
-       if test ${hdf5_cv_vsnprintf_works} = "yes"; then
-          AC_MSG_RESULT([yes])
-          AC_DEFINE([VSNPRINTF_WORKS], [1],
-                    [Define if vsnprintf() returns the correct value for formatted strings that don't fit into size allowed])
-       else
-          AC_MSG_RESULT([no])
-       fi
-    ,)
-
-dnl ----------------------------------------------------------------------
-dnl Check that a lone colon can be used as an argument
-dnl This is not true on Cray X1, which interprets a lone colon as a
-dnl system command.
-dnl
-AC_CACHE_CHECK([if lone colon can be used as an argument],
-               [hdf5_cv_lone_colon],
-               [
-  echo "int main(int argc, char * argv[]) {return 0;}" > conftest.c
-  $CC $CFLAGS conftest.c > /dev/null 2> /dev/null
-  echo "./a.out :" > conftest.sh
-  chmod 700 conftest.sh
-
-  ./conftest.sh 2> conftest.out
-  rm a.out
-  TEST_OUTPUT=`cat conftest.out`
-
-  if test "X$TEST_OUTPUT" = "X"; then
-    hdf5_cv_lone_colon=yes
-  else
-    hdf5_cv_lone_colon=no
-  fi
-               ])
-
-AC_SUBST(H5_LONE_COLON) H5_LONE_COLON="$hdf5_cv_lone_colon"
-
-dnl ----------------------------------------------------------------------
-dnl Check compiler characteristics
-dnl
-AC_C_CONST
-AC_C_INLINE
-
-AC_MSG_CHECKING([for __attribute__ extension])
-AC_TRY_COMPILE(,[int __attribute__((unused)) x],
-               AC_DEFINE([HAVE_ATTRIBUTE], [1],
-                         [Define if the __attribute__(()) extension is present])
-               AC_MSG_RESULT([yes]),
-               AC_MSG_RESULT([no]))
-
-AC_MSG_CHECKING([for __func__ extension])
-AC_TRY_COMPILE(,[ const char *fname = __func__; ],
-               AC_DEFINE([HAVE_C99_FUNC], [1],
-                         [Define if the compiler understands the __func__ keyword])
-               AC_MSG_RESULT([yes]),
-               AC_MSG_RESULT([no]))
-AC_MSG_CHECKING([for __FUNCTION__ extension])
-AC_TRY_COMPILE(,[ const char *fname = __FUNCTION__; ],
-               AC_DEFINE([HAVE_FUNCTION], [1],
-                         [Define if the compiler understands the __FUNCTION__ keyword])
-               AC_MSG_RESULT([yes]),
-               AC_MSG_RESULT([no]))
-AC_MSG_CHECKING([for C99 designated initialization support])
-AC_TRY_COMPILE(,[
-                typedef struct {
-                    int x;
-                    union {
-                        int i;
-                        double d;
-                    } u;
-                } di_struct_t;
-                di_struct_t x = {0, { .d = 0.0}}; ],
-               AC_DEFINE([HAVE_C99_DESIGNATED_INITIALIZER], [1],
-                         [Define if the compiler understands C99 designated initialization of structs and unions])
-               AC_MSG_RESULT([yes]),
-               AC_MSG_RESULT([no]))
-
-dnl ----------------------------------------------------------------------
-dnl Try to figure out how to print `long long'.  Some machines use `%lld'
-dnl and others use `%qd'.  There may be more!  The final `l' is a
-dnl default in case none of the others work.
-dnl Need to patch up LD_LIBRARY_PATH so that the execution can find all
-dnl the dynamic library.  The correct way to do it should be updating
-dnl LD_LIBRARY_PATH along with LDFLAGS or do it with the AC_TRY_RUN macro.
-dnl
-AC_MSG_CHECKING([how to print long long])
-AC_CACHE_VAL([hdf5_cv_printf_ll],
-LD_LIBRARY_PATH="$LD_LIBRARY_PATH`echo $AM_LDFLAGS $LDFLAGS | sed -e 's/-L/:/g' -e 's/ //g'`"
-export LD_LIBRARY_PATH
-
-for hdf5_cv_printf_ll in l ll L q unknown; do
-   AC_TRY_RUN([
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-int main(void)
-{
-	char *s = malloc(128);
-	long long x = (long long)1048576 * (long long)1048576;
-	sprintf(s,"%${hdf5_cv_printf_ll}d",x);
-	exit(strcmp(s,"1099511627776"));
-}
-   ], break,,continue)
-done)dnl
-
-AC_MSG_RESULT([%${hdf5_cv_printf_ll}d and %${hdf5_cv_printf_ll}u])
-AC_DEFINE_UNQUOTED([PRINTF_LL_WIDTH], ["$hdf5_cv_printf_ll"], 
-                   [Width for printf() for type `long long' or `__int64', use `ll'])
-
-dnl ----------------------------------------------------------------------
-dnl Check if pthread_attr_setscope(&attribute, PTHREAD_SCOPE_SYSTEM)
-dnl is supported on this system
-dnl
-AC_MSG_CHECKING([Threads support system scope])
-AC_CACHE_VAL([hdf5_cv_system_scope_threads],
-[AC_TRY_RUN([
-#if STDC_HEADERS
-#include <stdlib.h>
-#include <pthread.h>
-#endif
-
-int main(void)
-{
-    pthread_attr_t attribute;
-    int ret;
-
-    pthread_attr_init(&attribute);
-    ret=pthread_attr_setscope(&attribute, PTHREAD_SCOPE_SYSTEM);
-    exit(ret==0 ? 0 : 1);
-}
-], [hdf5_cv_system_scope_threads=yes], [hdf5_cv_system_scope_threads=no],)])
-
-if test ${hdf5_cv_system_scope_threads} = "yes"; then
-  AC_DEFINE([SYSTEM_SCOPE_THREADS], [1],
-            [Define if your system supports pthread_attr_setscope(&attribute, PTHREAD_SCOPE_SYSTEM) call.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Checking to see if GPFS is available on this filesystem
-dnl
-AC_ARG_ENABLE([gpfs],
-              [AC_HELP_STRING([--enable-gpfs],
-                              [Enable GPFS hints for the MPI/POSIX file
-                               driver. [default=no]])],,
-              [enableval=no])
-
-case "X-$enableval" in
-  X-yes)
-    AC_CHECK_HEADERS([gpfs.h],
-                     AC_MSG_CHECKING([for GPFS support])
-                     AC_TRY_COMPILE([#include <gpfs.h>],
-                                    [int fd = 0; gpfs_fcntl(fd, (void *)0);],
-                                    AC_DEFINE(HAVE_GPFS, 1,
-                                              [Define if we have GPFS support])
-                                    AC_MSG_RESULT([yes])
-                                    LIBS="$LIBS -lgpfs"
-                                    GPFS="yes",
-                                    AC_MSG_RESULT([no])
-                                    GPFS="no"))
-    ;;
-  X-no|*)
-    AC_MSG_CHECKING([for gpfs])
-    AC_MSG_RESULT([suppressed])
-    ;;
-esac
-   
-dnl ----------------------------------------------------------------------
-dnl Turn on debugging by setting compiler flags
-dnl This must come after the enable-production since it depends on production.
-dnl
-AC_MSG_CHECKING(for debug flags)
-AC_ARG_ENABLE([debug],
-              [AC_HELP_STRING([--enable-debug=all],
-                              [Turn on debugging in all packages. One may
-                               also specify a comma-separated list of
-                               package names without the leading H5 or
-                               the word no. The default is most packages
-			       if production is disabled; no if it is enabled.
-                               ])],
-              [DEBUG_PKG=$enableval])
-
-dnl Default to no if producton is enabled
-if test "X-$DEBUG_PKG" = X- ; then
-    if test "$enable_production" = yes ; then
-	DEBUG_PKG=no
-    else
-	DEBUG_PKG=yes
-    fi
-fi
-
-AC_SUBST([DEBUG_PKG])
-all_packages="ac,b,b2,d,e,f,g,hg,hl,i,mf,mm,o,p,s,t,v,z"
-case "X-$DEBUG_PKG" in
-  X-yes)
-    DEBUG_PKG="d,e,f,g,hg,i,mm,o,p,s,t,v,z"
-    H5_CPPFLAGS="$H5_CPPFLAGS -UNDEBUG"
-    AC_MSG_RESULT([default ($DEBUG_PKG)])
-    ;;
-  X-all)
-    DEBUG_PKG=$all_packages
-    H5_CPPFLAGS="$H5_CPPFLAGS -UNDEBUG"
-    AC_MSG_RESULT([all ($DEBUG_PKG)])
-    ;;
-  X-no|X-none)
-    AC_MSG_RESULT([none])
-    DEBUG_PKG=
-    H5_CPPFLAGS="$H5_CPPFLAGS -DNDEBUG"
-    ;;
-  *)
-    AC_MSG_RESULT([$DEBUG_PKG])
-    ;;
-esac
-
-if test -n "$DEBUG_PKG"; then
-  for pkg in `echo $DEBUG_PKG | ${TR} ${as_cr_letters}"," ${as_cr_LETTERS}" "`; do
-    H5_CPPFLAGS="$H5_CPPFLAGS -DH5${pkg}_DEBUG"
-  done
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Check if they would like the function stack support compiled in
-dnl
-AC_MSG_CHECKING([whether function stack tracking is enabled])
-AC_ARG_ENABLE([codestack],
-              [AC_HELP_STRING([--enable-codestack],
-                              [Enable the function stack tracing (for developer debugging).])],
-              [CODESTACK=$enableval])
-
-case "X-$CODESTACK" in
-  X-yes)
-      CODESTACK=yes
-      AC_MSG_RESULT([yes])
-      AC_DEFINE([HAVE_CODESTACK], [1],
-                [Define if the function stack tracing code is to be compiled in])
-    ;;
-  *)
-      CODESTACK=no
-      AC_MSG_RESULT([no])
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Check if they would like the metadata trace file code compiled in
-dnl
-AC_MSG_CHECKING([whether metadata trace file code is enabled])
-AC_ARG_ENABLE([metadata-trace-file],
-              [AC_HELP_STRING([--enable-metadata-trace-file],
-                              [Enable metadata trace file collection.])],
-              [METADATATRACEFILE=$enableval])
-
-case "X-$METADATATRACEFILE" in
-  X-yes)
-      METADATATRACEFILE=yes
-      AC_MSG_RESULT([yes])
-      AC_DEFINE([METADATA_TRACE_FILE], [1],
-                [Define if the metadata trace file code is to be compiled in])
-    ;;
-  *)
-      METADATATRACEFILE=no
-      AC_MSG_RESULT([no])
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Enable tracing of the API
-dnl This must come after the enable-debug since it depends on debug.
-dnl
-AC_SUBST([TRACE_API])
-AC_MSG_CHECKING([for API tracing]);
-AC_ARG_ENABLE([trace],
-              [AC_HELP_STRING([--enable-trace],
-                              [Enable API tracing capability. Default=no
-                               if debug is disabled.])],
-              TRACE=$enableval)
-
-dnl Default to no if debug is disabled
-if test "X-$TRACE" = X- ; then
-  if test -z "$DEBUG_PKG" ; then
-    TRACE=no
-  else
-    TRACE=yes
-  fi
-fi
-
-case "X-$TRACE" in
-  X-yes)
-    AC_MSG_RESULT([yes])
-    TRACE_API=yes
-    H5_CPPFLAGS="$H5_CPPFLAGS -DH5_DEBUG_API"
-    ;;
-  X-no|*)
-    AC_MSG_RESULT([no])
-    TRACE_API=no
-    H5_CPPFLAGS="$H5_CPPFLAGS -UH5_DEBUG_API"
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Enable instrumenting of the library's internal operations
-dnl This must come after the enable-debug since it depends on debug.
-dnl
-AC_SUBST([INSTRUMENT_LIBRARY])
-AC_MSG_CHECKING([for instrumented library]);
-AC_ARG_ENABLE([instrument],
-              [AC_HELP_STRING([--enable-instrument],
-                              [Enable library instrumentation of optimization
-                                tracing.  Default=no if debug is disabled.])],
-              INSTRUMENT=$enableval)
-
-dnl Default to no if debug is disabled
-if test "X-$INSTRUMENT" = X- ; then
-  if test -z "$DEBUG_PKG" ; then
-    INSTRUMENT=no
-  else
-    INSTRUMENT=yes
-  fi
-fi
-
-case "X-$INSTRUMENT" in
-  X-yes)
-    AC_MSG_RESULT([yes])
-    INSTRUMENT_LIBRARY=yes
-    AC_DEFINE([HAVE_INSTRUMENTED_LIBRARY], [1],
-              [Define if library will contain instrumentation to detect correct optimization operation])
-    ;;
-  X-no|*)
-    AC_MSG_RESULT([no])
-    INSTRUMENT_LIBRARY=no
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Check if they would like to securely clear file buffers before they are
-dnl     written.
-dnl
-AC_SUBST([CLEARFILEBUF])
-AC_MSG_CHECKING([whether to clear file buffers])
-AC_ARG_ENABLE([clear-file-buffers],
-              [AC_HELP_STRING([--enable-clear-file-buffers],
-                              [Securely clear file buffers before writing
-                              to file.  Default=yes.])],
-              [CLEARFILEBUF=$enableval])
-
-case "X-$CLEARFILEBUF" in
-  *)
-      CLEARFILEBUF=yes
-      AC_MSG_RESULT([yes])
-      AC_DEFINE([CLEAR_MEMORY], [1],
-                [Define if the memory buffers being written to disk should be
-                cleared before writing.])
-    ;;
-  X-no)
-      CLEARFILEBUF=no
-      AC_MSG_RESULT([no])
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Check if they would like to use a memory checking tool (like valgrind's
-dnl     'memcheck' tool, or Rational Purify, etc) and the library should be
-dnl     more scrupulous with it's memory operations.  Enabling this also
-dnl     disables the library's free space manager code.
-dnl
-AC_SUBST([USINGMEMCHECKER])
-AC_MSG_CHECKING([whether a memory checking tool will be used])
-AC_ARG_ENABLE([using-memchecker],
-              [AC_HELP_STRING([--enable-using-memchecker],
-                              [Enable this option if a memory allocation and/or
-                              bounds checking tool will be used on the HDF5
-                              library.  Enabling this causes the library to be
-                              more picky about it's memory operations and also
-                              disables the library's free space manager code.
-                              Default=no.])],
-              [USINGMEMCHECKER=$enableval])
-
-case "X-$USINGMEMCHECKER" in
-  X-yes)
-      USINGMEMCHECKER=yes
-      AC_MSG_RESULT([yes])
-      AC_DEFINE([USING_MEMCHECKER], [1],
-                [Define if a memory checking tool will be used on the library,
-                to cause library to be very picky about memory operations and
-                also disable the internal free list manager code.])
-    ;;
-  *)
-      USINGMEMCHECKER=no
-      AC_MSG_RESULT([no])
-    ;;
-esac
-
-dnl Checkpoint the cache
-AC_CACHE_SAVE
-
-dnl What header files and libraries do we have to look for for parallel
-dnl support?  For the most part, search paths are already specified with
-dnl CPPFLAGS and LDFLAGS or are known to the compiler.  If the user says
-dnl `--disable-parallel' but specifies a known parallel compiler (like mpicc
-dnl or mpcc) then parallel support is enabled but configure doesn't search
-dnl for any parallel header files or libraries.
-dnl
-AC_ARG_ENABLE([parallel],
-              [AC_HELP_STRING([--enable-parallel],
-                              [Search for MPI-IO and MPI support files])])
-
-dnl The --enable-parallel flag is not compatible with --enable-cxx.
-dnl If the user tried to specify both flags, throw an error, unless
-dnl they also provided the --enable-unsupported flag.
-if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
-  if test "X${HDF_CXX}" = "Xyes" -a "X${enable_parallel}" = "Xyes"; then
-    AC_MSG_ERROR([--enable-cxx and --enable-parallel flags are incompatible. Use --enable-unsupported to override this error.])
-  fi
-fi
-
-dnl --enable-parallel is also incompatible with --enable-threadsafe, unless
-dnl --enable-unsupported has been specified on the configure line.
-if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
-  if test "X${THREADSAFE}" = "Xyes" -a "X${enable_parallel}" = "Xyes"; then
-    AC_MSG_ERROR([--enable-threadsafe and --enable-parallel flags are incompatible. Use --enable-unsupported to override this error.])
-  fi
-fi
-
-dnl It's possible to build in parallel by specifying a parallel compiler
-dnl without using the --enable-parallel flag.  This isn't allowed with
-dnl C++ or threadsafe, either, unless the --enable-unsupported flag 
-dnl has also been specified.
-if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
-  if test "X${PARALLEL}" != "X" -a "X${enable_cxx}" = "Xyes" ; then
-    AC_MSG_ERROR([An MPI compiler is being used; --enable-cxx is not allowed. Use --enable-unsupported to override this error.])
-  fi
-  if test "X${PARALLEL}" != "X" -a "X${THREADSAFE}" = "Xyes"; then
-    AC_MSG_ERROR([An MPI compiler is being used; --enable-threadsafe is not allowed. Use --enable-unsupported to override this error.])
-  fi
-fi
-
-AC_MSG_CHECKING([for parallel support files])
-case "X-$enable_parallel" in
-  X-|X-no|X-none)
-    dnl Either we are not compiling for parallel or the header and
-    dnl library files and locations are known to the compiler (this is
-    dnl the case for a correct installation of mpicc for instance).
-    AC_MSG_RESULT([skipped])
-    ;;
-
-  X-yes)
-    dnl We want to compile a parallel library with a compiler that
-    dnl may already know how to link with MPI and MPI-IO.
-    AC_MSG_RESULT([provided by compiler])
-    PARALLEL=yes
-
-    dnl Try link a simple MPI program.  If fail, try again with -lmpi and
-    dnl -lmpich.
-    AC_TRY_LINK(, MPI_Init(),, \
-	AC_CHECK_LIB(mpi, MPI_Init,, \
-	    AC_CHECK_LIB(mpich, MPI_Init,, PARALLEL=no)))
-
-    dnl Then try link a simple MPI-IO program. If fail, try again with
-    dnl -lmpio.
-    if test "X$PARALLEL" = "Xyes"; then
-      AC_TRY_LINK(, [MPI_File_open()],,
-                  [AC_CHECK_LIB([mpio], [MPI_File_open],, [PARALLEL=no])])
-    fi
-
-    if test "X$HDF_FORTRAN" = "Xyes"; then
-      dnl Change to the Fortran 90 language
-      AC_LANG_PUSH(Fortran)
-
-      dnl Try link a simple MPI program.  If fail, try again with -lmpi.
-      AC_LINK_IFELSE([
-          program main
-          include 'mpif.h'
-          integer:: ierr
-          call mpi_file_open( ierr )
-          end],,
-          AC_CHECK_LIB(mpi, [
-            include 'mpif.h'
-            integer:: ierr
-            call mpi_file_open( ierr )],, PARALLEL=no))
-
-      dnl Then try link a simple MPI-IO program.  If fail, try again with
-      dnl -lmpio.
-      if test "X$PARALLEL" = "Xyes"; then
-        AC_LINK_IFELSE([
-            program main
-            include 'mpif.h'
-            integer:: ierr
-            call mpi_file_open( ierr )
-            end],,
-            AC_CHECK_LIB(mpio, [
-              include 'mpif.h'
-              integer:: ierr
-              call mpi_file_open( ierr )],, PARALLEL=no))
-      fi
-
-      dnl Change to the C language
-      AC_LANG_POP(Fortran)
-    fi
-
-    dnl Set RUNPARALLEL to mpiexec if not set yet.
-    dnl Check for building on Cray if RUNPARALLEL is not yet set by checking
-    dnl for 'aprun' command (which is the parallel job launcher, like mpiexec).
-    if test "X$PARALLEL" = "Xyes" -a -z "$RUNPARALLEL"; then
-        dnl Find the path where aprun is located.
-  	for path in `echo $PATH | ${TR} ":" " "`; do
-  	  if test -x $path/aprun; then
-            RUNPARALLEL="aprun -q -n \$\${NPROCS:=6}"
-  	    break;
-  	  fi
-	done
-    fi
-
-    dnl Set RUNPARALLEL to mpiexec if not set yet.
-    if test "X$PARALLEL" = "Xyes" -a -z "$RUNPARALLEL"; then
-      RUNPARALLEL="mpiexec -n \$\${NPROCS:=6}"
-    fi
-    ;;
-
-  *)
-    AC_MSG_RESULT([error])
-    AC_MSG_ERROR([\'$enable_parallel\' is not a valid parallel search type])
-    ;;
-esac
-
-dnl ----------------------------------------------------------------------
-dnl Print some other parallel information and do some sanity checks.
-dnl
-AC_SUBST([ADD_PARALLEL_FILES]) ADD_PARALLEL_FILES="no"
-
-if test -n "$PARALLEL"; then
-  dnl The 'testpar' directory should participate in the build
-  TESTPARALLEL=testpar
-
-  dnl We are building a parallel library
-  AC_DEFINE([HAVE_PARALLEL], [1], [Define if we have parallel support])
-
-  dnl Display what we found about running programs
-  AC_MSG_CHECKING([prefix for running on one processor])
-  AC_MSG_RESULT([$RUNSERIAL])
-  AC_MSG_CHECKING([prefix for running in parallel])
-  AC_MSG_RESULT([$RUNPARALLEL])
-
-  dnl Check that we can link a simple MPI and MPI-IO application
-  AC_MSG_CHECKING([whether a simple MPI-IO program can be linked])
-  AC_TRY_LINK(, [MPI_Init(); MPI_File_open();],
-              AC_MSG_RESULT([yes]),
-              AC_MSG_RESULT([no])
-              AC_MSG_ERROR([unable to link a simple MPI-IO application]))
-
-  dnl There *must* be some way to run in parallel even if it's just the
-  dnl word `none'.
-  if test -z "$RUNPARALLEL"; then
-    AC_MSG_ERROR([no way to run a parallel program])
-  fi
-
-  dnl If RUNSERIAL or RUNPARALLEL is the word `none' then replace it with
-  dnl the empty string.
-  if test "X$RUNSERIAL" = "Xnone"; then
-    RUNSERIAL=""
-  fi
-  if test "X$RUNPARALLEL" = "Xnone"; then
-    RUNPARALLEL=""
-  fi
-
-  if test "X$HDF_FORTRAN" = "Xyes"; then
-    ADD_PARALLEL_FILES="yes"
-    AC_MSG_CHECKING([for MPI_Comm_c2f and MPI_Comm_f2c functions])
-
-    AC_TRY_LINK([#include <mpi.h>],
-      [MPI_Comm c_comm; MPI_Comm_c2f(c_comm)],
-      AC_DEFINE([HAVE_MPI_MULTI_LANG_Comm], [1],
-                [Define if `MPI_Comm_c2f' and `MPI_Comm_f2c' exists])
-      AC_MSG_RESULT([yes]),
-      AC_MSG_RESULT([no])
-    )
-
-    AC_MSG_CHECKING([for MPI_Info_c2f and MPI_Info_f2c functions])
-    AC_TRY_LINK([#include <mpi.h>],
-      [MPI_Info c_info; MPI_Info_c2f(c_info)],
-      AC_DEFINE([HAVE_MPI_MULTI_LANG_Info], [1],
-                [Define if `MPI_Info_c2f' and `MPI_Info_f2c' exists])
-      AC_MSG_RESULT([yes]),
-      AC_MSG_RESULT([no])
-    )
-  fi
-
-  dnl --------------------------------------------------------------------
-  dnl Do we want MPE instrumentation feature on?
-  dnl
-  dnl This must be done after enable-parallel is checked since it depends
-  dnl on a mpich compiler.
-  dnl
-  MPE=yes
-  AC_ARG_WITH([mpe],
-              [AC_HELP_STRING([--with-mpe=DIR],
-                              [Use MPE instrumentation [default=no]])],,
-              [withval=no])
-
-  case "X-$withval" in
-    X-|X-no|X-none)
-      AC_MSG_CHECKING([for MPE])
-      AC_MSG_RESULT([suppressed])
-      unset MPE
-      ;;
-    X-yes)
-      AC_CHECK_HEADERS([mpe.h],, [unset MPE])
-      AC_CHECK_LIB([mpe], [MPE_Init_log],, [unset MPE])
-      AC_CHECK_LIB([lmpe], [CLOG_Init],, [unset MPE])
-      ;;
-    *)
-      case "$withval" in
-        *,*)
-          mpe_inc="`echo $withval | cut -f1 -d,`"
-          mpe_lib="`echo $withval | cut -f2 -d, -s`"
-          ;;
-        *)
-          if test -n "$withval"; then
-            mpe_inc="$withval/include"
-            mpe_lib="$withval/lib"
-          fi
-          ;;
-      esac
-  
-      dnl Trying to include -I/usr/include and -L/usr/lib is redundant and
-      dnl can mess some compilers up.
-      if test "X$mpe_inc" = "X/usr/include"; then
-        mpe_inc=""
-      fi
-      if test "X$mpe_lib" = "X/usr/lib"; then
-        mpe_lib=""
-      fi
-  
-      if test -n "$mpe_inc"; then
-        saved_CPPFLAGS="$CPPFLAGS"
-        saved_AM_CPPFLAGS="$AM_CPPFLAGS"
-        CPPFLAGS="$CPPFLAGS -I$mpe_inc"
-        AM_CPPFLAGS="$AM_CPPFLAGS -I$mpe_inc"
-        AC_CHECK_HEADERS([mpe.h],, [CPPFLAGS="$saved_CPPFLAGS"; AM_CPPFLAGS="$saved_AM_CPPFLAGS"; unset MPE])
-      else
-        AC_CHECK_HEADERS([mpe.h],, [unset MPE])
-      fi
-  
-      if test -n "$mpe_lib"; then
-        saved_LDFLAGS="$LDFLAGS"
-        saved_AM_LDFLAGS="$AM_LDFLAGS"
-        LDFLAGS="$LDFLAGS -L$mpe_lib"
-        AM_LDFLAGS="$AM_LDFLAGS -L$mpe_lib"
-        AC_CHECK_LIB([mpe], [MPE_Init_log],,
-                     [LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset MPE])
-        AC_CHECK_LIB([lmpe], [CLOG_Init],,
-                     [LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset MPE])
-
-      else
-        AC_CHECK_LIB([mpe], [MPE_Init_log],, [unset MPE])
-        AC_CHECK_LIB([lmpe], [CLOG_Init],, [unset MPE])
-      fi
-      ;;
-  esac
-
-  if test "X-$MPE" = "X-yes"; then
-    AC_DEFINE([HAVE_MPE], [1], [Define if we have MPE support])
-  fi
-
-  dnl ----------------------------------------------------------------------
-  dnl Set the flag to indicate that the MPI_File_set_size() function
-  dnl works with files over 2GB, unless it's already set in the cache.
-  dnl (This flag should be set for all machines, except for ASCI Red, where
-  dnl the cache value is set in it's config file)
-  dnl
-  AC_MSG_CHECKING([if MPI_File_set_size works for files over 2GB])
-  AC_CACHE_VAL([hdf5_cv_mpi_file_set_size_big], [hdf5_cv_mpi_file_set_size_big=yes])
-  
-  if test ${hdf5_cv_mpi_file_set_size_big} = "yes"; then
-    AC_DEFINE([MPI_FILE_SET_SIZE_BIG], [1],
-              [Define if your system's `MPI_File_set_size' function works for files over 2GB.])
-    AC_MSG_RESULT([yes])
-  else
-    AC_MSG_RESULT([no])
-  fi
-
-  dnl ----------------------------------------------------------------------
-  dnl Set the flag to indicate that the MPI_File_get_size() function
-  dnl works.  The default is enabled unless the user knows the function
-  dnl doesn't work on the system and disables it.  (This flag should be set
-  dnl for all machines except for SGI Altix Propack 4 where the function 
-  dnl doesn't return correct file size.)
-  dnl
-  AC_ARG_ENABLE([mpi-size],
-                [AC_HELP_STRING([--enable-mpi-size],
-                                [Some systems (only SGI Altix Propack 4 so far) return wrong value
-                                 from MPI_File_get_size.  By disabling this function, the library
-                                 will replace it with stat to get the correct file size.
-                                 [default=yes]])],
-                [MPI_GET_SIZE=$enableval])
-
-  AC_MSG_CHECKING([if MPI_File_get_size is enabled])
-
-  AC_SUBST(MPI_GET_SIZE)
-  case "X-$MPI_GET_SIZE" in
-    X-no)
-      AC_MSG_RESULT([no])
-      MPI_GET_SIZE=no
-      ;;
-    X-yes|*)
-      AC_MSG_RESULT([yes])
-      MPI_GET_SIZE=yes
-      AC_DEFINE([HAVE_MPI_GET_SIZE], [1],
-                [Define if MPI_File_get_size works correctly])
-      ;;
-  esac
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Turn on internal I/O filters by setting macros in header files
-dnl Internal I/O filters are contained entirely within the library and do
-dnl not depend on external headers or libraries.  The shuffle filter is
-dnl an example of an internal filter, while the gzip filter is an example of
-dnl an external filter.  Each external filter is controlled with an
-dnl "--with-foo=" configure flag.
-dnl
-AC_SUBST([FILTERS])
-AC_SUBST(USE_FILTER_SHUFFLE) USE_FILTER_SHUFFLE="no"
-AC_SUBST(USE_FILTER_FLETCHER32) USE_FILTER_FLETCHER32="no"
-AC_SUBST(USE_FILTER_NBIT) USE_FILTER_NBIT="no"
-AC_SUBST(USE_FILTER_SCALEOFFSET) USE_FILTER_SCALEOFFSET="no"
-AC_MSG_CHECKING([for I/O filters])
-AC_ARG_ENABLE([filters],
-              [AC_HELP_STRING([--enable-filters=all],
-                              [Turn on all internal I/O filters. One may
-                               also specify a comma-separated list of filters
-                               or the word no.  The default is all internal
-                               I/O filters.])],
-              [FILTERS=$enableval])
-
-dnl Eventually: all_filters="shuffle,foo,bar,baz"
-all_filters="shuffle,fletcher32,nbit,scaleoffset"
-case "X-$FILTERS" in
-  X-|X-all)
-    FILTERS=$all_filters
-    AC_MSG_RESULT([all ($FILTERS)])
-    ;;
-  X-no|X-none)
-    AC_MSG_RESULT([none])
-    FILTERS="none"
-    ;;
-  *)
-    AC_MSG_RESULT([$FILTERS])
-    ;;
-esac
-
-if test -n "$FILTERS"; then
-  for filter in `echo $FILTERS | tr ${as_cr_letters}',' ${as_cr_LETTERS}' '`; do
-    dnl ------------------------------------------------------------------
-    dnl Have to use separate 'if' construct for each filter, so that
-    dnl autoheader can detect the AC_DEFINE for each one...
-    dnl
-    if test $filter = "SHUFFLE"; then
-      AC_DEFINE([HAVE_FILTER_SHUFFLE], [1],
-                [Define if support for shuffle filter is enabled])
-      USE_FILTER_SHUFFLE="yes"
-    fi
-    if test $filter = "FLETCHER32"; then
-      AC_DEFINE([HAVE_FILTER_FLETCHER32], [1],
-                [Define if support for Fletcher32 checksum is enabled])
-      USE_FILTER_FLETCHER32="yes"
-    fi
-    if test $filter = "NBIT"; then
-      AC_DEFINE([HAVE_FILTER_NBIT], [1],
-                [Define if support for nbit filter is enabled])
-      USE_FILTER_NBIT="yes"
-    fi
-    if test $filter = "SCALEOFFSET"; then
-      AC_DEFINE([HAVE_FILTER_SCALEOFFSET], [1],
-                [Define if support for scaleoffset filter is enabled])
-      USE_FILTER_SCALEOFFSET="yes"
-    fi
-  done
-fi
-
-dnl ----------------------------------------------------------------------
-dnl This is defined only when we're using CodeWarrior, since it has a
-dnl broken "open()" call.
-dnl
-if test 1 = 2; then
-  AC_DEFINE([NO_SHARED_WRITING], [1],
-            [Define if shared writing must be disabled (CodeWarrior only)])
-fi
-
-dnl --------------------------------------------------------------------------
-dnl Should the Default Virtual File Driver be compiled?
-dnl
-
-AC_MSG_CHECKING([for Default Virtual File Driver definition])
-AC_ARG_WITH([default-vfd],
-            [AC_HELP_STRING([--with-default-vfd=driver],
-                            [Specify default file driver
-                             [default=sec2]])],,
-            withval=sec2)
-
-if test "X$withval" = "Xsec2"; then
-    AC_MSG_RESULT([yes])
-    default_vfd=yes
-    vfd_define=H5FD_SEC2
-elif test "X$withval" = "Xstdio"; then
-    AC_MSG_RESULT([yes])
-    default_vfd=yes
-    vfd_define=H5FD_STDIO
-else
-    AC_MSG_RESULT([no])
-    default_vfd=no
-fi
-
-if test "X$default_vfd" = "Xyes"; then
-  AC_DEFINE_UNQUOTED([DEFAULT_VFD], [$vfd_define],
-            [Define the default virtual file driver to compile])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Check if Direct I/O driver is enabled by --enable-direct-vfd
-dnl
-
-AC_MSG_CHECKING([for Direct Virtual File Driver support])
-
-AC_ARG_ENABLE([direct-vfd],
-              [AC_HELP_STRING([--enable-direct-vfd],
-                              [Build the Direct I/O Virtual File Driver
-                               [default=yes]])],
-              [DIRECT_VFD=$enableval], [DIRECT_VFD=yes])
-
-if test "$DIRECT_VFD" = "yes"; then
-   AC_CACHE_VAL([hdf5_cv_direct_io],
-       [AC_TRY_RUN([
-	  #include <sys/types.h>
-	  #include <sys/stat.h>
-	  #include <fcntl.h>
-          int main(void)
-          {
-             int fid; 
-             if((fid=open("tst_file", O_CREAT | O_TRUNC | O_DIRECT, 0755))<0)
-		exit(1);
-             close(fid);  
-             remove("tst_file"); 
-             exit (0);
-          }], AC_TRY_LINK(, [posix_memalign()], [hdf5_cv_direct_io=yes], [hdf5_cv_direct_io=no]), [hdf5_cv_direct_io=no],)])
-
-   if test ${hdf5_cv_direct_io} = "yes"; then
-      AC_MSG_RESULT([yes])
-      AC_DEFINE([HAVE_DIRECT], [1],
-                [Define if the direct I/O virtual file driver should be compiled])
-   else
-      AC_MSG_RESULT([no])
-      DIRECT_VFD=no
-   fi
-else
-      AC_MSG_RESULT([suppressed])
-fi
-
-AM_CONDITIONAL([DIRECT_VFD_CONDITIONAL], [test "X$DIRECT_VFD" = "Xyes"])
-
-dnl ----------------------------------------------------------------------
-dnl Decide whether the presence of user's exception handling functions is
-dnl checked and data conversion exceptions are returned.  This is mainly
-dnl for the speed optimization of hard conversions.  Soft conversions can
-dnl actually benefit little.  
-dnl
-AC_MSG_CHECKING([whether exception handling functions is checked during data conversions])
-AC_ARG_ENABLE([dconv-exception],
-              [AC_HELP_STRING([--enable-dconv-exception],
-                              [if exception handling functions is checked during 
-                              data conversions [default=yes]])],
-              [DCONV_EXCEPTION=$enableval], [DCONV_EXCEPTION=yes])
-
-if test "$DCONV_EXCEPTION" = "yes"; then
-  AC_MSG_RESULT([yes])
-  AC_DEFINE([WANT_DCONV_EXCEPTION], [1],
-            [Check exception handling functions during data conversions])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Decide whether the data accuracy has higher priority during data
-dnl conversions.  If not, some hard conversions will still be prefered even
-dnl though the data may be wrong (for example, some compilers don't 
-dnl support denormalized floating values) to maximize speed.
-dnl 
-AC_MSG_CHECKING([whether data accuracy is guaranteed during data conversions])
-AC_ARG_ENABLE([dconv-accuracy],
-              [AC_HELP_STRING([--enable-dconv-accuracy],
-                              [if data accuracy is guaranteed during 
-                              data conversions [default=yes]])],
-              [DATA_ACCURACY=$enableval], [DATA_ACCURACY=yes])
-
-if test "$DATA_ACCURACY" = "yes"; then
-  AC_MSG_RESULT([yes])
-  AC_DEFINE([WANT_DATA_ACCURACY], [1],
-            [Data accuracy is prefered to speed during data conversions])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can handle converting
-dnl denormalized floating-point values.
-dnl (This flag should be set for all machines, except for the Crays, where
-dnl the cache value is set in it's config file)
-dnl
-AC_MSG_CHECKING([if converting denormalized floating-point values is possible])
-AC_CACHE_VAL([hdf5_cv_convert_denormal_float], [hdf5_cv_convert_denormal_float=yes])
-
-if test ${hdf5_cv_convert_denormal_float} = "yes"; then
-  AC_DEFINE([CONVERT_DENORMAL_FLOAT], [1],
-            [Define if your system can handle converting denormalized floating-point values.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can handle converting
-dnl floating-point to long long values.
-dnl (This flag should be _unset_ for all machines, except for Windows, where
-dnl it's set in the custom Windows H5pubconf.h file)
-dnl
-AC_MSG_CHECKING([if converting floating-point values to long long is not working])
-AC_CACHE_VAL([hdf5_cv_convert_float_llong_not_works], [hdf5_cv_convert_float_llong_not_works=no])
-
-if test ${hdf5_cv_convert_float_llong_not_works} = "yes"; then
-  AC_DEFINE([HW_FP_TO_LLONG_NOT_WORKS], [1],
-            [Define if your system can't handle converting floating-point values to long long.])
-  AC_MSG_RESULT([true])
-else
-  AC_MSG_RESULT([false])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine has window style pathname,
-dnl that is, "drive-letter:\" (e.g. "C:") or "drive-letter:/" (e.g. "C:/").
-dnl (This flag should be _unset_ for all machines, except for Windows, where
-dnl it's set in the custom Windows H5pubconf.h file)
-dnl
-AC_MSG_CHECKING([if the machine has window style path name])
-
-case "`uname`" in
-  MINGW*)
-    AC_DEFINE([HAVE_WINDOW_PATH], [1],
-              [Define if your system has window style path name.])
-    AC_MSG_RESULT([yes])
-    ;;
-  *)
-    AC_MSG_RESULT([no])
-    ;;
-esac
-
-dnl -----------------------------------------------------------------------
-dnl Set flag to indicate that the machine can handle conversion from 
-dnl long double to integers accurately.  This flag should be set "yes" for 
-dnl all machines except all SGIs.  For SGIs, some conversions are
-dnl incorrect and its cache value is set "no" in its config/irix6.x and 
-dnl irix5.x.
-dnl
-AC_MSG_CHECKING([if converting from long double to integers is accurate])
-
-if test ${ac_cv_sizeof_long_double} = 0; then
-   hdf5_cv_ldouble_to_integer_accurate=${hdf5_cv_ldouble_to_integer_accurate=no}
-else
-   AC_CACHE_VAL([hdf5_cv_ldouble_to_integer_accurate], [hdf5_cv_ldouble_to_integer_accurate=yes])
-fi
-
-if test "${hdf5_cv_ldouble_to_integer_accurate}" = "yes"; then
-  AC_DEFINE([LDOUBLE_TO_INTEGER_ACCURATE], [1],
-            [Define if your system can convert long double to integers accurately.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl -----------------------------------------------------------------------
-dnl Set flag to indicate that the machine can do conversion from 
-dnl long double to integers regardless of accuracy.  This flag should be 
-dnl set "yes" for all machines except HP-UX 11.00.  For HP-UX 11.00, the
-dnl compiler has 'floating exception' when converting 'long double' to all 
-dnl integers except 'unsigned long long'.  Other HP-UX systems are unknown
-dnl yet. (1/8/05 - SLU)
-
-AC_MSG_CHECKING([if converting from long double to integers works])
-
-if test ${ac_cv_sizeof_long_double} = 0; then
-   hdf5_cv_ldouble_to_integer_works=${hdf5_cv_ldouble_to_integer_works=no}
-else
-   AC_CACHE_VAL([hdf5_cv_ldouble_to_integer_works],
-        [AC_TRY_RUN([
-        int main(void)
-        {
-            void *align;
-            long double ld= 9701917572145405952.00L;
-            unsigned char v1;
-            short v2;
-            unsigned int v3;
-            int  ret = 0;
-
-            align = (void*)malloc(sizeof(long double));
-            memcpy(align, &ld, sizeof(long double));
-
-            /*For HU-UX11.00, there's floating exception(core dump) when doing some of casting
-             *from 'long double' to integers*/
-            v1=(unsigned char)(*((long double*)align));
-            v2=(short)(*((long double*)align));
-            v3=(unsigned int)(*((long double*)align));
-
-    done:
-            exit(ret);
-        }
-        ], [hdf5_cv_ldouble_to_integer_works=yes], [hdf5_cv_ldouble_to_integer_works=no],)])
-fi
-
-if test ${hdf5_cv_ldouble_to_integer_works} = "yes"; then
-  AC_DEFINE([LDOUBLE_TO_INTEGER_WORKS], [1],
-            [Define if your system can convert from long double to integer values.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl -----------------------------------------------------------------------
-dnl Set flag to indicate that the machine can handle conversion from 
-dnl integers to long double.  (This flag should be set "yes" for all 
-dnl machines except all SGIs, where some conversions are
-dnl incorrect and its cache value is set "no" in its config/irix6.x and 
-dnl irix5.x) 
-dnl
-AC_MSG_CHECKING([if accurately converting from integers to long double])
-
-if test ${ac_cv_sizeof_long_double} = 0; then
-   hdf5_cv_integer_to_ldouble_accurate=${hdf5_cv_integer_to_ldouble_accurate=no}
-else
-   AC_CACHE_VAL([hdf5_cv_integer_to_ldouble_accurate], [hdf5_cv_integer_to_ldouble_accurate=yes])
-fi
-
-if test ${hdf5_cv_integer_to_ldouble_accurate} = "yes"; then
-  AC_DEFINE([INTEGER_TO_LDOUBLE_ACCURATE], [1],
-            [Define if your system can accurately convert from integers to long double values.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can accurately convert
-dnl 'unsigned long' to 'float' values.
-dnl (This flag should be set for all machines, except for Pathscale compiler
-dnl on Sandia's Linux machine where the compiler interprets 'unsigned long'
-dnl values as negative when the first bit of 'unsigned long' is on during 
-dnl the conversion to float.) 
-dnl
-AC_MSG_CHECKING([if accurately converting unsigned long to float values])
-
-AC_CACHE_VAL([hdf5_cv_ulong_to_float_accurate],
-    [AC_TRY_RUN([
-    int main(void)
-    {
-        int           ret = 0;
-        unsigned long l1;
-        unsigned long l2;
-        unsigned long l3;
-        float f1;
-        float f2;
-        float f3;
-
-
-        if(sizeof(unsigned long)==8) {
-            l1 = 0xffffffffffffffffUL;
-            l2 = 0xffffffffffff0000UL;
-            l3 = 0xf000000000000000UL;
-
-            f1 = (float)l1;
-            f2 = (float)l2;
-            f3 = (float)l3;
-
-            if((f1 < 0) || (f2 < 0) || (f3 < 0))
-                ret = 1;
-        }
-
-done:
-        exit(ret);
-    }
-    ], [hdf5_cv_ulong_to_float_accurate=yes], [hdf5_cv_ulong_to_float_accurate=no],)])
-
-if test ${hdf5_cv_ulong_to_float_accurate} = "yes"; then
-  AC_DEFINE([ULONG_TO_FLOAT_ACCURATE], [1],
-            [Define if your system accurately converting unsigned long to float values.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can accurately convert
-dnl 'unsigned (long) long' values to 'float' and 'double' values.
-dnl (This flag should be set for all machines, except for the SGIs, where
-dnl the cache value is set in the config/irix6.x config file) and Solaris
-dnl 64-bit machines, where the short program below tests if round-up is 
-dnl correctly handled.
-dnl
-AC_MSG_CHECKING([if accurately converting unsigned long long to floating-point values])
-
-if test ${host_os_novers} = "solaris2.x"; then
-    AC_CACHE_VAL([hdf5_cv_ulong_to_fp_bottom_bit_accurate],
-    [AC_TRY_RUN([
-    int main(void)
-    {
-        unsigned long l1;
-        unsigned long l2;
-        unsigned long l3;
-        unsigned long l4;
-        unsigned long long ld1;
-        unsigned long long ld2;
-        unsigned long long ld3;
-        unsigned long long ld4;
-        double        d1, d2, d3, d4;
-        unsigned char s[8];
-        int           ret = 0;
-
-        if(sizeof(unsigned long)==8) {
-            l1 = 0xf000000000000b00UL; /*Round-down case*/
-            l2 = 0xf000000000000401UL; /*Round-up case*/
-            l3 = 0xf000000000000400UL; /*Round-down case*/
-            l4 = 0xf000000000000c00UL; /*Round-up case*/
-            
-            d1 = (double)l1;
-            d2 = (double)l2;
-            d3 = (double)l3;
-            d4 = (double)l4;
-        } else if(sizeof(unsigned long long)==8) { 
-            ld1 = 0xf000000000000b00ULL; /*Round-down case*/
-            ld2 = 0xf000000000000401ULL; /*Round-up case*/
-            ld3 = 0xf000000000000400ULL; /*Round-down case*/
-            ld4 = 0xf000000000000c00ULL; /*Round-up case*/
-            
-            d1 = (double)ld1;
-            d2 = (double)ld2;
-            d3 = (double)ld3;
-            d4 = (double)ld4;
-        } else {
-            ret = 1;
-            goto done;
-        }
-        
-        memcpy(s, &d1, 8);
-        if(s[7]!=1)
-            ret = 1;
-
-        memcpy(s, &d2, 8);
-        if(s[7]!=1)
-            ret = 1;
-
-        memcpy(s, &d3, 8);
-        if(s[7]!=0)
-            ret = 1;
-
-        memcpy(s, &d4, 8);
-        if(s[7]!=2)
-            ret = 1;
-
-done:
-        exit(ret);
-    }
-    ], [hdf5_cv_ulong_to_fp_bottom_bit_accurate=yes], [hdf5_cv_ulong_to_fp_bottom_bit_accurate=no],)])
-else
-    AC_CACHE_VAL([hdf5_cv_ulong_to_fp_bottom_bit_accurate], [hdf5_cv_ulong_to_fp_bottom_bit_accurate=yes])
-fi
-
-if test ${hdf5_cv_ulong_to_fp_bottom_bit_accurate} = "yes"; then
-  AC_DEFINE([ULONG_TO_FP_BOTTOM_BIT_ACCURATE], [1],
-            [Define if your system can accurately convert unsigned (long) long values to floating-point values.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can accurately convert
-dnl 'float' or 'double' to 'unsigned long long' values.
-dnl (This flag should be set for all machines, except for PGI compiler 
-dnl where round-up happens when the fraction of float-point value is greater 
-dnl than 0.5.
-dnl
-AC_MSG_CHECKING([if accurately roundup converting floating-point to unsigned long long values])
-
-AC_CACHE_VAL([hdf5_cv_fp_to_ullong_accurate],
-    [AC_TRY_RUN([
-    int main(void)
-    {
-        float  f = 111.60f;
-        double d = 222.55L;
-        unsigned long long l1 = (unsigned long long)f;
-        unsigned long long l2 = (unsigned long long)d;
-        int           ret = 0;
-
-        if(l1 == 112) 
-            ret = 1;
-        if(l2 == 223) 
-            ret = 1;
-
-done:
-        exit(ret);
-    }
-    ], [hdf5_cv_fp_to_ullong_accurate=yes], [hdf5_cv_fp_to_ullong_accurate=no],)])
-
-if test ${hdf5_cv_fp_to_ullong_accurate} = "yes"; then
-  AC_DEFINE([FP_TO_ULLONG_ACCURATE], [1],
-            [Define if your system roundup accurately converting floating-point to unsigned long long values.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can accurately convert
-dnl 'float', 'double' or 'long double' to 'unsigned long long' values.
-dnl (This flag should be set for all machines, except for HP-UX machines
-dnl where the maximal number for unsigned long long is 0x7fffffffffffffff
-dnl during conversion.
-dnl
-AC_MSG_CHECKING([if right maximum converting floating-point to unsigned long long values])
-
-AC_CACHE_VAL([hdf5_cv_fp_to_ullong_right_maximum],
-    [AC_TRY_RUN([
-    int main(void)
-    {
-        float  f = 9701917572145405952.00f;
-        double d1 = 9701917572145405952.00L;
-        long double d2 = 9701917572145405952.00L;
-        double d3 = 2e40L;
-        unsigned long long l1 = (unsigned long long)f;
-        unsigned long long l2 = (unsigned long long)d1;
-        unsigned long long l3 = (unsigned long long)d2;
-        unsigned long long l4;
-        unsigned long long l5 = 0x7fffffffffffffffULL;
-        int           ret = 0;
-
-        if(l1 <= l5 || l2 <= l5 || l3 <= l5) 
-            ret = 1;
-
-        l4 = (unsigned long long)d3;
-        if(l4 <= l5)
-            ret = 1;
-
-done:
-        exit(ret);
-    }
-    ], [hdf5_cv_fp_to_ullong_right_maximum=yes], [hdf5_cv_fp_to_ullong_right_maximum=no],)])
-
-if test ${hdf5_cv_fp_to_ullong_right_maximum} = "yes"; then
-  AC_DEFINE([FP_TO_ULLONG_RIGHT_MAXIMUM], [1],
-            [Define if your system has right maximum convert floating-point to unsigned long long values.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can accurately convert
-dnl 'long double' to 'unsigned int' values.  (This flag should be set for 
-dnl all machines, except for some Intel compilers on some Linux.)
-dnl
-AC_MSG_CHECKING([if correctly converting long double to unsigned int values])
-
-if test ${ac_cv_sizeof_long_double} = 0; then
-   hdf5_cv_ldouble_to_uint_accurate=${hdf5_cv_ldouble_to_uint_accurate=no}
-else
-   AC_CACHE_VAL([hdf5_cv_ldouble_to_uint_accurate],
-        [AC_TRY_RUN([
-        int main(void)
-        {
-            long double ld = 2733248032.9183987530L;
-            unsigned int i;
-            int           ret = 0;
-
-            i = (unsigned int)ld;
-            if(i!=2733248032 && i!=2733248031 && i!=2733248033)
-                ret = 1;
-
-    done:
-            exit(ret);
-        }
-        ], [hdf5_cv_ldouble_to_uint_accurate=yes], [hdf5_cv_ldouble_to_uint_accurate=no],)])
-fi
-
-if test ${hdf5_cv_ldouble_to_uint_accurate} = "yes"; then
-  AC_DEFINE([LDOUBLE_TO_UINT_ACCURATE], [1],
-            [Define if your system can convert long double to unsigned int values correctly.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can _compile_
-dnl 'unsigned long long' to 'float' and 'double' typecasts.
-dnl (This flag should be set for all machines, except for under Windows when
-dnl compiled with Visual Studio 6, where the macro value is set in the
-dnl src/H5pubconf.h file)
-dnl
-AC_MSG_CHECKING([if compiling unsigned long long to floating-point typecasts work])
-AC_CACHE_VAL([hdf5_cv_ullong_to_fp_cast_works], [hdf5_cv_ullong_to_fp_cast_works=yes])
-
-if test ${hdf5_cv_ullong_to_fp_cast_works} = "yes"; then
-  AC_DEFINE([ULLONG_TO_FP_CAST_WORKS], [1],
-            [Define if your system can compile unsigned long long to floating-point casts.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can _compile_
-dnl 'long long' to 'float' and 'double' typecasts.
-dnl (This flag should be set for all machines, except for under Windows when
-dnl compiled with Visual Studio 6, where the macro value is set in the
-dnl src/H5pubconf.h file)
-dnl
-AC_MSG_CHECKING([if compiling long long to floating-point typecasts work])
-AC_CACHE_VAL([hdf5_cv_llong_to_fp_cast_works], [hdf5_cv_llong_to_fp_cast_works=yes])
-
-if test ${hdf5_cv_llong_to_fp_cast_works} = "yes"; then
-  AC_DEFINE([LLONG_TO_FP_CAST_WORKS], [1],
-            [Define if your system can compile long long to floating-point casts.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can convert from
-dnl 'unsigned long long' to 'long double' without precision loss.
-dnl (This flag should be set for all machines, except for FreeBSD(sleipnir)
-dnl where the last 2 bytes of mantissa are lost when compiler tries to do 
-dnl the conversion, and Cygwin where compiler doesn't do rounding correctly.)
-dnl
-AC_MSG_CHECKING([if converting unsigned long long to long double with precision])
-
-if test ${ac_cv_sizeof_long_double} = 0; then
-   hdf5_cv_ullong_to_ldouble_precision=${hdf5_cv_ullong_to_ldouble_precision=no}
-else
-   AC_CACHE_VAL([hdf5_cv_ullong_to_ldouble_precision],
-        [AC_TRY_RUN([
-        #include <stdlib.h>
-        #include <string.h>
-
-        int main(void)
-        {
-            /* General variables */
-            int endian;
-            int tst_value = 1; 
-            int ret = 0;
-
-            /* For FreeBSD */
-            unsigned long long l = 0xa601e80bda85fcefULL;
-            long double ld;
-            unsigned char *c1, *c2;
-            size_t size;
-
-            /* For Cygwin */
-            unsigned long long l_cyg = 0xfffffffffffffff0ULL;
-            long double ld_cyg;
-            unsigned char *c2_cyg;
-            size_t size_cyg;
-            
-            
-            /* Determine this system's endianess */
-            c1 = (unsigned char*)calloc(1, sizeof(int));
-            memcpy((void*)c1, &tst_value, sizeof(int));
-            if(c1[0]==1)
-                endian = 0;  /* little endian */
-            else 
-                endian = 1;  /* big endian */
-            
-            /* For FreeBSD */     
-            size = sizeof(long double);
-            memset(&ld, 0, size); 
-            ld = (long double)l;
-
-            c2 = (unsigned char*)calloc(1, size);
-            memcpy((void*)c2, &ld, size);
-
-            /* Test if the last 2 bytes of mantissa are lost.  Mainly for FreeBSD on Intel
-             * architecture(sleipnir) where it happens. */        
-            /*if(endian==0 && c2[0]==0 && c2[1]==0)*/ /*little endian*/
-            if(endian==0 && c2[0]==0) { /*little endian*/
-                ret = 1;
-                goto done;
-            }
-
-            /* For Cygwin */
-            size_cyg = sizeof(long double);
-            memset(&ld_cyg, 0, size); 
-            ld_cyg = (long double)l_cyg;
-
-            c2_cyg = (unsigned char*)calloc(1, size_cyg);
-            memcpy((void*)c2_cyg, &ld_cyg, size_cyg);
-
-            /* Test if the last 4 bytes(roughly) of mantissa are rounded up.  Mainly for Cygwin
-             * where the values like 0xffffffffffffffff,  0xfffffffffffffffe, ..., 
-             * 0xfffffffffffff000 ... are rounded up as 0x0000403f8000000000000000 
-             * instead of 0x0000403effffffffffffffff, 0x0000403efffffffffffffffe, ..., 
-             * 0x0000403efffffffffffff000 ...
-             */    
-            if(endian==0 && c2_cyg[0]==0 && c2_cyg[1]==0 && c2_cyg[2]==0 && c2_cyg[3]==0)
-                ret = 1;
-
-    done:
-            if(c1)
-                free(c1);
-            if(c2)
-                free(c2);
-            if(c2_cyg)
-                free(c2_cyg);
-            exit(ret);
-        }
-        ], [hdf5_cv_ullong_to_ldouble_precision=yes], [hdf5_cv_ullong_to_ldouble_precision=no],)])
-fi
-
-if test ${hdf5_cv_ullong_to_ldouble_precision} = "yes"; then
-  AC_DEFINE([ULLONG_TO_LDOUBLE_PRECISION], [1],
-            [Define if your system can convert unsigned long long to long double with correct precision.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can handle overflow converting
-dnl all floating-point to all integer types.
-dnl (This flag should be set for all machines, except for Cray X1 where
-dnl floating exception is generated when the floating-point value is greater
-dnl than the maximal integer value).
-dnl
-AC_MSG_CHECKING([if overflows normally converting floating-point to integer values])
-
-AC_CACHE_VAL([hdf5_cv_fp_to_integer_overflow_works],
-    [AC_TRY_RUN([
-    int main(void)
-    {
-        float  f = 2147483648.0f;
-        int    i;
-
-        i = (int)f;
-
-done:
-        exit(0);
-    }
-    ], [hdf5_cv_fp_to_integer_overflow_works=yes], [hdf5_cv_fp_to_integer_overflow_works=no],)])
-
-if test ${hdf5_cv_fp_to_integer_overflow_works} = "yes"; then
-  AC_DEFINE([FP_TO_INTEGER_OVERFLOW_WORKS], [1],
-            [Define if your system can handle overflow converting floating-point to integer values.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine is using a special algorithm to convert
-dnl 'long double' to '(unsigned) long' values.  (This flag should only be set for 
-dnl the IBM Power6 Linux.  When the bit sequence of long double is 
-dnl 0x4351ccf385ebc8a0bfcc2a3c3d855620, the converted value of (unsigned)long 
-dnl is 0x004733ce17af227f, not the same as the library's conversion to 0x004733ce17af2282.
-dnl The machine's conversion gets the correct value.  We define the macro and disable
-dnl this kind of test until we figure out what algorithm they use.
-dnl
-AC_MSG_CHECKING([if using special algorithm to convert long double to (unsigned) long values])
-
-if test ${ac_cv_sizeof_long_double} = 0; then
-   hdf5_cv_ldouble_to_long_special=${hdf5_cv_ldouble_to_long_special=no}
-else
-   AC_CACHE_VAL([hdf5_cv_ldouble_to_long_special],
-        [AC_TRY_RUN([
-        int main(void)
-        {
-            long double         ld = 20041683600089727.779961L;
-            long                ll;
-            unsigned long       ull;
-            unsigned char       s[16];
-            unsigned char       s2[8];
-            int                 ret = 1;
-            
-            if(sizeof(long double) == 16 && sizeof(long) == 8) {
-                /*make sure the long double type has 16 bytes in size and 
-                 * 11 bits of exponent.  If it is,
-                 *the bit sequence should be like below.  It's not 
-                 *a decent way to check but this info isn't available. */   
-                memcpy(s, &ld, 16);
-                if(s[0]==0x43 && s[1]==0x51 && s[2]==0xcc && s[3]==0xf3 &&
-                    s[4]==0x85 && s[5]==0xeb && s[6]==0xc8 && s[7]==0xa0 &&
-                    s[8]==0xbf && s[9]==0xcc && s[10]==0x2a && s[11]==0x3c) {
-
-                    /* Assign the hexadecimal value of long double type. */
-                    s[0]=0x43; s[1]=0x51; s[2]=0xcc; s[3]=0xf3;
-                    s[4]=0x85; s[5]=0xeb; s[6]=0xc8; s[7]=0xa0;
-                    s[8]=0xbf; s[9]=0xcc; s[10]=0x2a; s[11]=0x3c;
-                    s[12]=0x3d; s[13]=0x85; s[14]=0x56; s[15]=0x20;
-
-                    memcpy(&ld, s, 16);
-
-                    ll = (long)ld;
-                    memcpy(s2, &ll, 8);
-
-                    /* The library's algorithm converts it to 0x 00 47 33 ce 17 af 22 82
-                     * and gets wrong value 20041683600089730 on the IBM Power6 Linux.
-                     * But the IBM Power6 Linux converts it to 0x00 47 33 ce 17 af 22 7f
-                     * and gets the correct value 20041683600089727.  It uses some special
-                     * algorithm.  We're going to define the macro and skip the test until
-                     * we can figure out how they do it. */
-                    if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
-                       s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
-                        ret = 0;
-
-                    ull = (unsigned long)ld;
-                    memcpy(s2, &ull, 8);
-
-                    /* The unsigned long is the same as signed long. */
-                    if(s2[0]==0x00 && s2[1]==0x47 && s2[2]==0x33 && s2[3]==0xce &&
-                       s2[4]==0x17 && s2[5]==0xaf && s2[6]==0x22 && s2[7]==0x7f)
-                        ret = 0;
-                }    
-            }   
-            
-    done:
-            exit(ret);
-        }
-        ], [hdf5_cv_ldouble_to_long_special=yes], [hdf5_cv_ldouble_to_long_special=no],)])
-fi
-
-if test ${hdf5_cv_ldouble_to_long_special} = "yes"; then
-  AC_DEFINE([LDOUBLE_TO_LONG_SPECIAL], [1],
-            [Define if your system converts long double to (unsigned) long values with special algorithm.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine is using a special algorithm
-dnl to convert some values of '(unsigned) long' to 'long double' values.  
-dnl (This flag should be off for all machines, except for IBM Power6 Linux, 
-dnl when the bit sequences are 003fff..., 007fff..., 00ffff..., 01ffff..., 
-dnl ..., 7fffff..., the compiler uses a unknown algorithm.  We define a 
-dnl macro and skip the test for now until we know about the algorithm.
-dnl
-AC_MSG_CHECKING([if using special algorithm to convert (unsigned) long to long double values])
-
-if test ${ac_cv_sizeof_long_double} = 0; then
-   hdf5_cv_long_to_ldouble_special=${hdf5_cv_long_to_ldouble_special=no}
-else
-   AC_CACHE_VAL([hdf5_cv_long_to_ldouble_special],
-        [AC_TRY_RUN([
-        int main(void)
-        {
-            long double         ld;
-            long                ll;
-            unsigned long       ull;
-            unsigned char       s[16];
-            int                 flag=0, ret=1;
-        
-            /*Determine if long double has 16 byte in size, 11 bit exponent, and
-             *the bias is 0x3ff */ 
-            if(sizeof(long double) == 16) { 
-                ld = 1.0L;
-                memcpy(s, &ld, 16);
-                if(s[0]==0x3f && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
-                    s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00) 
-                    flag = 1; 
-            }
-             
-            if(flag==1 && sizeof(long)==8) {
-                ll = 0x003fffffffffffffL;
-                ld = (long double)ll;
-                memcpy(s, &ld, 16);
-                /* The library converts the value to 0x434fffffffffffff8000000000000000.
-                 * In decimal it is 18014398509481982.000000, one value short of the original.
-                 * The IBM Power6 Linux converts it to 0x4350000000000000bff0000000000000.
-                 * The value is correct in decimal. It uses some special
-                 * algorithm.  We're going to define the macro and skip the test until
-                 * we can figure out how they do it. */
-                if(s[0]==0x43 && s[1]==0x50 && s[2]==0x00 && s[3]==0x00 &&
-                    s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
-                    s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
-                    s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
-                    ret = 0;
-            }        
-            if(flag==1 && sizeof(unsigned long)==8) {
-                ull = 0xffffffffffffffffUL;
-                ld = (long double)ull;
-                memcpy(s, &ld, 16);
-                /* Use a different value from signed long to test. The problem is the same
-                 * for both long and unsigned long. The value is 18446744073709551615.
-                 * The library converts the value to 0x43effffffffffffffe000000000000000.
-                 * In decimal it's 18446744073709548544.000000, very different from the original.
-                 * The IBM Power6 Linux converts it to 0x43f0000000000000bff0000000000000.
-                 * The value is correct in decimal. It uses some special
-                 * algorithm.  We're going to define the macro and skip the test until
-                 * we can figure out how they do it. */
-                if(s[0]==0x43 && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
-                    s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00 &&
-                    s[8]==0xbf && s[9]==0xf0 && s[10]==0x00 && s[11]==0x00 &&
-                    s[12]==0x00 && s[13]==0x00 && s[14]==0x00 && s[15]==0x00)
-                    ret = 0;
-            }        
-    done:
-            exit(ret);
-        }
-        ], [hdf5_cv_long_to_ldouble_special=yes], [hdf5_cv_long_to_ldouble_special=no],)])
-fi
-
-if test ${hdf5_cv_long_to_ldouble_special} = "yes"; then
-  AC_DEFINE([LONG_TO_LDOUBLE_SPECIAL], [1],
-            [Define if your system can convert (unsigned) long to long double values with special algorithm.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can accurately convert
-dnl 'long double' to '(unsigned) long long' values.  (This flag should be set for 
-dnl all machines, except for Mac OS 10.4 and SGI IRIX64 6.5.  When the bit sequence
-dnl of long double is 0x4351ccf385ebc8a0bfcc2a3c..., the values of (unsigned)long long
-dnl start to go wrong on these two machines.  Adjusting it higher to 
-dnl 0x4351ccf385ebc8a0dfcc... or 0x4351ccf385ebc8a0ffcc... will make the converted 
-dnl values wildly wrong.  This test detects this wrong behavior and disable the test.  
-dnl
-AC_MSG_CHECKING([if correctly converting long double to (unsigned) long long values])
-
-if test ${ac_cv_sizeof_long_double} = 0; then
-   hdf5_cv_ldouble_to_llong_accurate=${hdf5_cv_ldouble_to_llong_accurate=no}
-else
-   AC_CACHE_VAL([hdf5_cv_ldouble_to_llong_accurate],
-        [AC_TRY_RUN([
-        int main(void)
-        {
-            long double         ld = 20041683600089727.779961L;
-            long long           ll;
-            unsigned long long  ull;
-            unsigned char       s[16];
-            int                 ret = 0;
-            
-            if(sizeof(long double) == 16) {
-                /*make sure the long double type is the same as the failing type 
-                 *which has 16 bytes in size and 11 bits of exponent.  If it is,
-                 *the bit sequence should be like below.  It's not 
-                 *a decent way to check but this info isn't available. */   
-                memcpy(s, &ld, 16);
-                if(s[0]==0x43 && s[1]==0x51 && s[2]==0xcc && s[3]==0xf3 &&
-                    s[4]==0x85 && s[5]==0xeb && s[6]==0xc8 && s[7]==0xa0 &&
-                    s[8]==0xbf && s[9]==0xcc && s[10]==0x2a && s[11]==0x3c) {
-
-                    /*slightly adjust the bit sequence (s[8]=0xdf).  The converted
-                     *values will go wild on Mac OS 10.4 and IRIX64 6.5.*/ 
-                    s[0]=0x43; s[1]=0x51; s[2]=0xcc; s[3]=0xf3;
-                    s[4]=0x85; s[5]=0xeb; s[6]=0xc8; s[7]=0xa0;
-                    s[8]=0xdf; s[9]=0xcc; s[10]=0x2a; s[11]=0x3c;
-                    s[12]=0x3d; s[13]=0x85; s[14]=0x56; s[15]=0x20;
-
-                    memcpy(&ld, s, 16);
-                    ll = (long long)ld;
-                    ull = (unsigned long long)ld;
-                    
-                    if(ll != 20041683600089728 || ull != 20041683600089728)
-                        ret = 1;
-                }    
-            }    
-    done:
-            exit(ret);
-        }
-        ], [hdf5_cv_ldouble_to_llong_accurate=yes], [hdf5_cv_ldouble_to_llong_accurate=no],)])
-fi
-
-if test ${hdf5_cv_ldouble_to_llong_accurate} = "yes"; then
-  AC_DEFINE([LDOUBLE_TO_LLONG_ACCURATE], [1],
-            [Define if your system can convert long double to (unsigned) long long values correctly.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine can accurately convert
-dnl '(unsigned) long long' to 'long double' values.  (This flag should be set for 
-dnl all machines, except for Mac OS 10.4, when the bit sequences are 003fff...,
-dnl 007fff..., 00ffff..., 01ffff..., ..., 7fffff..., the converted values are twice
-dnl as big as they should be. 
-dnl
-AC_MSG_CHECKING([if correctly converting (unsigned) long long to long double values])
-
-if test ${ac_cv_sizeof_long_double} = 0; then
-   hdf5_cv_llong_to_ldouble_correct=${hdf5_cv_llong_to_ldouble_correct=no}
-else
-   AC_CACHE_VAL([hdf5_cv_llong_to_ldouble_correct],
-        [AC_TRY_RUN([
-        int main(void)
-        {
-            long double         ld;
-            long long           ll;
-            unsigned long long  ull;
-            unsigned char       s[16];
-            int                 flag=0, ret=0;
-        
-            /*Determine if long double has 16 byte in size, 11 bit exponent, and
-             *the bias is 0x3ff */ 
-            if(sizeof(long double) == 16) { 
-                ld = 1.0L;
-                memcpy(s, &ld, 16);
-                if(s[0]==0x3f && s[1]==0xf0 && s[2]==0x00 && s[3]==0x00 &&
-                    s[4]==0x00 && s[5]==0x00 && s[6]==0x00 && s[7]==0x00) 
-                    flag = 1; 
-            }
-             
-            if(flag==1 && sizeof(long long)==8) {
-                ll = 0x01ffffffffffffffLL;
-                ld = (long double)ll;
-                memcpy(s, &ld, 16);
-                /*Check if the bit sequence is as supposed to be*/
-                if(s[0]!=0x43 || s[1]!=0x7f || s[2]!=0xff || s[3]!=0xff ||
-                    s[4]!=0xff || s[5]!=0xff || s[6]!=0xff || s[7]!=0xff ||
-                    s[8]!=0xf0 || s[9]!=0x00 || s[10]!=0x00 || s[11]!=0x00)
-                    ret = 1;
-            }        
-            if(flag==1 && sizeof(unsigned long long)==8) {
-                ull = 0x01ffffffffffffffULL;
-                ld = (long double)ull;
-                memcpy(s, &ld, 16);
-                if(s[0]!=0x43 || s[1]!=0x7f || s[2]!=0xff || s[3]!=0xff ||
-                    s[4]!=0xff || s[5]!=0xff || s[6]!=0xff || s[7]!=0xff ||
-                    s[8]!=0xf0 || s[9]!=0x00 || s[10]!=0x00 || s[11]!=0x00)
-                    ret = 1;
-            }        
-    done:
-            exit(ret);
-        }
-        ], [hdf5_cv_llong_to_ldouble_correct=yes], [hdf5_cv_llong_to_ldouble_correct=no],)])
-fi
-
-if test ${hdf5_cv_llong_to_ldouble_correct} = "yes"; then
-  AC_DEFINE([LLONG_TO_LDOUBLE_CORRECT], [1],
-            [Define if your system can convert (unsigned) long long to long double values correctly.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set the flag to indicate that the machine generates bad code
-dnl for the H5V_log2_gen() routine in src/H5Vprivate.h
-dnl (This flag should be set to no for all machines, except for SGI IRIX64,
-dnl where the cache value is set to yes in it's config file)
-dnl
-AC_MSG_CHECKING([if bad code for log2 routine is generated])
-AC_CACHE_VAL([hdf5_cv_bad_log2_code_generated], [hdf5_cv_bad_log2_code_generated=no])
-
-if test ${hdf5_cv_bad_log2_code_generated} = "yes"; then
-  AC_DEFINE([BAD_LOG2_CODE_GENERATED], [1],
-            [Define if your system generates wrong code for log2 routine.])
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Set some variables for general configuration information to be saved
-dnl and installed with the libraries.
-dnl
-
-dnl HDF5 version from the first line of the README.txt file.
-H5_VERSION="`cut -d' ' -f3 $srcdir/README.txt | head -1`"
-AC_SUBST([H5_VERSION])
-
-dnl Configuration date
-AC_SUBST([CONFIG_DATE]) CONFIG_DATE="`date`"
-
-dnl User doing the configuration
-AC_SUBST([CONFIG_USER]) CONFIG_USER="`whoami`@`hostname`"
-if test -n "$ORGANIZATION"; then
-  CONFIG_USER="$CONFIG_USER at $ORGANIZATION"
-fi
-
-dnl Configuration mode (production, development, profile, etc) saved above.
-AC_SUBST([CONFIG_MODE])
-
-dnl Byte sex from the AC_C_BIGENDIAN macro.
-AC_SUBST([BYTESEX])
-if test "X$ac_cv_c_bigendian" = "Xyes"; then
-  BYTESEX="big-endian"
-else
-  BYTESEX="little-endian"
-fi
-
-
-if test "X$ac_cv_c_bigendian" = "Xyes"; then
-  WORDS_BIGENDIAN="yes"
-else
-  WORDS_BIGENDIAN="no"
-fi
-AC_SUBST([WORDS_BIGENDIAN])
-
-dnl Parallel support? (set above except empty if none)
-PARALLEL=${PARALLEL:-no}
-
-dnl Compiler with version information. This consists of the full path
-dnl name of the compiler and the reported version number.
-AC_SUBST([CC_VERSION])
-dnl Strip anything that looks like a flag off of $CC
-CC_NOFLAGS=`echo $CC | sed 's/ -.*//'`
-
-if `echo $CC_NOFLAGS | grep ^/ >/dev/null 2>&1`; then
-  CC_VERSION="$CC"
-else
-  CC_VERSION="$CC";
-  for x in `echo $PATH | sed -e 's/:/ /g'`; do
-    if test -x $x/$CC_NOFLAGS; then
-      CC_VERSION="$x/$CC"
-      break
-    fi
-  done
-fi
-if test -n "$cc_version_info"; then
-  CC_VERSION="$CC_VERSION ( $cc_version_info)"
-fi
-
-AC_SUBST([FC_VERSION])
-dnl Strip anything that looks like a flag off of $CC
-FC_NOFLAGS=`echo $FC | sed 's/ -.*//'`
-
-if `echo $FC_NOFLAGS | grep ^/ >/dev/null 2>&1`; then
-  FC_VERSION="$FC"
-else
-  FC_VERSION="$FC";
-  for x in `echo $PATH | sed -e 's/:/ /g'`; do
-    if test -x $x/$FC_NOFLAGS; then
-      FC_VERSION="$x/$FC"
-      break
-    fi
-  done
-fi
-if test -n "$fc_version_info"; then
-  FC_VERSION="$FC_VERSION ( $fc_version_info)"
-fi
-
-AC_SUBST([CXX_VERSION])
-dnl Strip anything that looks like a flag off of $CC
-CXX_NOFLAGS=`echo $CXX | sed 's/ -.*//'`
-
-if `echo $CXX_NOFLAGS | grep ^/ >/dev/null 2>&1`; then
-  CXX_VERSION="$CXX"
-else
-  CXX_VERSION="$FC";
-  for x in `echo $PATH | sed -e 's/:/ /g'`; do
-    if test -x $x/$CXX_NOFLAGS; then
-      CXX_VERSION="$x/$CXX"
-      break
-    fi
-  done
-fi
-if test -n "$cxx_version_info"; then
-  CXX_VERSION="$CXX_VERSION ( $cxx_version_info)"
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Where is the root of the source tree. Give an absolute address so
-dnl we can find it no matter which directory of the distribution is our
-dnl current directory. The built-in pwd fails on some systems, but the
-dnl /bin/pwd version works OK.
-dnl
-if test -x /bin/pwd; then
-  pwd=/bin/pwd
-else
-  pwd=pwd
-fi
-AC_SUBST([ROOT]) ROOT="`$pwd`"
-
-dnl ----------------------------------------------------------------------
-dnl Move any compiler-specific libraries into the main LIBS varaible.
-dnl 
-LIBS="$DEFAULT_LIBS $LIBS"
-
-dnl ----------------------------------------------------------------------
-dnl Determine the runtime libraries we may need to include in the
-dnl libtools command so that executables will find the correct dynamic
-dnl libraries.
-dnl 
-AC_SUBST([DYNAMIC_DIRS]) DYNAMIC_DIRS=""
-
-if test -n "$AM_LDFLAGS $LDFLAGS"; then
-  for d in $AM_LDFLAGS $LDFLAGS ; do
-    case "$d" in
-      -L*)
-        d="`echo $d | sed -e 's/-L//g'`"
-        case "$d" in
-          .*)
-            dnl If the path isn't absolute, make it so by
-            dnl prepending the ROOT directory to it.
-            d=${ROOT}/$d
-            ;;
-        esac
-        DYNAMIC_DIRS="-R${d} $DYNAMIC_DIRS"
-        ;;
-    esac
-  done
-fi
-
-if test -n "$AM_CPPFLAGS"; then
-  TEMP_CPPFLAGS=""
-  for d in $AM_CPPFLAGS ; do
-    case "$d" in
-      -I.*)
-        dnl If the path isn't absolute, make it so by prepending
-        dnl the ROOT directory to it.
-        d="`echo $d | sed -e 's/-I//g'`"
-        d="-I${ROOT}/${d}"
-        ;;
-    esac
-    TEMP_CPPFLAGS="$d $TEMP_CPPFLAGS"
-  done
-  AM_CPPFLAGS=$TEMP_CPPFLAGS
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Check if they would like the High Level library  compiled
-dnl
-
-AC_SUBST(HL) HL=""
-# name of fortran folder inside "hl", if FORTRAN compile is requested
-AC_SUBST(HL_FOR) HL_FOR=""
-AC_MSG_CHECKING([if high level library is enabled])
-AC_ARG_ENABLE([hl],
-     [AC_HELP_STRING([--enable-hl],
-                     [Enable the high level library [default=yes]])],
-     [HDF5_HL=$enableval],
-     [HDF5_HL=yes])
-
-if test "X$HDF5_HL" = "Xyes"; then
- echo "yes"
- HL="hl"
- AC_DEFINE([INCLUDE_HL], [1],
-           [Define if HDF5's high-level library headers should be included in hdf5.h])
-else
- echo "no"
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Some programs shouldn't be built by default (e.g., programs to generate
-dnl data files used by tests, some optional tests).
-dnl Check if they want such programs built anyway.
-dnl
-AC_MSG_CHECKING([additional programs should be built])
-AC_ARG_ENABLE([build-all],
-     [AC_HELP_STRING([--enable-build-all],
-                     [Build helper programs that only developers should need [default=no]])],
-     [BUILD_ALL=$enableval],
-     [BUILD_ALL=no])
-
-if test "X$BUILD_ALL" = "Xyes"; then
- echo "yes"
-else
- echo "no"
-fi
-AM_CONDITIONAL([BUILD_ALL_CONDITIONAL], [test "X$BUILD_ALL" = "Xyes"])
-
-dnl ----------------------------------------------------------------------
-dnl Enable deprecated public API symbols
-dnl
-AC_SUBST([DEPRECATED_SYMBOLS])
-AC_MSG_CHECKING([if deprecated public symbols are available]);
-AC_ARG_ENABLE([deprecated-symbols],
-              [AC_HELP_STRING([--enable-deprecated-symbols],
-                     [Enable deprecated public API symbols [default=yes]])],
-             [DEPREC_SYMBOLS=$enableval],
-             [DEPREC_SYMBOLS=yes])
-
-case "X-$DEPREC_SYMBOLS" in
-  X-yes)
-    AC_MSG_RESULT([yes])
-    DEPRECATED_SYMBOLS=yes
-    ;;
-  X-no|*)
-    AC_MSG_RESULT([no])
-    DEPRECATED_SYMBOLS=no
-    AC_DEFINE([NO_DEPRECATED_SYMBOLS], [1],
-              [Define if deprecated public API symbols are disabled])
-    ;;
-esac
-
-dnl --------------------------------------------------------------------------
-dnl Which version of the public APIs should the 'base' versioned symbols use?
-dnl
-
-AC_SUBST([DEFAULT_API_VERSION])
-AC_MSG_CHECKING([which version of public symbols to use by default])
-AC_ARG_WITH([default-api-version],
-            [AC_HELP_STRING([--with-default-api-version=(v16|v18|v110)],
-                            [Specify default release version of public symbols
-                             [default=v110]])],,
-            withval=v110)
-
-if test "X$withval" = "Xv16"; then
-    AC_MSG_RESULT([v16])
-    DEFAULT_API_VERSION=v16
-    AC_DEFINE([USE_16_API_DEFAULT], [1],
-              [Define using v1.6 public API symbols by default])
-elif test "X$withval" = "Xv18"; then
-    AC_MSG_RESULT([v18])
-    DEFAULT_API_VERSION=v18
-elif test "X$withval" = "Xv110"; then
-    AC_MSG_RESULT([v110])
-    DEFAULT_API_VERSION=v110
-else
-    AC_MSG_ERROR([invalid version of public symbols given])
-fi
-
-dnl It's an error to try to disable deprecated public API symbols while
-dnl choosing an older version of the public API as the default. However,
-dnl if the user insists on doing this via the --enable-unsupported configure
-dnl flag, we'll let them.
-if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
-  if test "X${DEFAULT_API_VERSION}" != "Xv110" -a "X${DEPRECATED_SYMBOLS}" = "Xno" ; then
-    AC_MSG_ERROR([Removing old public API symbols not allowed when using them as default public API symbols. Use --enable-unsupported to override this error.])
-  fi
-fi
-
-dnl ----------------------------------------------------------------------
-dnl Enable strict file format checks
-dnl
-AC_SUBST([STRICT_FORMAT_CHECKS])
-AC_MSG_CHECKING([Whether to perform strict file format checks]);
-AC_ARG_ENABLE([strict-format-checks],
-              [AC_HELP_STRING([--enable-strict-format-checks],
-                     [Enable strict file format checks, default=yes if
-                        debug flag is enabled, no otherwise])],
-             [STRICT_CHECKS=$enableval])
-
-dnl Default to yes if debug is enabled
-if test "X-$STRICT_CHECKS" = X- ; then
-  if test -z "$DEBUG_PKG" ; then
-    STRICT_CHECKS=no
-  else
-    STRICT_CHECKS=yes
-  fi
-fi
-
-case "X-$STRICT_CHECKS" in
-  X-yes)
-    AC_MSG_RESULT([yes])
-    STRICT_FORMAT_CHECKS=yes
-    AC_DEFINE([STRICT_FORMAT_CHECKS], [1],
-              [Define if strict file format checks are enabled])
-    ;;
-  X-no|*)
-    AC_MSG_RESULT([no])
-    STRICT_FORMAT_CHECKS=no
-    ;;
-esac
-
-
-dnl ----------------------------------------------------------------------
-dnl Enable embedded library information
-dnl
-AC_MSG_CHECKING([Whether to have library information embedded in the executables])
-AC_ARG_ENABLE([embedded-libinfo],
-    [AC_HELP_STRING([--enable-embedded-libinfo],
-	[Enable embedded library information [default=yes]])],
-	[enable_embedded_libinfo=$enableval],
-	[enable_embedded_libinfo=yes])
-
-   if test "${enable_embedded_libinfo}" = "yes"; then
-      AC_MSG_RESULT([yes])
-      AC_DEFINE([HAVE_EMBEDDED_LIBINFO], [1],
-                [Define if library information should be embedded in the executables])
-   else
-      AC_MSG_RESULT([no])
-    fi
-
-
-dnl ----------------------------------------------------------------------
-dnl Check if pointer alignments are enforced
-dnl
-AC_MSG_CHECKING([if alignment restrictions are strictly enforced])
-AC_RUN_IFELSE([
-    AC_LANG_PROGRAM([
-        #include <stdlib.h>
-        #include <string.h>
-
-        typedef struct {
-            size_t len;
-            void *p;
-        } hvl_t;
-        ], [
-        char *chp = "beefs";
-        char **chpp = malloc (2 * sizeof (char *));
-        char **chpp2;
-        hvl_t vl = { 12345, (void *) chp };
-        hvl_t *vlp;
-        hvl_t *vlp2;
-
-        memcpy ((void *) ((char *) chpp + 1), &chp, sizeof (char *));
-        chpp2 = (char **) ((char *) chpp + 1);
-        if (strcmp (*chpp2, chp)) {
-            free (chpp);
-            return 1;
-        }
-        free (chpp);
-
-        vlp = malloc (2 * sizeof (hvl_t));
-        memcpy ((void *) ((char *) vlp + 1), &vl, sizeof (hvl_t));
-        vlp2 = (hvl_t *) ((char *) vlp + 1);
-        if (vlp2->len != vl.len || vlp2->p != vl.p) {
-            free (vlp);
-            return 1;
-        }
-        free (vlp);
-    ])
-    ], [
-    AC_DEFINE([NO_ALIGNMENT_RESTRICTIONS], [1], [Define if we can violate pointer alignment restrictions])
-    AC_MSG_RESULT([no])
-    ], [
-    AC_MSG_RESULT([yes])
-    ], [
-    AC_MSG_RESULT([unknown, assuming yes])
-    ])
-
-
-dnl ----------------------------------------------------------------------
-dnl Restore user's CFLAGS.
-CFLAGS="$saved_user_CFLAGS"
-FCFLAGS="$saved_user_FCFLAGS"
-CXXFLAGS="$saved_user_CXXFLAGS"
-CPPFLAGS="$saved_user_CPPFLAGS"
-LDFLAGS="$saved_user_LDFLAGS"
-
-
-dnl ----------------------------------------------------------------------
-dnl Create automake conditionals to tell automake makefiles which directories
-dnl need to be compiled
-
-AM_CONDITIONAL([BUILD_CXX_CONDITIONAL], [test "X$HDF_CXX" = "Xyes"])
-AM_CONDITIONAL([BUILD_PARALLEL_CONDITIONAL], [test -n "$TESTPARALLEL"])
-AM_CONDITIONAL([BUILD_FORTRAN_CONDITIONAL], [test "X$HDF_FORTRAN" = "Xyes"])
-AM_CONDITIONAL([BUILD_HDF5_HL_CONDITIONAL], [test "X$HDF5_HL" = "Xyes"])
-
-
-dnl ----------------------------------------------------------------------
-dnl Build the Makefiles.
-dnl
-
-dnl The directory search list
-AC_SUBST([SEARCH]) SEARCH='$(srcdir) $(top_builddir)/src $(top_srcdir)/src'
-cmd='echo $SEARCH |sed "s/ /'$SEARCH_SEP'/g"'
-SEARCH="$SEARCH_RULE`eval $cmd`"
-export SEARCH
-
-dnl We don't need to say when we're entering directories if we're using
-dnl GNU make because make does it for us.
-if test "X$GMAKE" = "Xyes"; then
-  AC_SUBST([SETX]) SETX=":"
-else
-  AC_SUBST([SETX]) SETX="set -x"
-fi
-
-dnl Some cleanup stuff
-rm -f conftest conftest.o conftest.c dummy.o *.mod
-
-dnl Build config.status, touch the stamp files, and build all the Makefiles.
-dnl The order is such that the first `make' does not need to update any
-dnl configuration information. See config/commence.in for the order in which
-dnl things need to be done.
-
-# First the stamp1 file for H5config.h.in
-mkdir ./config >/dev/null 2>&1
-touch ./config/stamp1
-
-# Then the config.status file (but not makefiles)
-saved_no_create=$no_create
-no_create=yes
-
-PARALLEL_MAKE=""
-FORTRAN_PARALLEL_MAKE=""
-
-if test -n "$TESTPARALLEL"; then
-  PARALLEL_MAKE="$TESTPARALLEL/Makefile $TESTPARALLEL/testph5.sh"
-
-  if test "X$HDF_FORTRAN" = "Xyes"; then
-    FORTRAN_PARALLEL_MAKE=fortran/$TESTPARALLEL/Makefile
-  fi
-fi
-
-AC_CONFIG_FILES([src/libhdf5.settings
-                 Makefile
-                 src/Makefile
-                 test/Makefile
-                 test/testcheck_version.sh
-                 test/testerror.sh
-                 test/testflushrefresh.sh
-                 test/H5srcdir_str.h
-                 test/testlibinfo.sh
-                 test/testlinks_env.sh
-                 testpar/Makefile
-                 testpar/testph5.sh
-                 perform/Makefile
-                 tools/Makefile
-                 tools/h5dump/Makefile
-                 tools/h5dump/testh5dump.sh
-                 tools/h5dump/testh5dumppbits.sh
-                 tools/h5dump/testh5dumpxml.sh
-                 tools/h5ls/testh5ls.sh
-                 tools/h5import/Makefile
-                 tools/h5diff/Makefile
-                 tools/h5jam/Makefile
-                 tools/h5jam/testh5jam.sh
-                 tools/h5repack/Makefile
-                 tools/h5repack/h5repack.sh
-                 tools/h5ls/Makefile
-                 tools/h5copy/Makefile
-                 tools/lib/Makefile
-                 tools/misc/Makefile
-                 tools/misc/h5cc
-                 tools/misc/testh5repart.sh
-                 tools/h5stat/testh5stat.sh
-                 tools/h5stat/Makefile
-                 examples/Makefile
-                 examples/run-c-ex.sh
-                 examples/testh5cc.sh
-                 c++/Makefile
-                 c++/src/Makefile
-                 c++/src/h5c++
-                 c++/test/Makefile
-                 c++/test/H5srcdir_str.h
-                 c++/examples/Makefile
-                 c++/examples/run-c++-ex.sh
-                 c++/examples/testh5c++.sh
-                 fortran/Makefile
-                 fortran/src/h5fc
-                 fortran/src/Makefile
-                 fortran/test/Makefile
-                 fortran/testpar/Makefile
-                 fortran/examples/Makefile
-                 fortran/examples/run-fortran-ex.sh
-                 fortran/examples/testh5fc.sh
-                 hl/Makefile
-                 hl/src/Makefile
-                 hl/test/Makefile
-                 hl/test/H5srcdir_str.h
-                 hl/test/test_ld.sh
-                 hl/tools/Makefile
-                 hl/tools/gif2h5/Makefile
-		 hl/tools/h5watch/Makefile
-               	 hl/tools/h5watch/testh5watch.sh
-                 hl/examples/Makefile
-                 hl/examples/run-hlc-ex.sh
-                 hl/c++/Makefile
-                 hl/c++/src/Makefile
-                 hl/c++/test/Makefile
-                 hl/c++/examples/Makefile
-                 hl/c++/examples/run-hlc++-ex.sh
-                 hl/fortran/Makefile
-                 hl/fortran/src/Makefile
-                 hl/fortran/test/Makefile
-                 hl/fortran/examples/Makefile
-                 hl/fortran/examples/run-hlfortran-ex.sh])
-
-AC_OUTPUT
-LT_OUTPUT
-no_create=$saved_no_create
-
-# Then the stamp2 file for H5config.h
-touch ./config/stamp2
-
-# Finally the makefiles
-test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
-
-dnl Post processing to patch up some deficiencies in libtool
-case $host_os in
-  linux* | freebsd* )
-    # If gcc is not used, need to set $wl to use "-Wl,"
-    if $CC -v 2>&1 | grep '^gcc' > /dev/null ; then
-      : using gcc
-    else
-      echo 'fixing $wl in' $ofile
-ed - $ofile <<EOF 2> /dev/null
-g/^wl=""/s//wl="-Wl,"/
-w
-q
-EOF
-    fi
-    ;;
-esac
-
-dnl Are we compiling static libraries, shared libraries, or both?  This
-dnl is only used for the libhdf5.settings file. We can't just look at
-dnl $enable_static and $enable_shared because if they're yes the ltconfig
-dnl might have decided that one or the other is simply not possible.
-dnl Therefore we have to ask the generated `libtool' shell script
-dnl which 'features' it has enabled.
-if (./libtool --features | grep '^enable shared libraries' > /dev/null); then
-  enable_shared=yes
-else
-  enable_shared=no
-fi
-
-if (./libtool --features | grep '^enable static libraries' > /dev/null); then
-  enable_static=yes
-else
-  enable_static=no
-fi
-
-if test "X$enable_static" = "Xyes" && test "X$enable_shared" = "Xyes"; then
-  STATIC_SHARED="static, shared"
-elif test "X$enable_static" = "Xyes"; then
-  STATIC_SHARED="static"
-elif test "X$enable_shared" = "Xyes"; then
-  STATIC_SHARED="shared"
-else
-  STATIC_SHARED="none"
-fi
-
-chmod 755 tools/misc/h5cc
-
-if test "X$HDF_FORTRAN" = "Xyes"; then
-  chmod 755 fortran/src/h5fc
-fi
-
-if test "X$HDF_CXX" = "Xyes"; then
-  chmod 755 c++/src/h5c++
-fi
-
-dnl We don't want inline defined for C++ compilers
-dnl Don't worry about the C++ ifdef wrappers in the H5pubconf file, since
-dnl 'H5_inline' isn't a C++ keyword.
-cat >> src/H5config.h <<EOF
-
-#if defined(__cplusplus) && defined(inline)
-#undef inline
-#endif
-EOF
-
-dnl show the configure settings
-cat src/libhdf5.settings