mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-11-21 01:04:10 +08:00
1d680fe04c
* Fixed warnings and started H5Epublic.h.
* Include H5FD* headers to correctly resolve references.
* Doxygen2 (#330)
* H5Eauto_is_v2.
* Added a few more calls.
* Added a few more H5E calls.
* First cut of H5E v2.
* Added the deprecated v1 calls.
* Updated spacing.
* Once more.
* Taking some inspiration from Eigen3.
* Add doxygen for the assigned functions: H5Pregister1,H5Pinsert1,H5Pen… (#352)
* Add doxygen for the assigned functions: H5Pregister1,H5Pinsert1,H5Pencode1, H5Pget_filter_by_id1,H5Pget_version, H5Pset_file_space,H5Pget_file_space. Someone already adds H5Pget_filter1. Also fixs an extra parameter 'close' call back function for HPregister2.
* doxygen work. fixs format by using clang-format.
* doxgen work for H5Pregister1 etc. Addressed Barbara and Gerd's comments.
For Quincey's comments, since we are not supposed to change the source code.
I leave this to future improvements.
* added documentation for H5P APIs (#350)
* add documenation for H5Pget_buffer,H5Pget_data_transform,H5Pget_edc_check,H5Pget_hyper_vector_size,H5Pget_preserve,H5Pget_type_conv_cb,H5Pget_vlen_mem_manager,H5Pset_btree_ratios
* format corrections
* fixed grammer
* fixed herr_t
* Better name.
* A fresh look.
* add doxygen to H5Ppublic.h
* use attention instead of warning
* Add doxygen comments in H5Ppublic.h (#375)
* Add doxygen comments in H5Ppublic.h
* H5Pset_meta_block_size
* H5Pset_metadata_read_attempts
* H5Pset_multi_type
* H5Pset_object_flush_cb
* H5Pset_sieve_buf_size
* H5Pset_small_data_block_size
* H5Pset_all_coll_metadata_ops
* H5Pget_all_coll_metadata_ops
* Add DOXYGEN_EXAMPLES_DIR to src/CMakeLists.txt
* Fix clang-format errors
* Fix filenames in doxygen/examples
* add doxygen to H5Ppublic.h (#378)
* add doxygen to H5Ppublic.h
* use attention instead of warning
Co-authored-by: Kimmy Mu <kmu@hdfgroup.org>
* Revert "add doxygen to H5Ppublic.h (#378)"
This reverts commit 2ee1821b13.
* Updated Doxygen variables.
* I forgot to copy two images.
* Enable desktop search by default.
* Add my assigned Doxygen documentation.
* Remove whitespace at EOL. Appease clang-format.
* Addressed Chris' comments.
* Added an alias for asynchronous functions.
* One space is enough for all of us.
* Slightly restructured RM page.
* address some issues
* reformatting
* Style external links.
* reformatting
* reformatting
* Added "Metadata Caching in HDF5" as a technical note example.
* Revise this soon!
* Added specification examples.
* Fixed references.
* Added H5AC cache image stuff and file format study.
* Added older FMT versions. Where did 1.0 go?
* Updated C/C++ note and replaced ambiguous labels.
* Reformat source with clang v10.0.1.
* Added the VFL technical note.
* Added what I believe might be called version 1.0 of the format.
* Added the remaining specs.
* Added H5Z callback documentation and fixed a few mistakes.
* Added dox for deprecated H5G calls and fixed a few snippet blockIDs.
* clang-format happy?
* Ok?
* Bonus track: Deprecated H5D functions.
* Carry over the more detailed group description.
* Added documentation for the missing and deprecated H5R calls.
* Life is easier and less repetitive w/ snippets. Use them!
* Eliminate the snippet block ID artifacts in the HTML rendering.
* Fixed snippet HTML artifacts and added a few missing calls.
* Under 20 H5Ps to go!
* Almost complete!
* "This is a form of pedantry up with which I will not put." (Churchill)
* Let's not waste as much space on bulleted lists!
* First complete (?) draft of the Doxygen-based RM.
* Completeness check and minor fixes along the way.
* Pedantry.
* Adding missing H5FD calls checkpoint.
* Pedantry.
* More pedantry.
* Added H5Pset_fapl_log.
* First draft of H5ES.
* Fixed warnings.
* Prep. for map module.
* First cut of the map module.
* Pedantry.
* Possible H5F introduction.
* Fix the indentation.
* Pedantry.
* Ditto.
* Thanks to the reviewers for their comments.
* Added missing images.
* Line numbers are a distraction here.
* More examples, references, and clean-up. Don't repeat yourself!
* Clang pedantry.
* Ditto.
* More reviewer comments...
* Templatized references and cleaned up \todos.
* Committing clang-format changes
* Fixed MANIFEST.
* Addressed Quincey's comments. (OCPLs)
* Fixed a few more \todo items.
* Fixed more \todo items.
* Added attribute life cycle.
* Forgot the examples file.
* Committing clang-format changes
* Pedantry.
* Live and learn!
* Added a sample H5D life cycle.
* Committing clang-format changes
* Pedantry.
Co-authored-by: kyang2014 <kyang2014@users.noreply.github.com>
Co-authored-by: Scot Breitenfeld <brtnfld@hdfgroup.org>
Co-authored-by: Kimmy Mu <kmu@hdfgroup.org>
Co-authored-by: Christopher Hogan <ChristopherHogan@users.noreply.github.com>
Co-authored-by: jya-kmu <53388330+jya-kmu@users.noreply.github.com>
Co-authored-by: David Young <dyoung@hdfgroup.org>
Co-authored-by: Larry Knox <lrknox@hdfgroup.org>
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
4229 lines
144 KiB
Plaintext
4229 lines
144 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://www.hdfgroup.org/licenses.
|
|
## If you do not have access to either file, you may request a copy from
|
|
## help@hdfgroup.org.
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Initialize configure.
|
|
##
|
|
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.13.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 determines the behavior of "rebuild rules" that contain
|
|
## dependencies for Makefile.in files, configure, src/H5config.h, etc. If
|
|
## AM_MAINTAINER_MODE is enabled, these files will be rebuilt if out of date.
|
|
## When disabled, the autotools build files can get out of sync and the build
|
|
## system will not complain or try to regenerate downstream files.
|
|
##
|
|
## The AM_MAINTAINER_MODE macro also determines whether the
|
|
## --(enable|disable)-maintainer-mode configure option is available. When the
|
|
## macro is present, with or without a parameter, the option will be added
|
|
## to the generated configure script.
|
|
##
|
|
## In summary:
|
|
##
|
|
## AM_MAINTAINER_MODE([enable])
|
|
## - Build dependencies ON by default
|
|
## - Configure option exists
|
|
##
|
|
## AM_MAINTAINER_MODE([disable])
|
|
## - Build dependencies OFF by default
|
|
## - Configure option exists
|
|
##
|
|
## AM_MAINTAINER_MODE
|
|
## - Build dependencies OFF by default
|
|
## - Configure option exists
|
|
##
|
|
## No AM_MAINTAINER_MODE macro
|
|
## - Build dependencies ON by default
|
|
## - No configure option to control build dependencies
|
|
##
|
|
## The biggest concern for us is that version control systems like git
|
|
## usually don't preserve dependencies between timestamps, so the build
|
|
## system will often think that upstream build files like Makefile.am are
|
|
## dirty and that rebuilding needs to occur when it doesn't. This is a problem
|
|
## in release branches where we provide the autotools-generated files. Users
|
|
## who don't have autoconf, automake, etc. will then have difficulty building
|
|
## release branches checked out from git.
|
|
##
|
|
## By default, maintainer mode is enabled in development branches and disabled
|
|
## in release branches.
|
|
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
|
|
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
|
|
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])
|
|
AC_SUBST([AR_FLAGS])
|
|
|
|
## 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}"
|
|
AR_FLAGS="${AR_FLAGS}"
|
|
|
|
## 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
|
|
;;
|
|
netbsd*)
|
|
host_os_novers=netbsd
|
|
;;
|
|
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
|
|
|
|
##
|
|
## Enable/disable sanitizer checks for clang compilers, initially address sanitizer
|
|
##
|
|
AC_MSG_CHECKING([for clang sanitizer checks])
|
|
AC_ARG_ENABLE([sanitize-checks],
|
|
[AS_HELP_STRING([--enable-sanitize-checks=address],
|
|
[(clang/clang++ compilers only) Enable sanitize checks.
|
|
Address is useful for detecting issues dealing with
|
|
memory. See AddressSanitizer in config/sanitizer/README.md
|
|
for more information.
|
|
[default=none]
|
|
])],
|
|
[CLANG_SANITIZE_CHECKS=$enableval])
|
|
|
|
# Set default
|
|
if test "X-$CLANG_SANITIZE_CHECKS" = X- ; then
|
|
CLANG_SANITIZE_CHECKS=none
|
|
fi
|
|
|
|
if test "X$CC_BASENAME" = "Xclang"; then
|
|
AC_SUBST([CLANG_SANITIZE_CHECKS])
|
|
|
|
# There are several sanitizer tools. At present we are testing
|
|
# and describing only -fsanitizer=address with autotools.
|
|
case "X-$CLANG_SANITIZE_CHECKS" in
|
|
X-no|X-none)
|
|
CLANG_SANITIZE_CHECKS=none
|
|
CLANG_SANITIZE_LIST=
|
|
;;
|
|
*)
|
|
CLANG_SANITIZE_LIST=$CLANG_SANITIZE_CHECKS
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT([$CLANG_SANITIZE_CHECKS])
|
|
|
|
# Other tools can be added to the list of checks
|
|
# The clang compiler doesn't support some of them; they should be
|
|
# checked before adding them to the list in the help message.
|
|
# The sanitizers/sanitizers.cmake file lists these options:
|
|
# address, memory, memoryWithOrigins, undefined, thread, leak,
|
|
# 'address;undefined'. Which and which combinations of these are
|
|
# supported varies by compiler version, but unsupported options
|
|
# or combinations will result in configure errors reported in config.log.
|
|
# Comma separated lists of sanitize options wil be entered intact in
|
|
# one -fsanitize=<list> flag. Space separated lists will be entered in
|
|
# separate -fsanitize=<item> flags.
|
|
# NOTE: No sanity checking done here!
|
|
if test -n "$CLANG_SANITIZE_LIST"; then
|
|
H5_CFLAGS="$H5_CFLAGS -fno-omit-frame-pointer"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS -fno-omit-frame-pointer"
|
|
for sanitizer in `echo $CLANG_SANITIZE_LIST`; do
|
|
H5_CFLAGS="$H5_CFLAGS -fsanitize=${sanitizer}"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS -fsanitize=${sanitizer}"
|
|
done
|
|
fi
|
|
fi
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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 extension __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([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])
|
|
|
|
# Set the default ar flags to cr
|
|
# The Automake default is to use cru and the 'u' causes ar
|
|
# to emit warnings on some platforms.
|
|
AR_FLAGS=cr
|
|
|
|
|
|
## 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])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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"])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if they would like to disable building tests
|
|
##
|
|
|
|
## This needs to be exposed for the library info file.
|
|
AC_SUBST([HDF5_TESTS])
|
|
|
|
## Default is to build tests
|
|
HDF5_TESTS=yes
|
|
|
|
AC_MSG_CHECKING([if building tests is disabled])
|
|
|
|
AC_ARG_ENABLE([tests],
|
|
[AS_HELP_STRING([--enable-tests],
|
|
[Compile the HDF5 tests [default=yes]])],
|
|
[HDF5_TESTS=$enableval])
|
|
|
|
if test "X$HDF5_TESTS" = "Xno"; then
|
|
AC_MSG_RESULT([yes])
|
|
echo "Building HDF5 tests is disabled"
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
fi
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if they would like to disable building tools
|
|
##
|
|
|
|
## This needs to be exposed for the library info file.
|
|
AC_SUBST([HDF5_TOOLS])
|
|
|
|
## Default is to build tests and tools
|
|
HDF5_TOOLS=yes
|
|
|
|
AC_MSG_CHECKING([if building tools is disabled])
|
|
|
|
AC_ARG_ENABLE([tools],
|
|
[AS_HELP_STRING([--enable-tools],
|
|
[Compile the HDF5 tools [default=yes]])],
|
|
[HDF5_TOOLS=$enableval])
|
|
|
|
if test "X$HDF5_TOOLS" = "Xno"; then
|
|
AC_MSG_RESULT([yes])
|
|
echo "Building HDF5 tools is disabled"
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
fi
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if they would like to enable building doxygen files
|
|
##
|
|
|
|
## This needs to be exposed for the library info file.
|
|
AC_SUBST([HDF5_DOXYGEN])
|
|
|
|
## Default is to not build DOXYGEN
|
|
HDF5_DOXYGEN=no
|
|
|
|
AC_MSG_CHECKING([if building doxygen is enabled])
|
|
|
|
AC_ARG_ENABLE([doxygen],
|
|
[AS_HELP_STRING([--enable-doxygen],
|
|
[Compile the HDF5 doxygen files [default=no]])],
|
|
[HDF5_DOXYGEN=$enableval])
|
|
|
|
if test "X$HDF5_DOXYGEN" = "Xyes"; then
|
|
AC_MSG_RESULT([yes])
|
|
DX_DOXYGEN_FEATURE(ON)
|
|
DX_DOT_FEATURE(OFF)
|
|
DX_HTML_FEATURE(ON)
|
|
DX_CHM_FEATURE(OFF)
|
|
DX_CHI_FEATURE(OFF)
|
|
DX_MAN_FEATURE(ON)
|
|
DX_RTF_FEATURE(OFF)
|
|
DX_XML_FEATURE(OFF)
|
|
DX_PDF_FEATURE(OFF)
|
|
DX_PS_FEATURE(OFF)
|
|
|
|
AC_SUBST([DOXYGEN_PACKAGE])
|
|
AC_SUBST([DOXYGEN_VERSION_STRING])
|
|
AC_SUBST([DOXYGEN_INCLUDE_ALIASES])
|
|
AC_SUBST([DOXYGEN_PROJECT_LOGO])
|
|
AC_SUBST([DOXYGEN_PROJECT_BRIEF])
|
|
AC_SUBST([DOXYGEN_INPUT_DIRECTORY])
|
|
AC_SUBST([DOXYGEN_OPTIMIZE_OUTPUT_FOR_C])
|
|
AC_SUBST([DOXYGEN_MACRO_EXPANSION])
|
|
AC_SUBST([DOXYGEN_OUTPUT_DIRECTORY])
|
|
AC_SUBST([DOXYGEN_EXAMPLES_DIRECTORY])
|
|
AC_SUBST([DOXYGEN_LAYOUT_FILE])
|
|
AC_SUBST([DOXYGEN_HTML_HEADER])
|
|
AC_SUBST([DOXYGEN_HTML_FOOTER])
|
|
AC_SUBST([DOXYGEN_HTML_EXTRA_STYLESHEET])
|
|
AC_SUBST([DOXYGEN_HTML_EXTRA_FILES])
|
|
AC_SUBST([DOXYGEN_SERVER_BASED_SEARCH])
|
|
AC_SUBST([DOXYGEN_EXTERNAL_SEARCH])
|
|
AC_SUBST([DOXYGEN_SEARCHENGINE_URL])
|
|
|
|
DOXYGEN_PACKAGE=${PACKAGE_NAME}
|
|
DOXYGEN_VERSION_STRING=${PACKAGE_VERSION}
|
|
DOXYGEN_INCLUDE_ALIASES='$(SRCDIR)/doxygen/aliases'
|
|
DOXYGEN_PROJECT_LOGO='$(SRCDIR)/doxygen/img/HDFG-logo.png'
|
|
DOXYGEN_PROJECT_BRIEF=
|
|
DOXYGEN_INPUT_DIRECTORY='$(SRCDIR) $(SRCDIR)/doxygen/dox'
|
|
DOXYGEN_OPTIMIZE_OUTPUT_FOR_C=YES
|
|
DOXYGEN_MACRO_EXPANSION=YES
|
|
DOXYGEN_OUTPUT_DIRECTORY=hdf5lib_docs
|
|
DOXYGEN_EXAMPLES_DIRECTORY='$(SRCDIR)/doxygen/examples'
|
|
DOXYGEN_LAYOUT_FILE='$(SRCDIR)/doxygen/hdf5doxy_layout.xml'
|
|
DOXYGEN_HTML_HEADER='$(SRCDIR)/doxygen/hdf5_header.html'
|
|
DOXYGEN_HTML_FOOTER='$(SRCDIR)/doxygen/hdf5_footer.html'
|
|
DOXYGEN_HTML_EXTRA_STYLESHEET='$(SRCDIR)/doxygen/hdf5doxy.css'
|
|
DOXYGEN_HTML_EXTRA_FILES='$(SRCDIR)/doxygen/hdf5_navtree_hacks.js $(SRCDIR)/doxygen/img/ftv2node.png $(SRCDIR)/doxygen/img/ftv2pnode.png'
|
|
DOXYGEN_SERVER_BASED_SEARCH=NO
|
|
DOXYGEN_EXTERNAL_SEARCH=NO
|
|
DOXYGEN_SEARCHENGINE_URL=
|
|
|
|
DX_INIT_DOXYGEN([HDF5], [../doxygen/Doxyfile], [hdf5lib_docs])
|
|
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
echo "Doxygen support is disabled"
|
|
fi
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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])
|
|
AC_CHECK_HEADERS([netdb.h netinet/in.h arpa/inet.h])
|
|
|
|
## Darwin
|
|
AC_SUBST([H5_IS_DARWIN])
|
|
H5_IS_DARWIN="no"
|
|
case $host_os in
|
|
darwin*)
|
|
AC_DEFINE([HAVE_DARWIN], [1], [Define if Darwin or Mac OS X])
|
|
H5_IS_DARWIN="yes"
|
|
;;
|
|
esac
|
|
|
|
## Windows
|
|
case "`uname`" in
|
|
CYGWIN*)
|
|
AC_CHECK_HEADERS([io.h sys/timeb.h])
|
|
UNAME_CYGWIN="yes"
|
|
;;
|
|
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. Even later, this was changed to 200809L to support
|
|
## pread/pwrite in VFDs.
|
|
##
|
|
## 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=200809L $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
|
|
|
|
AC_CHECK_SIZEOF(time_t, [], [
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_TIME_H
|
|
#include <time.h>
|
|
#endif
|
|
])
|
|
|
|
## 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 "X-$withval" in
|
|
X-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
|
|
;;
|
|
X-|X-no|X-none)
|
|
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 "X-$withval" in
|
|
X-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
|
|
;;
|
|
X-|X-no|X-none)
|
|
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 "X-$withval" in
|
|
X-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
|
|
;;
|
|
X-|X-no|X-none)
|
|
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
|
|
|
|
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"; then
|
|
AC_CHECK_LIB([sz], [SZ_BufftoBuffCompress],,
|
|
[CPPFLAGS="$saved_CPPFLAGS"; AM_CPPFLAGS="$saved_AM_CPPFLAGS"; LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset HAVE_SZLIB])
|
|
if test -n "$HAVE_SZLIB"; then
|
|
AC_CHECK_HEADERS([szlib.h],
|
|
[HAVE_SZLIB_H="yes"],
|
|
[CPPFLAGS="$saved_CPPFLAGS"; AM_CPPFLAGS="$saved_AM_CPPFLAGS"] [unset HAVE_SZLIB])
|
|
else
|
|
AC_MSG_RESULT([Using SZ_BufftoBuffCompress from libsz in $szlib_lib failed. Szip not enabled.])
|
|
fi
|
|
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])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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 ll l 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], [OPTION CHANGE: use --enable-build-mode=debug])],
|
|
[AC_MSG_ERROR([--enable-debug is no longer supported, use --enable-build-mode=debug instead.])])
|
|
|
|
AC_ARG_ENABLE([production],
|
|
[AS_HELP_STRING([--enable-production], [OPTION CHANGE: use --enable-build-mode=production])],
|
|
[AC_MSG_ERROR([--enable-production is no longer supported, use --enable-build-mode=production instead.])])
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if the compiler should include build diagnostics
|
|
##
|
|
AC_MSG_CHECKING([enable build diagnostics])
|
|
AC_ARG_ENABLE([diags],
|
|
[AS_HELP_STRING([--enable-diags=(yes|no|<custom>)],
|
|
[Allow default enhanced diagnostics to the build.
|
|
This is independent of the build mode and optimization
|
|
level.
|
|
[default=no]
|
|
])],
|
|
[DIAGS=$enableval])
|
|
|
|
## Set default
|
|
if test "X-$DIAGS" = X- ; then
|
|
DIAGS=no
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([DIAGS])
|
|
|
|
case "X-$DIAGS" in
|
|
X-yes)
|
|
H5_CFLAGS="$H5_CFLAGS $DIAGS_CFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $DIAGS_CXXFLAGS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $DIAGS_FCFLAGS"
|
|
AC_MSG_RESULT([yes])
|
|
;;
|
|
X-no)
|
|
H5_CFLAGS="$H5_CFLAGS $NO_DIAGS_CFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $NO_DIAGS_CXXFLAGS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $NO_DIAGS_FCFLAGS"
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
H5_CFLAGS="$H5_CFLAGS $DIAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $DIAGS"
|
|
H5_FCFLAGS="$H5_FCFLAGS $DIAGS"
|
|
DIAGS="custom ($DIAGS)"
|
|
AC_MSG_RESULT([$DIAGS])
|
|
;;
|
|
esac
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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
|
|
|
|
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 we should consider certain compiler warnings as errors
|
|
##
|
|
## These should NOT be on by default as the risk of breakage is high
|
|
## when compiling HDF5 on new (or new versions) of platforms and
|
|
## compilers. It can also cause failures when header files we have no
|
|
## control over (e.g. MPI, HDFS) raise warnings.
|
|
##
|
|
AC_MSG_CHECKING([enable warnings as errors])
|
|
AC_ARG_ENABLE([warnings-as-errors],
|
|
[AS_HELP_STRING([--enable-warnings-as-errors],
|
|
[Determines whether certain warnings will be
|
|
considered errors. This is mainly for use
|
|
by HDF5 library developers.
|
|
[default=no]
|
|
])],
|
|
[WARNINGS_AS_ERRORS=$enableval])
|
|
|
|
## Set default
|
|
if test "X-$WARNINGS_AS_ERRORS" = X- ; then
|
|
WARNINGS_AS_ERRORS=no
|
|
fi
|
|
|
|
case "X-$WARNINGS_AS_ERRORS" in
|
|
X-yes)
|
|
H5_CFLAGS="$H5_CFLAGS $H5_ECFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $H5_ECXXFLAGS"
|
|
AC_MSG_RESULT([yes])
|
|
;;
|
|
X-no)
|
|
H5_CFLAGS="$H5_CFLAGS $H5_NECFLAGS"
|
|
H5_CXXFLAGS="$H5_CXXFLAGS $H5_NECXXFLAGS"
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $WARNINGS_AS_ERRORS])
|
|
;;
|
|
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
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if file locking should be used
|
|
##
|
|
AC_MSG_CHECKING([enable file locking])
|
|
AC_ARG_ENABLE([file-locking],
|
|
[AS_HELP_STRING([--enable-file-locking=(yes|no|best-effort)],
|
|
[Sets the default for whether or not to use file
|
|
locking when opening files. Can be overridden
|
|
with the HDF5_USE_FILE_LOCKING environment variable
|
|
and the H5Pset_file_locking() API call.
|
|
best-effort attempts to use file locking but does
|
|
not fail when file locks have been disabled on
|
|
the file system (useful with Lustre).
|
|
[default=best-effort]
|
|
])],
|
|
[DESIRED_FILE_LOCKING=$enableval])
|
|
|
|
## Set defaults
|
|
if test "X-$DESIRED_FILE_LOCKING" = X- ; then
|
|
DESIRED_FILE_LOCKING=best-effort
|
|
fi
|
|
|
|
## Allow this variable to be substituted in
|
|
## other files (src/libhdf5.settings.in, etc.)
|
|
AC_SUBST([DESIRED_FILE_LOCKING])
|
|
AC_SUBST([USE_FILE_LOCKING])
|
|
AC_SUBST([IGNORE_DISABLED_FILE_LOCKS])
|
|
|
|
case "X-$DESIRED_FILE_LOCKING" in
|
|
X-best-effort)
|
|
AC_MSG_RESULT([best-effort])
|
|
AC_DEFINE([USE_FILE_LOCKING], [1],
|
|
[Define if the library will use file locking])
|
|
AC_DEFINE([IGNORE_DISABLED_FILE_LOCKS], [1],
|
|
[Define if the library will ignore file locks when disabled])
|
|
;;
|
|
X-yes)
|
|
AC_MSG_RESULT([yes])
|
|
AC_DEFINE([USE_FILE_LOCKING], [1],
|
|
[Define if the library will use file locking])
|
|
;;
|
|
X-no)
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $USE_FILE_LOCKING])
|
|
;;
|
|
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,CX,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
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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
|
|
AC_SUBST([PARALLEL_FILTERED_WRITES])
|
|
AC_SUBST([LARGE_PARALLEL_IO])
|
|
|
|
if test -n "$PARALLEL"; then
|
|
if test "X$HDF5_TESTS" = "Xyes"; then
|
|
## The 'testpar' directory should participate in the build
|
|
TESTPARALLEL=testpar
|
|
fi
|
|
|
|
## 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
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check for the MPI-3 functions necessary for the Parallel Compression
|
|
## feature. If these are not present, issue a warning that Parallel
|
|
## Compression will be disabled.
|
|
##
|
|
AC_MSG_CHECKING([for MPI_Mprobe and MPI_Imrecv functions])
|
|
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[
|
|
#include <mpi.h>
|
|
]],
|
|
[[
|
|
MPI_Message message;
|
|
MPI_Init(0, (void *) 0);
|
|
MPI_Mprobe(0, 0, 0, &message, (void *) 0);
|
|
MPI_Imrecv((void *) 0, 0, 0, (void *) 0, (void *) 0);
|
|
]]
|
|
)],
|
|
[AC_MSG_RESULT([yes])
|
|
PARALLEL_FILTERED_WRITES=yes],
|
|
[AC_MSG_RESULT([no])
|
|
AC_MSG_WARN([A simple MPI program using the MPI_Mprobe and MPI_Imrecv functions could not be compiled and linked.
|
|
Parallel writes of filtered data will be disabled.])
|
|
PARALLEL_FILTERED_WRITES=no]
|
|
)
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check for the MPI-3 functions necessary for the big I/O feature.
|
|
## If these are not present, issue a warning that the big I/O feature
|
|
## will be disabled.
|
|
##
|
|
AC_MSG_CHECKING([for MPI_Get_elements_x and MPI_Type_size_x functions])
|
|
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[
|
|
#include <mpi.h>
|
|
]],
|
|
[[
|
|
MPI_Count count;
|
|
MPI_Init(0, (void *) 0);
|
|
MPI_Get_elements_x(0, 0, &count);
|
|
MPI_Type_size_x(0, &count);
|
|
]]
|
|
)],
|
|
[AC_MSG_RESULT([yes])
|
|
LARGE_PARALLEL_IO=yes],
|
|
[AC_MSG_RESULT([no])
|
|
AC_MSG_WARN([A simple MPI program using the MPI_Get_elements_x and MPI_Type_size_x functions could not be compiled and linked.
|
|
Reading/Writing >2GB of data in a single parallel I/O operation will be disabled.])
|
|
LARGE_PARALLEL_IO=no]
|
|
)
|
|
|
|
fi
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if the map API is enabled by --enable-map-api
|
|
##
|
|
AC_SUBST([MAP_API])
|
|
|
|
## Default is no map API
|
|
MAP_API=no
|
|
|
|
AC_MSG_CHECKING([if the map API (H5M) is enabled])
|
|
|
|
AC_ARG_ENABLE([map-api],
|
|
[AS_HELP_STRING([--enable-map-api],
|
|
[Build the map API (H5M).
|
|
This is not yet supported in the native file format
|
|
and requires a VOL connector that supports it.
|
|
[default=no]])],
|
|
[MAP_API=$enableval], [MAP_API=no])
|
|
|
|
if test "X$MAP_API" = "Xyes"; then
|
|
AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_MAP_API], [1],
|
|
[Define if the map API (H5M) should be compiled])
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
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"])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check whether the Mirror VFD can be built.
|
|
## Auto-enabled if the required libraries are present.
|
|
##
|
|
AC_SUBST([MIRROR_VFD])
|
|
|
|
## Default is no Mirror VFD
|
|
MIRROR_VFD=no
|
|
|
|
AC_ARG_ENABLE([mirror-vfd],
|
|
[AS_HELP_STRING([--enable-mirror-vfd],
|
|
[Build the socket-based Mirror virtual file driver (VFD).
|
|
[default=no]])],
|
|
[MIRROR_VFD=$enableval], [MIRROR_VFD=no])
|
|
|
|
if test "X$MIRROR_VFD" = "Xyes"; then
|
|
|
|
AC_CHECK_HEADERS([arpa/inet.h],, [unset MIRROR_VFD])
|
|
AC_CHECK_HEADERS([netinet/in.h],, [unset MIRROR_VFD])
|
|
AC_CHECK_HEADERS([netdb.h],, [unset MIRROR_VFD])
|
|
AC_CHECK_HEADERS([sys/socket.h],, [unset MIRROR_VFD])
|
|
AC_CHECK_FUNC([fork], [], [unset MIRROR_VFD])
|
|
|
|
AC_MSG_CHECKING([if the Mirror virtual file driver (VFD) can be built])
|
|
if test "X$MIRROR_VFD" = "Xyes"; then
|
|
AC_DEFINE([HAVE_MIRROR_VFD], [1],
|
|
[Define whether the Mirror virtual file driver (VFD) will be compiled])
|
|
AC_MSG_RESULT([yes])
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
MIRROR_VFD=no
|
|
AC_MSG_ERROR([The Mirror VFD cannot be built.
|
|
Missing one or more of: arpa/inet.h, netinet/in.h,
|
|
netdb.h, sys/socket.h, fork().])
|
|
fi
|
|
else
|
|
AC_MSG_CHECKING([if the Mirror virtual file driver (VFD) is enabled])
|
|
AC_MSG_RESULT([no])
|
|
MIRROR_VFD=no
|
|
fi
|
|
|
|
## Mirror VFD files built only if able.
|
|
AM_CONDITIONAL([MIRROR_VFD_CONDITIONAL], [test "X$MIRROR_VFD" = "Xyes"])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Check if Read-Only S3 virtual file driver is enabled by --enable-ros3-vfd
|
|
##
|
|
AC_SUBST([ROS3_VFD])
|
|
|
|
## Default is no Read-Only S3 VFD
|
|
ROS3_VFD=no
|
|
|
|
AC_ARG_ENABLE([ros3-vfd],
|
|
[AS_HELP_STRING([--enable-ros3-vfd],
|
|
[Build the Read-Only S3 virtual file driver (VFD).
|
|
[default=no]])],
|
|
[ROS3_VFD=$enableval], [ROS3_VFD=no])
|
|
|
|
if test "X$ROS3_VFD" = "Xyes"; then
|
|
AC_CHECK_HEADERS([curl/curl.h],, [unset ROS3_VFD])
|
|
AC_CHECK_HEADERS([openssl/evp.h],, [unset ROS3_VFD])
|
|
AC_CHECK_HEADERS([openssl/hmac.h],, [unset ROS3_VFD])
|
|
AC_CHECK_HEADERS([openssl/sha.h],, [unset ROS3_VFD])
|
|
if test "X$ROS3_VFD" = "Xyes"; then
|
|
AC_CHECK_LIB([curl], [curl_global_init],, [unset ROS3_VFD])
|
|
AC_CHECK_LIB([crypto], [EVP_sha256],, [unset ROS3_VFD])
|
|
fi
|
|
|
|
AC_MSG_CHECKING([if the Read-Only S3 virtual file driver (VFD) is enabled])
|
|
if test "X$ROS3_VFD" = "Xyes"; then
|
|
AC_DEFINE([HAVE_ROS3_VFD], [1],
|
|
[Define whether the Read-Only S3 virtual file driver (VFD) should be compiled])
|
|
AC_MSG_RESULT([yes])
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
ROS3_VFD=no
|
|
AC_MSG_ERROR([The Read-Only S3 VFD was requested but cannot be built.
|
|
Please check that openssl and cURL are available on your
|
|
system, and/or re-configure without option
|
|
--enable-ros3-vfd.])
|
|
fi
|
|
else
|
|
AC_MSG_CHECKING([if the Read-Only S3 virtual file driver (VFD) is enabled])
|
|
AC_MSG_RESULT([no])
|
|
ROS3_VFD=no
|
|
|
|
fi
|
|
|
|
## Read-only S3 files are not built if not required.
|
|
AM_CONDITIONAL([ROS3_VFD_CONDITIONAL], [test "X$ROS3_VFD" = "Xyes"])
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Is libhdfs (Hadoop Distributed File System) present?
|
|
## It might be specified with the `--with-libhdfs' command-line switch.
|
|
## If found, enables the HDFS VFD.
|
|
##
|
|
AC_SUBST([HAVE_LIBHDFS])
|
|
AC_ARG_WITH([libhdfs],
|
|
[AS_HELP_STRING([--with-libhdfs=DIR],
|
|
[Provide libhdfs library to enable HDFS virtual file driver (VFD) [default=no]])],,
|
|
[withval=no])
|
|
|
|
case $withval in
|
|
no)
|
|
HAVE_LIBHDFS="no"
|
|
AC_MSG_CHECKING([for libhdfs])
|
|
AC_MSG_RESULT([suppressed])
|
|
;;
|
|
*)
|
|
HAVE_LIBHDFS="yes"
|
|
case "$withval" in
|
|
*,*)
|
|
libhdfs_inc="`echo $withval |cut -f1 -d,`"
|
|
libhdfs_lib="`echo $withval |cut -f2 -d, -s`"
|
|
;;
|
|
yes)
|
|
libhdfs_inc="$HADOOP_HOME/include"
|
|
libhdfs_lib="$HADOOP_HOME/lib"
|
|
;;
|
|
*)
|
|
if test -n "$withval"; then
|
|
libhdfs_inc="$withval/include"
|
|
libhdfs_lib="$withval/lib"
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
if test -n "$libhdfs_inc"; then
|
|
CPPFLAGS="$CPPFLAGS -I$libhdfs_inc"
|
|
AM_CPPFLAGS="$AM_CPPFLAGS -I$libhdfs_inc"
|
|
fi
|
|
AC_CHECK_HEADERS([hdfs.h],,
|
|
[unset HAVE_LIBHDFS])
|
|
|
|
if test "x$HAVE_LIBHDFS" = "xyes"; then
|
|
dnl Check for '-ljvm' needed by libhdfs
|
|
JNI_LDFLAGS=""
|
|
if test $JAVA_HOME != ""
|
|
then
|
|
JNI_LDFLAGS="-L$JAVA_HOME/jre/lib/$OS_ARCH -L$JAVA_HOME/jre/lib/$OS_ARCH/server"
|
|
fi
|
|
ldflags_bak=$LDFLAGS
|
|
LDFLAGS="$LDFLAGS $JNI_LDFLAGS"
|
|
AC_CHECK_LIB([jvm], [JNI_GetCreatedJavaVMs])
|
|
LDFLAGS=$ldflags_bak
|
|
AC_SUBST([JNI_LDFLAGS])
|
|
if test -n "$libhdfs_lib"; then
|
|
## Hadoop distribution hides libraries down one level in 'lib/native'
|
|
libhdfs_lib="$libhdfs_lib/native"
|
|
LDFLAGS="$LDFLAGS -L$libhdfs_lib $JNI_LDFLAGS"
|
|
AM_LDFLAGS="$AM_LDFLAGS -L$libhdfs_lib $JNI_LDFLAGS"
|
|
fi
|
|
AC_CHECK_LIB([hdfs], [hdfsConnect],,
|
|
[unset HAVE_LIBHDFS])
|
|
fi
|
|
|
|
if test -z "$HAVE_LIBHDFS"; then
|
|
AC_MSG_ERROR([Set to use libhdfs library, but could not find or use
|
|
libhdfs. Please verify that the path to HADOOP_HOME is
|
|
valid, and/or reconfigure without --with-libhdfs.])
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
if test "x$HAVE_LIBHDFS" = "xyes"; then
|
|
AC_DEFINE([HAVE_LIBHDFS], [1],
|
|
[Proceed to build with libhdfs])
|
|
fi
|
|
|
|
## Read-only HDFS files are not built if not required.
|
|
AM_CONDITIONAL([HDFS_VFD_CONDITIONAL], [test "X$HAVE_LIBHDFS" = "Xyes"])
|
|
|
|
## Checkpoint the cache
|
|
AC_CACHE_SAVE
|
|
|
|
## ----------------------------------------------------------------------
|
|
## Use custom examples path.
|
|
##
|
|
AC_MSG_CHECKING([for custom examples path definition])
|
|
AC_ARG_WITH([examplesdir],
|
|
[AS_HELP_STRING([--with-examplesdir=location],
|
|
[Specify path for examples
|
|
[default="DATAROOTDIR/hdf5_examples"]])],,
|
|
withval="${datarootdir}/hdf5_examples")
|
|
|
|
if test "X$withval" = "X"; then
|
|
AC_MSG_RESULT([default])
|
|
examplesdir="${datarootdir}/hdf5_examples"
|
|
else
|
|
AC_MSG_RESULT([$withval])
|
|
examplesdir=$withval
|
|
fi
|
|
|
|
AC_SUBST([examplesdir])
|
|
AC_DEFINE_UNQUOTED([EXAMPLESDIR], ["$examplesdir"],
|
|
[Define the examples directory])
|
|
|
|
## ----------------------------------------------------------------------
|
|
## 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 the flag to indicate that the machine is IBM ppc64le and cannot
|
|
## accurately convert some long double values.
|
|
##
|
|
AC_MSG_CHECKING([if the system is IBM ppc64le and cannot correctly convert some long double values])
|
|
|
|
TEST_SRC="`(echo \"#define H5_DISABLE_SOME_LDOUBLE_CONV_TEST 1\"; cat $srcdir/config/cmake/ConversionTests.c)`"
|
|
|
|
if test ${ac_cv_sizeof_long_double} = 0; then
|
|
hdf5_cv_disable_some_ldouble_conv=${hdf5_cv_disable_some_ldouble_conv=no}
|
|
else
|
|
AC_CACHE_VAL([hdf5_cv_disable_some_ldouble_conv],
|
|
[AC_RUN_IFELSE([AC_LANG_SOURCE([$TEST_SRC])],
|
|
[hdf5_cv_disable_some_ldouble_conv=yes], [hdf5_cv_disable_some_ldouble_conv=no],[])])
|
|
fi
|
|
|
|
if test ${hdf5_cv_disable_some_ldouble_conv} = "yes"; then
|
|
AC_DEFINE([DISABLE_SOME_LDOUBLE_CONV], [1],
|
|
[Define if your system is IBM ppc64le and cannot convert some 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}
|
|
|
|
## Parallel writes to filtered datasets support?
|
|
PARALLEL_FILTERED_WRITES=${PARALLEL_FILTERED_WRITES:-no}
|
|
|
|
## >2GB writes in parallel support?
|
|
LARGE_PARALLEL_IO=${LARGE_PARALLEL_IO:-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|v112|v114)],
|
|
[Specify default release version of public symbols
|
|
[default=v114]])],,
|
|
[withval=v114])
|
|
|
|
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
|
|
AC_DEFINE([USE_110_API_DEFAULT], [1],
|
|
[Define using v1.10 public API symbols by default])
|
|
elif test "X$withval" = "Xv112"; then
|
|
AC_MSG_RESULT([v112])
|
|
DEFAULT_API_VERSION=v112
|
|
AC_DEFINE([USE_112_API_DEFAULT], [1],
|
|
[Define using v1.12 public API symbols by default])
|
|
elif test "X$withval" = "Xv114"; then
|
|
AC_MSG_RESULT([v114])
|
|
DEFAULT_API_VERSION=v114
|
|
AC_DEFINE([USE_114_API_DEFAULT], [1],
|
|
[Define using v1.14 public API symbols by default])
|
|
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}" != "Xv114" -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 use of pread/pwrite instead of read/write in certain VFDs.
|
|
##
|
|
AC_SUBST([PREADWRITE])
|
|
|
|
## Check these first to avoid interspersed output in the AC_ARG_ENABLE line
|
|
## below. (Probably overkill to check for both, but we'll be extra careful)
|
|
PREADWRITE_HAVE_BOTH=yes
|
|
AC_CHECK_FUNC([pread], [], [PREADWRITE_HAVE_BOTH=no])
|
|
AC_CHECK_FUNC([pwrite], [], [PREADWRITE_HAVE_BOTH=no])
|
|
|
|
AC_MSG_CHECKING([whether to use pread/pwrite instead of read/write in certain VFDs])
|
|
AC_ARG_ENABLE([preadwrite],
|
|
[AS_HELP_STRING([--enable-preadwrite],
|
|
[Enable using pread/pwrite instead of read/write in sec2/log/core VFDs.
|
|
[default=yes if pread/pwrite are present]])],
|
|
[PREADWRITE=$enableval])
|
|
|
|
## Set the default level.
|
|
if test "X-$PREADWRITE" = X- ; then
|
|
PREADWRITE=yes
|
|
fi
|
|
|
|
case "X-$PREADWRITE" in
|
|
X-yes)
|
|
if test "X-$PREADWRITE_HAVE_BOTH" = "X-yes"; then
|
|
AC_DEFINE([HAVE_PREADWRITE], [1], [Define if both pread and pwrite exist.])
|
|
AC_MSG_RESULT([yes])
|
|
else
|
|
AC_MSG_RESULT([no])
|
|
fi
|
|
;;
|
|
X-no)
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([Unrecognized value: $PREADWRITE])
|
|
;;
|
|
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 "X$PARALLEL" = "Xyes"])
|
|
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"])
|
|
AM_CONDITIONAL([BUILD_TESTS_CONDITIONAL], [test "X$HDF5_TESTS" = "Xyes"])
|
|
AM_CONDITIONAL([BUILD_TESTS_PARALLEL_CONDITIONAL], [test -n "$TESTPARALLEL"])
|
|
AM_CONDITIONAL([BUILD_TOOLS_CONDITIONAL], [test "X$HDF5_TOOLS" = "Xyes"])
|
|
AM_CONDITIONAL([BUILD_DOXYGEN_CONDITIONAL], [test "X$HDF5_DOXYGEN" = "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
|
|
|
|
if test "X$HDF_FORTRAN" = "Xyes"; then
|
|
|
|
### libtool does not pass the correct argument linking (-Wl,-Wl,,) for the NAG Fortran compiler
|
|
### on Linux (other OSs have not been tested).
|
|
### Therefore, detect if we are using the NAG Fortran compiler, and replace the wl="-Wl," for Fortran to
|
|
### wl="-Wl,-Wl,," in the libtool file. (HDFFV-10037)
|
|
case "`uname`" in
|
|
Linux*)
|
|
|
|
fortran_linux_linker_option="-Wl,"
|
|
if test "X$FC_BASENAME" = "Xnagfor"; then
|
|
fortran_linux_linker_option="-Wl,-Wl,,"
|
|
fi
|
|
|
|
## Set the correct linker option for use in h5fc.in markup
|
|
AC_SUBST([fortran_linux_linker_option])
|
|
;;
|
|
esac
|
|
|
|
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
|
|
doxygen/Doxyfile
|
|
src/Makefile
|
|
test/Makefile
|
|
test/H5srcdir_str.h
|
|
test/testabort_fail.sh
|
|
test/testcheck_version.sh
|
|
test/testerror.sh
|
|
test/testexternal_env.sh
|
|
test/testflushrefresh.sh
|
|
test/testlibinfo.sh
|
|
test/testlinks_env.sh
|
|
test/testswmr.sh
|
|
test/testvds_env.sh
|
|
test/testvdsswmr.sh
|
|
test/test_filter_plugin.sh
|
|
test/test_mirror.sh
|
|
test/test_usecases.sh
|
|
test/test_vol_plugin.sh
|
|
testpar/Makefile
|
|
testpar/testpflush.sh
|
|
utils/Makefile
|
|
utils/mirror_vfd/Makefile
|
|
tools/Makefile
|
|
tools/lib/Makefile
|
|
tools/libtest/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/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
|
|
bin/h5cc
|
|
bin/Makefile
|
|
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/JavaIntroExample.sh
|
|
java/examples/datasets/Makefile
|
|
java/examples/datasets/JavaDatasetExample.sh
|
|
java/examples/datatypes/Makefile
|
|
java/examples/datatypes/JavaDatatypeExample.sh
|
|
java/examples/groups/Makefile
|
|
java/examples/groups/JavaGroupExample.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 bin/h5cc
|
|
if test "X$HDF_CXX" = "Xyes"; then
|
|
chmod 755 c++/src/h5c++
|
|
fi
|
|
|
|
|
|
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
|
|
|
|
### libtool does not pass the correct argument linking (-Wl,-Wl,,) for the NAG Fortran compiler
|
|
### on Linux (other OSs have not been tested).
|
|
### Therefore, detect if we are using the NAG Fortran compiler, and replace the wl="-Wl," for Fortran to
|
|
### wl="-Wl,-Wl,," in the libtool file. (HDFFV-10037)
|
|
case "`uname`" in
|
|
Linux*)
|
|
if test "X$FC_BASENAME" = "Xnagfor"; then
|
|
cat libtool | awk '/BEGIN LIBTOOL TAG CONFIG: FC/{flag=1}flag&&/wl=/{$NF="wl=\"-Wl,-Wl,,\"";flag=0}1' > libtool.tmp && mv -f libtool.tmp libtool && chmod 755 libtool
|
|
fi
|
|
;;
|
|
esac
|
|
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
|