mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-12-27 08:01:04 +08:00
5262b98b34
* commit '804a88fafdca3d6a76312ab01ac4d6d5b103e9dc': Fix for HDFFV-10160 Modifications to fix the assertion/abort failure when the application does not close the file.
3501 lines
120 KiB
Plaintext
3501 lines
120 KiB
Plaintext
## 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 COPYING file, which can be found at the root of the source code
|
|
## distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases.
|
|
## 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.11.0], [help@hdfgroup.org])
|
|
|
|
AC_CONFIG_SRCDIR([src/H5.c])
|
|
AC_CONFIG_HEADERS([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 subdir-objects])
|
|
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) # use silent rules where available - automake 1.11
|
|
|
|
## AM_MAINTAINER_MODE turns off "rebuild rules" that contain dependencies
|
|
## for Makefiles, configure, src/H5config.h, etc. If AM_MAINTAINER_MODE
|
|
## is enabled, 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.
|
|
##
|
|
## By default, it is enabled. Users can configure with
|
|
## --disable-maintainer-mode to prevent running the autotools.
|
|
AM_MAINTAINER_MODE([enable])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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.
|
|
##
|
|
## There are currently no hosts, but if there were they would be
|
|
## listed by hostname and the alias would point to a file in
|
|
## the config directory:
|
|
##
|
|
##case $host_alias in
|
|
## <some host>)
|
|
## host_alias=<config file in config directory>
|
|
## ;;
|
|
##esac
|
|
|
|
AC_CANONICAL_HOST
|
|
AC_SUBST([CPPFLAGS])
|
|
AC_SUBST([JNIFLAGS])
|
|
|
|
## 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_JNIFLAGS])
|
|
AC_SUBST([H5_JAVACFLAGS])
|
|
AC_SUBST([H5_JAVAFLAGS])
|
|
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_JNIFLAGS])
|
|
AC_SUBST([AM_JAVACFLAGS])
|
|
AC_SUBST([AM_JAVAFLAGS])
|
|
AC_SUBST([AM_LDFLAGS])
|
|
|
|
## Make sure flags are initialized.
|
|
AM_CFLAGS="${AM_CFLAGS}"
|
|
AM_CXXFLAGS="${AM_CXXFLAGS}"
|
|
AM_FCFLAGS="${AM_FCFLAGS}"
|
|
AM_CPPFLAGS="${AM_CPPFLAGS}"
|
|
AM_JNIFLAGS="${AM_JNIFLAGS}"
|
|
AM_JAVACFLAGS="${AM_JAVACFLAGS}"
|
|
AM_JAVAFLAGS="${AM_JAVAFLAGS}"
|
|
AM_LDFLAGS="${AM_LDFLAGS}"
|
|
CFLAGS="${CFLAGS}"
|
|
CXXFLAGS="${CXXFLAGS}"
|
|
FCFLAGS="${FCFLAGS}"
|
|
CPPFLAGS="${CPPFLAGS}"
|
|
JNIFLAGS="${JNIFLAGS}"
|
|
JAVACFLAGS="${JAVACFLAGS}"
|
|
JAVAFLAGS="${JAVAFLAGS}"
|
|
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_JAVACFLAGS="$JAVACFLAGS"
|
|
saved_user_JAVAFLAGS="$JAVAFLAGS"
|
|
saved_user_LDFLAGS="$LDFLAGS"
|
|
saved_user_CPPFLAGS="$CPPFLAGS"
|
|
|
|
## 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])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Save system information for the library settings file.
|
|
##
|
|
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 and scripts relies upon them heavily and there's
|
|
## no use continuing if it's broken.
|
|
##
|
|
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
|
|
|
|
## xargs basename used in configure to get the CC_BASENAME value
|
|
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
|
|
;;
|
|
solaris*)
|
|
host_os_novers=solaris
|
|
;;
|
|
*)
|
|
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
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Determine build mode (debug, production, clean).
|
|
## This has to be done early since the build mode is referred to
|
|
## frequently.
|
|
##
|
|
AC_MSG_CHECKING([build mode])
|
|
AC_ARG_ENABLE([build-mode],
|
|
[AS_HELP_STRING([--enable-build-mode=(debug|production|clean)],
|
|
[Sets the build mode. Debug turns on symbols, API
|
|
tracing, asserts, and debug optimization,
|
|
as well as several other minor configure options
|
|
that aid in debugging.
|
|
Production turns high optimizations on.
|
|
Clean turns nothing on and disables optimization
|
|
(i.e.: a 'clean slate' configuration).
|
|
All these settings can be overridden by using
|
|
specific configure flags.
|
|
[default=debug]
|
|
])],
|
|
[BUILD_MODE=$enableval])
|
|
|
|
## Set the default
|
|
## Depends on branch, set via script at branch creation time
|
|
if test "X-$BUILD_MODE" = X- ; then
|
|
BUILD_MODE=debug
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([BUILD_MODE])
|
|
|
|
case "X-$BUILD_MODE" in
|
|
X-clean)
|
|
AC_MSG_RESULT([clean])
|
|
;;
|
|
X-debug)
|
|
AC_DEFINE([DEBUG_BUILD], [1], [Define if this is a debug build.])
|
|
H5_CFLAGS="$H5_CFLAGS $DEBUG_CFLAGS"
|
|
H5_CPPFLAGS="$H5_CPPFLAGS $DEBUG_CPPFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $DEBUG_CXXFLAGS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $DEBUG_FCFLAGS"
|
|
AC_MSG_RESULT([debug])
|
|
;;
|
|
X-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"
|
|
AC_MSG_RESULT([production])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized build mode: $BUILD_MODE. Use debug, production, or clean.])
|
|
esac
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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}"
|
|
JAVACFLAGS="${AM_JAVACFLAGS} ${JAVACFLAGS}"
|
|
JAVAFLAGS="${AM_JAVAFLAGS} ${JAVAFLAGS}"
|
|
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
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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])
|
|
AC_CHECK_SIZEOF([short])
|
|
AC_CHECK_SIZEOF([int])
|
|
AC_CHECK_SIZEOF([unsigned])
|
|
AC_CHECK_SIZEOF([long])
|
|
AC_CHECK_SIZEOF([long long])
|
|
AC_CHECK_SIZEOF([__int64])
|
|
AC_CHECK_SIZEOF([float])
|
|
AC_CHECK_SIZEOF([double])
|
|
AC_CHECK_SIZEOF([long double])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check for non-standard extenstion __FLOAT128
|
|
##
|
|
HAVE_FLOAT128=0
|
|
HAVE_QUADMATH=0
|
|
FLT128_DIG=0
|
|
LDBL_DIG=0
|
|
|
|
AC_CHECK_SIZEOF([__float128])
|
|
AC_CHECK_SIZEOF([_Quad])
|
|
AC_CHECK_HEADERS([quadmath.h], [HAVE_QUADMATH=1], [])
|
|
PAC_FC_LDBL_DIG
|
|
|
|
AC_SUBST([PAC_C_MAX_REAL_PRECISION])
|
|
|
|
if test "$ac_cv_sizeof___float128" != 0 && test "$FLT128_DIG" != 0 ; then
|
|
AC_DEFINE([HAVE_FLOAT128], [1], [Determine if __float128 is available])
|
|
PAC_C_MAX_REAL_PRECISION=$FLT128_DIG
|
|
else
|
|
PAC_C_MAX_REAL_PRECISION=$LDBL_DIG
|
|
fi
|
|
AC_DEFINE_UNQUOTED([PAC_C_MAX_REAL_PRECISION], $PAC_C_MAX_REAL_PRECISION, [Determine the maximum decimal precision in C])
|
|
AC_MSG_RESULT([$PAC_C_MAX_REAL_PRECISION])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if they would like the Fortran interface compiled
|
|
##
|
|
|
|
## This needs to be exposed for the library info file even if Fortran is disabled.
|
|
AC_SUBST([HDF_FORTRAN])
|
|
|
|
## Default is no Fortran
|
|
HDF_FORTRAN=no
|
|
|
|
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 interface [default=no]])],
|
|
[HDF_FORTRAN=$enableval])
|
|
|
|
if test "X$HDF_FORTRAN" = "Xyes"; then
|
|
echo "yes"
|
|
else
|
|
echo "no"
|
|
fi
|
|
|
|
if test "X$HDF_FORTRAN" = "Xyes"; then
|
|
|
|
## We will output an include file for Fortran, H5config_f.inc which
|
|
## contains various configure definitions used by the Fortran Library.
|
|
## Prepend H5_ to all macro names. This avoids name conflict between HDF5 macro
|
|
## names and those generated by another software package that uses the HDF5 library.
|
|
AC_CONFIG_HEADERS([fortran/src/H5config_f.inc],
|
|
[cat fortran/src/H5config_f.inc | sed '1d;s%^/\* \(.*\) \*/%\1%;s/#define /#define H5_/;s/#undef /#undef H5_/' >fortran/src/H5config_f.inc.tmp; mv -f fortran/src/H5config_f.inc.tmp fortran/src/H5config_f.inc])
|
|
|
|
AC_SUBST([FC])
|
|
|
|
HDF5_INTERFACES="$HDF5_INTERFACES fortran"
|
|
|
|
## --------------------------------------------------------------------
|
|
## 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 compiler and how to include modules.
|
|
##
|
|
AC_PROG_FC([PAC_FC_SEARCH_LIST],)
|
|
AC_F9X_MODS
|
|
|
|
## Change to the Fortran 90 language
|
|
AC_LANG_PUSH(Fortran)
|
|
|
|
## Checking if the compiler supports the required Fortran 2003 features and
|
|
## stopping if it does not.
|
|
PAC_PROG_FC_HAVE_F2003_REQUIREMENTS
|
|
|
|
if test "X$HAVE_F2003_REQUIREMENTS" = "Xno"; then
|
|
AC_MSG_ERROR([Fortran compiler lacks required Fortran 2003 features; unsupported Fortran 2003 compiler, remove --enable-fortran])
|
|
fi
|
|
|
|
## --------------------------------------------------------------------
|
|
## Define wrappers for the C compiler to use Fortran function names
|
|
##
|
|
AC_FC_WRAPPERS
|
|
|
|
## --------------------------------------------------------------------
|
|
## See if the fortran compiler supports the intrinsic function "SIZEOF"
|
|
PAC_PROG_FC_SIZEOF
|
|
|
|
## See if the fortran compiler supports the intrinsic function "C_SIZEOF"
|
|
PAC_PROG_FC_C_SIZEOF
|
|
|
|
## See if the fortran compiler supports the intrinsic function "STORAGE_SIZE"
|
|
PAC_PROG_FC_STORAGE_SIZE
|
|
|
|
## Set the sizeof function for use later in the fortran tests
|
|
if test "X$HAVE_STORAGE_SIZE_FORTRAN" = "Xyes";then
|
|
FC_SIZEOF_A="STORAGE_SIZE(a, c_size_t)/STORAGE_SIZE(c_char_'a',c_size_t)"
|
|
FC_SIZEOF_B="STORAGE_SIZE(b, c_size_t)/STORAGE_SIZE(c_char_'a',c_size_t)"
|
|
FC_SIZEOF_C="STORAGE_SIZE(c, c_size_t)/STORAGE_SIZE(c_char_'a',c_size_t)"
|
|
else
|
|
if test "X$HAVE_SIZEOF_FORTRAN" = "Xyes";then
|
|
FC_SIZEOF_A="SIZEOF(a)"
|
|
FC_SIZEOF_B="SIZEOF(b)"
|
|
FC_SIZEOF_C="SIZEOF(c)"
|
|
else
|
|
## If neither intrinsic functions SIZEOF or STORAGE_SIZE is available then stop configure with an error
|
|
AC_MSG_ERROR([Fortran compiler requires either intrinsic functions SIZEOF or STORAGE_SIZE])
|
|
fi
|
|
fi
|
|
|
|
## See if the fortran compiler supports the intrinsic module "ISO_FORTRAN_ENV"
|
|
PAC_PROG_FC_ISO_FORTRAN_ENV
|
|
## Check KIND and size of native integer
|
|
PAC_FC_NATIVE_INTEGER
|
|
|
|
## Find all available KINDs
|
|
PAC_FC_AVAIL_KINDS
|
|
## Find all sizeofs for available KINDs
|
|
PAC_FC_SIZEOF_INT_KINDS
|
|
PAC_FC_SIZEOF_REAL_KINDS
|
|
|
|
AC_SUBST([PAC_FC_ALL_REAL_KINDS])
|
|
AC_SUBST([PAC_FC_MAX_REAL_PRECISION])
|
|
AC_SUBST([PAC_FORTRAN_NUM_INTEGER_KINDS])
|
|
AC_SUBST([PAC_FC_ALL_INTEGER_KINDS])
|
|
AC_SUBST([PAC_FC_ALL_REAL_KINDS_SIZEOF])
|
|
AC_SUBST([PAC_FC_ALL_INTEGER_KINDS_SIZEOF])
|
|
AC_SUBST([PAC_FORTRAN_NATIVE_INTEGER_KIND])
|
|
AC_SUBST([PAC_FORTRAN_NATIVE_INTEGER_SIZEOF])
|
|
AC_SUBST([PAC_FORTRAN_NATIVE_REAL_KIND])
|
|
AC_SUBST([PAC_FORTRAN_NATIVE_REAL_SIZEOF])
|
|
AC_SUBST([PAC_FORTRAN_NATIVE_DOUBLE_KIND])
|
|
AC_SUBST([PAC_FORTRAN_NATIVE_DOUBLE_SIZEOF])
|
|
AC_SUBST([HAVE_Fortran_INTEGER_SIZEOF_16])
|
|
AC_SUBST([FORTRAN_HAVE_C_LONG_DOUBLE])
|
|
AC_SUBST([FORTRAN_C_LONG_DOUBLE_IS_UNIQUE])
|
|
AC_SUBST([FORTRAN_SIZEOF_LONG_DOUBLE])
|
|
AC_SUBST([H5CONFIG_F_NUM_RKIND])
|
|
AC_SUBST([H5CONFIG_F_RKIND])
|
|
AC_SUBST([H5CONFIG_F_RKIND_SIZEOF])
|
|
AC_SUBST([H5CONFIG_F_NUM_IKIND])
|
|
AC_SUBST([H5CONFIG_F_IKIND])
|
|
AC_SUBST([Fortran_COMPILER_ID])
|
|
Fortran_COMPILER_ID=none
|
|
AC_DEFINE_UNQUOTED([Fortran_COMPILER_ID], $Fortran_COMPILER_ID, [Define Fortran compiler ID])
|
|
|
|
## Setting definition if there is a 16 byte fortran integer
|
|
if `echo $PAC_FC_ALL_INTEGER_KINDS_SIZEOF | grep '16' >/dev/null`; then
|
|
HAVE_Fortran_INTEGER_SIZEOF_16="1"
|
|
AC_DEFINE([HAVE_Fortran_INTEGER_SIZEOF_16], [1], [Determine if INTEGER*16 is available])
|
|
else
|
|
HAVE_Fortran_INTEGER_SIZEOF_16="0"
|
|
AC_DEFINE([HAVE_Fortran_INTEGER_SIZEOF_16], [0], [Determine if INTEGER*16 is available])
|
|
fi
|
|
|
|
if test "X$HAVE_STORAGE_SIZE_FORTRAN" = "Xyes"; then
|
|
AC_DEFINE([FORTRAN_HAVE_STORAGE_SIZE], [1], [Define if we have Fortran intrinsic STORAGE_SIZE])
|
|
fi
|
|
|
|
if test "X$HAVE_C_SIZEOF_FORTRAN" = "Xyes"; then
|
|
AC_DEFINE([FORTRAN_HAVE_C_SIZEOF], [1], [Define if we have Fortran intrinsic C_SIZEOF])
|
|
fi
|
|
|
|
if test "X$HAVE_SIZEOF_FORTRAN" = "Xyes"; then
|
|
AC_DEFINE([FORTRAN_HAVE_SIZEOF], [1], [Define if we have Fortran intrinsic SIZEOF])
|
|
fi
|
|
|
|
## See if C_LONG_DOUBLE is available
|
|
PAC_PROG_FC_HAVE_C_LONG_DOUBLE
|
|
|
|
FORTRAN_HAVE_C_LONG_DOUBLE="0"
|
|
if test "X$HAVE_C_LONG_DOUBLE_FORTRAN" = "Xyes"; then
|
|
FORTRAN_HAVE_C_LONG_DOUBLE="1"
|
|
AC_DEFINE([FORTRAN_HAVE_C_LONG_DOUBLE], [1], [Define if we have Fortran C_LONG_DOUBLE])
|
|
fi
|
|
|
|
## Is C_LONG_DOUBLE different from C_DOUBLE
|
|
FORTRAN_C_LONG_DOUBLE_IS_UNIQUE="0"
|
|
if test "$FORTRAN_HAVE_C_LONG_DOUBLE" = "1"; then
|
|
PAC_PROG_FC_C_LONG_DOUBLE_EQ_C_DOUBLE
|
|
if test "X$C_LONG_DOUBLE_IS_UNIQUE_FORTRAN" = "Xyes"; then
|
|
FORTRAN_C_LONG_DOUBLE_IS_UNIQUE="1"
|
|
AC_DEFINE([FORTRAN_C_LONG_DOUBLE_IS_UNIQUE], [1], [Define if Fortran C_LONG_DOUBLE is different from C_DOUBLE])
|
|
else
|
|
FORTRAN_C_LONG_DOUBLE_IS_UNIQUE="0"
|
|
fi
|
|
fi
|
|
|
|
FORTRAN_SIZEOF_LONG_DOUBLE=${ac_cv_sizeof_long_double}
|
|
AC_DEFINE_UNQUOTED([FORTRAN_SIZEOF_LONG_DOUBLE], ["${ac_cv_sizeof_long_double}"], [Determine the size of C long double])
|
|
|
|
dnl get the largest sizeof for REAL kinds
|
|
max_real_fortran_sizeof="`echo $PAC_FC_ALL_REAL_KINDS_SIZEOF | sed -ne 's/.*,\([[0-9]]*\)}/\1/p'`"
|
|
max_real_fortran_kind="`echo $PAC_FC_ALL_REAL_KINDS | sed -ne 's/.*,\([[0-9]]*\)}/\1/p'`"
|
|
|
|
dnl remove the invalid kind from the list
|
|
if test "$ac_cv_sizeof___float128" != 0;then
|
|
if test "$ac_cv_sizeof___float128" != "$max_real_fortran_sizeof" &&
|
|
test "${ac_cv_sizeof_long_double}" != "$max_real_fortran_sizeof" &&
|
|
dnl account for the fact that the C compiler can have 16-byte __float128 and the Fortran compiler only has 8-byte doubles,
|
|
dnl so we don't want to remove the 8-byte Fortran doubles. This is sometimes the case if different C and Fortran vendors
|
|
dnl are used (for example gnu and pgi).
|
|
test "${ac_cv_sizeof_double}" != "$max_real_fortran_sizeof" ; then
|
|
AC_MSG_WARN([
|
|
Fortran REAL(KIND=$max_real_fortran_kind) is $max_real_fortran_sizeof Bytes, but no corresponding C float type exists of that size
|
|
!!! Fortran interfaces will not be generated for REAL(KIND=$max_real_fortran_kind) !!!
|
|
])
|
|
PAC_FC_ALL_REAL_KINDS="`echo $PAC_FC_ALL_REAL_KINDS | sed -e 's/,[[0-9]]\+}/}/g'`"
|
|
PAC_FC_ALL_REAL_KINDS_SIZEOF="`echo $PAC_FC_ALL_REAL_KINDS_SIZEOF | sed -e 's/,[[0-9]]\+}/}/g'`"
|
|
|
|
fi
|
|
fi
|
|
AC_MSG_CHECKING([for Fortran interoperable KINDS with C])
|
|
AC_MSG_RESULT([$PAC_FC_ALL_REAL_KINDS])
|
|
|
|
dnl count the number of real kinds
|
|
H5CONFIG_F_NUM_RKIND="INTEGER, PARAMETER :: num_rkinds = `echo \"[$]PAC_FC_ALL_REAL_KINDS\" | tr -d -c ',\n' | awk '{ print length + 1; }'`"
|
|
H5CONFIG_F_RKIND="INTEGER, DIMENSION(1:num_rkinds) :: rkind = (/`echo $PAC_FC_ALL_REAL_KINDS | sed -e 's/{//g' | sed -e 's/}//g' | sed -e 's/ /,/g'`/)"
|
|
H5CONFIG_F_RKIND_SIZEOF="INTEGER, DIMENSION(1:num_rkinds) :: rkind_sizeof = (/`echo $PAC_FC_ALL_REAL_KINDS_SIZEOF | sed -e 's/{//g' | sed -e 's/}//g'| sed -e 's/ /,/g'`/)"
|
|
|
|
AC_DEFINE_UNQUOTED([H5CONFIG_F_NUM_RKIND], $H5CONFIG_F_NUM_RKIND, [Define number of valid Fortran REAL KINDs])
|
|
AC_DEFINE_UNQUOTED([H5CONFIG_F_RKIND], $H5CONFIG_F_RKIND, [Define valid Fortran REAL KINDs])
|
|
AC_DEFINE_UNQUOTED([H5CONFIG_F_RKIND_SIZEOF], $H5CONFIG_F_RKIND_SIZEOF, [Define valid Fortran REAL KINDs Sizeof])
|
|
|
|
## Change back to the C language
|
|
AC_LANG_POP(Fortran)
|
|
else
|
|
FC="no"
|
|
fi
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if they would like the C++ interface compiled
|
|
##
|
|
## This needs to be exposed for the library info file even if C++ is disabled.
|
|
AC_SUBST([HDF_CXX])
|
|
|
|
## Default is no C++
|
|
HDF_CXX=no
|
|
|
|
## 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++"
|
|
|
|
## Expose the compiler for *.in files
|
|
AC_SUBST([CXX])
|
|
|
|
## Change to the C++ language
|
|
AC_LANG_PUSH(C++)
|
|
|
|
## Checking if C++ needs old style header files in includes
|
|
PAC_PROG_CXX_HEADERS
|
|
|
|
## Checking if C++ can handle namespaces
|
|
PAC_PROG_CXX_NAMESPACE
|
|
|
|
## if C++ can handle static cast
|
|
PAC_PROG_CXX_STATIC_CAST
|
|
|
|
## Checking if C++ has offsetof extension,
|
|
## note: this test has to be the last of the C++ tests because it sets a definition
|
|
## which would be used in the other tests, causing them to fail.
|
|
PAC_PROG_CXX_OFFSETOF
|
|
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
CXX="no"
|
|
fi
|
|
|
|
## Change back to the C language
|
|
AC_LANG_POP(C++)
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if they would like the High Level library compiled
|
|
##
|
|
|
|
## This needs to be exposed for the library info file even if the HL
|
|
## library is disabled.
|
|
AC_SUBST([HDF5_HL])
|
|
|
|
## The high-level library is enabled unless the build mode is clean.
|
|
if test "X-$BUILD_MODE" = "X-clean" ; then
|
|
HDF5_HL=no
|
|
else
|
|
HDF5_HL=yes
|
|
fi
|
|
|
|
## high-level library directories (set when needed, blank until then)
|
|
##
|
|
## main high-level library
|
|
AC_SUBST(HL)
|
|
HL=""
|
|
## Fortran high-level library
|
|
AC_SUBST(HL_FOR)
|
|
HL_FOR=""
|
|
|
|
AC_MSG_CHECKING([if the high-level library is enabled])
|
|
AC_ARG_ENABLE([hl],
|
|
[AS_HELP_STRING([--enable-hl],
|
|
[Enable the high-level library.
|
|
[default=yes (unless build mode = clean)]
|
|
])],
|
|
[HDF5_HL=$enableval])
|
|
|
|
if test "X-$HDF5_HL" = "X-yes"; then
|
|
AC_MSG_RESULT([yes])
|
|
HL="hl"
|
|
AC_DEFINE([INCLUDE_HL], [1],
|
|
[Define if the high-level library headers should be included in hdf5.h])
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
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
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Set up ${TR} which is used to process the package list for extra
|
|
## debugging output in the C library.
|
|
|
|
AC_PATH_PROG([TR], [tr])
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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.
|
|
##
|
|
## Note: This is still true as of Cygwin 1.7.32 (Aug 2014) on both 32-
|
|
## and 64-bit platforms. Given how long this has been true, it seems
|
|
## unlikely to change, but we should probably re-test this periodically.
|
|
|
|
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
|
|
## 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
|
|
## we're building 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])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Disable shared libraries on CYGWIN. (LK - 04/16/15)
|
|
## A number of tests run by "make check" fail on CYGWIN, so for HDF5 v1.8.15
|
|
## we will change the default for shared libraries to disabled.
|
|
|
|
|
|
case "`uname`" in
|
|
CYGWIN*)
|
|
enable_shared="no"
|
|
CHECK_WARN="Shared libraries are not currently supported on CYGWIN."
|
|
;;
|
|
esac
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if they would like the Java native interface (JNI) compiled
|
|
##
|
|
|
|
## This needs to be exposed for the library info file even if Java is disabled.
|
|
AC_SUBST([HDF_JAVA])
|
|
|
|
## Default is no Java
|
|
HDF_JAVA=no
|
|
|
|
AC_SUBST([H5_CLASSPATH]) H5_CLASSPATH=""
|
|
AC_MSG_CHECKING([if Java JNI interface enabled])
|
|
|
|
AC_ARG_ENABLE([java],
|
|
[AS_HELP_STRING([--enable-java],
|
|
[Compile the Java JNI interface [default=no]])],
|
|
[HDF_JAVA=$enableval])
|
|
|
|
if test "X$HDF_JAVA" = "Xyes"; then
|
|
if test "X${enable_shared}" != "Xno"; then
|
|
echo "yes"
|
|
if test "X$CLASSPATH" = "X"; then
|
|
H5_CLASSPATH=".:$srcdir/java/lib"
|
|
else
|
|
H5_CLASSPATH=".:$CLASSPATH:$srcdir/java/lib"
|
|
fi
|
|
## Checks for programs.
|
|
AX_JAVA_OPTIONS
|
|
H5_JAVACFLAGS=$JAVACFLAGS
|
|
H5_JAVAFLAGS=$JAVAFLAGS
|
|
AX_PROG_JAVAC
|
|
AX_PROG_JAVA
|
|
AX_PROG_JAR
|
|
AX_PROG_JAVADOC
|
|
## Find the include directories needed for building JNI code
|
|
AX_JNI_INCLUDE_DIR()
|
|
for JNI_INCLUDE_DIR in $JNI_INCLUDE_DIRS
|
|
do
|
|
JNIFLAGS="$JNIFLAGS -I$JNI_INCLUDE_DIR"
|
|
done
|
|
## Find junit for testing the JNI code
|
|
AX_CHECK_CLASSPATH()
|
|
CLASSPATH_ENV=$H5_CLASSPATH
|
|
AX_CHECK_JUNIT()
|
|
AX_CHECK_JAVA_HOME
|
|
|
|
AC_MSG_RESULT([yes])
|
|
else
|
|
AC_MSG_ERROR([Java requires shared libraries to be built])
|
|
HDF_JAVA="no"
|
|
AC_MSG_RESULT([no])
|
|
fi
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
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"
|
|
## tell libtool to do the right thing with COMMON symbols, this fixes
|
|
## corrupt values with COMMON and EQUIVALENCE when building shared
|
|
## Fortran libraries on OSX with gnu and Intel compilers (HDFFV-2772).
|
|
case "`uname`" in
|
|
Darwin*)
|
|
H5_LDFLAGS="$H5_LDFLAGS -Wl,-commons,use_dylibs"
|
|
;;
|
|
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"])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Create libtool. If shared/static libraries are going to be enabled
|
|
## or disabled, it should happen before these macros.
|
|
LT_PREREQ([2.2])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## dlopen - This will use an improved version of libtool
|
|
## win32-dll - This will build clean dlls on win32 platforms.
|
|
LT_INIT([dlopen,win32-dll])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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_SUBST([STATIC_EXEC])
|
|
|
|
## Default is no
|
|
STATIC_EXEC=no
|
|
|
|
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
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check for system libraries. "dl" stands for dynamically loaded library
|
|
##
|
|
AC_CHECK_LIB([m], [ceil])
|
|
AC_CHECK_LIB([dl], [dlopen])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check for system header files.
|
|
##
|
|
AC_HEADER_STDC
|
|
AC_HEADER_TIME
|
|
|
|
## 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 sys/file.h])
|
|
AC_CHECK_HEADERS([stddef.h setjmp.h features.h])
|
|
AC_CHECK_HEADERS([dirent.h])
|
|
AC_CHECK_HEADERS([stdint.h], [C9x=yes])
|
|
AC_CHECK_HEADERS([stdbool.h])
|
|
|
|
## 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
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Add necessary defines for Linux Systems.
|
|
##
|
|
case "$host_cpu-$host_vendor-$host_os" in
|
|
*linux*)
|
|
## 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. This was later updated to 200112L so that
|
|
## posix_memalign() is visible for the direct VFD code on Linux
|
|
## systems.
|
|
##
|
|
## 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=200112L $H5_CPPFLAGS"
|
|
|
|
## Need to add this so that O_DIRECT is visible for the direct
|
|
## VFD on Linux systems.
|
|
H5_CPPFLAGS="-D_GNU_SOURCE $H5_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"
|
|
|
|
## 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])
|
|
AC_CHECK_SIZEOF( [uint8_t])
|
|
AC_CHECK_SIZEOF( [int_least8_t])
|
|
AC_CHECK_SIZEOF( [uint_least8_t])
|
|
AC_CHECK_SIZEOF( [int_fast8_t])
|
|
AC_CHECK_SIZEOF( [uint_fast8_t])
|
|
|
|
AC_CHECK_SIZEOF( [int16_t])
|
|
AC_CHECK_SIZEOF( [uint16_t])
|
|
AC_CHECK_SIZEOF( [int_least16_t])
|
|
AC_CHECK_SIZEOF([uint_least16_t])
|
|
AC_CHECK_SIZEOF( [int_fast16_t])
|
|
AC_CHECK_SIZEOF( [uint_fast16_t])
|
|
|
|
AC_CHECK_SIZEOF( [int32_t])
|
|
AC_CHECK_SIZEOF( [uint32_t])
|
|
AC_CHECK_SIZEOF( [int_least32_t])
|
|
AC_CHECK_SIZEOF([uint_least32_t])
|
|
AC_CHECK_SIZEOF( [int_fast32_t])
|
|
AC_CHECK_SIZEOF( [uint_fast32_t])
|
|
|
|
AC_CHECK_SIZEOF( [int64_t])
|
|
AC_CHECK_SIZEOF( [uint64_t])
|
|
AC_CHECK_SIZEOF( [int_least64_t])
|
|
AC_CHECK_SIZEOF([uint_least64_t])
|
|
AC_CHECK_SIZEOF( [int_fast64_t])
|
|
AC_CHECK_SIZEOF( [uint_fast64_t])
|
|
|
|
AC_CHECK_SIZEOF([size_t])
|
|
AC_CHECK_SIZEOF([ssize_t])
|
|
AC_CHECK_SIZEOF([ptrdiff_t])
|
|
|
|
cat >>confdefs.h <<\EOF
|
|
#include <sys/types.h> /*for off_t definition*/
|
|
EOF
|
|
AC_CHECK_SIZEOF([off_t])
|
|
|
|
if test "X$C9x" = "Xyes"; then
|
|
cat >>confdefs.h <<\EOF
|
|
#ifdef HAVE_STDBOOL_H
|
|
#include <stdbool.h> /* for bool definition */
|
|
#else
|
|
#define bool _Bool
|
|
#endif
|
|
EOF
|
|
AC_CHECK_SIZEOF([bool])
|
|
fi
|
|
|
|
## 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_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#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 dmalloc (debug malloc library) requested? 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_SUBST([HAVE_DMALLOC])
|
|
|
|
## Default is not present
|
|
HAVE_DMALLOC=no
|
|
|
|
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
|
|
|
|
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
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Make the external filters list available to *.in files
|
|
## At this point it's unset (no external filters by default) but it
|
|
## will be filled in during the deflate (zlib) and szip processing
|
|
## below.
|
|
##
|
|
AC_SUBST([EXTERNAL_FILTERS])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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 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
|
|
|
|
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
|
|
|
|
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_RUN_IFELSE(
|
|
[AC_LANG_PROGRAM([
|
|
#include "szlib.h"
|
|
],[[
|
|
/* 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_SUBST([THREADSAFE])
|
|
|
|
## Default is no thread-safety
|
|
THREADSAFE=no
|
|
|
|
AC_MSG_CHECKING([for thread safe support])
|
|
AC_ARG_ENABLE([threadsafe],
|
|
[AS_HELP_STRING([--enable-threadsafe],
|
|
[Enable thread-safe capability. Not compatible with the high-level library, Fortran, or C++ wrappers.
|
|
[default=no]])],
|
|
[THREADSAFE=$enableval])
|
|
|
|
## The high-level, C++, Fortran and Java interfaces are not compatible
|
|
## with the thread-safety option because the lock is not hoisted
|
|
## into the higher-level API calls.
|
|
|
|
## --enable-threadsafe is incompatible with --enable-hl unless
|
|
## --enable-unsupported has been specified on the configure line.
|
|
##
|
|
## Note that the high-level library is enabled by default so most
|
|
## users will have to add --disable-hl to the configure options.
|
|
if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
|
|
if test "X${HDF5_HL}" = "Xyes" -a "X${enable_threadsafe}" = "Xyes"; then
|
|
AC_MSG_ERROR([The thread-safe library is incompatible with the high-level library. --disable-hl can be used to prevent building the high-level library (recommended). Alternatively, --enable-unsupported will allow building the high-level library, though this configuration is not supported by The HDF Group.])
|
|
fi
|
|
fi
|
|
|
|
## 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
|
|
|
|
## --enable-threadsafe is also incompatible with --enable-java unless
|
|
## --enable-unsupported has been specified on the configure line.
|
|
if test "X${ALLOW_UNSUPPORTED}" != "Xyes"; then
|
|
if test "X${HDF_JAVA}" = "Xyes" -a "X${enable_threadsafe}" = "Xyes"; then
|
|
AC_MSG_ERROR([--enable-java 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 "check", 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=check])
|
|
|
|
case "$withval" in
|
|
check | 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_ERROR([Must use Pthreads with thread safety])
|
|
;;
|
|
*)
|
|
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
|
|
|
|
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
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if pthread_attr_setscope(&attribute, PTHREAD_SCOPE_SYSTEM)
|
|
## is supported on this system
|
|
##
|
|
## Unfortunately, this probably needs to be an AC_RUN_IFELSE since
|
|
## it's impossible to determine if PTHREAD_SCOPE_SYSTEM is
|
|
## supported a priori. POSIX.1-2001 requires that a conformant
|
|
## system need only support one of SYSTEM or PROCESS scopes.
|
|
##
|
|
## For cross-compiling, we've added a pessimistic 'no'. You can
|
|
## hand-hack the config file if you know otherwise.
|
|
AC_MSG_CHECKING([Pthreads supports system scope])
|
|
AC_CACHE_VAL([hdf5_cv_system_scope_threads],
|
|
[AC_RUN_IFELSE(
|
|
[AC_LANG_PROGRAM([
|
|
#if STDC_HEADERS
|
|
#include <stdlib.h>
|
|
#include <pthread.h>
|
|
#endif
|
|
],[
|
|
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], [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])
|
|
AC_MSG_NOTICE([Always 'no' if cross-compiling. Edit the config file if your platform supports pthread_attr_setscope(&attribute, PTHREAD_SCOPE_SYSTEM).])
|
|
fi
|
|
fi
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check for MONOTONIC_TIMER support (used in clock_gettime). This has
|
|
## to be done after any POSIX 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_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#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_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
#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
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Does the struct stat have the st_blocks field? This field is not Posix.
|
|
##
|
|
AC_MSG_CHECKING([for st_blocks in struct stat])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM[[
|
|
#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 getpwuid])
|
|
;;
|
|
esac
|
|
AC_CHECK_FUNCS([_scrsize ioctl])
|
|
|
|
AC_MSG_CHECKING([for struct videoconfig])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[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_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[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_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#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_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#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.
|
|
##
|
|
## NOTE: clock_gettime may require linking to the rt or posix4 library
|
|
## so we'll search for it before calling AC_CHECK_FUNCS.
|
|
AC_SEARCH_LIBS([clock_gettime], [rt posix4])
|
|
AC_CHECK_FUNCS([alarm clock_gettime difftime fcntl flock fork frexpf])
|
|
AC_CHECK_FUNCS([frexpl gethostname getrusage gettimeofday])
|
|
AC_CHECK_FUNCS([lstat rand_r random setsysinfo])
|
|
AC_CHECK_FUNCS([signal longjmp setjmp siglongjmp sigsetjmp sigprocmask])
|
|
AC_CHECK_FUNCS([snprintf srandom strdup symlink system])
|
|
AC_CHECK_FUNCS([strtoll strtoull])
|
|
AC_CHECK_FUNCS([tmpfile asprintf vasprintf vsnprintf waitpid])
|
|
AC_CHECK_FUNCS([roundf lroundf llroundf round lround llround])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check compiler characteristics
|
|
##
|
|
AC_C_CONST
|
|
|
|
AC_MSG_CHECKING([if the compiler understands __inline__])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_SOURCE([[static __inline__ void f(void){return;};]])],
|
|
[AC_DEFINE([HAVE___INLINE__], [1], [Define if the compiler understands __inline__]) AC_MSG_RESULT([yes])],
|
|
[AC_MSG_RESULT([no])]
|
|
)
|
|
|
|
AC_MSG_CHECKING([if the compiler understands __inline])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_SOURCE([[static __inline void f(void){return;};]])],
|
|
[AC_DEFINE([HAVE___INLINE], [1], [Define if the compiler understands __inline]) AC_MSG_RESULT([yes])],
|
|
[AC_MSG_RESULT([no])]
|
|
)
|
|
|
|
AC_MSG_CHECKING([if the compiler understands inline])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_SOURCE([[static inline void f(void){return;};]])],
|
|
[AC_DEFINE([HAVE_INLINE], [1], [Define if the compiler understands inline]) AC_MSG_RESULT([yes])],
|
|
[AC_MSG_RESULT([no])]
|
|
)
|
|
|
|
AC_MSG_CHECKING([for __attribute__ extension])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[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_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[ 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_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],,[[ 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_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[
|
|
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_RUN_IFELSE(
|
|
[AC_LANG_PROGRAM([
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
],[[
|
|
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'])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Remove old ways of determining debug/production build.
|
|
## These were used in 1.8.x and earlier. We should probably keep these checks
|
|
## around to help people migrate to 1.10.x and newer versions.
|
|
##
|
|
AC_ARG_ENABLE([debug],
|
|
[AS_HELP_STRING([--enable-debug], [DEPRECATED: use --enable-build-mode=debug])],
|
|
[AC_MSG_ERROR([--enable-debug is deprecated, use --enable-build-mode=debug instead.])])
|
|
|
|
AC_ARG_ENABLE([production],
|
|
[AS_HELP_STRING([--enable-production], [DEPRECATED: use --enable-build-mode=production])],
|
|
[AC_MSG_ERROR([--enable-production is deprecated, use --enable-build-mode=production instead.])])
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if the compiler should include symbols
|
|
##
|
|
AC_MSG_CHECKING([enable debugging symbols])
|
|
AC_ARG_ENABLE([symbols],
|
|
[AS_HELP_STRING([--enable-symbols=(yes|no|<custom>)],
|
|
[Add debug symbols to the library (e.g.: build with -g).
|
|
This is independent of the build mode and optimization
|
|
level. The custom string allows special settings like
|
|
-ggdb, etc. to be used.
|
|
[default=yes if debug build, otherwise no]
|
|
])],
|
|
[SYMBOLS=$enableval])
|
|
|
|
## Set default
|
|
if test "X-$SYMBOLS" = X- ; then
|
|
if test "X-$BUILD_MODE" = "X-debug" ; then
|
|
SYMBOLS=yes
|
|
else
|
|
SYMBOLS=no
|
|
fi
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([SYMBOLS])
|
|
|
|
case "X-$SYMBOLS" in
|
|
X-yes)
|
|
H5_CFLAGS="$H5_CFLAGS $SYMBOLS_CFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $SYMBOLS_CXXFLAGS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $SYMBOLS_FCFLAGS"
|
|
AC_MSG_RESULT([yes])
|
|
;;
|
|
X-no)
|
|
H5_CFLAGS="$H5_CFLAGS $NO_SYMBOLS_CFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $NO_SYMBOLS_CXXFLAGS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $NO_SYMBOLS_FCFLAGS"
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
H5_CFLAGS="$H5_CFLAGS $SYMBOLS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $SYMBOLS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $SYMBOLS"
|
|
SYMBOLS="custom ($SYMBOLS)"
|
|
AC_MSG_RESULT([$SYMBOLS])
|
|
;;
|
|
esac
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if the assert macro should be enabled
|
|
##
|
|
AC_MSG_CHECKING([enable asserts])
|
|
AC_ARG_ENABLE([asserts],
|
|
[AS_HELP_STRING([--enable-asserts],
|
|
[Determines whether NDEBUG is defined or not, which
|
|
controls assertions.
|
|
This is independent of the build mode and presence
|
|
of debugging symbols.
|
|
[default=yes if debug build, otherwise no]
|
|
])],
|
|
[ASSERTS=$enableval])
|
|
|
|
## Set default
|
|
if test "X-$ASSERTS" = X- ; then
|
|
if test "X-$BUILD_MODE" = "X-debug" ; then
|
|
ASSERTS=yes
|
|
else
|
|
ASSERTS=no
|
|
fi
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([ASSERTS])
|
|
|
|
case "X-$ASSERTS" in
|
|
X-yes)
|
|
H5_CPPFLAGS="$H5_CPPFLAGS -UNDEBUG"
|
|
AC_MSG_RESULT([yes])
|
|
;;
|
|
X-no)
|
|
H5_CPPFLAGS="$H5_CPPFLAGS -DNDEBUG"
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $ASSERTS])
|
|
;;
|
|
esac
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if developer warnings should be turned on
|
|
## These are warnings that provide suggestions like gcc's -Wsuggest-attribute.
|
|
## They do not indicate code problems.
|
|
##
|
|
## Note that developers don't need to build with these regularly. They
|
|
## are just handy to check once in a while (before releases, etc.).
|
|
##
|
|
AC_MSG_CHECKING([enable developer warnings])
|
|
AC_ARG_ENABLE([developer-warnings],
|
|
[AS_HELP_STRING([--enable-developer-warnings],
|
|
[Determines whether developer warnings will be
|
|
emitted. These are usually performance suggestions
|
|
(e.g. -Wsuggest-attribute) and do not flag poor code
|
|
quality.
|
|
[default=no]
|
|
])],
|
|
[DEV_WARNINGS=$enableval])
|
|
|
|
## Set default
|
|
if test "X-$DEV_WARNINGS" = X- ; then
|
|
DEV_WARNINGS=no
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([DEV_WARNINGS])
|
|
|
|
case "X-$DEV_WARNINGS" in
|
|
X-yes)
|
|
H5_CFLAGS="$H5_CFLAGS $DEVELOPER_WARNING_CFLAGS"
|
|
AC_MSG_RESULT([yes])
|
|
;;
|
|
X-no)
|
|
H5_CFLAGS="$H5_CFLAGS $NO_DEVELOPER_WARNING_CFLAGS"
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $DEV_WARNINGS])
|
|
;;
|
|
esac
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if the compiler should use profiling flags/settings
|
|
##
|
|
AC_MSG_CHECKING([profiling])
|
|
AC_ARG_ENABLE([profiling],
|
|
[AS_HELP_STRING([--enable-profiling=(yes|no|<custom>)],
|
|
[Enable profiling flags (e.g.: -pg).
|
|
This can be set independently from the build mode.
|
|
The custom setting can be used to pass alternative
|
|
profiling flags (e.g.: -P for using Prof with gcc).
|
|
[default=no]
|
|
])],
|
|
[PROFILING=$enableval])
|
|
|
|
## Default is no profiling
|
|
if test "X-$PROFILING" = X- ; then
|
|
PROFILING=no
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([PROFILING])
|
|
|
|
case "X-$PROFILING" in
|
|
X-yes)
|
|
H5_CFLAGS="$H5_CFLAGS $PROFILE_CFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $PROFILE_CXXFLAGS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $PROFILE_FCFLAGS"
|
|
AC_MSG_RESULT([yes])
|
|
;;
|
|
X-no)
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
H5_CFLAGS="$H5_CFLAGS $PROFILING"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $PROFILING"
|
|
H5_FCFLAGS="$H5_FCFLAGS $PROFILING"
|
|
PROFILING="custom ($PROFILING)"
|
|
AC_MSG_RESULT([$PROFILING])
|
|
;;
|
|
esac
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if the compiler should use a particular optimization setting
|
|
##
|
|
AC_MSG_CHECKING([optimization level])
|
|
AC_ARG_ENABLE([optimization],
|
|
[AS_HELP_STRING([--enable-optimization=(high|debug|none|<custom>)],
|
|
[Enable optimization flags/settings (e.g.: -O3).
|
|
This can be set independently from the build mode.
|
|
Optimizations for a given compiler can be specified
|
|
at several levels: High, with aggressive optimizations
|
|
turned on; debug, with optimizations that are
|
|
unlikely to interfere with debugging or profiling;
|
|
and none, with no optimizations at all.
|
|
See the compiler-specific config/*-flags file for more
|
|
details.
|
|
Alternatively, optimization options can
|
|
be specified directly by specifying them as a
|
|
string value. These custom optimzation flags will
|
|
completely replace all other optimization flags.
|
|
[default depends on build mode: debug=debug,
|
|
production=high, clean=none]
|
|
])],
|
|
[OPTIMIZATION=$enableval])
|
|
|
|
## Set the default optimization level. This depends on the compiler mode.
|
|
if test "X-$OPTIMIZATION" = X- ; then
|
|
case "X-$BUILD_MODE" in
|
|
X-debug)
|
|
OPTIMIZATION=debug
|
|
;;
|
|
X-production)
|
|
OPTIMIZATION=high
|
|
;;
|
|
X-clean)
|
|
OPTIMIZATION=none
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([OPTIMIZATION])
|
|
|
|
case "X-$OPTIMIZATION" in
|
|
X-high)
|
|
H5_CFLAGS="$H5_CFLAGS $HIGH_OPT_CFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $HIGH_OPT_CXXFLAGS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $HIGH_OPT_FCFLAGS"
|
|
AC_MSG_RESULT([high])
|
|
;;
|
|
X-debug)
|
|
H5_CFLAGS="$H5_CFLAGS $DEBUG_OPT_CFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $DEBUG_OPT_CXXFLAGS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $DEBUG_OPT_FCFLAGS"
|
|
AC_MSG_RESULT([debug])
|
|
;;
|
|
X-none)
|
|
H5_CFLAGS="$H5_CFLAGS $NO_OPT_CFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $NO_OPT_CXXFLAGS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $NO_OPT_FCFLAGS"
|
|
AC_MSG_RESULT([none])
|
|
;;
|
|
*)
|
|
H5_CFLAGS="$H5_CFLAGS $OPTIMIZATION"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $OPTIMIZATION"
|
|
H5_FCFLAGS="$H5_FCFLAGS $OPTIMIZATION"
|
|
OPTIMIZATION="custom ($OPTIMIZATION)"
|
|
AC_MSG_RESULT([$OPTIMIZATION])
|
|
;;
|
|
esac
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Enable/disable internal package-level debugging output
|
|
##
|
|
AC_MSG_CHECKING([for internal debug output])
|
|
AC_ARG_ENABLE([internal-debug],
|
|
[AS_HELP_STRING([--enable-internal-debug=(yes|all|no|none|<pkg list>)],
|
|
[Enable extra debugging output on HDF5 library
|
|
errors. One may also specify a comma-separated
|
|
list of package names without the leading H5.
|
|
This is independent of the build mode
|
|
and is mainly of interest to HDF Group developers.
|
|
Yes/all and no/none are synonymous.
|
|
[default=all if debug build, otherwise none]
|
|
])],
|
|
[INTERNAL_DEBUG_OUTPUT=$enableval])
|
|
|
|
## Set default
|
|
if test "X-$INTERNAL_DEBUG_OUTPUT" = X- ; then
|
|
if test "X-$BUILD_MODE" = "X-debug" ; then
|
|
INTERNAL_DEBUG_OUTPUT=all
|
|
else
|
|
INTERNAL_DEBUG_OUTPUT=none
|
|
fi
|
|
fi
|
|
|
|
AC_SUBST([INTERNAL_DEBUG_OUTPUT])
|
|
|
|
## These are all the packages that use H5*_DEBUG.
|
|
## There is no harm in specifying a package not in this list;
|
|
## you'll just get an unused H5<pkg>_DEBUG symbol.
|
|
##
|
|
## Some packages that define debug checks or output are
|
|
## too specialized or have huge performance hits. These
|
|
## are not listed in the "all" packages list.
|
|
##
|
|
## all_packages="AC,B,B2,D,F,FA,FL,FS,HL,I,O,S,ST,T,Z"
|
|
all_packages="AC,B2,D,F,HL,I,O,S,ST,T,Z"
|
|
|
|
case "X-$INTERNAL_DEBUG_OUTPUT" in
|
|
X-yes|X-all)
|
|
INTERNAL_DEBUG_OUTPUT=$all_packages
|
|
DEBUG_PKG_LIST=$all_packages
|
|
;;
|
|
X-no|X-none)
|
|
INTERNAL_DEBUG_OUTPUT=none
|
|
DEBUG_PKG_LIST=
|
|
;;
|
|
*)
|
|
DEBUG_PKG_LIST=$INTERNAL_DEBUG_OUTPUT
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT([$INTERNAL_DEBUG_OUTPUT])
|
|
|
|
## Define H5*_DEBUG symbols that control package output
|
|
## NOTE: No sanity checking done here!
|
|
if test -n "$DEBUG_PKG_LIST"; then
|
|
for pkg in `echo $DEBUG_PKG_LIST | ${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).
|
|
[default=no]
|
|
])],
|
|
[CODESTACK=$enableval])
|
|
|
|
## Set the default level.
|
|
if test "X-$CODESTACK" = X- ; then
|
|
CODESTACK=no
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([CODESTACK])
|
|
|
|
case "X-$CODESTACK" in
|
|
X-yes)
|
|
AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_CODESTACK], [1],
|
|
[Define if the function stack tracing code is to be compiled in])
|
|
;;
|
|
X-no)
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $CODESTACK])
|
|
;;
|
|
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.
|
|
[default=no]
|
|
])],
|
|
[METADATATRACEFILE=$enableval])
|
|
|
|
## Set the default level.
|
|
if test "X-$METADATATRACEFILE" = X- ; then
|
|
METADATATRACEFILE=no
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([METADATATRACEFILE])
|
|
|
|
case "X-$METADATATRACEFILE" in
|
|
X-yes)
|
|
AC_MSG_RESULT([yes])
|
|
AC_DEFINE([METADATA_TRACE_FILE], [1],
|
|
[Define if the metadata trace file code is to be compiled in])
|
|
;;
|
|
X-no)
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $METADATATRACEFILE])
|
|
;;
|
|
esac
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Enable tracing of the API
|
|
##
|
|
AC_MSG_CHECKING([for API tracing]);
|
|
AC_ARG_ENABLE([trace],
|
|
[AS_HELP_STRING([--enable-trace],
|
|
[Enable HDF5 API tracing capability.
|
|
[default=yes if debug build, otherwise no]
|
|
])],
|
|
[TRACE_API=$enableval])
|
|
|
|
## Set the default level.
|
|
if test "X-$TRACE_API" = X- ; then
|
|
if test "X-$BUILD_MODE" = "X-debug" ; then
|
|
TRACE_API=yes
|
|
else
|
|
TRACE_API=no
|
|
fi
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([TRACE_API])
|
|
|
|
case "X-$TRACE_API" in
|
|
X-yes)
|
|
AC_MSG_RESULT([yes])
|
|
H5_CPPFLAGS="$H5_CPPFLAGS -DH5_DEBUG_API"
|
|
;;
|
|
X-no)
|
|
AC_MSG_RESULT([no])
|
|
H5_CPPFLAGS="$H5_CPPFLAGS -UH5_DEBUG_API"
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $TRACE_API])
|
|
;;
|
|
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_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 its memory operations and also
|
|
disables the library's free space manager code.
|
|
This option is orthogonal to the
|
|
--enable-memory-alloc-sanity-check option.
|
|
[default=no]
|
|
])],
|
|
[USINGMEMCHECKER=$enableval])
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([USINGMEMCHECKER])
|
|
|
|
## Set the default level.
|
|
if test "X-$USINGMEMCHECKER" = X- ; then
|
|
USINGMEMCHECKER=no
|
|
fi
|
|
|
|
case "X-$USINGMEMCHECKER" in
|
|
X-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.])
|
|
AC_MSG_RESULT([yes])
|
|
;;
|
|
X-no)
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $USINGMEMCHECKER])
|
|
;;
|
|
esac
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if they would like to enable the internal memory allocation sanity
|
|
## checking code.
|
|
##
|
|
AC_MSG_CHECKING([whether internal memory allocation sanity checking is used])
|
|
AC_ARG_ENABLE([memory-alloc-sanity-check],
|
|
[AS_HELP_STRING([--enable-memory-alloc-sanity-check],
|
|
[Enable this option to turn on internal memory
|
|
allocation sanity checking. This could cause
|
|
more memory use and somewhat slower allocation.
|
|
This option is orthogonal to the
|
|
--enable-using-memchecker option.
|
|
[default=yes if debug build, otherwise no]
|
|
])],
|
|
[MEMORYALLOCSANITYCHECK=$enableval])
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([MEMORYALLOCSANITYCHECK])
|
|
|
|
## Set default
|
|
if test "X-$MEMORYALLOCSANITYCHECK" = X- ; then
|
|
if test "X-$BUILD_MODE" = "X-debug" ; then
|
|
MEMORYALLOCSANITYCHECK=yes
|
|
else
|
|
MEMORYALLOCSANITYCHECK=no
|
|
fi
|
|
fi
|
|
|
|
case "X-$MEMORYALLOCSANITYCHECK" in
|
|
X-yes)
|
|
AC_DEFINE([MEMORY_ALLOC_SANITY_CHECK], [1],
|
|
[Define to enable internal memory allocation sanity checking.])
|
|
AC_MSG_RESULT([yes])
|
|
;;
|
|
X-no)
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $MEMORYALLOCSANITYCHECK])
|
|
;;
|
|
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.
|
|
##
|
|
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
|
|
|
|
## The --enable-parallel flag is not compatible with --enable-java.
|
|
## 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_JAVA}" = "Xyes" -a "X${enable_parallel}" = "Xyes"; then
|
|
AC_MSG_ERROR([--enable-java 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
|
|
|
|
AC_MSG_CHECKING([for parallel support files])
|
|
case "X-$enable_parallel" in
|
|
X-|X-no|X-none)
|
|
## We are not compiling for parallel.
|
|
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.
|
|
AC_MSG_CHECKING([whether a simple MPI-IO C program can be linked])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <mpi.h>]],
|
|
[[ MPI_Init(0, (void *)0);
|
|
MPI_File_open(0, (void *)0, 0, 0, (void *)0);]])],
|
|
[AC_MSG_RESULT([yes])],
|
|
[AC_MSG_RESULT([no])
|
|
AC_MSG_ERROR([unable to link a simple MPI-IO C program])])
|
|
|
|
if test "X$HDF_FORTRAN" = "Xyes"; then
|
|
PAC_PROG_FC_MPI_CHECK
|
|
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.
|
|
## Needs to be done outside of the PARALLEL block since the serial
|
|
## build also needs to have values defined.
|
|
##
|
|
AC_SUBST([ADD_PARALLEL_FILES]) ADD_PARALLEL_FILES="no"
|
|
AC_SUBST([MPE]) MPE=no
|
|
AC_SUBST([INSTRUMENT_LIBRARY]) INSTRUMENT_LIBRARY=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])
|
|
|
|
## 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. This means that no launch commands were requested,
|
|
## so we will not use any launch commands.
|
|
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_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
#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 exist])
|
|
AC_MSG_RESULT([yes])],
|
|
[AC_MSG_RESULT([no])]
|
|
)
|
|
|
|
AC_MSG_CHECKING([for MPI_Info_c2f and MPI_Info_f2c functions])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#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 exist])
|
|
AC_MSG_RESULT([yes])],
|
|
[AC_MSG_RESULT([no])]
|
|
)
|
|
fi
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Enable instrumenting of the library's internal operations
|
|
## in parallel builds.
|
|
##
|
|
|
|
## Set default
|
|
if test "X-$BUILD_MODE" = "X-debug" ; then
|
|
INSTRUMENT_LIBRARY=yes
|
|
else
|
|
INSTRUMENT_LIBRARY=no
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for instrumented library]);
|
|
AC_ARG_ENABLE([instrument],
|
|
[AS_HELP_STRING([--enable-instrument],
|
|
[Enable library instrumentation of optimization
|
|
tracing (only used with parallel builds).
|
|
[default=yes if a parallel debug build, otherwise no]
|
|
])],
|
|
[INSTRUMENT_LIBRARY=$enableval])
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([INSTRUMENT_LIBRARY])
|
|
|
|
case "X-$INSTRUMENT_LIBRARY" in
|
|
X-yes)
|
|
AC_DEFINE([HAVE_INSTRUMENTED_LIBRARY], [1],
|
|
[Define if parallel library will contain instrumentation to detect correct optimization operation])
|
|
AC_MSG_RESULT([yes])
|
|
;;
|
|
X-no)
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $INSTRUMENT_LIBRARY])
|
|
;;
|
|
esac
|
|
|
|
## --------------------------------------------------------------------
|
|
## 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])
|
|
;;
|
|
*)
|
|
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
|
|
|
|
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])
|
|
else
|
|
AC_CHECK_LIB([mpe], [MPE_Init_log],, [unset MPE])
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
if test "X-$MPE" = "X-yes"; then
|
|
AC_DEFINE([HAVE_MPE], [1], [Define if we have MPE support])
|
|
fi
|
|
fi
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if Direct I/O driver is enabled by --enable-direct-vfd
|
|
##
|
|
AC_SUBST([DIRECT_VFD])
|
|
|
|
## Default is no direct VFD
|
|
DIRECT_VFD=no
|
|
|
|
AC_CACHE_VAL([hdf5_cv_direct_io],
|
|
AC_CHECK_DECL([O_DIRECT], [hdf5_cv_direct_io=yes], [hdf5_cv_direct_io=no], [[#include <fcntl.h>]]))
|
|
AC_CACHE_VAL([hdf5_cv_posix_memalign],
|
|
AC_CHECK_FUNC([posix_memalign], [hdf5_cv_posix_memalign=yes], [hdf5_cv_posix_memalign=no]))
|
|
|
|
AC_MSG_CHECKING([if the direct I/O virtual file driver (VFD) is enabled])
|
|
|
|
AC_ARG_ENABLE([direct-vfd],
|
|
[AS_HELP_STRING([--enable-direct-vfd],
|
|
[Build the direct I/O virtual file driver (VFD).
|
|
This is based on the POSIX (sec2) VFD and
|
|
requires the open() call to take the O_DIRECT
|
|
flag. [default=no]])],
|
|
[DIRECT_VFD=$enableval], [DIRECT_VFD=no])
|
|
|
|
if test "X$DIRECT_VFD" = "Xyes"; then
|
|
if test ${hdf5_cv_direct_io} = "yes" && test ${hdf5_cv_posix_memalign} = "yes" ; then
|
|
AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_DIRECT], [1],
|
|
[Define if the direct I/O virtual file driver (VFD) should be compiled])
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
DIRECT_VFD=no
|
|
AC_MSG_ERROR([The direct VFD was requested but cannot be built. This is either
|
|
due to O_DIRECT not being found in fcntl.h or a lack of
|
|
posix_memalign() on your system. Please re-configure without
|
|
specifying --enable-direct-vfd.])
|
|
fi
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
fi
|
|
|
|
## Direct VFD files are not built if not required.
|
|
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 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 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])
|
|
|
|
## NOTE: Place all configure test programs into cmake's source file, then use a preprocessor directive
|
|
## to select the proper test program. This is done by echoing the #define and cat'ing the cmake
|
|
## source file. (HDFFV-9467)
|
|
|
|
TEST_SRC="`(echo \"#define H5_LDOUBLE_TO_LONG_SPECIAL_TEST 1\"; cat $srcdir/config/cmake/ConversionTests.c)`"
|
|
|
|
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_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([$TEST_SRC])]
|
|
, [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])
|
|
|
|
TEST_SRC="`(echo \"#define H5_LONG_TO_LDOUBLE_SPECIAL_TEST 1\"; cat $srcdir/config/cmake/ConversionTests.c)`"
|
|
|
|
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_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([$TEST_SRC])]
|
|
, [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, SGI IRIX64 6.5 and
|
|
## Powerpc Linux using XL compilers.
|
|
## 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])
|
|
|
|
TEST_SRC="`(echo \"#define H5_LDOUBLE_TO_LLONG_ACCURATE_TEST 1\"; cat $srcdir/config/cmake/ConversionTests.c)`"
|
|
|
|
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_RUN_IFELSE([AC_LANG_SOURCE([$TEST_SRC])],
|
|
[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 and Powerpc Linux using
|
|
## XL compilers.
|
|
## 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])
|
|
|
|
TEST_SRC="`(echo \"#define H5_LLONG_TO_LDOUBLE_CORRECT_TEST 1\"; cat $srcdir/config/cmake/ConversionTests.c)`"
|
|
|
|
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_RUN_IFELSE([AC_LANG_SOURCE([$TEST_SRC])],
|
|
[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 some variables for general configuration information to be saved
|
|
## and installed with the libraries (used to generate libhdf5.settings).
|
|
##
|
|
|
|
## 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, debug, 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="$CXX";
|
|
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
|
|
|
|
AC_SUBST([JAVA_VERSION])
|
|
## Strip anything that looks like a flag off of $JAVA
|
|
JAVA_NOFLAGS=`echo $JAVA | sed 's/ -.*//'`
|
|
|
|
if `echo $JAVA_NOFLAGS | grep ^/ >/dev/null 2>&1`; then
|
|
JAVA_VERSION="$JAVA"
|
|
else
|
|
JAVA_VERSION="$JAVA";
|
|
for x in `echo $PATH | sed -e 's/:/ /g'`; do
|
|
if test -x $x/$JAVA_NOFLAGS; then
|
|
JAVA_VERSION="$x/$JAVA"
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
java_version_info=`$JAVA -version 2>&1 |\
|
|
grep 'version' | sed -e 's/version "//' | sed -e 's/"//'`
|
|
if test -n "$java_version_info"; then
|
|
JAVA_VERSION="$JAVA_VERSION ($java_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`"
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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
|
|
##
|
|
|
|
## Enabled unless the build mode is clean.
|
|
if test "X-$BUILD_MODE" = "X-clean" ; then
|
|
DEPREC_SYMBOLS=no
|
|
else
|
|
DEPREC_SYMBOLS=yes
|
|
fi
|
|
|
|
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 (unless build mode = clean)]
|
|
])],
|
|
[DEPREC_SYMBOLS=$enableval])
|
|
|
|
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
|
|
AC_DEFINE([USE_18_API_DEFAULT], [1],
|
|
[Define using v1.8 public API symbols by default])
|
|
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 build, otherwise no]
|
|
])],
|
|
[STRICT_FORMAT_CHECKS=$enableval])
|
|
|
|
## Set the default level. This depends on the compiler mode.
|
|
if test "X-$STRICT_FORMAT_CHECKS" = X- ; then
|
|
if test "X-$BUILD_MODE" = "X-debug" ; then
|
|
STRICT_FORMAT_CHECKS=yes
|
|
else
|
|
STRICT_FORMAT_CHECKS=no
|
|
fi
|
|
fi
|
|
|
|
case "X-$STRICT_FORMAT_CHECKS" in
|
|
X-yes)
|
|
AC_MSG_RESULT([yes])
|
|
AC_DEFINE([STRICT_FORMAT_CHECKS], [1],
|
|
[Define if strict file format checks are enabled])
|
|
;;
|
|
X-no)
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $STRICT_FORMAT_CHECKS])
|
|
;;
|
|
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])
|
|
|
|
TEST_SRC="`(echo \"#define H5_NO_ALIGNMENT_RESTRICTIONS_TEST 1\"; cat $srcdir/config/cmake/ConversionTests.c)`"
|
|
|
|
AC_RUN_IFELSE([
|
|
AC_LANG_SOURCE([$TEST_SRC])
|
|
], [
|
|
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"
|
|
JAVACFLAGS="$saved_user_JAVACFLAGS"
|
|
JAVAFLAGS="$saved_user_JAVAFLAGS"
|
|
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_JAVA_CONDITIONAL], [test "X$HDF_JAVA" = "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'
|
|
export SEARCH
|
|
|
|
## 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
|
|
|
|
## 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
|
|
|
|
## Expose things for *.in markup
|
|
AC_SUBST([STATIC_SHARED])
|
|
AC_SUBST([enable_shared])
|
|
AC_SUBST([enable_static])
|
|
|
|
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/testflushrefresh.sh
|
|
test/H5srcdir_str.h
|
|
test/testlibinfo.sh
|
|
test/testlinks_env.sh
|
|
test/test_filenotclosed.sh
|
|
test/testswmr.sh
|
|
test/test_plugin.sh
|
|
test/test_usecases.sh
|
|
test/testvdsswmr.sh
|
|
testpar/Makefile
|
|
tools/Makefile
|
|
tools/lib/Makefile
|
|
tools/src/Makefile
|
|
tools/src/h5dump/Makefile
|
|
tools/src/h5import/Makefile
|
|
tools/src/h5diff/Makefile
|
|
tools/src/h5jam/Makefile
|
|
tools/src/h5repack/Makefile
|
|
tools/src/h5ls/Makefile
|
|
tools/src/h5copy/Makefile
|
|
tools/src/misc/Makefile
|
|
tools/src/misc/h5cc
|
|
tools/src/h5stat/Makefile
|
|
tools/test/Makefile
|
|
tools/test/h5dump/Makefile
|
|
tools/test/h5dump/h5dump_plugin.sh
|
|
tools/test/h5dump/testh5dump.sh
|
|
tools/test/h5dump/testh5dumppbits.sh
|
|
tools/test/h5dump/testh5dumpvds.sh
|
|
tools/test/h5dump/testh5dumpxml.sh
|
|
tools/test/h5ls/Makefile
|
|
tools/test/h5ls/h5ls_plugin.sh
|
|
tools/test/h5ls/testh5ls.sh
|
|
tools/test/h5ls/testh5lsvds.sh
|
|
tools/test/h5import/Makefile
|
|
tools/test/h5import/h5importtestutil.sh
|
|
tools/test/h5diff/Makefile
|
|
tools/test/h5diff/h5diff_plugin.sh
|
|
tools/test/h5diff/testh5diff.sh
|
|
tools/test/h5diff/testph5diff.sh
|
|
tools/src/h5format_convert/Makefile
|
|
tools/test/h5format_convert/Makefile
|
|
tools/test/h5format_convert/testh5fc.sh
|
|
tools/test/h5jam/Makefile
|
|
tools/test/h5jam/testh5jam.sh
|
|
tools/test/h5repack/Makefile
|
|
tools/test/h5repack/h5repack.sh
|
|
tools/test/h5repack/h5repack_plugin.sh
|
|
tools/test/h5copy/Makefile
|
|
tools/test/h5copy/testh5copy.sh
|
|
tools/test/misc/Makefile
|
|
tools/test/misc/testh5clear.sh
|
|
tools/test/misc/testh5mkgrp.sh
|
|
tools/test/misc/testh5repart.sh
|
|
tools/test/misc/vds/Makefile
|
|
tools/test/h5stat/Makefile
|
|
tools/test/h5stat/testh5stat.sh
|
|
tools/test/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/src/H5fort_type_defines.h
|
|
fortran/test/Makefile
|
|
fortran/testpar/Makefile
|
|
fortran/examples/Makefile
|
|
fortran/examples/run-fortran-ex.sh
|
|
fortran/examples/testh5fc.sh
|
|
java/Makefile
|
|
java/src/Makefile
|
|
java/src/jni/Makefile
|
|
java/test/Makefile
|
|
java/test/junit.sh
|
|
java/examples/Makefile
|
|
java/examples/intro/Makefile
|
|
java/examples/intro/runExample.sh
|
|
java/examples/datasets/Makefile
|
|
java/examples/datasets/runExample.sh
|
|
java/examples/datatypes/Makefile
|
|
java/examples/datatypes/runExample.sh
|
|
java/examples/groups/Makefile
|
|
java/examples/groups/runExample.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/tools/h5watch/Makefile
|
|
hl/tools/h5watch/testh5watch.sh
|
|
hl/examples/Makefile
|
|
hl/examples/run-hlc-ex.sh
|
|
hl/c++/Makefile
|
|
hl/c++/src/Makefile
|
|
hl/c++/test/Makefile
|
|
hl/c++/examples/Makefile
|
|
hl/c++/examples/run-hlc++-ex.sh
|
|
hl/fortran/Makefile
|
|
hl/fortran/src/Makefile
|
|
hl/fortran/test/Makefile
|
|
hl/fortran/examples/Makefile
|
|
hl/fortran/examples/run-hlfortran-ex.sh])
|
|
|
|
AC_CONFIG_COMMANDS([.classes], [], [$MKDIR_P java/src/.classes;
|
|
$MKDIR_P java/test/.classes;
|
|
$MKDIR_P java/examples/intro/.classes;
|
|
$MKDIR_P java/examples/datasets/.classes;
|
|
$MKDIR_P java/examples/datatypes/.classes;
|
|
$MKDIR_P java/examples/groups/.classes])
|
|
|
|
AC_OUTPUT
|
|
|
|
chmod 755 tools/src/misc/h5cc
|
|
|
|
if test "X$HDF_FORTRAN" = "Xyes"; then
|
|
chmod 755 fortran/src/h5fc
|
|
## libtool does not pass the correct argument linker (wl=) for the Intel Fortran compiler
|
|
## on OS X, which is needed when building shared libraries on OS X. This script
|
|
## replaces the 3rd occurrence, which is for Fortran, of wl="" with wl="-Wl," (HDFFV-2772)
|
|
case "`uname`" in
|
|
Darwin*)
|
|
cat libtool | awk '/wl=\"/{c++;if(c==3){sub("wl=\"\"","wl=\"-Wl,\"");c=0}}1' > libtool.tmp && mv -f libtool.tmp libtool && chmod 755 libtool
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if test "X$HDF_CXX" = "Xyes"; then
|
|
chmod 755 c++/src/h5c++
|
|
fi
|
|
|
|
## HDF5 configure code created by autotools with gcc 4.9.2 is adding problematic
|
|
## linker flags: -l with no library name; -l <libname>, specifically gfortran or m.
|
|
## This sed script corrects "-l <libname>" first and then "-l " with no library name.
|
|
## If the order is not preserved, all instances of "-l " will be removed.
|
|
sed -e '/^postdeps/ s/-l \([a-zA-Z]\)/-l\1/g' -e '/^postdeps/ s/-l //g' -i libtool
|
|
|
|
## show the configure settings
|
|
cat src/libhdf5.settings
|