summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--configure.ac.orig4572
1 files changed, 4572 insertions, 0 deletions
diff --git a/configure.ac.orig b/configure.ac.orig
new file mode 100644
index 0000000..e70ed30
--- /dev/null
+++ b/configure.ac.orig
@@ -0,0 +1,4572 @@
+## Process this file with autoconf to produce configure.
+##
+## Copyright by The HDF Group.
+## Copyright by the Board of Trustees of the University of Illinois.
+## All rights reserved.
+##
+## This file is part of HDF5. The full HDF5 copyright notice, including
+## terms governing use, modification, and redistribution, is contained in
+## the files COPYING and Copyright.html. COPYING can be found at the root
+## of the source code distribution tree; Copyright.html can be found at the
+## root level of an installed copy of the electronic HDF5 document set and
+## is linked from the top-level documents page. It can also be found at
+## http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have
+## access to either file, you may request a copy from help@hdfgroup.org.
+
+## ----------------------------------------------------------------------
+## Initialize configure.
+##
+AC_REVISION($Id: configure.ac 22697 2012-08-19 14:35:47Z hdftest $)
+AC_PREREQ([2.69])
+
+## AC_INIT takes the name of the package, the version number, and an
+## email address to report bugs. AC_CONFIG_SRCDIR takes a unique file
+## as its argument.
+##
+## NOTE: Do not forget to change the version number here when we do a
+## release!!!
+##
+AC_INIT([HDF5], [1.9.212], [help@hdfgroup.org])
+AC_CONFIG_SRCDIR([src/H5.c])
+AC_CONFIG_HEADER([src/H5config.h])
+
+AC_CONFIG_AUX_DIR([bin])
+AC_CONFIG_MACRO_DIR([m4])
+
+## AM_INIT_AUTOMAKE takes a list of options that should be applied to
+## every Makefile.am when automake is run.
+AM_INIT_AUTOMAKE([foreign])
+AM_SILENT_RULES([yes])
+
+## AM_MAINTAINER_MODE turns off "rebuild rules" that contain dependencies
+## for Makefiles, configure, src/H5config.h, etc. If AM_MAINTAINER_MODE
+## is *not* included here, these files will be rebuilt if out of date.
+## This is a problem because if users try to build on a machine with
+## the wrong versions of autoconf and automake, these files will be
+## rebuilt with the wrong versions and bad things can happen.
+## Also, CVS doesn't preserve dependencies between timestamps, so
+## Makefiles will often think rebuilding needs to occur when it doesn't.
+## Developers should './configure --enable-maintainer-mode' to turn on
+## rebuild rules.
+AM_MAINTAINER_MODE
+
+## ----------------------------------------------------------------------
+## Set prefix default (install directory) to a directory in the build area.
+## This allows multiple src-dir builds within one host.
+AC_PREFIX_DEFAULT([`pwd`/hdf5])
+
+## Run post processing on files created by configure.
+## src/H5pubconf.h:
+## Generate src/H5pubconf.h from src/H5config.h by prepending H5_ to all
+## macro names. This avoid name conflict between HDF5 macro names and those
+## generated by another software package that uses the HDF5 library.
+## src/libhdf5.settings:
+## Remove all lines begun with "#" which are generated by CONDITIONAL's of
+## configure.
+AC_CONFIG_COMMANDS([pubconf], [
+ 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
+])
+
+## It's possible to configure for a host other than the one on which
+## configure is currently running by using the --host=foo flag.
+## For machines on which HDF5 is often configured, it can be convenient
+## 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])
+
+## H5_CFLAGS (and company) are for CFLAGS that should be used on HDF5, but
+## 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])
+
+## AM_CFLAGS (and company) are for CFLAGS that should be used on HDF5,
+## 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])
+
+## 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}"
+
+## Configure may need to alter any of the *FLAGS variables in order for
+## various checks to work correctly. Save the user's value here so it
+## 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"
+
+## Different compilers may need default libraries. They are specified in
+## the config/* files, so we put this statement here so that it'll be
+## set by the code which follows...
+##
+DEFAULT_LIBS=""
+
+## Support F9X variable to define Fortran compiler if FC variable is
+## not used. This should be deprecated in the future.
+if test "x" = "x$FC"; then
+ FC=${F9X}
+fi
+
+## ----------------------------------------------------------------------
+## Dump all shell variables values.
+##
+AC_MSG_CHECKING([shell variables initial values])
+set >&AS_MESSAGE_LOG_FD
+AC_MSG_RESULT([done])
+
+## Define all symbol variables used for configure summary.
+## EXTERNAL_FILTERS equals all external filters. Default none.
+## MPE: whether MPE option is enabled. Default no.
+## STATIC_EXEC: whether static-exec is enabled. Default no.
+## HDF_FORTRAN: whether Fortran is enabled. Default no.
+## HDF_FORTRAN2003: whether Fortran 2003 is enabled. Default no.
+## FC: Fortran compiler.
+## HDF_CXX: whether C++ is enabled. Default no.
+## CXX: C++ compiler.
+## HDF5_HL: whether high-level library is enabled. Default is yes.
+## LARGEFILE: whether largefile support is enabled. Default yes.
+## INSTRUMENT: whether INSTRUMENT is enabled. No default set here.
+## CODESTACK: whether CODESTACK is enabled. Default no.
+## HAVE_DMALLOC: whether system has dmalloc support. Default no.
+## DIRECT_VFD: whether DIRECT_VFD is enabled. Default no.
+## THREADSAFE: whether THREADSAFE is enabled. Default no.
+## STATIC_SHARED: whether static and/or shared libraries are requested.
+## enable_shared: whether shared lib is enabled.
+## enable_static: whether static lib is enabled.
+## 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([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`
+
+## ----------------------------------------------------------------------
+## Some platforms have broken basename, and/or xargs programs. Check
+## that it actually does what it's supposed to do. Catch this early
+## since configure relies upon them heavily and there's no use continuing
+## if it's broken.
+##
+
+## Avoid depending upon Character Ranges.
+## These are defined by autoconf.
+## as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+## 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
+
+## ----------------------------------------------------------------------
+## Check that the cache file was build on the same host as what we're
+## running on now.
+##
+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
+
+## ----------------------------------------------------------------------
+## Source any special files that we need. These files normally aren't
+## present but can be used by the maintainers to fine tune things like
+## turning on debug or profiling flags for the compiler. The search order
+## is:
+##
+## CPU-VENDOR-OS
+## VENDOR-OS
+## CPU-OS
+## CPU-VENDOR
+## OS
+## VENDOR
+## CPU
+##
+## If the `OS' ends with a version number then remove it. For instance,
+## `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
+
+## 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
+
+## ----------------------------------------------------------------------
+## Some built-in configure checks can only see CFLAGS (not AM_CFLAGS), so
+## we need to add this in so configure works as intended. We will need to
+## 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}"
+
+## ----------------------------------------------------------------------
+## Enable dependency tracking unless the configure options or a
+## site-specific file told us not to. This prevents configure from
+## silently disabling dependencies for some compilers.
+##
+if test -z "${enable_dependency_tracking}"; then
+ enable_dependency_tracking="yes"
+fi
+
+## ----------------------------------------------------------------------
+## Check for programs.
+##
+AC_PROG_CC
+CC_BASENAME="`echo $CC | cut -f1 -d' ' | xargs basename 2>/dev/null`"
+
+## ----------------------------------------------------------------------------
+## Configure disallows unsupported combinations of options. However, users
+## may want to override and build with unsupported combinations for their
+## own use. They can use the --enable-unsupported configure flag, which
+## ignores any errors from configure due to incompatible flags.
+AC_MSG_CHECKING([if unsupported combinations of configure options are allowed])
+AC_ARG_ENABLE([unsupported],
+ [AS_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
+
+## ----------------------------------------------------------------------
+## Check if they would like the Fortran interface compiled
+##
+AC_SUBST([HDF5_INTERFACES]) HDF5_INTERFACES=""
+AC_MSG_CHECKING([if Fortran interface enabled])
+AC_ARG_ENABLE([fortran],
+ [AS_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
+
+
+## ----------------------------------------------------------------------
+## Check if they would like the Fortran 2003 interface compiled
+##
+AC_MSG_CHECKING([if Fortran 2003 interface enabled])
+AC_ARG_ENABLE([fortran2003],
+ [AS_HELP_STRING([--enable-fortran2003],
+ [Compile the Fortran 2003 interface, must also specify --enable-fortran [default=no]])],
+ [HDF_FORTRAN2003=$enableval])
+
+## ----------------------------------------------------------------------
+## Check to make sure --enable-fortran is present if --enable-fortran2003
+## 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"
+HAVE_C_SIZEOF="no"
+HAVE_STORAGE_SIZE="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"
+
+ ## --------------------------------------------------------------------
+ ## Default for FORTRAN 2003 compliant compilers
+ ##
+ HAVE_FORTRAN_2003="no"
+ HAVE_F2003_REQUIREMENTS="no"
+
+ ## --------------------------------------------------------------------
+ ## HDF5 integer variables for the H5fortran_types.f90 file.
+ ##
+ 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])
+
+ ## --------------------------------------------------------------------
+ ## Fortran source extention
+ ##
+ AC_FC_SRCEXT([f90])
+
+ AC_SUBST([F9XSUFFIXFLAG])
+ AC_SUBST([FSEARCH_DIRS])
+
+ ## --------------------------------------------------------------------
+ ## Check for a Fortran 9X compiler and how to include modules.
+ ##
+ AC_PROG_FC([f90 pgf90 slf90 f95 g95 xlf95 efc ifort ftn],)
+ AC_F9X_MODS
+
+ ## It seems that libtool (as of Libtool 1.5.14) is trying to
+ ## configure itself for Fortran 77.
+ ## Tell it that our F77 compiler is $FC (actually a F9X compiler)
+ F77=$FC
+
+ ## Change to the Fortran 90 language
+ AC_LANG_PUSH(Fortran)
+
+ ## --------------------------------------------------------------------
+ ## Define wrappers for the C compiler to use Fortran function names
+ ##
+ AC_FC_WRAPPERS
+
+ ## --------------------------------------------------------------------
+ ## See if the compiler will support the "-I." option
+ ##
+ 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")
+
+ ## --------------------------------------------------------------------
+ ## 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])])
+
+ ## See if the fortran compiler supports the intrinsic function "C_SIZEOF"
+
+ AC_MSG_CHECKING([if Fortran compiler supports intrinsic C_SIZEOF])
+ AC_TRY_RUN([
+ PROGRAM main
+ USE ISO_C_BINDING
+ INTEGER(C_INT) :: a
+ INTEGER(C_SIZE_T) :: result
+ result = C_SIZEOF(a)
+ END PROGRAM
+ ], [AC_MSG_RESULT([yes])
+ HAVE_C_SIZEOF="yes"],
+ [AC_MSG_RESULT([no])])
+
+ ## See if the fortran compiler supports the intrinsic function "STORAGE_SIZE"
+
+ AC_MSG_CHECKING([if Fortran compiler supports intrinsic STORAGE_SIZE])
+ AC_TRY_RUN([
+ PROGRAM main
+ INTEGER :: a
+ INTEGER :: result
+ result = STORAGE_SIZE(a)
+ END PROGRAM
+ ], [AC_MSG_RESULT([yes])
+ HAVE_STORAGE_SIZE="yes"],
+ [AC_MSG_RESULT([no])])
+
+ ## Check to see if -r8 was specified to determine if we need to
+ ## 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
+
+ ## Checking if the compiler supports the required Fortran 2003 features and
+ ## 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
+ ## echo $HAVE_FORTRAN_2003
+ AC_MSG_ERROR([Fortran compiler lacks required Fortran 2003 features; unsupported Fortran 2003 compiler, remove --enable-fortran2003])
+ else
+ ## echo $HAVE_FORTRAN_2003
+ HAVE_FORTRAN_2003="yes"
+ fi
+ fi
+else
+ FC="no"
+fi
+
+## Change back to the C language
+AC_LANG_POP(Fortran)
+
+AM_CONDITIONAL([FORTRAN_HAVE_SIZEOF], [test "X$HAVE_SIZEOF" = "Xyes"])
+AM_CONDITIONAL([FORTRAN_HAVE_C_SIZEOF], [test "X$HAVE_C_SIZEOF" = "Xyes"])
+AM_CONDITIONAL([FORTRAN_HAVE_STORAGE_SIZE], [test "X$HAVE_STORAGE_SIZE" = "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"])
+
+
+
+## ----------------------------------------------------------------------
+## Check if they would like the C++ interface compiled
+##
+## We need to check for a C++ compiler unconditionally, since
+## AC_PROG_CXX defines some macros that Automake 1.9.x uses and will
+## miss even if c++ is not enabled.
+ AC_PROG_CXX
+ AC_PROG_CXXCPP ## this is checked for when AC_HEADER_STDC is done
+
+AC_MSG_CHECKING([if c++ interface enabled])
+
+AC_ARG_ENABLE([cxx],
+ [AS_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++"
+
+ ## 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
+
+## Change back to the C language
+AC_LANG_POP(C++)
+
+## ----------------------------------------------------------------------
+## Check if they have Perl installed on their system. We only need Perl
+## if they're using a GNU compiler.
+##
+AC_SUBST([PERL]) PERL=""
+if test "X$GCC" = "Xyes"; then
+ AC_CHECK_PROGS([PERL], [perl],, [$PATH])
+fi
+
+
+## ----------------------------------------------------------------------
+## Check which archiving tool to use. This needs to be done before
+## the AM_PROG_LIBTOOL macro.
+##
+
+if test -z "$AR"; then
+ AC_CHECK_PROGS([AR], [ar xar], [:], [$PATH])
+fi
+AC_SUBST([AR])
+
+## Export the AR macro so that it will be placed in the libtool file
+## correctly.
+export AR
+
+AC_PROG_MAKE_SET
+AC_PROG_INSTALL
+
+
+## ----------------------------------------------------------------------
+## 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
+
+
+## ----------------------------------------------------------------------
+## Check that time can be used with srcdir. This is okay on most systems,
+## but seems to cause problems on Cygwin.
+## 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
+
+
+## The following variables are used to distinguish between building a
+## serial and parallel library.
+##
+## HAVE_PARALLEL -- defined in H5config.h if we are building
+## a parallel library even if configure wasn't
+## able to find some header file or library that
+## might be required. This is defined if the
+## compiler looks like a parallel compiler (e.g.,
+## mpicc or mpcc) or if the user explicitly states
+## that a parallel library is being built by supplying
+## the `--enable-parallel' configure switch.
+##
+## PARALLEL -- This variable is set to a non-null value if
+## configure thinks we're compiling a parallel
+## version of the library.
+##
+## RUNSERIAL -- This is a command which will be prepended to
+## the executable name to run the executable using
+## a single process. For serial versions of the
+## library this will normally be empty. For parallel
+## versions it might be something like `mpiexec -n 1'.
+## The value of this variable is substituted in *.in
+## files.
+##
+## RUNPARALLEL -- This is a command which will be prepended to
+## the executable name to run the executable on
+## multiple processors. For the serial library the
+## value will normally be the empty string. For
+## parallel library it should be something like
+## "mpiexec -n \$\${NPROCS:=6}" where NPROCS will
+## eventually contain the number of processors on which
+## to run the executable (the double dollarsigns are to
+## protect the expansion until make executes the
+## command). The value of this variable is
+## substituted in *.in files.
+##
+AC_SUBST([PARALLEL])
+AC_SUBST([RUNSERIAL])
+AC_SUBST([RUNPARALLEL])
+AC_SUBST([TESTPARALLEL])
+
+## ----------------------------------------------------------------------
+## If the compiler is obviously a parallel compiler then we're building
+## a parallel version of hdf5 and should define HAVE_PARALLEL. Furthermore,
+## the name of the compiler might tell us how to run the resulting
+## executable. For `mpicc' the executable should be run with `mpiexec' from
+## the same directory as mpicc if it exists.
+##
+case "$CC_BASENAME" in
+ mpicc)
+ ## The mpich compiler. Use mpiexec from the same directory if it
+ ## exists.
+ PARALLEL=mpicc
+ AC_MSG_CHECKING([for mpiexec])
+
+ ## 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
+
+ ## 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)
+ ## The IBM compiler
+ PARALLEL="$CC_BASENAME"
+ ;;
+
+ *)
+ ## Probably not a parallel compiler, but if `--enable-parallel'
+ ## is defined below then we're still building a parallel hdf5.
+ ;;
+esac
+
+## ----------------------------------------------------------------------
+## If the Fortran compiler is obviously a parallel compiler then we're
+## building a parallel version of hdf5 and should define HAVE_PARALLEL.
+## Furthermore, the name of the compiler might tell us how to run the
+## resulting executable. For `mpif90' the executable should be run with
+## `mpiexec' from the same directory as mpif90 if it exists.
+##
+
+if test "X$HDF_FORTRAN" = "Xyes" ; then
+ ## Change to the Fortran 90 language
+ AC_LANG_PUSH(Fortran)
+
+ case "$FC" in
+ *mpif90*)
+ ## The Fortran mpich compiler. Use mpiexec from the same directory
+ ## if it exists.
+ PARALLEL=mpif90
+ AC_MSG_CHECKING([for mpiexec])
+
+ ## 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
+
+ ## 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*)
+ ## The IBM compiler
+ PARALLEL="$FC"
+ ;;
+
+ *)
+ ## Probably not a parallel compiler, but if `--enable-parallel'
+ ## is defined below then we're still building a parallel hdf5.
+ ;;
+ esac
+
+ ## Change to the C language
+ AC_LANG_POP(Fortran)
+fi
+
+## -----------------------------------------------------------------------------
+## If shared libraries are being used with parallel, disable them, unless the
+## 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
+
+## ----------------------------------------------------------------------
+## Fortran libraries are not currently supported on Mac. Disable them.
+## (this is overridable with --enable-unsupported).
+##
+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"
+
+ ## 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
+
+ ## 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"])
+
+## ----------------------------------------------------------------------
+## Disable C++ shared libraries if +DD64 flag is detected.
+##
+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"
+
+ ## 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
+
+ ## 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"])
+
+## ----------------------------------------------------------------------
+## pgcc version 6.0x have optimization (-O, -O2 or -O3) problem. Detect
+## these versions and add option "-Mx,28,0x8" to the compiler to avoid
+## the problem if optimization is enabled.
+##
+
+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
+
+## ----------------------------------------------------------------------
+## Shared libraries are not currently supported under Cygwin, so configure
+## 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
+
+## ----------------------------------------------------------------------
+## Windows won't create DLLs without the following macro.
+##
+AC_LIBTOOL_WIN32_DLL
+
+## ----------------------------------------------------------------------
+## Create libtool. If shared/static libraries are going to be enabled
+## or disabled, it should happen before these macros.
+LT_PREREQ([2.2])
+LT_INIT([dlopen])
+
+## ----------------------------------------------------------------------
+## Check if we should install only statically linked executables.
+## This check needs to occur after libtool is initialized because
+## we check a libtool cache value and may issue a warning based
+## on its result.
+AC_MSG_CHECKING([if we should install only statically linked executables])
+AC_ARG_ENABLE([static_exec],
+ [AS_HELP_STRING([--enable-static-exec],
+ [Install only statically linked executables
+ [default=no]])],
+ [STATIC_EXEC=$enableval])
+
+if test "X$STATIC_EXEC" = "Xyes"; then
+ echo "yes"
+ ## 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."
+ LT_STATIC_EXEC=""
+ else
+ LT_STATIC_EXEC="-all-static"
+ fi
+else
+ echo "no"
+ LT_STATIC_EXEC=""
+fi
+AM_CONDITIONAL([USE_PLUGINS_CONDITIONAL], [test "X$LT_STATIC_EXEC" = X])
+
+AC_SUBST([LT_STATIC_EXEC])
+
+## Fix up the INSTALL macro if it's a relative path. We want the
+## full-path to the binary instead.
+case "$INSTALL" in
+ *install-sh*)
+ INSTALL='\${top_srcdir}/bin/install-sh -c'
+ ;;
+esac
+
+## ----------------------------------------------------------------------
+## Some users have reported problems with libtool's use of '-Wl,-rpath' to
+## link shared libraries in nondefault directories. Allow users to
+## disable embedding the rpath information in the executables and to
+## 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],
+ [AS_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=
+ hardcode_into_libs=no
+ ;;
+ X-|X-yes)
+ AC_MSG_RESULT([yes])
+ ;;
+ *)
+ AC_MSG_RESULT([error])
+ AC_MSG_ERROR([\'$enableval\' is not a valid rpath type])
+ ;;
+esac
+
+## ----------------------------------------------------------------------
+## Sometimes makes think the `.PATH:' appearing before the first rule
+## with an action should override the `all' default target. So we have
+## to decide what the proper syntax is.
+##
+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
+
+ ## The second most common method is like above except with the
+ ## 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
+
+ ## 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
+
+ ## 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
+
+## ----------------------------------------------------------------------
+## pmake will throw an error if variables are undefined in a Makefile.
+## These errors can be changed to warnings using the -V flag.
+##
+AC_SUBST([AM_MAKEFLAGS]) AM_MAKEFLAGS=""
+
+## 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
+
+## ----------------------------------------------------------------------
+## Production flags? Save the value in $CONFIG_MODE so we have it for
+## the record.
+##
+AC_MSG_CHECKING([for production mode])
+AC_ARG_ENABLE([production],
+ [AS_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
+
+## ----------------------------------------------------------------------
+## Check for system libraries. "dl" stands for dynamically loaded library
+##
+AC_CHECK_LIB([m], [ceil])
+AC_CHECK_LIB([dl], [dlopen])
+
+if test "`uname`" = "SunOS" -o "`uname -sr`" = "HP-UX B.11.00"; then
+ ## ...for Solaris
+ AC_CHECK_LIB([socket], [socket])
+ AC_CHECK_LIB([nsl], [xdr_int])
+fi
+
+dnl AC_CHECK_LIB([coug], [main]) ## ...for ASCI/Red
+
+## ----------------------------------------------------------------------
+## Check for system header files.
+##
+AC_HEADER_STDC
+AC_HEADER_TIME
+
+## ----------------------------------------------------------------------
+## Check for these two functions before the time headers are checked
+## for, otherwise they are not detected correctly on Solaris (the
+## configure test will fail due to multiply-defined symbols).
+##
+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"])
+
+## 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([dirent.h])
+AC_CHECK_HEADERS([stdint.h], [C9x=yes])
+
+## Darwin
+AC_CHECK_HEADERS([mach/mach_time.h])
+## Also need to detect Darwin for pubconf
+case $host_os in
+ darwin*)
+ AC_DEFINE([HAVE_DARWIN], [1], [Define if Darwin or Mac OS X])
+ ;;
+esac
+
+## 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*)
+ ## The <sys/sysinfo.h> and <sys/proc.h> are needed on the DEC
+ ## Alpha to turn off UAC fixing. We do *not* attempt to
+ ## locate these files on other systems because there are too
+ ## many problems with including them.
+ AC_CHECK_HEADERS([sys/sysinfo.h sys/proc.h])
+ ;;
+ mips*-sgi*-irix*)
+ ## The <sys/fpu.h> is needed on the SGI machines to turn off
+ ## denormalized floating-point values going to zero. We do *not*
+ ## attempt to locate these files on other systems because there
+ ## may be problems with including them.
+ AC_CHECK_HEADERS([sys/fpu.h])
+ AC_CHECK_FUNCS([get_fpc_csr])
+ ;;
+esac
+
+## ----------------------------------------------------------------------
+## Some platforms require that all symbols are resolved when a library
+## is linked. We can use the -no-undefined flag to tell libtool that
+## it will be able to build shared libraries on these architectures,
+## as it will not do so by default.
+##
+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*)
+ ## Add in the -no-undefined flag to LDFLAGS for libtool.
+ AC_MSG_RESULT([yes])
+ H5_LDFLAGS="$H5_LDFLAGS -no-undefined"
+ ;;
+ *)
+ ## Don't add in anything.
+ AC_MSG_RESULT([no])
+ ;;
+ esac
+fi
+
+## ----------------------------------------------------------------------
+## Test for Largefile support.
+##
+AC_MSG_CHECKING([if configure should try to set up large file support])
+
+AC_ARG_ENABLE([largefile],
+ [AS_HELP_STRING([--disable-largefile],
+ [omit support for large files])])
+
+## If largefile support is enabled, then set up appropriate compiler options.
+if test "$enable_largefile" != no; then
+ AC_MSG_RESULT([yes])
+
+ ## Check for needed compiler options. This check is pulled drectly
+ ## 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
+
+ ## Use the macro _AC_SYS_LARGEFILE_MACRO_VALUE to test defines
+ ## that might need to be set for largefile support to behave
+ ## correctly. This macro is defined in acsite.m4 and overrides
+ ## the version provided by Autoconf (as of v2.65). The custom
+ ## macro additionally adds the appropriate defines to AM_CPPFLAGS
+ ## so that later configure checks have them visible.
+
+ ## 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])
+
+ ## 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
+
+ ## Now actually test to see if we can create large files after we've
+ ## 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
+
+## ----------------------------------------------------------------------
+## Add necessary defines for Linux Systems.
+##
+case "$host_cpu-$host_vendor-$host_os" in
+ *linux*)
+ ## If largefile support is enabled, then make available various
+ ## 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
+
+ ## Add POSIX support on Linux systems, so <features.h> defines
+ ## __USE_POSIX, which is required to get the prototype for fdopen
+ ## defined correctly in <stdio.h>.
+ ## This flag was removed from h5cc as of 2009-10-17 when it was found
+ ## that the flag broke compiling netCDF-4 code with h5cc, but kept in
+ ## H5_CPPFLAGS because fdopen and HDfdopen fail without it. HDfdopen
+ ## is used only by H5_debug_mask which is used only when debugging in
+ ## H5_init_library (all in H5.c). When the flag was removed this was
+ ## the only compile failure noted.
+ ## This was originally defined as _POSIX_SOURCE which was updated to
+ ## _POSIX_C_SOURCE=199506L to expose a greater amount of POSIX
+ ## functionality so clock_gettime and CLOCK_MONOTONIC are defined
+ ## correctly.
+ ## POSIX feature information can be found in the gcc manual at:
+ ## http://www.gnu.org/s/libc/manual/html_node/Feature-Test-Macros.html
+ H5_CPPFLAGS="-D_POSIX_C_SOURCE=199506L $H5_CPPFLAGS"
+
+ ## Also add BSD support on Linux systems, so <features.h> defines
+ ## __USE_BSD, which is required to get the prototype for strdup
+ ## defined correctly in <string.h> and snprintf & vsnprintf defined
+ ## correctly in <stdio.h>
+ ## Linking to the bsd-compat library is required as per the gcc manual:
+ ## http://www.gnu.org/s/libc/manual/html_node/Feature-Test-Macros.html
+ ## however, we do not do this since it breaks the big test on some
+ ## older platforms.
+ AM_CPPFLAGS="-D_BSD_SOURCE $AM_CPPFLAGS"
+ ;;
+esac
+
+## Need to add the AM_ and H5_ into CFLAGS/CPPFLAGS to make them visible
+## for configure checks.
+## 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()])])
+
+## ----------------------------------------------------------------------
+## Data types and their sizes.
+##
+AC_TYPE_OFF_T
+AC_CHECK_TYPE([size_t], [],
+ [AC_DEFINE_UNQUOTED([size_t], [unsigned long],
+ [Define to `unsigned long' if <sys/types.h> does not define.])])
+AC_CHECK_TYPE([ssize_t], [],
+ [AC_DEFINE_UNQUOTED([ssize_t], [long],
+ [Define to `long' if <sys/types.h> does not define.])])
+AC_CHECK_TYPE([ptrdiff_t], [],
+ [AC_DEFINE_UNQUOTED([ptrdiff_t], [long],
+ [Define to `long' if <sys/types.h> does not define.])])
+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])
+
+## Checkpoint the cache
+AC_CACHE_SAVE
+
+## 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])
+
+## Checkpoint the cache
+AC_CACHE_SAVE
+
+## ----------------------------------------------------------------------
+## Check if the dev_t type is a scalar type (must come after the check for
+## 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])
+)
+
+## ----------------------------------------------------------------------
+## Fake --with-xxx option to allow us to create a help message for the
+## following --with-xxx options which can take either a =DIR or =INC,LIB
+## specifier.
+##
+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
+ ])
+
+## ----------------------------------------------------------------------
+## Is the dmalloc present? It has a header file `dmalloc.h' and a library
+## `-ldmalloc' and their locations might be specified with the `--with-dmalloc'
+## command-line switch. The value is an include path and/or a library path.
+## If the library path is specified then it must be preceded by a comma.
+##
+AC_ARG_WITH([dmalloc],
+ [AS_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],, [unset HAVE_DMALLOC])
+ if test "x$HAVE_DMALLOC" = "xyes"; then
+ AC_CHECK_LIB([dmalloc], [dmalloc_shutdown],, [unset HAVE_DMALLOC])
+ fi
+ 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
+
+ ## Trying to include -I/usr/include and -L/usr/lib is redundant and
+ ## 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"] [unset HAVE_DMALLOC])
+
+ if test "x$HAVE_DMALLOC" = "xyes"; then
+ 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])
+ fi
+
+ if test -z "$HAVE_DMALLOC" -a -n "$HDF5_CONFIG_ABORT"; then
+ AC_MSG_ERROR([couldn't find dmalloc library])
+ fi
+ ;;
+esac
+
+## ----------------------------------------------------------------------
+## Is the GNU zlib present? It has a header file `zlib.h' and a library
+## `-lz' and their locations might be specified with the `--with-zlib'
+## command-line switch. The value is an include path and/or a library path.
+## If the library path is specified then it must be preceded by a comma.
+##
+AC_SUBST([USE_FILTER_DEFLATE]) USE_FILTER_DEFLATE="no"
+AC_ARG_WITH([zlib],
+ [AS_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"], [unset HAVE_ZLIB])
+ if test "x$HAVE_ZLIB" = "xyes" -a "x$HAVE_ZLIB_H" = "xyes"; then
+ AC_CHECK_LIB([z], [compress2],, [unset HAVE_ZLIB])
+ fi
+ if test -z "$HAVE_ZLIB"; then
+ if test -n "$HDF5_CONFIG_ABORT"; then
+ AC_MSG_ERROR([couldn't find zlib library])
+ fi
+ else
+ AC_CHECK_FUNC([compress2], [HAVE_COMPRESS2="yes"])
+ 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
+
+ ## Trying to include -I/usr/include and -L/usr/lib is redundant and
+ ## 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"] [unset HAVE_ZLIB])
+
+ if test -n "$zlib_lib"; then
+ LDFLAGS="$LDFLAGS -L$zlib_lib"
+ AM_LDFLAGS="$AM_LDFLAGS -L$zlib_lib"
+ fi
+
+ if test "x$HAVE_ZLIB" = "xyes" -a "x$HAVE_ZLIB_H" = "xyes"; then
+ AC_CHECK_LIB([z], [compress2],,
+ [LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset HAVE_ZLIB])
+ fi
+
+ if test -z "$HAVE_ZLIB"; then
+ if test -n "$HDF5_CONFIG_ABORT"; then
+ AC_MSG_ERROR([couldn't find zlib library])
+ fi
+ else
+ AC_CHECK_FUNC([compress2], [HAVE_COMPRESS2="yes"])
+ 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"
+
+ ## 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
+
+
+## ----------------------------------------------------------------------
+## Is the szlib present? It has a header file `szlib.h' and a library
+## `-lsz' and their locations might be specified with the `--with-szlib'
+## command-line switch. The value is an include path and/or a library path.
+## If the library path is specified then it must be preceded by a comma.
+##
+AC_SUBST([USE_FILTER_SZIP]) USE_FILTER_SZIP="no"
+AC_ARG_WITH([szlib],
+ [AS_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"], [unset HAVE_SZLIB])
+ if test "x$HAVE_SZLIB" = "xyes" -a "x$HAVE_SZLIB_H" = "xyes"; then
+ AC_CHECK_LIB([sz], [SZ_BufftoBuffCompress],, [unset HAVE_SZLIB])
+ fi
+ 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
+
+ ## Trying to include -I/usr/include and -L/usr/lib is redundant and
+ ## 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"] [unset HAVE_SZLIB])
+
+ if test -n "$szlib_lib"; then
+ LDFLAGS="$LDFLAGS -L$szlib_lib"
+ AM_LDFLAGS="$AM_LDFLAGS -L$szlib_lib"
+ fi
+
+ if test "x$HAVE_SZLIB" = "xyes" -a "x$HAVE_SZLIB_H" = "xyes"; then
+ AC_CHECK_LIB([sz], [SZ_BufftoBuffCompress],,
+ [LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset HAVE_SZLIB])
+ fi
+
+ 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
+ ## SZLIB library is available. Check if it can encode
+ AC_MSG_CHECKING([for szlib encoder])
+
+ ## Set LD_LIBRARY_PATH so encoder test can find the library and run.
+ ## Also add LL_PATH substitution to Makefiles so they can use the
+ ## path as well, for testing examples.
+ if test -z "$LD_LIBRARY_PATH"; then
+ export LD_LIBRARY_PATH="$szlib_lib"
+ else
+ export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$szlib_lib"
+ 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
+
+ ## 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"])
+
+## Checkpoint the cache
+AC_CACHE_SAVE
+
+## ----------------------------------------------------------------------
+## Enable thread-safe version of library. It requires Pthreads support
+## on POSIX systems.
+##
+AC_MSG_CHECKING([for thread safe support])
+AC_ARG_ENABLE([threadsafe],
+ [AS_HELP_STRING([--enable-threadsafe],
+ [Enable thread-safe capability])],
+ [THREADSAFE=$enableval])
+
+## The --enable-threadsafe flag is not compatible with --enable-cxx.
+## If the user tried to specify both flags, throw an error, unless
+## they also provided the --enable-unsupported flag.
+if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
+ if test "X${HDF_CXX}" = "Xyes" -a "X${enable_threadsafe}" = "Xyes"; then
+ AC_MSG_ERROR([--enable-cxx and --enable-threadsafe flags are incompatible. Use --enable-unsupported to override this error.])
+ fi
+fi
+
+## --enable-threadsafe is also incompatible with --enable-fortran, unless
+## --enable-unsupported has been specified on the configure line.
+if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
+ if test "X${HDF_FORTRAN}" = "Xyes" -a "X${enable_threadsafe}" = "Xyes"; then
+ AC_MSG_ERROR([--enable-fortran and --enable-threadsafe flags are incompatible. Use --enable-unsupported to override this error.])
+ fi
+fi
+
+case "X-$THREADSAFE" in
+ X-|X-no)
+ AC_MSG_RESULT([no])
+ ;;
+ X-yes)
+ THREADSAFE=yes
+ AC_MSG_RESULT([yes])
+ ;;
+ *)
+ 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])
+
+ ## ----------------------------------------------------------------------
+ ## Is the pthreads library present? It has a header file `pthread.h' and
+ ## a library `-lpthread' and their locations might be specified with the
+ ## `--with-pthread' command-line switch. The value is an include path
+ ## and/or a library path. If the library path is specified then it must
+ ## be preceded by a comma.
+ ##
+ ## Thread-safety in HDF5 only uses Pthreads via configure, so the
+ ## default is "yes", though this only has an effect when
+ ## --enable-threadsafe is specified.
+ AC_SUBST([HAVE_PTHREAD]) HAVE_PTHREAD=yes
+ AC_ARG_WITH([pthread],
+ [AS_HELP_STRING([--with-pthread=DIR],
+ [Specify alternative path to Pthreads library when thread-safe capability is built])],,
+ [withval=yes])
+
+ case "$withval" in
+ yes)
+ AC_CHECK_HEADERS([pthread.h],, [unset HAVE_PTHREAD])
+ if test "x$HAVE_PTHREAD" = "xyes"; then
+ AC_CHECK_LIB([pthread], [pthread_self],, [unset HAVE_PTHREAD])
+ fi
+ ;;
+ no)
+ AC_MSG_CHECKING([for pthread])
+ AC_MSG_RESULT([suppressed])
+ unset HAVE_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
+
+ ## Trying to include -I/usr/include and -L/usr/lib is redundant and
+ ## 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 HAVE_PTHREAD])
+ else
+ AC_CHECK_HEADERS([pthread.h],, [unset HAVE_PTHREAD])
+ fi
+
+ if test "x$HAVE_PTHREAD" = "xyes"; then
+ 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 HAVE_PTHREAD])
+ else
+ AC_CHECK_LIB([pthread], [pthread_self],, [unset HAVE_PTHREAD])
+ fi
+ fi
+ ;;
+ esac
+fi
+
+## ----------------------------------------------------------------------
+## Check for MONOTONIC_TIMER support (used in clock_gettime). This has
+## to be done after any POSIX/BSD defines to ensure that the test gets
+## the correct POSIX level on linux.
+AC_CHECK_DECL([CLOCK_MONOTONIC],[have_clock_monotonic="yes"],[have_clock_monotonic="no"],[[#include <time.h>]])
+
+## ----------------------------------------------------------------------
+## How does one figure out the local time zone? Anyone know of a
+## Posix way to do this?
+##
+
+## 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])])
+
+## 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])])
+
+## 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
+
+## 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])])
+
+## 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
+
+## ----------------------------------------------------------------------
+## Does the struct stat have the st_blocks field? This field is not Posix.
+##
+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])])
+
+## ----------------------------------------------------------------------
+## How do we figure out the width of a tty in characters?
+##
+AC_CHECK_FUNCS([_getvideoconfig gettextinfo])
+case "`uname`" in
+ CYGWIN*)
+ ;;
+ *)
+ AC_CHECK_FUNCS([GetConsoleScreenBufferInfo])
+ ;;
+esac
+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])])
+
+
+## ----------------------------------------------------------------------
+## Check for functions.
+##
+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 asprintf vasprintf waitpid])
+
+## Check for vsnprintf() separately, so we can detect situations where it
+## doesn't return the correct size for formatted strings that are too large
+## for the buffer provided
+AC_CHECK_FUNCS([vsnprintf],
+
+ ## Check if vsnprintf() returns correct size for strings that don't fit
+ ## into the size allowed. If vsnprintf() works correctly on this platform,
+ ## it should return a value of 42 for the test below
+ ##
+ ## Note that vsnprintf fails in two different ways:
+ ## - In IRIX64, calls to vnsprintf() with a formatted string that
+ ## is larger than the buffer size allowed incorrectly
+ ## return the size of the buffer minus one.
+ ## - In HP/UX, calls to vsnprintf() with a formatted string that
+ ## is larger than the buffer size allowed incorrectly
+ ## 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
+ ,)
+
+## ----------------------------------------------------------------------
+## Check that a lone colon can be used as an argument
+## This is not true on Cray X1, which interprets a lone colon as a
+## system command.
+##
+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 -o a.out> /dev/null 2> /dev/null
+ echo "./a.out :" > conftest.sh
+ chmod 700 conftest.sh
+
+ ./conftest.sh 2> conftest.out
+ rm -f 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"
+
+## ----------------------------------------------------------------------
+## Check compiler characteristics
+##
+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])])
+
+## ----------------------------------------------------------------------
+## Try to figure out how to print `long long'. Some machines use `%lld'
+## and others use `%qd'. There may be more! The final `l' is a
+## default in case none of the others work.
+##
+AC_MSG_CHECKING([how to print long long])
+AC_CACHE_VAL([hdf5_cv_printf_ll], [
+
+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])
+
+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'])
+
+## ----------------------------------------------------------------------
+## Check if pthread_attr_setscope(&attribute, PTHREAD_SCOPE_SYSTEM)
+## is supported on this system
+##
+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
+
+## ----------------------------------------------------------------------
+## Turn on debugging by setting compiler flags
+## This must come after the enable-production since it depends on production.
+##
+AC_MSG_CHECKING([for debug flags])
+AC_ARG_ENABLE([debug],
+ [AS_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])
+
+## 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
+
+## ----------------------------------------------------------------------
+## Check if they would like the function stack support compiled in
+##
+AC_MSG_CHECKING([whether function stack tracking is enabled])
+AC_ARG_ENABLE([codestack],
+ [AS_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
+
+## ----------------------------------------------------------------------
+## Check if they would like the metadata trace file code compiled in
+##
+AC_MSG_CHECKING([whether metadata trace file code is enabled])
+AC_ARG_ENABLE([metadata-trace-file],
+ [AS_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
+
+## ----------------------------------------------------------------------
+## Enable tracing of the API
+## This must come after the enable-debug since it depends on debug.
+##
+AC_SUBST([TRACE_API])
+AC_MSG_CHECKING([for API tracing]);
+AC_ARG_ENABLE([trace],
+ [AS_HELP_STRING([--enable-trace],
+ [Enable API tracing capability. Default=no
+ if debug is disabled.])],
+ [TRACE=$enableval])
+
+## 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
+
+## ----------------------------------------------------------------------
+## Enable instrumenting of the library's internal operations
+## This must come after the enable-debug since it depends on debug.
+##
+AC_SUBST([INSTRUMENT_LIBRARY])
+AC_MSG_CHECKING([for instrumented library]);
+AC_ARG_ENABLE([instrument],
+ [AS_HELP_STRING([--enable-instrument],
+ [Enable library instrumentation of optimization
+ tracing. Default=no if debug is disabled.])],
+ [INSTRUMENT=$enableval])
+
+## 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
+
+## ----------------------------------------------------------------------
+## Check if they would like to securely clear file buffers before they are
+## written.
+##
+AC_SUBST([CLEARFILEBUF])
+AC_MSG_CHECKING([whether to clear file buffers])
+AC_ARG_ENABLE([clear-file-buffers],
+ [AS_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
+
+## ----------------------------------------------------------------------
+## Check if they would like to use a memory checking tool (like valgrind's
+## 'memcheck' tool, or Rational Purify, etc) and the library should be
+## more scrupulous with it's memory operations. Enabling this also
+## disables the library's free space manager code.
+##
+AC_SUBST([USINGMEMCHECKER])
+AC_MSG_CHECKING([whether a memory checking tool will be used])
+AC_ARG_ENABLE([using-memchecker],
+ [AS_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
+
+## Checkpoint the cache
+AC_CACHE_SAVE
+
+## What header files and libraries do we have to look for for parallel
+## support? For the most part, search paths are already specified with
+## CPPFLAGS and LDFLAGS or are known to the compiler. If the user says
+## `--disable-parallel' but specifies a known parallel compiler (like mpicc
+## or mpcc) then parallel support is enabled but configure doesn't search
+## for any parallel header files or libraries.
+##
+AC_ARG_ENABLE([parallel],
+ [AS_HELP_STRING([--enable-parallel],
+ [Search for MPI-IO and MPI support files])])
+
+## The --enable-parallel flag is not compatible with --enable-cxx.
+## If the user tried to specify both flags, throw an error, unless
+## 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
+
+## --enable-parallel is also incompatible with --enable-threadsafe, unless
+## --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
+
+## It's possible to build in parallel by specifying a parallel compiler
+## without using the --enable-parallel flag. This isn't allowed with
+## C++ or threadsafe, either, unless the --enable-unsupported flag
+## 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)
+ ## Either we are not compiling for parallel or the header and
+ ## library files and locations are known to the compiler (this is
+ ## the case for a correct installation of mpicc for instance).
+ AC_MSG_RESULT([skipped])
+ ;;
+
+ X-yes)
+ ## We want to compile a parallel library with a compiler that
+ ## may already know how to link with MPI and MPI-IO.
+ AC_MSG_RESULT([provided by compiler])
+ PARALLEL=yes
+
+ ## Try link a simple MPI program. If fail, try again with -lmpi and
+ ## -lmpich.
+ AC_TRY_LINK(, [MPI_Init()],,
+ [AC_CHECK_LIB([mpi], [MPI_Init],,
+ [AC_CHECK_LIB([mpich], [MPI_Init],, [PARALLEL=no])])])
+
+ ## Then try link a simple MPI-IO program. If fail, try again with
+ ## -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
+ ## Change to the Fortran 90 language
+ AC_LANG_PUSH(Fortran)
+
+ ## 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], [mpi_file_open],, [PARALLEL=no])])
+
+ ## Then try link a simple MPI-IO program. If fail, try again with
+ ## -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], [mpi_file_open],, [PARALLEL=no])])
+ fi
+
+ ## Change to the C language
+ AC_LANG_POP(Fortran)
+ fi
+
+ ## Set RUNPARALLEL to mpiexec if not set yet.
+ ## Check for building on Cray if RUNPARALLEL is not yet set by checking
+ ## for 'aprun' command (which is the parallel job launcher, like mpiexec).
+ if test "X$PARALLEL" = "Xyes" -a -z "$RUNPARALLEL"; then
+ ## 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
+
+ ## 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
+
+## ----------------------------------------------------------------------
+## Print some other parallel information and do some sanity checks.
+##
+AC_SUBST([ADD_PARALLEL_FILES]) ADD_PARALLEL_FILES="no"
+
+if test -n "$PARALLEL"; then
+ ## The 'testpar' directory should participate in the build
+ TESTPARALLEL=testpar
+
+ ## We are building a parallel library
+ AC_DEFINE([HAVE_PARALLEL], [1], [Define if we have parallel support])
+
+ ## 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])
+
+ ## 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])])
+
+ ## There *must* be some way to run in parallel even if it's just the
+ ## word `none'.
+ if test -z "$RUNPARALLEL"; then
+ AC_MSG_ERROR([no way to run a parallel program])
+ fi
+
+ ## If RUNSERIAL or RUNPARALLEL is the word `none' then replace it with
+ ## 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
+
+ ## --------------------------------------------------------------------
+ ## Do we want MPE instrumentation feature on?
+ ##
+ ## This must be done after enable-parallel is checked since it depends
+ ## on a mpich compiler.
+ ##
+ MPE=yes
+ AC_ARG_WITH([mpe],
+ [AS_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], [MPE_Init_mpi_io],, [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
+
+ ## Trying to include -I/usr/include and -L/usr/lib is redundant and
+ ## 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], [MPE_Init_mpi_io],,
+ [LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset MPE])
+
+ else
+ AC_CHECK_LIB([mpe], [MPE_Init_log],, [unset MPE])
+ AC_CHECK_LIB([lmpe], [MPE_Init_mpi_io],, [unset MPE])
+ fi
+ ;;
+ esac
+
+ if test "X-$MPE" = "X-yes"; then
+ AC_DEFINE([HAVE_MPE], [1], [Define if we have MPE support])
+ fi
+fi
+
+## ----------------------------------------------------------------------
+## Turn on internal I/O filters by setting macros in header files
+## Internal I/O filters are contained entirely within the library and do
+## not depend on external headers or libraries. The shuffle filter is
+## an example of an internal filter, while the gzip filter is an example of
+## an external filter. Each external filter is controlled with an
+## "--with-foo=" configure flag.
+##
+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],
+ [AS_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])
+
+## 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
+ ## ------------------------------------------------------------------
+ ## Have to use separate 'if' construct for each filter, so that
+ ## autoheader can detect the AC_DEFINE for each one...
+ ##
+ 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
+
+## ----------------------------------------------------------------------
+## This is defined only when we're using CodeWarrior, since it has a
+## broken "open()" call.
+#
+if test 1 = 2; then
+ AC_DEFINE([NO_SHARED_WRITING], [1],
+ [Define if shared writing must be disabled (CodeWarrior only)])
+fi
+
+## --------------------------------------------------------------------------
+## Should the Default Virtual File Driver be compiled?
+##
+
+AC_MSG_CHECKING([for Default Virtual File Driver definition])
+AC_ARG_WITH([default-vfd],
+ [AS_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
+
+## ----------------------------------------------------------------------
+## Check if Direct I/O driver is enabled by --enable-direct-vfd
+##
+
+AC_MSG_CHECKING([for Direct Virtual File Driver support])
+
+AC_ARG_ENABLE([direct-vfd],
+ [AS_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"])
+
+## ----------------------------------------------------------------------
+## Enable custom plugin default path for library. It requires SHARED support.
+##
+AC_MSG_CHECKING([for custom plugin default path definition])
+AC_ARG_WITH([default-plugindir],
+ [AS_HELP_STRING([--with-default-plugindir=location],
+ [Specify default location for plugins
+ [default="/usr/local/hdf5/lib/plugin"]])],,
+ withval="/usr/local/hdf5/lib/plugin")
+
+if test "X$withval" = "X"; then
+ AC_MSG_RESULT([default])
+ default_plugindir="/usr/local/hdf5/lib/plugin"
+else
+ AC_MSG_RESULT([$withval])
+ default_plugindir=$withval
+fi
+
+AC_DEFINE_UNQUOTED([DEFAULT_PLUGINDIR], ["$default_plugindir"],
+ [Define the default plugins path to compile])
+
+## ----------------------------------------------------------------------
+## Decide whether the presence of user's exception handling functions is
+## checked and data conversion exceptions are returned. This is mainly
+## for the speed optimization of hard conversions. Soft conversions can
+## actually benefit little.
+##
+AC_MSG_CHECKING([whether exception handling functions is checked during data conversions])
+AC_ARG_ENABLE([dconv-exception],
+ [AS_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
+
+## ----------------------------------------------------------------------
+## Decide whether the data accuracy has higher priority during data
+## conversions. If not, some hard conversions will still be prefered even
+## though the data may be wrong (for example, some compilers don't
+## support denormalized floating values) to maximize speed.
+##
+AC_MSG_CHECKING([whether data accuracy is guaranteed during data conversions])
+AC_ARG_ENABLE([dconv-accuracy],
+ [AS_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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can handle converting
+## denormalized floating-point values.
+## (This flag should be set for all machines, except for the Crays, where
+## the cache value is set in it's config file)
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can handle converting
+## floating-point to long long values.
+## (This flag should be _unset_ for all machines, except for Windows, where
+## it's set in the custom Windows H5pubconf.h file)
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine has window style pathname,
+## that is, "drive-letter:\" (e.g. "C:") or "drive-letter:/" (e.g. "C:/").
+## (This flag should be _unset_ for all machines, except for Windows, where
+## it's set in the custom Windows H5pubconf.h file)
+##
+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
+
+## -----------------------------------------------------------------------
+## Set flag to indicate that the machine can handle conversion from
+## long double to integers accurately. This flag should be set "yes" for
+## all machines except all SGIs. For SGIs, some conversions are
+## incorrect and its cache value is set "no" in its config/irix6.x and
+## irix5.x.
+##
+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
+
+## -----------------------------------------------------------------------
+## Set flag to indicate that the machine can do conversion from
+## long double to integers regardless of accuracy. This flag should be
+## set "yes" for all machines except HP-UX 11.00. For HP-UX 11.00, the
+## compiler has 'floating exception' when converting 'long double' to all
+## integers except 'unsigned long long'. Other HP-UX systems are unknown
+## 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
+
+## -----------------------------------------------------------------------
+## Set flag to indicate that the machine can handle conversion from
+## integers to long double. (This flag should be set "yes" for all
+## machines except all SGIs, where some conversions are
+## incorrect and its cache value is set "no" in its config/irix6.x and
+## irix5.x)
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can accurately convert
+## 'unsigned long' to 'float' values.
+## (This flag should be set for all machines, except for Pathscale compiler
+## on Sandia's Linux machine where the compiler interprets 'unsigned long'
+## values as negative when the first bit of 'unsigned long' is on during
+## the conversion to float.)
+##
+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
+
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can accurately convert
+## 'unsigned (long) long' values to 'float' and 'double' values.
+## (This flag should be set for all machines, except for the SGIs, where
+## the cache value is set in the config/irix6.x config file) and Solaris
+## 64-bit machines, where the short program below tests if round-up is
+## correctly handled.
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can accurately convert
+## 'float' or 'double' to 'unsigned long long' values.
+## (This flag should be set for all machines, except for PGI compiler
+## where round-up happens when the fraction of float-point value is greater
+## than 0.5.
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can accurately convert
+## 'float', 'double' or 'long double' to 'unsigned long long' values.
+## (This flag should be set for all machines, except for HP-UX machines
+## where the maximal number for unsigned long long is 0x7fffffffffffffff
+## during conversion.
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can accurately convert
+## 'long double' to 'unsigned int' values. (This flag should be set for
+## all machines, except for some Intel compilers on some Linux.)
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can _compile_
+## 'unsigned long long' to 'float' and 'double' typecasts.
+## (This flag should be set for all machines, except for under Windows when
+## compiled with Visual Studio 6, where the macro value is set in the
+## src/H5pubconf.h file)
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can _compile_
+## 'long long' to 'float' and 'double' typecasts.
+## (This flag should be set for all machines, except for under Windows when
+## compiled with Visual Studio 6, where the macro value is set in the
+## src/H5pubconf.h file)
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can convert from
+## 'unsigned long long' to 'long double' without precision loss.
+## (This flag should be set for all machines, except for FreeBSD(sleipnir)
+## where the last 2 bytes of mantissa are lost when compiler tries to do
+## the conversion, and Cygwin where compiler doesn't do rounding correctly.)
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can handle overflow converting
+## all floating-point to all integer types.
+## (This flag should be set for all machines, except for Cray X1 where
+## floating exception is generated when the floating-point value is greater
+## than the maximal integer value).
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine is using a special algorithm to convert
+## 'long double' to '(unsigned) long' values. (This flag should only be set for
+## the IBM Power6 Linux. When the bit sequence of long double is
+## 0x4351ccf385ebc8a0bfcc2a3c3d855620, the converted value of (unsigned)long
+## is 0x004733ce17af227f, not the same as the library's conversion to 0x004733ce17af2282.
+## The machine's conversion gets the correct value. We define the macro and disable
+## this kind of test until we figure out what algorithm they use.
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine is using a special algorithm
+## to convert some values of '(unsigned) long' to 'long double' values.
+## (This flag should be off for all machines, except for IBM Power6 Linux,
+## when the bit sequences are 003fff..., 007fff..., 00ffff..., 01ffff...,
+## ..., 7fffff..., the compiler uses a unknown algorithm. We define a
+## macro and skip the test for now until we know about the algorithm.
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can accurately convert
+## 'long double' to '(unsigned) long long' values. (This flag should be set for
+## all machines, except for Mac OS 10.4 and SGI IRIX64 6.5. When the bit sequence
+## of long double is 0x4351ccf385ebc8a0bfcc2a3c..., the values of (unsigned)long long
+## start to go wrong on these two machines. Adjusting it higher to
+## 0x4351ccf385ebc8a0dfcc... or 0x4351ccf385ebc8a0ffcc... will make the converted
+## values wildly wrong. This test detects this wrong behavior and disable the test.
+##
+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
+
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine can accurately convert
+## '(unsigned) long long' to 'long double' values. (This flag should be set for
+## all machines, except for Mac OS 10.4, when the bit sequences are 003fff...,
+## 007fff..., 00ffff..., 01ffff..., ..., 7fffff..., the converted values are twice
+## as big as they should be.
+##
+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
+
+## ----------------------------------------------------------------------
+## Set the flag to indicate that the machine generates bad code
+## for the H5VM_log2_gen() routine in src/H5VMprivate.h
+## (This flag should be set to no for all machines, except for SGI IRIX64,
+## where the cache value is set to yes in it's config file)
+##
+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
+
+## ----------------------------------------------------------------------
+## Set some variables for general configuration information to be saved
+## and installed with the libraries.
+##
+
+## 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])
+
+## Configuration date
+AC_SUBST([CONFIG_DATE]) CONFIG_DATE="`date`"
+
+## User doing the configuration
+AC_SUBST([CONFIG_USER]) CONFIG_USER="`whoami`@`hostname`"
+if test -n "$ORGANIZATION"; then
+ CONFIG_USER="$CONFIG_USER at $ORGANIZATION"
+fi
+
+## Configuration mode (production, development, profile, etc) saved above.
+AC_SUBST([CONFIG_MODE])
+
+## 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])
+
+## Parallel support? (set above except empty if none)
+PARALLEL=${PARALLEL:-no}
+
+## Compiler with version information. This consists of the full path
+## name of the compiler and the reported version number.
+AC_SUBST([CC_VERSION])
+## 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])
+## Strip anything that looks like a flag off of $FC
+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])
+## Strip anything that looks like a flag off of $CXX
+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
+
+## ----------------------------------------------------------------------
+## Where is the root of the source tree. Give an absolute address so
+## we can find it no matter which directory of the distribution is our
+## current directory. The built-in pwd fails on some systems, but the
+## /bin/pwd version works OK.
+##
+if test -x /bin/pwd; then
+ pwd=/bin/pwd
+else
+ pwd=pwd
+fi
+AC_SUBST([ROOT]) ROOT="`$pwd`"
+
+## ----------------------------------------------------------------------
+## Move any compiler-specific libraries into the main LIBS varaible.
+##
+LIBS="$DEFAULT_LIBS $LIBS"
+
+## ----------------------------------------------------------------------
+## Determine the runtime libraries we may need to include in the
+## libtools command so that executables will find the correct dynamic
+## libraries.
+##
+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
+ .*)
+ ## If the path isn't absolute, make it so by
+ ## 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.*)
+ ## If the path isn't absolute, make it so by prepending
+ ## 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
+
+## ----------------------------------------------------------------------
+## Check if they would like the High Level library compiled
+##
+
+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],
+ [AS_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])
+
+## Check if Fortran's default real is double precision. If it is and HL is being built then configure
+## should fail due to bug HDFFV-889.
+ if test "X$FORTRAN_DEFAULT_REALisDBLE" = "Xyes"; then
+ AC_MSG_ERROR([Fortran high-level routines are not supported when the default REAL is DOUBLE PRECISION, use configure option --disable-hl.])
+ fi
+else
+ echo "no"
+fi
+
+
+## ----------------------------------------------------------------------
+## Some programs shouldn't be built by default (e.g., programs to generate
+## data files used by tests, some optional tests).
+## Check if they want such programs built anyway.
+##
+AC_MSG_CHECKING([additional programs should be built])
+AC_ARG_ENABLE([build-all],
+ [AS_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"])
+
+## ----------------------------------------------------------------------
+## Enable deprecated public API symbols
+##
+AC_SUBST([DEPRECATED_SYMBOLS])
+AC_MSG_CHECKING([if deprecated public symbols are available]);
+AC_ARG_ENABLE([deprecated-symbols],
+ [AS_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
+
+## --------------------------------------------------------------------------
+## Which version of the public APIs should the 'base' versioned symbols use?
+##
+
+AC_SUBST([DEFAULT_API_VERSION])
+AC_MSG_CHECKING([which version of public symbols to use by default])
+AC_ARG_WITH([default-api-version],
+ [AS_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
+
+## It's an error to try to disable deprecated public API symbols while
+## choosing an older version of the public API as the default. However,
+## if the user insists on doing this via the --enable-unsupported configure
+## 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
+
+## ----------------------------------------------------------------------
+## Enable strict file format checks
+##
+AC_SUBST([STRICT_FORMAT_CHECKS])
+AC_MSG_CHECKING([whether to perform strict file format checks]);
+AC_ARG_ENABLE([strict-format-checks],
+ [AS_HELP_STRING([--enable-strict-format-checks],
+ [Enable strict file format checks, default=yes if
+ debug flag is enabled, no otherwise])],
+ [STRICT_CHECKS=$enableval])
+
+## 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
+
+
+## ----------------------------------------------------------------------
+## Enable embedded library information
+##
+AC_MSG_CHECKING([whether to have library information embedded in the executables])
+AC_ARG_ENABLE([embedded-libinfo],
+ [AS_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
+
+
+## ----------------------------------------------------------------------
+## Check if pointer alignments are enforced
+##
+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])
+ ])
+
+
+## ----------------------------------------------------------------------
+## Restore user's CFLAGS.
+CFLAGS="$saved_user_CFLAGS"
+FCFLAGS="$saved_user_FCFLAGS"
+CXXFLAGS="$saved_user_CXXFLAGS"
+CPPFLAGS="$saved_user_CPPFLAGS"
+LDFLAGS="$saved_user_LDFLAGS"
+
+
+## ----------------------------------------------------------------------
+## Create automake conditionals to tell automake makefiles which directories
+## 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"])
+
+
+## ----------------------------------------------------------------------
+## Build the Makefiles.
+##
+
+## 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
+
+## We don't need to say when we're entering directories if we're using
+## 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
+
+## Some cleanup stuff
+rm -f conftest conftest.o conftest.c dummy.o *.mod
+
+## Build config.status, touch the stamp files, and build all the Makefiles.
+## The order is such that the first `make' does not need to update any
+## configuration information. See config/commence.in for the order in which
+## 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"
+
+ if test "X$HDF_FORTRAN" = "Xyes"; then
+ FORTRAN_PARALLEL_MAKE=fortran/$TESTPARALLEL/Makefile
+ fi
+fi
+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
+
+## 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
+
+## Are we compiling static libraries, shared libraries, or both? This
+## is only used for the libhdf5.settings file. We can't just look at
+## $enable_static and $enable_shared because if they're yes the ltconfig
+## might have decided that one or the other is simply not possible.
+## Therefore we have to ask the generated `libtool' shell script
+## 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
+
+## ----------------------------------------------------------------------
+## Set a macro if shared library is enabled.
+##
+AM_CONDITIONAL([HAVE_SHARED_CONDITIONAL], [test "X$enable_shared" = "Xyes"])
+
+AC_CONFIG_FILES([src/libhdf5.settings
+ Makefile
+ src/Makefile
+ test/Makefile
+ test/testcheck_version.sh
+ test/testerror.sh
+ test/H5srcdir_str.h
+ test/testlibinfo.sh
+ test/testlinks_env.sh
+ test/test_plugin.sh
+ testpar/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/h5import/h5importtestutil.sh
+ tools/h5diff/Makefile
+ tools/h5diff/testh5diff.sh
+ tools/h5diff/testph5diff.sh
+ tools/h5jam/Makefile
+ tools/h5jam/testh5jam.sh
+ tools/h5repack/Makefile
+ tools/h5repack/h5repack.sh
+ tools/h5repack/h5repack_plugin.sh
+ tools/h5ls/Makefile
+ tools/h5copy/Makefile
+ tools/h5copy/testh5copy.sh
+ tools/lib/Makefile
+ tools/misc/Makefile
+ tools/misc/h5cc
+ tools/misc/testh5mkgrp.sh
+ tools/misc/testh5repart.sh
+ tools/h5stat/testh5stat.sh
+ tools/h5stat/Makefile
+ tools/perform/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/tools/Makefile
+ hl/tools/gif2h5/Makefile
+ hl/tools/gif2h5/h52giftest.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
+
+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
+
+## We don't want inline defined for C++ compilers
+## Don't worry about the C++ ifdef wrappers in the H5pubconf file, since
+## 'H5_inline' isn't a C++ keyword.
+cat >> src/H5config.h <<EOF
+
+#if defined(__cplusplus) && defined(inline)
+#undef inline
+#endif
+EOF
+
+## show the configure settings
+cat src/libhdf5.settings