mirror of
https://github.com/Unidata/netcdf-c.git
synced 2024-11-27 07:30:33 +08:00
d85bb6fe20
disengagement of enable-netcdf4 from enable-hdf5. That is, with the advent of nczarr, it is possible to turn off hdf5 but still need netcdf-4 enabled because nczarr uses libsrc4, but not libhdf5. This change involves a bunch of things: 1. Modify configure.ac and CMakelist to make enable_hdf5 control if hdf5 support is provided. For back compatibility, disable-netcdf4 is treated as disable-hdf5. But internally, netcdf4 support is controlled only by the enabling of formats that require it. 2. In support of #1, modify .travis.yml to use enable/disable-hdf5 instead of enable/disable-netcdf4. 3. test_common.in is modified to track selected features, including enable-hdf5 and enable-s3-tests. This is used in selected tests that mix netcdf-3 and netcdf4 tests. 4. The conflation of USE_HDF5 and USE_NETCDF4 is common in code, tests, and build files, so all of those had to be weeded out. 5. It turns out that some of the NC4_dim functions really are HDF5 specific, but are not treated as such. So they are moved from nc4dim.c to hdf5dim.c or hdf5dispatch.c 6. Some generic functions in libhdf5 can be (and were) moved to libsrc4.
1674 lines
65 KiB
Plaintext
1674 lines
65 KiB
Plaintext
# -*- Autoconf -*-
|
|
## Process this file with autoconf to produce a configure script.
|
|
|
|
# This is part of Unidata's netCDF package. Copyright 2005-2018, see
|
|
# the COPYRIGHT file for more information.
|
|
# Ed Hartnett, Ward Fisher, Dennis Heimbigner
|
|
|
|
# Running autoconf on this file will trigger a warning if
|
|
# autoconf is not at least the specified version.
|
|
AC_PREREQ([2.59])
|
|
|
|
# Initialize with name, version, and support email address.
|
|
AC_INIT([netCDF], [4.8.0-development], [support-netcdf@unidata.ucar.edu], [netcdf-c])
|
|
|
|
##
|
|
# Prefer an empty CFLAGS variable instead of the default -g -O2.
|
|
# See:
|
|
# * http://www.gnu.org/savannah-checkouts/gnu/autoconf/manual/autoconf-2.69/html_node/C-Compiler.html#C-Compiler
|
|
##
|
|
: ${CFLAGS=""}
|
|
|
|
AC_SUBST([NC_VERSION_MAJOR]) NC_VERSION_MAJOR=4
|
|
AC_SUBST([NC_VERSION_MINOR]) NC_VERSION_MINOR=8
|
|
AC_SUBST([NC_VERSION_PATCH]) NC_VERSION_PATCH=0
|
|
AC_SUBST([NC_VERSION_NOTE]) NC_VERSION_NOTE="-development"
|
|
|
|
#####
|
|
# Set some variables used to generate a libnetcdf.settings file,
|
|
# pattered after the files generated by libhdf4, libhdf5.
|
|
#####
|
|
|
|
# Create the VERSION file, which contains the package version from
|
|
# AC_INIT.
|
|
echo AC_PACKAGE_VERSION>VERSION
|
|
AC_SUBST(PACKAGE_VERSION)
|
|
|
|
AC_MSG_NOTICE([netCDF AC_PACKAGE_VERSION])
|
|
|
|
# Keep libtool macros in an m4 directory.
|
|
AC_CONFIG_MACRO_DIR([m4])
|
|
|
|
# Configuration Date
|
|
if test "x$SOURCE_DATE_EPOCH" != "x" ; then
|
|
AC_SUBST([CONFIG_DATE]) CONFIG_DATE="`date -u -d "${SOURCE_DATE_EPOCH}"`"
|
|
else
|
|
AC_SUBST([CONFIG_DATE]) CONFIG_DATE="`date`"
|
|
fi
|
|
|
|
# Find out about the host we're building on.
|
|
AC_CANONICAL_HOST
|
|
|
|
# Find out about the target we're building for.
|
|
AC_CANONICAL_TARGET
|
|
|
|
AC_CONFIG_HEADERS([config.h])
|
|
|
|
##
|
|
# Some files need to exist in build directories
|
|
# that do not correspond to their source directory, or
|
|
# the test program makes an assumption about where files
|
|
# live. AC_CONFIG_LINKS provides a mechanism to link/copy files
|
|
# if an out-of-source build is happening.
|
|
##
|
|
|
|
AC_CONFIG_LINKS([nc_test4/ref_hdf5_compat1.nc:nc_test4/ref_hdf5_compat1.nc])
|
|
AC_CONFIG_LINKS([nc_test4/ref_hdf5_compat2.nc:nc_test4/ref_hdf5_compat2.nc])
|
|
AC_CONFIG_LINKS([nc_test4/ref_hdf5_compat3.nc:nc_test4/ref_hdf5_compat3.nc])
|
|
|
|
AC_CONFIG_LINKS([hdf4_test/ref_chunked.hdf4:hdf4_test/ref_chunked.hdf4])
|
|
AC_CONFIG_LINKS([hdf4_test/ref_contiguous.hdf4:hdf4_test/ref_contiguous.hdf4])
|
|
|
|
AM_INIT_AUTOMAKE([foreign dist-zip subdir-objects])
|
|
|
|
# Check for the existence of this file before proceeding.
|
|
AC_CONFIG_SRCDIR([include/netcdf.h])
|
|
|
|
AC_MSG_NOTICE([checking supported formats])
|
|
|
|
# An explicit disable of netcdf-4 | netcdf4 is treated as if it was disable-hdf5
|
|
AC_MSG_CHECKING([whether we should build with netcdf4 (alias for HDF5)])
|
|
AC_ARG_ENABLE([netcdf4], [AS_HELP_STRING([--disable-netcdf4],
|
|
[(synonym for --enable-hdf5)])])
|
|
test "x$enable_netcdf4" = xno || enable_netcdf4=yes
|
|
AC_MSG_RESULT([$enable_netcdf4])
|
|
AC_MSG_CHECKING([whether we should build with netcdf-4 (alias for HDF5)])
|
|
AC_ARG_ENABLE([netcdf-4], [AS_HELP_STRING([--disable-netcdf-4],
|
|
[(synonym for --disable-netcdf4)])])
|
|
test "x$enable_netcdf_4" = xno || enable_netcdf_4=yes
|
|
AC_MSG_RESULT([$enable_netcdf_4])
|
|
# Propagate the alias
|
|
if test "x$enable_netcdf_4" = xno ; then enable_netcdf4=no; fi
|
|
if test "x$enable_netcdf4" = xno ; then enable_netcdf_4=no; fi
|
|
|
|
# Does the user want to use HDF5?
|
|
AC_MSG_CHECKING([whether we should build with HDF5])
|
|
AC_ARG_ENABLE([hdf5], [AS_HELP_STRING([--disable-hdf5],
|
|
[do not build with HDF5])])
|
|
test "x$enable_hdf5" = xno || enable_hdf5=yes
|
|
if test "x$enable_netcdf4" = xno ; then enable_hdf5=no ; fi
|
|
# disable-netcdf4 is synonym for disable-hdf5
|
|
AC_MSG_RESULT([$enable_hdf5])
|
|
|
|
# Check whether we want to enable CDF5 support.
|
|
AC_MSG_CHECKING([whether CDF5 support should be disabled])
|
|
AC_ARG_ENABLE([cdf5],
|
|
[AS_HELP_STRING([--disable-cdf5],
|
|
[build without CDF5 support. @<:@default: auto@:>@])],
|
|
[enable_cdf5=${enableval}], [enable_cdf5=auto]
|
|
)
|
|
AC_MSG_RESULT($enable_cdf5)
|
|
|
|
# Does the user want to turn on HDF4 read ability?
|
|
AC_MSG_CHECKING([whether reading of HDF4 SD files is to be enabled])
|
|
AC_ARG_ENABLE([hdf4], [AS_HELP_STRING([--enable-hdf4],
|
|
[build netcdf with HDF4 read capability (HDF4, HDF5 and zlib required)])])
|
|
test "x$enable_hdf4" = xyes || enable_hdf4=no
|
|
AC_MSG_RESULT($enable_hdf4)
|
|
|
|
AC_MSG_CHECKING([whether parallel I/O for classic files is to be enabled])
|
|
AC_ARG_ENABLE([pnetcdf], [AS_HELP_STRING([--enable-pnetcdf],
|
|
[build with parallel I/O for classic files. @<:@default: disabled@:>@])])
|
|
test "x$enable_pnetcdf" = xyes || enable_pnetcdf=no
|
|
AC_MSG_RESULT($enable_pnetcdf)
|
|
|
|
## Capture the state of the --enable-dap flag => enable dap2+dap4
|
|
AC_MSG_CHECKING([whether DAP client(s) are to be built])
|
|
AC_ARG_ENABLE([dap],
|
|
[AS_HELP_STRING([--disable-dap],
|
|
[build without DAP client support.])])
|
|
test "x$enable_dap" = xno || enable_dap=yes
|
|
AC_MSG_RESULT($enable_dap)
|
|
|
|
AC_MSG_CHECKING([whether netcdf zarr storage format should be enabled])
|
|
AC_ARG_ENABLE([nczarr],
|
|
[AS_HELP_STRING([--enable-nczarr],
|
|
[enable netcdf zarr storage support; requires netCDF-4 and libcurl])])
|
|
test "x$enable_nczarr" = xyes || enable_nczarr=no
|
|
AC_MSG_RESULT($enable_nczarr)
|
|
|
|
# HDF5 | HDF4 | NCZarr => netcdf-4
|
|
if test "x$enable_hdf5" = xyes || test "x$enable_hdf4" = xyes || test "x$enable_nczarr" = xyes ; then
|
|
enable_netcdf_4=yes
|
|
fi
|
|
AC_MSG_CHECKING([whether netcdf-4 should be forcibly enabled])
|
|
AC_MSG_RESULT([$enable_netcdf_4])
|
|
# Synonym
|
|
enable_netcdf4=${enable_netcdf_4}
|
|
|
|
AC_MSG_NOTICE([checking user options])
|
|
|
|
# Did the user specify a default minimum blocksize (NCIO_MINBLOCKSIZE) for posixio?
|
|
AC_MSG_CHECKING([whether a NCIO_MINBLOCKSIZE was specified])
|
|
AC_ARG_WITH([minblocksize],
|
|
[AS_HELP_STRING([--with-minblocksize=<integer>],
|
|
[Specify minimum I/O blocksize for netCDF classic and 64-bit offset format files.])],
|
|
[NCIO_MINBLOCKSIZE=$with_minblocksize], [NCIO_MINBLOCKSIZE=256])
|
|
AC_MSG_RESULT([$NCIO_MINBLOCKSIZE])
|
|
AC_DEFINE_UNQUOTED([NCIO_MINBLOCKSIZE], [$NCIO_MINBLOCKSIZE], [min blocksize for posixio.])
|
|
|
|
# Find valgrind, if available, and add targets for it.
|
|
AX_VALGRIND_DFLT([sgcheck], [off])
|
|
AX_VALGRIND_CHECK
|
|
AM_CONDITIONAL(ENABLE_VALGRIND, [test "x$VALGRIND_ENABLED" = xyes])
|
|
|
|
###
|
|
# Doxygen and doxygen-related options.
|
|
###
|
|
AC_ARG_ENABLE([doxygen],
|
|
[AS_HELP_STRING([--enable-doxygen],
|
|
[Enable generation of documentation.])])
|
|
test "x$enable_doxygen" = xyes || enable_doxygen=no
|
|
AM_CONDITIONAL([BUILD_DOCS], [test "x$enable_doxygen" = xyes])
|
|
|
|
AC_ARG_ENABLE([doxygen-tasks],
|
|
[AS_HELP_STRING([--enable-doxygen-tasks],
|
|
[Enable Doxygen-generated test, todo and bug list documentation. Developers only.])])
|
|
test "x$enable_doxygen_tasks" = xyes || enable_doxygen_tasks=no
|
|
AM_CONDITIONAL([SHOW_DOXYGEN_TAG_LIST], [test "x$enable_doxygen_tasks" = xyes])
|
|
AC_SUBST([SHOW_DOXYGEN_TAG_LIST], [$enable_doxygen_tasks])
|
|
|
|
###
|
|
# Determine if we should build documentation
|
|
# configured for releases on the Unidata web server.
|
|
###
|
|
AC_ARG_ENABLE([doxygen-build-release-docs],
|
|
[AS_HELP_STRING([--enable-doxygen-build-release-docs],
|
|
[Build release documentation. This is of interest only to developers.])])
|
|
test "x$enable_doxygen_build_release_docs" = xyes || enable_doxygen_build_release_docs=no
|
|
AM_CONDITIONAL([DOXYGEN_BUILD_RELEASE_DOCS], [test "x$enable_doxygen_build_release_docs" = xyes])
|
|
|
|
if test $enable_doxygen_build_release_docs = yes; then
|
|
AC_SUBST([DOXYGEN_CSS_FILE], ["release.css"])
|
|
AC_SUBST([DOXYGEN_HEADER_FILE], ["release_header.html"])
|
|
AC_SUBST([DOXYGEN_SEARCHENGINE], ["NO"])
|
|
else
|
|
AC_SUBST([DOXYGEN_CSS_FILE], [])
|
|
AC_SUBST([DOXYGEN_HEADER_FILE], [])
|
|
AC_SUBST([DOXYGEN_SEARCHENGINE], ["YES"])
|
|
fi
|
|
AC_SUBST([DOXYGEN_SERVER_BASED_SEARCH], ["NO"])
|
|
|
|
AC_ARG_ENABLE([doxygen-pdf-output],
|
|
[AS_HELP_STRING([--enable-doxygen-pdf-output],
|
|
[Build netCDF library documentation in PDF format. Experimental.])])
|
|
AM_CONDITIONAL([NC_ENABLE_DOXYGEN_PDF_OUTPUT], [test "x$enable_doxygen_pdf_output" = xyes])
|
|
AC_SUBST([NC_ENABLE_DOXYGEN_PDF_OUTPUT], [$enable_doxygen_pdf_output])
|
|
|
|
AC_ARG_ENABLE([dot],
|
|
[AS_HELP_STRING([--enable-dot],
|
|
[Use dot (provided by graphviz) to generate charts and graphs in the doxygen-based documentation.])])
|
|
test "x$enable_dot" = xyes || enable_dot=no
|
|
|
|
AC_ARG_ENABLE([internal-docs],
|
|
[AS_HELP_STRING([--enable-internal-docs],
|
|
[Include documentation of library internals. This is of interest only to those developing the netCDF library.])])
|
|
test "x$enable_internal_docs" = xyes || enable_internal_docs=no
|
|
AC_SUBST([BUILD_INTERNAL_DOCS], [$enable_internal_docs])
|
|
|
|
# Doxygen is apparently buggy when trying to combine a markdown
|
|
# file with @internal. The equivalent can be faked using
|
|
# the Doxygen ENABLED_SECTIONS mechanism. See docs/testserver.dox
|
|
# to see how this is done.
|
|
sections=
|
|
if test "x$enable_internal_docs" = xyes ; then
|
|
sections="$sections INTERNAL"
|
|
fi
|
|
AC_SUBST([ENABLED_DOC_SECTIONS], [$sections])
|
|
|
|
AC_MSG_CHECKING([if fsync support is enabled])
|
|
AC_ARG_ENABLE([fsync],
|
|
[AS_HELP_STRING([--enable-fsync],
|
|
[enable fsync support])],
|
|
[],
|
|
[enable_fsync=no])
|
|
test "x$enable_fsync" = xno || enable_fsync=yes
|
|
AC_MSG_RESULT($enable_fsync)
|
|
if test "x$enable_fsync" = xyes ; then
|
|
AC_DEFINE([USE_FSYNC], [1], [if true, include experimental fsync code])
|
|
fi
|
|
|
|
# Temporary until JNA bug is fixed (which is probably never).
|
|
# The problem being solved is this:
|
|
# > On Windows using the microsoft runtime, it is an error
|
|
# > for one library to free memory allocated by a different library.
|
|
# This is probably only an issue when using the netcdf-c library
|
|
# via JNA under Java.
|
|
AC_MSG_CHECKING([if jna bug workaround is enabled])
|
|
AC_ARG_ENABLE([jna],
|
|
[AS_HELP_STRING([--enable-jna],
|
|
[enable jna bug workaround])],
|
|
[],
|
|
[enable_jna=no])
|
|
test "x$enable_jna" = xno || enable_jna=yes
|
|
AC_MSG_RESULT($enable_jna)
|
|
if test "x$enable_jna" = xyes ; then
|
|
AC_DEFINE([JNA], [1], [if true, include jna bug workaround code])
|
|
fi
|
|
|
|
# Should tests with unfixed memory leaks be run?
|
|
AC_MSG_CHECKING([if unfixed tests with memory leaks should be enabled])
|
|
AC_ARG_ENABLE([unfixed-memory-leaks],
|
|
[AS_HELP_STRING([--enable-unfixed-memory-leaks],
|
|
[Enable tests in the ncdump directory that have unfixed memory leaks])])
|
|
test "x$enable_unfixed_memory_leaks" = xyes || enable_unfixed_memory_leaks=no
|
|
AC_MSG_RESULT($enable_unfixed_memory_leaks)
|
|
AM_CONDITIONAL([ENABLE_UNFIXED_MEMORY_LEAKS], [test "x$enable_unfixed_memory_leaks" = xyes])
|
|
|
|
# Does the user want to turn off unit tests (useful for test coverage
|
|
# analysis).
|
|
AC_MSG_CHECKING([if unit tests should be disabled])
|
|
AC_ARG_ENABLE([unit-tests],
|
|
[AS_HELP_STRING([--disable-unit-tests],
|
|
[Disable tests in unit_test directory. Other tests still run.])])
|
|
test "x$enable_unit_tests" = xno || enable_unit_tests=yes
|
|
AC_MSG_RESULT($enable_unit_tests)
|
|
AM_CONDITIONAL([BUILD_UNIT_TESTS], [test "x$enable_unit_tests" = xyes])
|
|
|
|
# Does the user require dynamic loading?
|
|
# This is only for those hdf5 installs that support it.
|
|
AC_MSG_CHECKING([do we require hdf5 dynamic-loading support])
|
|
AC_ARG_ENABLE([dynamic-loading], [AS_HELP_STRING([--enable-dynamic-loading],
|
|
[enable dynamic loading for use with supported hdf5 installs (libdl, HDF5 required)])])
|
|
test "x$enable_dynamic_loading" = xno || enable_dynamic_loading=yes
|
|
AC_MSG_RESULT([$enable_dynamic_loading])
|
|
|
|
|
|
# Does the user want to turn on extra HDF4 file tests?
|
|
AC_MSG_CHECKING([whether to fetch some sample HDF4 files from Unidata ftp site to test HDF4 reading (requires wget)])
|
|
AC_ARG_ENABLE([hdf4-file-tests], [AS_HELP_STRING([--enable-hdf4-file-tests],
|
|
[get some HDF4 files from Unidata ftp site and test that they can be read])])
|
|
test "x$enable_hdf4" = xyes -a "x$enable_hdf4_file_tests" = xyes || enable_hdf4_file_tests=no
|
|
if test "x$enable_hdf4_file_tests" = xyes; then
|
|
AC_DEFINE([USE_HDF4_FILE_TESTS], 1, [If true, use use wget to fetch some sample HDF4 data, and then test against it.])
|
|
fi
|
|
AC_MSG_RESULT($enable_hdf4_file_tests)
|
|
|
|
# Does the user want to try to install netcdf-fortran
|
|
# automatically?
|
|
AC_MSG_CHECKING([whether we should attempt to install netcdf-fortran (EXPERIMENTAL)])
|
|
AC_ARG_ENABLE([remote-fortran-bootstrap], [AS_HELP_STRING([--enable-remote-fortran-bootstrap],
|
|
[Download and install netcdf-fortran (EXPERIMENTAL)])])
|
|
test "x$enable_remote_fortran_bootstrap" = xyes || enable_remote_fortran_bootstrap=no
|
|
AC_MSG_RESULT([$enable_remote_fortran_bootstrap])
|
|
|
|
# Does the user want to run extra parallel tests when parallel netCDF-4 is built?
|
|
AC_MSG_CHECKING([whether parallel IO tests should be run])
|
|
AC_ARG_ENABLE([parallel-tests],
|
|
[AS_HELP_STRING([--enable-parallel-tests],
|
|
[Run extra parallel IO tests. Requires netCDF-4
|
|
with parallel I/O support.])])
|
|
test "x$enable_parallel_tests" = xyes || enable_parallel_tests=no
|
|
AC_MSG_RESULT($enable_parallel_tests)
|
|
|
|
# Did the user specify an MPI launcher other than mpiexec?
|
|
AC_MSG_CHECKING([whether a user specified program to run mpi programs])
|
|
AC_ARG_WITH([mpiexec],
|
|
[AS_HELP_STRING([--with-mpiexec=<command>],
|
|
[Specify command to launch MPI parallel tests.])],
|
|
[MPIEXEC=$with_mpiexec], [MPIEXEC=mpiexec])
|
|
AC_MSG_RESULT([$MPIEXEC])
|
|
AC_SUBST([MPIEXEC], [$MPIEXEC])
|
|
|
|
# Did the user specify a default chunk size?
|
|
AC_MSG_CHECKING([whether a default chunk size in bytes was specified])
|
|
AC_ARG_WITH([default-chunk-size],
|
|
[AS_HELP_STRING([--with-default-chunk-size=<integer>],
|
|
[Specify default size of chunks in bytes.])],
|
|
[DEFAULT_CHUNK_SIZE=$with_default_chunk_size], [DEFAULT_CHUNK_SIZE=4194304])
|
|
AC_MSG_RESULT([$DEFAULT_CHUNK_SIZE])
|
|
AC_DEFINE_UNQUOTED([DEFAULT_CHUNK_SIZE], [$DEFAULT_CHUNK_SIZE], [default chunk size in bytes])
|
|
|
|
# Did the user specify a max per-var cache size?
|
|
AC_MSG_CHECKING([whether a maximum per-variable cache size for HDF5 was specified])
|
|
AC_ARG_WITH([max-default-cache-size],
|
|
[AS_HELP_STRING([--with-max-default-cache-size=<integer>],
|
|
[Specify maximum size (in bytes) for the default per-var chunk cache.])],
|
|
[MAX_DEFAULT_CACHE_SIZE=$with_max_default_cache_size], [MAX_DEFAULT_CACHE_SIZE=67108864])
|
|
AC_MSG_RESULT([$MAX_DEFAULT_CACHE_SIZE])
|
|
AC_DEFINE_UNQUOTED([MAX_DEFAULT_CACHE_SIZE], [$MAX_DEFAULT_CACHE_SIZE], [max size of the default per-var chunk cache.])
|
|
|
|
# Did the user specify a number of chunks in default per-var cache size?
|
|
AC_MSG_CHECKING([whether a number of chunks for the default per-variable cache was specified])
|
|
AC_ARG_WITH([default-chunks-in-cache],
|
|
[AS_HELP_STRING([--with-default-chunks-in-cache=<integer>],
|
|
[Specify the number of chunks to store in default per-variable cache.])],
|
|
[DEFAULT_CHUNKS_IN_CACHE=$with_default_chunks_in_cache], [DEFAULT_CHUNKS_IN_CACHE=10])
|
|
AC_MSG_RESULT([$DEFAULT_CHUNKS_IN_CACHE])
|
|
AC_DEFINE_UNQUOTED([DEFAULT_CHUNKS_IN_CACHE], [$DEFAULT_CHUNKS_IN_CACHE], [num chunks in default per-var chunk cache.])
|
|
|
|
# Did the user specify a default cache size?
|
|
AC_MSG_CHECKING([whether a default file cache size for HDF5 was specified])
|
|
AC_ARG_WITH([chunk-cache-size],
|
|
[AS_HELP_STRING([--with-chunk-cache-size=<integer>],
|
|
[Specify default file cache chunk size for HDF5 files in bytes.])],
|
|
[CHUNK_CACHE_SIZE=$with_chunk_cache_size], [CHUNK_CACHE_SIZE=16777216])
|
|
AC_MSG_RESULT([$CHUNK_CACHE_SIZE])
|
|
AC_DEFINE_UNQUOTED([CHUNK_CACHE_SIZE], [$CHUNK_CACHE_SIZE], [default file chunk cache size in bytes.])
|
|
|
|
# Did the user specify a default cache nelems?
|
|
AC_MSG_CHECKING([whether a default file cache maximum number of elements for HDF5 was specified])
|
|
AC_ARG_WITH([chunk-cache-nelems],
|
|
[AS_HELP_STRING([--with-chunk-cache-nelems=<integer>],
|
|
[Specify default maximum number of elements in the file chunk cache chunk for HDF5 files (should be prime number).])],
|
|
[CHUNK_CACHE_NELEMS=$with_chunk_cache_nelems], [CHUNK_CACHE_NELEMS=4133])
|
|
AC_MSG_RESULT([$CHUNK_CACHE_NELEMS])
|
|
AC_DEFINE_UNQUOTED([CHUNK_CACHE_NELEMS], [$CHUNK_CACHE_NELEMS], [default file chunk cache nelems.])
|
|
|
|
# Did the user specify a default cache preemption?
|
|
AC_MSG_CHECKING([whether a default cache preemption for HDF5 was specified])
|
|
AC_ARG_WITH([chunk-cache-preemption],
|
|
[AS_HELP_STRING([--with-chunk-cache-preemption=<float between 0 and 1 inclusive>],
|
|
[Specify default file chunk cache preemption policy for HDF5 files (a number between 0 and 1, inclusive).])],
|
|
[CHUNK_CACHE_PREEMPTION=$with_chunk_cache_preemption], [CHUNK_CACHE_PREEMPTION=0.75])
|
|
AC_MSG_RESULT([$CHUNK_CACHE_PREEMPTION])
|
|
AC_DEFINE_UNQUOTED([CHUNK_CACHE_PREEMPTION], [$CHUNK_CACHE_PREEMPTION], [default file chunk cache preemption policy.])
|
|
|
|
# Does the user want to enable netcdf-4 logging?
|
|
AC_MSG_CHECKING([whether netCDF-4 logging is enabled])
|
|
AC_ARG_ENABLE([logging],
|
|
[AS_HELP_STRING([--enable-logging],
|
|
[enable logging capability (only applies when netCDF-4 is built). \
|
|
This debugging features is only of interest to netCDF developers. \
|
|
Ignored if netCDF-4 is not enabled.])])
|
|
test "x$enable_logging" = xyes || enable_logging=no
|
|
AC_MSG_RESULT([$enable_logging])
|
|
|
|
# Does the user want to turn off nc_set_log_level() function? (It will
|
|
# always be defined if --enable-logging is used.)
|
|
AC_MSG_CHECKING([whether nc_set_log_level() function is included (will do nothing unless enable-logging is also used)])
|
|
AC_ARG_ENABLE([set_log_level_func], [AS_HELP_STRING([--disable-set-log-level-func],
|
|
[disable the nc_set_log_level function])])
|
|
test "x$enable_set_log_level_func" = xno -a "x$enable_logging" = xno || enable_set_log_level_func=yes
|
|
if test "x$enable_set_log_level_func" = xyes -a "x$enable_netcdf_4" = xyes; then
|
|
AC_DEFINE([ENABLE_SET_LOG_LEVEL], 1, [If true, define nc_set_log_level.])
|
|
fi
|
|
AC_MSG_RESULT($enable_set_log_level_func)
|
|
|
|
# We need curl for DAP and byterange
|
|
AC_CHECK_LIB([curl],[curl_easy_setopt],[found_curl=yes],[found_curl=no])
|
|
if test "x$enable_dap" = "xyes" ; then
|
|
AC_SEARCH_LIBS([curl_easy_setopt],[curl curl.dll], [],
|
|
[AC_MSG_ERROR([curl required for remote access. Install curl or build with --disable-dap.])])
|
|
fi
|
|
|
|
# --enable-dap => enable-dap4
|
|
enable_dap4=$enable_dap
|
|
# Default is to do the short remote tests.
|
|
# Temporary: Change default to npt do these tests
|
|
AC_MSG_CHECKING([whether dap remote testing should be enabled (default on)])
|
|
AC_ARG_ENABLE([dap-remote-tests],
|
|
[AS_HELP_STRING([--disable-dap-remote-tests],
|
|
[disable dap remote tests])])
|
|
test "x$enable_dap_remote_tests" = xyes || enable_dap_remote_tests=no
|
|
if test "x$enable_dap" = "xno" ; then
|
|
enable_dap_remote_tests=no
|
|
fi
|
|
AC_MSG_RESULT($enable_dap_remote_tests)
|
|
|
|
# Default is not to do the remote authorization tests.
|
|
AC_MSG_CHECKING([whether dap remote authorization testing should be enabled (default off)])
|
|
AC_ARG_ENABLE([dap-auth-tests],
|
|
[AS_HELP_STRING([--enable-dap-auth-tests],
|
|
[enable dap remote authorization tests])])
|
|
test "x$enable_dap_auth_tests" = xyes || enable_dap_auth_tests=no
|
|
# dap must be enabled
|
|
if test "x$enable_dap" = "xno" ; then
|
|
enable_dap_auth_tests=no
|
|
fi
|
|
# if remote tests are disabled, then so is this
|
|
if test "x$enable_dap_remote_tests" = "xno" ; then
|
|
enable_dap_remote_tests=no
|
|
fi
|
|
AC_MSG_RESULT($enable_dap_auth_tests)
|
|
|
|
# Did the user specify a list of test servers to try for remote tests?
|
|
AC_MSG_CHECKING([which remote test server(s) to use])
|
|
AC_ARG_WITH([testservers],
|
|
[AS_HELP_STRING([--with-testservers=<host:port>,<host:port>...],
|
|
[Specify the testserver(s) to try for remote tests.])],
|
|
[REMOTETESTSERVERS=$with_testservers], [REMOTETESTSERVERS=no])
|
|
msg="$REMOTETESTSERVERS"
|
|
if test "x$REMOTETESTSERVERS" = xno ; then
|
|
svclist="remotetest.unidata.ucar.edu"
|
|
REMOTETESTSERVERS="$svclist"
|
|
fi
|
|
AC_MSG_RESULT([$svclist])
|
|
AC_DEFINE_UNQUOTED([REMOTETESTSERVERS], ["$REMOTETESTSERVERS"], [the testservers for remote tests.])
|
|
|
|
# Set the config.h flags
|
|
if test "x$enable_dap" = xyes; then
|
|
AC_DEFINE([USE_DAP], [1], [if true, build DAP Client])
|
|
AC_DEFINE([ENABLE_DAP], [1], [if true, build DAP Client])
|
|
fi
|
|
|
|
if test "x$enable_dap_remote_tests" = xyes; then
|
|
AC_DEFINE([ENABLE_DAP_REMOTE_TESTS], [1], [if true, do remote tests])
|
|
fi
|
|
|
|
AC_MSG_CHECKING([whether the time-consuming dap tests should be enabled (default off)])
|
|
AC_ARG_ENABLE([dap-long-tests],
|
|
[AS_HELP_STRING([--enable-dap-long-tests],
|
|
[enable dap long tests])])
|
|
test "x$enable_dap_long_tests" = xyes || enable_dap_long_tests=no
|
|
if test "x$enable_dap_remote_tests" = "xno" ; then
|
|
enable_dap_long_tests=no
|
|
fi
|
|
AC_MSG_RESULT([$enable_dap_long_tests])
|
|
|
|
AM_CONDITIONAL(INTERNAL_OCLIB,[test "x" = "x"])
|
|
|
|
# Control zarr storage
|
|
if test "x$enable_nczarr" = xyes ; then
|
|
if test "x$enable_netcdf_4" = xno ; then
|
|
AC_MSG_ERROR([netCDF-4 disabled, so you must not enable nczarr])
|
|
enable_nczarr=no
|
|
fi
|
|
fi
|
|
if test "x$enable_nczarr" = xyes; then
|
|
AC_DEFINE([ENABLE_NCZARR], [1], [if true, build NCZarr Client])
|
|
AC_SUBST(ENABLE_NCZARR)
|
|
fi
|
|
AM_CONDITIONAL(ENABLE_NCZARR, [test x$enable_nczarr = xyes])
|
|
|
|
# Check for enabling S3 support
|
|
AC_MSG_CHECKING([whether netcdf zarr S3 support should be enabled])
|
|
AC_ARG_ENABLE([s3-sdk],
|
|
[AS_HELP_STRING([--enable-s3-sdk],
|
|
[enable netcdf zarr S3 support; make sure to set LDFLAGS])])
|
|
test "x$enable_s3_sdk" = xyes || enable_s3_sdk=no
|
|
have_aws=${enable_s3_sdk}
|
|
AC_MSG_RESULT($enable_s3_sdk)
|
|
if test "x$have_aws" = xyes ; then
|
|
AC_DEFINE([ENABLE_S3_SDK], [1], [If true, then S3 sdk was found])
|
|
fi
|
|
AM_CONDITIONAL(ENABLE_S3_SDK, [test "x$have_aws" = xyes])
|
|
|
|
# Check for enabling S3 testing
|
|
AC_MSG_CHECKING([whether netcdf zarr S3 testing should be enabled])
|
|
AC_ARG_ENABLE([s3-tests],
|
|
[AS_HELP_STRING([--enable-s3-tests],
|
|
[enable netcdf zarr S3 testing])])
|
|
test "x$enable_s3_tests" = xyes || enable_s3_tests=no
|
|
AC_MSG_RESULT($enable_s3_tests)
|
|
|
|
if test "x$have_aws" = xno ; then
|
|
AC_MSG_WARN([aws libraries not found, so default to --disable-s3-tests])
|
|
enable_s3_tests=no
|
|
fi
|
|
|
|
if test "x$enable_s3_tests" = xyes ; then
|
|
AC_DEFINE([ENABLE_S3_TESTS], [1], [if true, build libnczarr with S3 tests enabled])
|
|
fi
|
|
AM_CONDITIONAL(ENABLE_S3_TESTS, [test "x$enable_s3_tests" = xyes])
|
|
|
|
# Check whether we want to enable strict null byte header padding.
|
|
# See https://github.com/Unidata/netcdf-c/issues/657 for more information.
|
|
AC_MSG_CHECKING([whether to enable strict null-byte header padding when reading (default off)])
|
|
AC_ARG_ENABLE([strict-null-byte-header-padding],
|
|
[AS_HELP_STRING([--enable-strict-null-byte-header-padding],
|
|
[enable strict null-byte header padding when reading netCDF3 files.])])
|
|
test "x$enable_strict_null_byte_header_padding" = xyes || enable_strict_null_byte_header_padding=no
|
|
AC_MSG_RESULT($enable_strict_null_byte_header_padding)
|
|
|
|
if test "x$enable_strict_null_byte_header_padding" = xyes; then
|
|
AC_DEFINE([USE_STRICT_NULL_BYTE_HEADER_PADDING], [1], [if true, enable strict null byte header padding])
|
|
fi
|
|
|
|
AM_CONDITIONAL(USE_STRICT_NULL_BYTE_HEADER_PADDING, [test x$enable_strict_null_byte_header_padding = xyes ])
|
|
|
|
# Does the user want to use the ffio module?
|
|
AC_MSG_CHECKING([whether FFIO will be used])
|
|
AC_ARG_ENABLE([ffio],
|
|
[AS_HELP_STRING([--enable-ffio],
|
|
[use ffio instead of posixio (ex. on the Cray)])])
|
|
test "x$enable_ffio" = xyes || enable_ffio=no
|
|
AC_MSG_RESULT($enable_ffio)
|
|
if test "x$enable_ffio" = xyes; then
|
|
AC_DEFINE([USE_FFIO], [1], [if true, use ffio instead of posixio])
|
|
fi
|
|
AM_CONDITIONAL(USE_FFIO, [test x$enable_ffio = xyes])
|
|
|
|
# Does the user want to use the stdio module?
|
|
AC_MSG_CHECKING([whether STDIO will be used])
|
|
AC_ARG_ENABLE([stdio],
|
|
[AS_HELP_STRING([--enable-stdio],
|
|
[use stdio instead of posixio (ex. on the Cray)])])
|
|
test "x$enable_stdio" = xyes || enable_stdio=no
|
|
AC_MSG_RESULT($enable_stdio)
|
|
if test "x$enable_stdio" = xyes; then
|
|
AC_DEFINE([USE_STDIO], [1], [if true, use stdio instead of posixio])
|
|
fi
|
|
AM_CONDITIONAL(USE_STDIO, [test x$enable_stdio = xyes])
|
|
|
|
nc_build_c=yes
|
|
nc_build_v2=yes
|
|
nc_build_utilities=yes
|
|
nc_build_tests=yes
|
|
nc_build_examples=yes
|
|
|
|
# Does the user want to build examples?
|
|
AC_MSG_CHECKING([whether examples should be built])
|
|
AC_ARG_ENABLE([examples],
|
|
[AS_HELP_STRING([--disable-examples],
|
|
[don't build the netCDF examples during make check \
|
|
(examples are treated as extra tests by netCDF)])])
|
|
test "x$enable_examples" = xno && nc_build_examples=no
|
|
AC_MSG_RESULT($nc_build_examples)
|
|
AM_CONDITIONAL(BUILD_EXAMPLES, [test x$nc_build_examples = xyes])
|
|
|
|
# Does the user want to disable the V2 API?
|
|
AC_MSG_CHECKING([whether v2 netCDF API should be built])
|
|
AC_ARG_ENABLE([v2],
|
|
[AS_HELP_STRING([--disable-v2],
|
|
[turn off the netCDF version 2 API])])
|
|
test "x$enable_v2" = xno && nc_build_v2=no
|
|
AC_MSG_RESULT($nc_build_v2)
|
|
AM_CONDITIONAL(BUILD_V2, [test x$nc_build_v2 = xyes])
|
|
if test "x$nc_build_v2" = xno; then
|
|
AC_DEFINE_UNQUOTED(NO_NETCDF_2, 1, [do not build the netCDF version 2 API])
|
|
else
|
|
AC_DEFINE_UNQUOTED(USE_NETCDF_2, 1, [build the netCDF version 2 API])
|
|
fi
|
|
|
|
# Does the user want to disable ncgen/ncdump/nccopy?
|
|
AC_MSG_CHECKING([whether the ncgen/ncdump/nccopy should be built])
|
|
AC_ARG_ENABLE([utilities],
|
|
[AS_HELP_STRING([--disable-utilities],
|
|
[don't build netCDF utilities ncgen, ncdump, and nccopy])])
|
|
test "x$nc_build_c" = xno && enable_utilities=no
|
|
test "x$enable_utilities" = xno && nc_build_utilities=no
|
|
AC_MSG_RESULT($nc_build_utilities)
|
|
AM_CONDITIONAL(BUILD_UTILITIES, [test x$nc_build_utilities = xyes])
|
|
|
|
# Does the user want to disable all tests?
|
|
AC_MSG_CHECKING([whether test should be built and run])
|
|
AC_ARG_ENABLE([testsets],
|
|
[AS_HELP_STRING([--disable-testsets],
|
|
[don't build or run netCDF tests])])
|
|
test "x$enable_testsets" = xno || enable_testsets=yes
|
|
nc_build_tests=$enable_testsets
|
|
AC_MSG_RESULT($nc_build_tests)
|
|
AM_CONDITIONAL(BUILD_TESTSETS, [test x$nc_build_tests = xyes])
|
|
|
|
# Does the user want to run tests for large files (> 2GiB)?
|
|
AC_MSG_CHECKING([whether large file (> 2GB) tests should be run])
|
|
AC_ARG_ENABLE([large-file-tests],
|
|
[AS_HELP_STRING([--enable-large-file-tests],
|
|
[Run tests which create very large data files (~13 GB disk space
|
|
required, but it will be recovered when tests are complete). See
|
|
option --with-temp-large to specify temporary directory])])
|
|
test "x$enable_large_file_tests" = xyes || enable_large_file_tests=no
|
|
AC_MSG_RESULT($enable_large_file_tests)
|
|
AM_CONDITIONAL(LARGE_FILE_TESTS, [test x$enable_large_file_tests = xyes])
|
|
if test "x$enable_large_file_tests" = xyes; then
|
|
AC_DEFINE([LARGE_FILE_TESTS], [1], [do large file tests])
|
|
fi
|
|
|
|
# Does the user want to run benchmarks?
|
|
AC_MSG_CHECKING([whether benchmarks should be run])
|
|
AC_ARG_ENABLE([benchmarks],
|
|
[AS_HELP_STRING([--enable-benchmarks],
|
|
[Run benchmarks. This will cause sample data files from the Unidata ftp
|
|
site to be fetched. The benchmarks are a bunch of extra tests, which
|
|
are timed. We use these tests to check netCDF performance.])])
|
|
test "x$enable_benchmarks" = xyes || enable_benchmarks=no
|
|
AC_MSG_RESULT($enable_benchmarks)
|
|
if test "x$enable_HDF5" = xno -a "x$enable_benchmarks" = xyes; then
|
|
AC_MSG_ERROR([Can't use benchmarks if HDF5 is disabled.])
|
|
fi
|
|
AM_CONDITIONAL(BUILD_BENCHMARKS, [test x$enable_benchmarks = xyes])
|
|
|
|
# Does the user want to use extreme numbers in testing.
|
|
AC_MSG_CHECKING([whether extreme numbers should be used in tests])
|
|
AC_ARG_ENABLE([extreme-numbers],
|
|
[AS_HELP_STRING([--disable-extreme-numbers],
|
|
[don't use extreme numbers during testing, such as MAX_INT - 1])])
|
|
case "$host_cpu $host_os" in
|
|
*386*solaris*)
|
|
test "x$enable_extreme_numbers" = xyes || enable_extreme_numbers=no
|
|
;;
|
|
*)
|
|
test "x$enable_extreme_numbers" = xno || enable_extreme_numbers=yes
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($enable_extreme_numbers)
|
|
|
|
if test "x$enable_extreme_numbers" = xyes; then
|
|
AC_DEFINE(USE_EXTREME_NUMBERS, 1, [set this to use extreme numbers in tests])
|
|
fi
|
|
|
|
# If the env. variable TEMP_LARGE is set, or if
|
|
# --with-temp-large=<directory>, use it as a place for the large
|
|
# (i.e. > 2 GiB) files created during the large file testing.
|
|
AC_MSG_CHECKING([where to put large temp files if large file tests are run])
|
|
AC_ARG_WITH([temp-large],
|
|
[AS_HELP_STRING([--with-temp-large=<directory>],
|
|
[specify directory where large files (i.e. >2 GB) \
|
|
will be written, if large files tests are run with
|
|
--enable-large-file-tests])],
|
|
[TEMP_LARGE=$with_temp_large])
|
|
TEMP_LARGE=${TEMP_LARGE-.}
|
|
AC_MSG_RESULT($TEMP_LARGE)
|
|
#AC_SUBST(TEMP_LARGE)
|
|
AC_DEFINE_UNQUOTED([TEMP_LARGE], ["$TEMP_LARGE"], [Place to put very large netCDF test files.])
|
|
|
|
# Specify extra values to add to _NCProperties attribute
|
|
# --with-ncproperties-extra="<name>=<value>|...".
|
|
# Note: need to figure out a way to do this programmatically also
|
|
AC_MSG_CHECKING([Extra values for _NCProperties])
|
|
AC_ARG_WITH([ncproperties-extra],
|
|
[AS_HELP_STRING([--with-ncproperties-extra="<name>=<value>,...],
|
|
[specify extra pairs for _NCProperties])],
|
|
[NCPROPERTIES_EXTRA=$with_ncproperties_extra],
|
|
[NCPROPERTIES_EXTRA=""])
|
|
AC_MSG_RESULT([$NCPROPERTIES_EXTRA])
|
|
AC_DEFINE_UNQUOTED([NCPROPERTIES_EXTRA], ["$NCPROPERTIES_EXTRA"], [Extra pairs for _NCProperties])
|
|
|
|
# Did the user specify a user-defined format 0?
|
|
AC_MSG_CHECKING([whether user-defined format 0 was specified])
|
|
AC_ARG_WITH([udf0],
|
|
[AS_HELP_STRING([--with-udf0=<dispatch_name>],
|
|
[Specify a dispatch table for user-defined format 0.])],
|
|
[UDF0_DISPATCH=$with_udf0])
|
|
AC_MSG_RESULT([$UDF0_DISPATCH])
|
|
if test -n "$UDF0_DISPATCH"; then
|
|
AC_DEFINE_UNQUOTED([UDF0_DISPATCH], [$UDF0_DISPATCH], [dispatch table for user-defined format 0.])
|
|
AC_DEFINE_UNQUOTED([UDF0_DISPATCH_FUNC], [get_$UDF0_DISPATCH()], [function to get dispatch table for user-defined format 0.])
|
|
AC_DEFINE([USE_UDF0], [1], [if true, use user-defined format 0 in utilities])
|
|
AC_CHECK_LIB([$UDF0_DISPATCH], [get_$UDF0_DISPATCH], [],
|
|
[AC_MSG_ERROR([Can't find or link to the user-defined format 0 library.])],
|
|
[])
|
|
fi
|
|
|
|
# Did the user specify a magic number for user-defined format 0?
|
|
AC_MSG_CHECKING([whether a magic number for user-defined format 0 was specified])
|
|
AC_ARG_WITH([udf0-magic-number],
|
|
[AS_HELP_STRING([--with-udf0-magic-number=<magic_number>],
|
|
[Specify a magic number for user-defined format 0 (ignored unless --with-udf0 is also used).])],
|
|
[UDF0_MAGIC_NUMBER=$with_udf0_magic_number])
|
|
AC_MSG_RESULT([$UDF0_MAGIC_NUMBER])
|
|
|
|
# Did the user specify a user-defined format 1?
|
|
AC_MSG_CHECKING([whether user-defined format 1 was specified])
|
|
AC_ARG_WITH([udf1],
|
|
[AS_HELP_STRING([--with-udf1=<dispatch_name>],
|
|
[Specify a dispatch table for user-defined format 1.])],
|
|
[UDF1_DISPATCH=$with_udf1])
|
|
AC_MSG_RESULT([$UDF1_DISPATCH])
|
|
if test -n "$UDF1_DISPATCH"; then
|
|
AC_DEFINE_UNQUOTED([UDF1_DISPATCH], [$UDF1_DISPATCH], [dispatch table for user-defined format 1.])
|
|
AC_DEFINE_UNQUOTED([UDF1_DISPATCH_FUNC], [get_$UDF1_DISPATCH()], [function to get dispatch table for user-defined format 1.])
|
|
AC_DEFINE([USE_UDF1], [1], [if true, use user-defined format 1 in utilities])
|
|
AC_CHECK_LIB([$UDF1_DISPATCH], [get_$UDF1_DISPATCH], [],
|
|
[AC_MSG_ERROR([Can't find or link to the user-defined format 1 library.])],
|
|
[])
|
|
fi
|
|
|
|
# Did the user specify a magic number for user-defined format 0?
|
|
AC_MSG_CHECKING([whether a magic number for user-defined format 1 was specified])
|
|
AC_ARG_WITH([udf1-magic-number],
|
|
[AS_HELP_STRING([--with-udf1-magic-number=<magic_number>],
|
|
[Specify a magic number for user-defined format 1 (ignored unless --with-udf1 is also used).])],
|
|
[UDF1_MAGIC_NUMBER=$with_udf1_magic_number])
|
|
AC_MSG_RESULT([$UDF1_MAGIC_NUMBER])
|
|
|
|
# According to the autoconf mailing list gurus, we must test for
|
|
# compilers unconditionally. That is, we can't skip looking for the
|
|
# fortran compilers, just because the user doesn't want fortran. This
|
|
# is due to a limitation in autoconf.
|
|
|
|
# Find the C compiler.
|
|
AC_MSG_NOTICE([finding C compiler])
|
|
|
|
## 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_PROG_CC
|
|
AC_PROG_CXX
|
|
AM_PROG_CC_C_O
|
|
AC_C_CONST
|
|
|
|
# CURLOPT_USERNAME is not defined until curl version 7.19.1
|
|
# CURLOPT_PASSWORD is not defined until curl version 7.19.1
|
|
# CURLOPT_KEYPASSWD is not defined until curl version 7.16.4
|
|
# CURLINFO_RESPONSE_CODE is not defined until curl version 7.10.7
|
|
# CURLOPT_CHUNK_BGN_FUNCTION is not defined until curl version 7.21.0
|
|
# CURL_MAX_READ_SIZE is not defined until 7.59
|
|
|
|
# Save/restore CFLAGS
|
|
SAVECFLAGS="$CFLAGS"
|
|
CFLAGS="${curl_cflags}"
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[#include "curl/curl.h"],
|
|
[[int x = CURLOPT_USERNAME;]])],
|
|
[haveusername=yes],
|
|
[haveusername=no])
|
|
AC_MSG_CHECKING([whether CURLOPT_USERNAME is defined])
|
|
AC_MSG_RESULT([${haveusername}])
|
|
if test $haveusername = yes; then
|
|
AC_DEFINE([HAVE_CURLOPT_USERNAME],[1],[Is CURLOPT_USERNAME defined])
|
|
fi
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[#include "curl/curl.h"],
|
|
[[int x = CURLOPT_PASSWORD;]])],
|
|
[havepassword=yes],
|
|
[havepassword=no])
|
|
AC_MSG_CHECKING([whether CURLOPT_PASSWORD is defined])
|
|
AC_MSG_RESULT([${havepassword}])
|
|
if test $havepassword = yes; then
|
|
AC_DEFINE([HAVE_CURLOPT_PASSWORD],[1],[Is CURLOPT_PASSWORD defined])
|
|
fi
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[#include "curl/curl.h"],
|
|
[[int x = CURLOPT_KEYPASSWD;]])],
|
|
[havekeypassword=yes],
|
|
[havekeypassword=no])
|
|
AC_MSG_CHECKING([whether CURLOPT_KEYPASSWD is defined])
|
|
AC_MSG_RESULT([${havekeypassword}])
|
|
if test $havekeypassword = yes; then
|
|
AC_DEFINE([HAVE_CURLOPT_KEYPASSWD],[1],[Is CURLOPT_KEYPASSWD defined])
|
|
fi
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[#include "curl/curl.h"],
|
|
[[int x = CURLINFO_RESPONSE_CODE;]])],
|
|
[haveresponsecode=yes],
|
|
[haveresponsecode=no])
|
|
AC_MSG_CHECKING([whether CURLINFO_RESPONSE_CODE is defined])
|
|
AC_MSG_RESULT([${haveresponsecode}])
|
|
if test $haveresponsecode = yes; then
|
|
AC_DEFINE([HAVE_CURLINFO_RESPONSE_CODE],[1],[Is CURLINFO_RESPONSE_CODE defined])
|
|
fi
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[#include "curl/curl.h"],
|
|
[[int x = CURLOPT_BUFFERSIZE;]])],
|
|
[havecurloption=yes],
|
|
[havecurloption=no])
|
|
AC_MSG_CHECKING([whether CURLOPT_BUFFERSIZE is defined])
|
|
AC_MSG_RESULT([${havecurloption}])
|
|
if test $havecurloption = yes; then
|
|
AC_DEFINE([HAVE_CURLOPT_BUFFERSIZE],[1],[Is CURLOPT_BUFFERSIZE defined])
|
|
fi
|
|
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[#include "curl/curl.h"],
|
|
[[int x = CURLOPT_TCP_KEEPALIVE;]])],
|
|
[havecurloption=yes],
|
|
[havecurloption=no])
|
|
AC_MSG_CHECKING([whether CURLOPT_TCP_KEEPALIVE is defined])
|
|
AC_MSG_RESULT([${havecurloption}])
|
|
if test $havecurloption = yes; then
|
|
AC_DEFINE([HAVE_CURLOPT_KEEPALIVE],[1],[Is CURLOPT_TCP_KEEPALIVE defined])
|
|
fi
|
|
# CURLOPT_VERIFYHOST semantics differ depending on version
|
|
AC_MSG_CHECKING([whether libcurl is version 7.66 or later?])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[#include "curl/curl.h"],
|
|
[[
|
|
#if LIBCURL_VERSION_NUM < 0x074200
|
|
error "<7.66";
|
|
#endif
|
|
]])], [libcurl766=yes], [libcurl766=no])
|
|
|
|
AC_MSG_RESULT([$libcurl766])
|
|
if test x$libcurl66 = xno; then
|
|
AC_DEFINE([HAVE_LIBCURL_766],[1],[Is libcurl version 7.66 or later])
|
|
fi
|
|
|
|
CFLAGS="$SAVECFLAGS"
|
|
|
|
# Set up libtool.
|
|
AC_MSG_NOTICE([setting up libtool])
|
|
LT_PREREQ([2.2])
|
|
LT_INIT()
|
|
|
|
AC_MSG_NOTICE([finding other utilities])
|
|
|
|
# Is m4 installed? If not, bail.
|
|
AC_CHECK_PROGS([NC_M4], [m4])
|
|
if test -z "$NC_M4"; then
|
|
AC_MSG_ERROR([Cannot find m4 utility. Install m4 and try again.])
|
|
fi
|
|
|
|
# Is doxygen installed? If so, have configure construct the Doxyfile.
|
|
AC_CHECK_PROGS([DOXYGEN], [doxygen])
|
|
if test -z "$DOXYGEN"; then
|
|
AC_MSG_WARN([Doxygen not found - documentation will not be built])
|
|
fi
|
|
|
|
# Is graphviz/dot installed? If so, we'll use dot to create
|
|
# graphs in the documentation.
|
|
AC_CHECK_PROGS([DOT], [dot])
|
|
if test -z "$DOT"; then
|
|
AC_MSG_WARN([dot not found - will use simple charts in documentation])
|
|
HAVE_DOT=NO
|
|
elif test "x$enable_dot" = xno; then
|
|
HAVE_DOT=NO
|
|
else
|
|
HAVE_DOT=YES
|
|
fi
|
|
# If we have doxygen, and it's enabled, then process the file.
|
|
if test "x$enable_doxygen" != xno; then
|
|
if test -n "$DOXYGEN"; then
|
|
AC_SUBST(HAVE_DOT)
|
|
AC_CONFIG_FILES([docs/Doxyfile])
|
|
fi
|
|
# Note: the list of files to input to doxygen
|
|
# has been moved to docs/Doxyfile.in so
|
|
# that make distcheck works correctly.
|
|
# Any new inputs should be inserted into
|
|
# docs/Doxyfile.in and possibley docs/Makefile.am
|
|
fi
|
|
|
|
# Find the install program.
|
|
AC_PROG_INSTALL
|
|
|
|
# Check to see if any macros must be set to enable large (>2GB) files.
|
|
AC_SYS_LARGEFILE
|
|
|
|
AC_MSG_NOTICE([displaying some results])
|
|
|
|
## This next macro just prints some results for debugging
|
|
## support issues.
|
|
UD_DISPLAY_RESULTS
|
|
|
|
# For nightly build testing, output CC, FC, etc.
|
|
echo "CPPFLAGS=$CPPFLAGS CC=$CC CFLAGS=$CFLAGS LDFLAGS=$LDFLAGS LIBS=$LIBS" >> comps.txt
|
|
|
|
AC_MSG_NOTICE([checking types, headers, and functions])
|
|
|
|
AC_CHECK_HEADERS([sys/param.h])
|
|
AC_CHECK_HEADERS([libgen.h])
|
|
#AC_CHECK_HEADERS([locale.h])
|
|
AC_HEADER_STDC
|
|
AC_CHECK_HEADERS([locale.h stdio.h stdarg.h fcntl.h malloc.h stdlib.h string.h strings.h unistd.h sys/stat.h getopt.h sys/time.h sys/types.h dirent.h])
|
|
|
|
# Do sys/resource.h separately
|
|
#AC_CHECK_HEADERS([sys/resource.h],[havesysresource=1],[havesysresource=0])
|
|
#if test "x$enable_dll" != xyes ; then
|
|
AC_CHECK_HEADERS([sys/resource.h])
|
|
#fi
|
|
|
|
# See if we have ftw.h to walk directory trees
|
|
AC_CHECK_HEADERS([ftw.h])
|
|
|
|
# See if we can do stack tracing programmatically
|
|
AC_CHECK_HEADERS([execinfo.h])
|
|
|
|
# Check for these functions...
|
|
AC_CHECK_FUNCS([strlcat snprintf strcasecmp fileno \
|
|
strdup strtoll strtoull \
|
|
mkstemp mktemp random \
|
|
getrlimit gettimeofday fsync MPI_Comm_f2c MPI_Info_f2c \
|
|
strncasecmp])
|
|
|
|
# disable dap4 if netcdf-4 is disabled
|
|
#if test "x$enable_netcdf_4" = "xno" ; then
|
|
if test "x$enable_hdf5" = "xno" ; then
|
|
AC_MSG_WARN([netcdf-4 not enabled; disabling DAP4])
|
|
enable_dap4=no
|
|
fi
|
|
|
|
if test "x$enable_dap4" = xyes; then
|
|
AC_DEFINE([ENABLE_DAP4], [1], [if true, build DAP4 Client])
|
|
fi
|
|
|
|
# check for useful, but not essential, memio support
|
|
AC_CHECK_FUNCS([memmove getpagesize sysconf])
|
|
|
|
# Does the user want to allow use of mmap for NC_DISKLESS?
|
|
AC_MSG_CHECKING([whether mmap is enabled for in-memory files])
|
|
AC_ARG_ENABLE([mmap],
|
|
[AS_HELP_STRING([--enable-mmap],
|
|
[allow mmap for in-memory files])])
|
|
test "x$enable_mmap" = xyes || enable_mmap=no
|
|
AC_MSG_RESULT($enable_mmap)
|
|
|
|
# check for mmap availability before committing to use mmap
|
|
have_mmap="$enable_mmap"
|
|
AC_CHECK_FUNCS([mmap],[havemmapfcn=yes],[havemmapfcn=no])
|
|
if test "x$havemmapfcn" = xno ; then
|
|
have_mmap=no
|
|
fi
|
|
|
|
# check for mremap availability; not strictly needed
|
|
AC_CHECK_FUNCS([mremap],[havemremapfcn=yes],[havemmapfcn=no])
|
|
|
|
# Check for MAP_ANONYMOUS
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
[#include <sys/mman.h>],
|
|
[[int x = MAP_ANONYMOUS;]])],
|
|
[havemapanon=yes],
|
|
[havemapanon=no])
|
|
AC_MSG_CHECKING([whether MAP_ANONYMOUS is defined])
|
|
AC_MSG_RESULT([${havemapanon}])
|
|
if test "x$havemapanon" != xyes ; then
|
|
have_mmap=no
|
|
fi
|
|
|
|
if test "x$have_mmap" != xyes ; then
|
|
echo "mmap functionality is not available: disabling mmap"
|
|
enable_mmap=no
|
|
fi
|
|
|
|
if test "x$enable_mmap" = xyes; then
|
|
AC_DEFINE([USE_MMAP], [1], [if true, use mmap for in-memory files])
|
|
fi
|
|
|
|
# Does the user want to allow reading of remote data via range headers?
|
|
AC_MSG_CHECKING([whether byte range support is enabled])
|
|
AC_ARG_ENABLE([byterange],
|
|
[AS_HELP_STRING([--enable-byterange],
|
|
[allow byte-range I/O])])
|
|
test "x$enable_byterange" = xyes || enable_byterange=no
|
|
AC_MSG_RESULT($enable_byterange)
|
|
# Need curl for byte ranges
|
|
if test "x$found_curl" = xno && test "x$enable_byterange" = xyes ; then
|
|
AC_MSG_ERROR([curl required for byte range support. Install curl or build without --enable-byterange.])
|
|
enable_byterange=no
|
|
fi
|
|
|
|
if test "x$enable_byterange" = xyes; then
|
|
AC_DEFINE([ENABLE_BYTERANGE], [1], [if true, support byte-range read of remote datasets.])
|
|
fi
|
|
|
|
AC_FUNC_ALLOCA
|
|
AC_CHECK_DECLS([isnan, isinf, isfinite],,,[#include <math.h>])
|
|
AC_STRUCT_ST_BLKSIZE
|
|
UD_CHECK_IEEE
|
|
AC_CHECK_TYPES([size_t, ssize_t, schar, uchar, longlong, ushort, uint, int64, uint64, size64_t, ssize64_t, _off64_t])
|
|
AC_TYPE_OFF_T
|
|
AC_TYPE_UINTPTR_T
|
|
AC_C_CHAR_UNSIGNED
|
|
AC_C_BIGENDIAN
|
|
|
|
###
|
|
# Crude hack to work around an issue
|
|
# in Cygwin.
|
|
###
|
|
SLEEPCMD=""
|
|
PLTFORMOUT="$(uname | cut -d '_' -f 1)"
|
|
if test "$PLTFORMOUT" = "CYGWIN"; then
|
|
ISCYGWIN=yes
|
|
SLEEPCMD="sleep 5"
|
|
AC_MSG_NOTICE([Pausing between sizeof() checks to mitigate a Cygwin issue.])
|
|
fi
|
|
AM_CONDITIONAL(ISCYGWIN, [test "x$ISCYGWIN" = xyes])
|
|
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF(short)
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF(int)
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF(long)
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF(long long)
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF(float)
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF(double)
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF(off_t)
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF(size_t)
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF(unsigned long long)
|
|
|
|
|
|
if test "$ac_cv_sizeof_size_t" -lt "8" ; then
|
|
if test "x${enable_cdf5}" = xyes ; then
|
|
dnl unable to support CDF5, but --enable-cdf5 is explicitly set
|
|
AC_MSG_ERROR([Unable to support CDF5 feature because size_t is less than 8 bytes])
|
|
fi
|
|
enable_cdf5=no
|
|
else
|
|
if test "x${enable_cdf5}" != xno ; then
|
|
enable_cdf5=yes
|
|
fi
|
|
fi
|
|
|
|
if test "x${enable_cdf5}" = xyes; then
|
|
AC_DEFINE([ENABLE_CDF5], [1], [if true, enable CDF5 Support])
|
|
fi
|
|
AM_CONDITIONAL(ENABLE_CDF5, [test x$enable_cdf5 = xyes ])
|
|
|
|
$SLEEPCMD
|
|
if test "$ac_cv_type_uchar" = yes ; then
|
|
AC_CHECK_SIZEOF(uchar)
|
|
else
|
|
AC_CHECK_SIZEOF(unsigned char)
|
|
fi
|
|
|
|
$SLEEPCMD
|
|
if test "$ac_cv_type_ushort" = yes ; then
|
|
AC_CHECK_SIZEOF(ushort)
|
|
else
|
|
AC_CHECK_SIZEOF(unsigned short int)
|
|
fi
|
|
|
|
$SLEEPCMD
|
|
if test "$ac_cv_type_uint" = yes ; then
|
|
AC_CHECK_SIZEOF(uint)
|
|
else
|
|
AC_CHECK_SIZEOF(unsigned int)
|
|
fi
|
|
$SLEEPCMD
|
|
if test "$ac_cv_type_ushort" = yes ; then
|
|
AC_CHECK_SIZEOF(ushort)
|
|
else
|
|
AC_CHECK_SIZEOF(unsigned short int)
|
|
fi
|
|
$SLEEPCMD
|
|
if test "$ac_cv_type_uint" = yes ; then
|
|
AC_CHECK_SIZEOF(uint)
|
|
else
|
|
AC_CHECK_SIZEOF(unsigned int)
|
|
fi
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF(ssize_t)
|
|
$SLEEPCMD
|
|
AC_CHECK_SIZEOF([void*])
|
|
|
|
if test "x$enable_hdf5" = xyes || test "x$enable_dap" = xyes; then
|
|
AC_SEARCH_LIBS([deflate], [zlibwapi zlibstat zlib zlib1 z], [], [
|
|
AC_MSG_ERROR([Can't find or link to the z library. Turn off netCDF-4 and \
|
|
DAP clients with --disable-hdf5 --disable-dap, or see config.log for errors.])])
|
|
AC_SEARCH_LIBS([dlopen], [dl dld], [], [])
|
|
fi
|
|
|
|
# We need the math library
|
|
AC_CHECK_LIB([m], [floor], [],
|
|
[AC_MSG_ERROR([Can't find or link to the math library.])])
|
|
|
|
if test "x$enable_netcdf_4" = xyes; then
|
|
AC_DEFINE([USE_NETCDF4], [1], [if true, build netCDF-4])
|
|
fi
|
|
|
|
# Set defaults
|
|
hdf5_parallel=no
|
|
hdf5_supports_par_filters=no
|
|
enable_szlib=no
|
|
|
|
if test "x$enable_hdf5" = xyes; then
|
|
|
|
AC_DEFINE([USE_HDF5], [1], [if true, use HDF5])
|
|
AC_DEFINE([H5_USE_16_API], [1], [use HDF5 1.6 API])
|
|
|
|
# Check for the main hdf5 and hdf5_hl library.
|
|
|
|
AC_SEARCH_LIBS([H5Fflush], [hdf5dll hdf5], [],
|
|
[AC_MSG_ERROR([Can't find or link to the hdf5 library. Use --disable-hdf5, or see config.log for errors.])])
|
|
AC_SEARCH_LIBS([H5DSis_scale], [hdf5_hldll hdf5_hl], [],
|
|
[AC_MSG_ERROR([Can't find or link to the hdf5 high-level. Use --disable-hdf5, or see config.log for errors.])])
|
|
|
|
AC_CHECK_HEADERS([hdf5.h], [], [AC_MSG_ERROR([Compiling a test with HDF5 failed. Either hdf5.h cannot be found, or config.log should be checked for other reason.])])
|
|
|
|
# Was HDF5 built with zlib as netCDF requires?
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include "H5public.h"],
|
|
[[#if !H5_HAVE_ZLIB_H
|
|
# error
|
|
#endif]
|
|
])], [], [AC_MSG_ERROR([HDF5 was not built with zlib, which is required. Rebuild HDF5 with zlib.])])
|
|
|
|
# H5Pset_fapl_mpiposix and H5Pget_fapl_mpiposix have been removed since HDF5 1.8.12.
|
|
# Use H5Pset_fapl_mpio and H5Pget_fapl_mpio, instead.
|
|
AC_CHECK_FUNCS([H5Pget_fapl_mpio H5Pset_deflate H5Z_SZIP H5free_memory H5resize_memory H5allocate_memory H5Pset_libver_bounds H5Pset_all_coll_metadata_ops H5Dread_chunk])
|
|
|
|
# Check to see if HDF5 library has collective metadata APIs, (HDF5 >= 1.10.0)
|
|
if test "x$ac_cv_func_H5Pset_all_coll_metadata_ops" = xyes; then
|
|
AC_DEFINE([HDF5_HAS_COLL_METADATA_OPS], [1], [if true, use collective metadata ops in parallel netCDF-4])
|
|
fi
|
|
|
|
# If parallel is available in hdf5, enable it in the C code. Also add some stuff to netcdf.h.
|
|
if test "x$ac_cv_func_H5Pget_fapl_mpio" = xyes -o "x$ac_cv_func_H5Pget_fapl_mpiposix" = xyes; then
|
|
hdf5_parallel=yes
|
|
fi
|
|
|
|
AC_MSG_CHECKING([whether parallel io is enabled in hdf5])
|
|
AC_MSG_RESULT([$hdf5_parallel])
|
|
|
|
# Check to see if HDF5 library is 1.10.3 or greater. If so, allows
|
|
# parallel I/O with filters. This allows zlib/szip compression to
|
|
# be used with parallel I/O, which is very helpful to HPC users.
|
|
if test "x$ac_cv_func_H5Dread_chunk" = xyes; then
|
|
AC_DEFINE([HDF5_SUPPORTS_PAR_FILTERS], [1], [if true, HDF5 is at least version 1.10.3 and allows parallel I/O with zip])
|
|
hdf5_supports_par_filters=yes
|
|
fi
|
|
AC_MSG_CHECKING([whether HDF5 allows parallel filters])
|
|
AC_MSG_RESULT([$ac_cv_func_H5Dread_chunk])
|
|
|
|
# Check to see if user asked for parallel build, but HDF5 does not support it.
|
|
if test "x$hdf5_parallel" = "xno"; then
|
|
if test "x$enable_parallel_tests" = "xyes"; then
|
|
AC_MSG_ERROR([Parallel tests requested, but no parallel HDF5 installation detected.])
|
|
fi
|
|
fi
|
|
|
|
# Check whether HDF5 was built with the SZLIB library. If so we
|
|
# must be able to link to szip library.
|
|
AC_MSG_CHECKING([whether szlib was used when building HDF5])
|
|
if test "x$ac_cv_func_H5Z_SZIP" = xyes; then
|
|
enable_szlib=yes
|
|
AC_DEFINE([USE_SZIP], [1], [if true, compile in szip compression in netCDF-4 variables])
|
|
fi
|
|
AC_MSG_RESULT([$enable_szlib])
|
|
fi
|
|
|
|
# If the user wants hdf4 built in, check it out.
|
|
if test "x$enable_hdf4" = xyes; then
|
|
AC_CHECK_LIB([jpeg], [jpeg_CreateCompress], [],
|
|
[AC_MSG_ERROR([Jpeg library required for --enable-hdf4 builds.])])
|
|
AC_CHECK_HEADERS([mfhdf.h], [], [nc_mfhdf_h_missing=yes])
|
|
if test "x$nc_mfhdf_h_missing" = xyes; then
|
|
AC_MSG_ERROR([Cannot find mfhdf.h, yet --enable-hdf4 was used.])
|
|
fi
|
|
AC_CHECK_LIB([df], [Hclose], [], [AC_MSG_ERROR([Can't find or link to the hdf4 df library. See config.log for errors.])])
|
|
AC_CHECK_LIB([mfhdf], [NC_arrayfill], [AC_MSG_ERROR([HDF4 library must be built with --disable-netcdf.])], [])
|
|
AC_CHECK_LIB([mfhdf], [SDcreate], [], [AC_MSG_ERROR([Can't find or link to the hdf4 mfhdf library. See config.log for errors.])])
|
|
|
|
AC_CHECK_LIB([jpeg], [jpeg_set_quality], [], [AC_MSG_ERROR([Can't find or link to the jpeg library (required by hdf4). See config.log for errors.])])
|
|
AC_DEFINE([USE_HDF4], [1], [if true, use HDF4 too])
|
|
fi
|
|
|
|
# There are several cases for parallelism:
|
|
# 1. PnetCDF enabled => we want to parallelism for CDF-1,CDF-2,and CDF-5
|
|
# 2. hdf5 has mpio enabled
|
|
# a. do not want to use it for netcdf4
|
|
# b. do want to use it for netcdf4
|
|
|
|
# Should we provide parallel io for netcdf-4?
|
|
if test "x$enable_hdf5" = xyes ; then
|
|
AC_ARG_ENABLE([parallel4],
|
|
[AS_HELP_STRING([--disable-parallel4],
|
|
[disable parallel I/O for netcdf-4, even if it's enabled in libhdf5])],
|
|
[user_set_parallel4=${enableval}]2)
|
|
test "x$enable_parallel4" = xno || enable_parallel4=yes
|
|
|
|
# If user wants parallel IO for netCDF-4, make sure HDF5 can provide it.
|
|
if test "x$enable_parallel4" = xyes; then
|
|
if test "x$hdf5_parallel" = xno; then
|
|
# If user specifically asked for parallel4, then error out.
|
|
if test "x$user_set_parallel4" = xyes; then
|
|
AC_MSG_ERROR([Paralllel IO in netCDF-4 requested, but HDF5 does not provide parallel IO.])
|
|
fi
|
|
# User didn't specify, so disable parallel4
|
|
enable_parallel4=no
|
|
AC_MSG_WARN([Parallel io disabled for netcdf-4 because hdf5 does not support])
|
|
fi
|
|
fi
|
|
else
|
|
enable_parallel4=no
|
|
fi
|
|
AC_MSG_CHECKING([whether parallel I/O is enabled for netcdf-4])
|
|
AC_MSG_RESULT($enable_parallel4)
|
|
|
|
# We have already tested for parallel io in netcdf4
|
|
# parallel I/O for CDF-1, 2, and 5 files can also be done through PnetCDF
|
|
# See if the PnetCDF lib is available and of the
|
|
# right version (1.6.0 or later)
|
|
if test "x$enable_pnetcdf" = xyes; then
|
|
pnetcdf_conflict=no
|
|
AC_CHECK_LIB([pnetcdf], [ncmpi_create], [],[pnetcdf_conflict=yes])
|
|
|
|
if test "x$pnetcdf_conflict" = xyes ; then
|
|
AC_MSG_ERROR([Cannot link to PnetCDF library.])
|
|
fi
|
|
|
|
# Pnetcdf did not support utf-8 until 1.6.0
|
|
|
|
AC_MSG_CHECKING([Is libpnetcdf version 1.6.0 or later?])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <pnetcdf.h>]], [[
|
|
#if (PNETCDF_VERSION_MAJOR*1000 + PNETCDF_VERSION_MINOR < 1006)
|
|
choke me
|
|
#endif
|
|
]])], [pnetcdf16=yes], [pnetcdf16=no])
|
|
AC_MSG_RESULT([$pnetcdf16])
|
|
if test x$pnetcdf16 = xno; then
|
|
AC_MSG_ERROR([--enable-pnetcdf requires version 1.6.0 or later])
|
|
fi
|
|
fi
|
|
|
|
# Now, set enable_parallel if either enable_pnetcdf or enable_parallel4 is set
|
|
if test "x$enable_pnetcdf" = xyes -o "x$enable_parallel4" = xyes; then
|
|
enable_parallel=yes
|
|
else
|
|
enable_parallel=no
|
|
fi
|
|
AM_CONDITIONAL(ENABLE_PARALLEL, [test x$enable_parallel = xyes ])
|
|
|
|
if test "x$hdf5_parallel" = xyes; then
|
|
# Provide more precise parallel control
|
|
AC_DEFINE([HDF5_PARALLEL], [1], [if true, hdf5 has parallelism enabled])
|
|
fi
|
|
|
|
# Set config flags
|
|
if test "x$enable_parallel4" = xyes; then
|
|
# Provide more precise parallel control
|
|
AC_DEFINE([USE_PARALLEL4], [1], [if true, parallel netcdf-4 is in use])
|
|
fi
|
|
|
|
if test "x$enable_pnetcdf" = xyes; then
|
|
AC_DEFINE([USE_PNETCDF], [1], [if true, PnetCDF is used])
|
|
fi
|
|
|
|
# If enable_parallel is in use, enable it in the C code. Also add some stuff to netcdf.h.
|
|
if test "x$enable_parallel" = xyes; then
|
|
AC_DEFINE([USE_PARALLEL], [1], [if true, PnetCDF or parallel netcdf-4 is in use])
|
|
fi
|
|
|
|
AC_ARG_ENABLE([erange_fill],
|
|
[AS_HELP_STRING([--enable-erange-fill],
|
|
[Enable use of fill value when out-of-range type
|
|
conversion causes NC_ERANGE error. @<:@default: disabled@:>@])],
|
|
[enable_erange_fill=${enableval}], [enable_erange_fill=auto]
|
|
)
|
|
|
|
# check PnetCDF's settings on enable_erange_fill and relax_coord_bound
|
|
if test "x$enable_pnetcdf" = xyes; then
|
|
UD_CHECK_HEADER_PATH([pnetcdf.h])
|
|
|
|
AC_MSG_CHECKING([if erange-fill is enabled in PnetCDF])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <pnetcdf.h>]], [[
|
|
#if !defined(PNETCDF_ERANGE_FILL) || PNETCDF_ERANGE_FILL == 0
|
|
choke me
|
|
#endif]])], [enable_erange_fill_pnetcdf=yes], [enable_erange_fill_pnetcdf=no])
|
|
AC_MSG_RESULT([$enable_erange_fill_pnetcdf])
|
|
if test "x$enable_erange_fill" = xauto ; then
|
|
enable_erange_fill=$enable_erange_fill_pnetcdf
|
|
elif test "$enable_erange_fill" != "$enable_erange_fill_pnetcdf"; then
|
|
if test "$enable_erange_fill" = yes; then
|
|
AC_MSG_ERROR([Enabling erange-fill conflicts with PnetCDF setting])
|
|
else
|
|
AC_MSG_ERROR([Disabling erange-fill conflicts with PnetCDF setting])
|
|
fi
|
|
fi
|
|
|
|
AC_MSG_CHECKING([if relax-coord-bound is enabled in PnetCDF])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <pnetcdf.h>]], [[
|
|
#if !defined(PNETCDF_RELAX_COORD_BOUND) || PNETCDF_RELAX_COORD_BOUND == 0
|
|
choke me
|
|
#endif]])], [relax_coord_bound_pnetcdf=yes], [relax_coord_bound_pnetcdf=no])
|
|
AC_MSG_RESULT([$relax_coord_bound_pnetcdf])
|
|
if test x"$relax_coord_bound_pnetcdf" != xyes; then
|
|
AC_MSG_ERROR([PNetCDF must be built with relax-coord-bound])
|
|
fi
|
|
else
|
|
if test "x$enable_erange_fill" = xauto; then
|
|
# if --enable-erange-fill is not used, default setting is no
|
|
enable_erange_fill=no
|
|
fi
|
|
fi
|
|
|
|
if test "x$enable_erange_fill" = xyes ; then
|
|
if test "x$M4FLAGS" = x ; then
|
|
M4FLAGS="-DERANGE_FILL"
|
|
else
|
|
M4FLAGS="$M4FLAGS -DERANGE_FILL"
|
|
fi
|
|
AC_DEFINE([ERANGE_FILL], [1], [if true, use _FillValue for NC_ERANGE data elements])
|
|
fi
|
|
AC_SUBST(M4FLAGS)
|
|
|
|
# Check for downloading/building fortran via postinstall script.
|
|
if test "x$enable_remote_fortran_bootstrap" = xyes; then
|
|
AC_DEFINE([BUILD_FORTRAN], 1, [If true, will attempt to download and build netcdf-fortran.])
|
|
fi
|
|
|
|
# No logging for netcdf-3.
|
|
if test "x$enable_netcdf_4" = xno; then
|
|
enable_logging=no
|
|
fi
|
|
if test "x$enable_logging" = xyes; then
|
|
AC_DEFINE([LOGGING], 1, [If true, turn on logging.])
|
|
fi
|
|
|
|
# Automake conditionals need to be called, whether the answer is yes
|
|
# or no.
|
|
AM_CONDITIONAL(BUILD_PARALLEL, [test x$enable_parallel = xyes])
|
|
AM_CONDITIONAL(TEST_PARALLEL4, [test "x$enable_parallel4" = xyes -a "x$enable_parallel_tests" = xyes])
|
|
AM_CONDITIONAL(BUILD_DAP, [test "x$enable_dap" = xyes])
|
|
AM_CONDITIONAL(USE_DAP, [test "x$enable_dap" = xyes]) # Alias
|
|
# Provide protocol specific flags
|
|
AM_CONDITIONAL(ENABLE_DAP, [test "x$enable_dap" = xyes])
|
|
AM_CONDITIONAL(ENABLE_DAP4, [test "x$enable_dap4" = xyes])
|
|
AM_CONDITIONAL(USE_STRICT_NULL_BYTE_HEADER_PADDING, [test x$enable_strict_null_byte_header_padding = xyes])
|
|
AM_CONDITIONAL(ENABLE_CDF5, [test "x$enable_cdf5" = xyes])
|
|
AM_CONDITIONAL(ENABLE_DAP_REMOTE_TESTS, [test "x$enable_dap_remote_tests" = xyes])
|
|
AM_CONDITIONAL(ENABLE_DAP_AUTH_TESTS, [test "x$enable_dap_auth_tests" = xyes])
|
|
AM_CONDITIONAL(ENABLE_DAP_LONG_TESTS, [test "x$enable_dap_long_tests" = xyes])
|
|
AM_CONDITIONAL(USE_SZIP, [test "x$ac_cv_func_H5Z_SZIP" = xyes])
|
|
AM_CONDITIONAL(USE_PNETCDF_DIR, [test ! "x$PNETCDFDIR" = x])
|
|
AM_CONDITIONAL(USE_LOGGING, [test "x$enable_logging" = xyes])
|
|
AM_CONDITIONAL(CROSS_COMPILING, [test "x$cross_compiling" = xyes])
|
|
AM_CONDITIONAL(USE_NETCDF4, [test x$enable_netcdf_4 = xyes])
|
|
AM_CONDITIONAL(USE_HDF5, [test x$enable_hdf5 = xyes])
|
|
AM_CONDITIONAL(USE_HDF4, [test x$enable_hdf4 = xyes])
|
|
AM_CONDITIONAL(USE_HDF4_FILE_TESTS, [test x$enable_hdf4_file_tests = xyes])
|
|
AM_CONDITIONAL(USE_RENAMEV3, [test x$enable_netcdf_4 = xyes -o x$enable_dap = xyes])
|
|
AM_CONDITIONAL(BUILD_FORTRAN, [test x$enable_remote_fortran_bootstrap = xyes])
|
|
AM_CONDITIONAL(USE_PNETCDF, [test x$enable_pnetcdf = xyes])
|
|
AM_CONDITIONAL(USE_DISPATCH, [test x$enable_dispatch = xyes])
|
|
AM_CONDITIONAL(BUILD_MMAP, [test x$enable_mmap = xyes])
|
|
AM_CONDITIONAL(BUILD_DOCS, [test x$enable_doxygen = xyes])
|
|
AM_CONDITIONAL(SHOW_DOXYGEN_TAG_LIST, [test x$enable_doxygen_tasks = xyes])
|
|
AM_CONDITIONAL(ENABLE_METADATA_PERF, [test x$enable_metadata_perf = xyes])
|
|
AM_CONDITIONAL(ENABLE_BYTERANGE, [test "x$enable_byterange" = xyes])
|
|
AM_CONDITIONAL(RELAX_COORD_BOUND, [test "xyes" = xyes])
|
|
AM_CONDITIONAL(HAS_PAR_FILTERS, [test x$hdf5_supports_par_filters = xyes ])
|
|
AM_CONDITIONAL(ENABLE_NCZARR, [test "x$enable_nczarr" = xyes])
|
|
AM_CONDITIONAL(HAVE_AWS, [test "x$have_aws" = xyes])
|
|
|
|
# If the machine doesn't have a long long, and we want netCDF-4, then
|
|
# we've got problems!
|
|
if test "x$enable_netcdf_4" = xyes; then
|
|
AC_TYPE_LONG_LONG_INT
|
|
AC_TYPE_UNSIGNED_LONG_LONG_INT
|
|
dnl if test ! "x$ac_cv_type_long_long_int" = xyes -o ! "x$ac_cv_type_unsigned_long_long_int" = xyes; then
|
|
dnl AC_MSG_ERROR([This platform does not support long long types. These are required for netCDF-4.])
|
|
dnl fi
|
|
fi
|
|
|
|
# Create the file name for a "make ftpbin" which is used to generate a
|
|
# binary distribution. For each release we generate binary releases on
|
|
# the thousands of machines in Unidata's vast underground complex at
|
|
# an undisclosed location in the Rocky Mountains. The binary
|
|
# distributions, along with the 25-foot thick cement slabs and the
|
|
# giant springs, will help distribute netCDF even after a catastrophic
|
|
# meteor strike.
|
|
AC_MSG_CHECKING([what to call the output of the ftpbin target])
|
|
BINFILE_NAME=binary-netcdf-$PACKAGE_VERSION
|
|
test "x$enable_netcdf_4" = xno && BINFILE_NAME=${BINFILE_NAME}_nc3
|
|
BINFILE_NAME=${BINFILE_NAME}.tar
|
|
AC_SUBST(BINFILE_NAME)
|
|
AC_MSG_RESULT([$BINFILE_NAME $FC $CXX])
|
|
|
|
##
|
|
# Bugfix for Cygwin.
|
|
##
|
|
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])
|
|
NOUNDEFINED=" -no-undefined"
|
|
;;
|
|
*)
|
|
## Don't add anything
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
esac
|
|
|
|
AC_MSG_CHECKING([value of LIBS])
|
|
AC_MSG_RESULT([$LIBS])
|
|
|
|
# Flags for nc-config script; by design $prefix, $includir, $libdir,
|
|
# etc. are left as shell variables in the script so as to facilitate
|
|
# relocation
|
|
if test "x$with_netcdf_c_lib" = x ; then
|
|
NC_LIBS="-lnetcdf"
|
|
else
|
|
NC_LIBS="$with_netcdf_c_lib"
|
|
fi
|
|
if test "x$enable_shared" != xyes; then
|
|
NC_LIBS="$LDFLAGS $NC_LIBS $LIBS"
|
|
fi
|
|
|
|
case "x$target_os" in
|
|
xsolaris*)
|
|
NEWNCLIBS=""
|
|
for x in $NC_LIBS ; do
|
|
case "$x" in
|
|
-L*) r=`echo "$x" | sed -e 's|^-L|-R|'`
|
|
NEWNCLIBS="$NEWNCLIBS $x $r"
|
|
;;
|
|
*) NEWNCLIBS="$NEWNCLIBS $x" ;;
|
|
esac
|
|
done
|
|
NC_LIBS="$NEWNCLIBS"
|
|
;;
|
|
*);;
|
|
esac
|
|
|
|
NC_FLIBS="-lnetcdff $NC_LIBS"
|
|
|
|
# Control filter test/example
|
|
AC_MSG_CHECKING([whether filter testing should be run])
|
|
AC_ARG_ENABLE([filter-testing],
|
|
[AS_HELP_STRING([--disable-filter-testing],
|
|
[Do not run filter test and example; requires shared libraries and netCDF-4])])
|
|
test "x$enable_filter_testing" = xno || enable_filter_testing=yes
|
|
AC_MSG_RESULT($enable_filter_testing)
|
|
|
|
# Enable client side filter registration
|
|
AC_MSG_CHECKING([If client-side filters are enabled (default off)])
|
|
AC_ARG_ENABLE([clientside-filters],
|
|
[AS_HELP_STRING([--enable-clientside-filters],
|
|
[enable client side filters])],
|
|
[],
|
|
[enable_clientside_filters=no])
|
|
test "x$enable_clientside_filters" = xyes || enable_clientside_filters=no
|
|
AC_MSG_RESULT($enable_clientside_filters)
|
|
if test "x$enable_clientside_filters" = xyes ; then
|
|
AC_DEFINE([ENABLE_CLIENTSIDE_FILTERS], [1], [if true, enable client-side filters])
|
|
fi
|
|
|
|
if test "x$enable_hdf5" = xno ; then
|
|
AC_MSG_WARN([HDF5 disabled => --disable-filter-testing && --disable-client-filters])
|
|
enable_filter_testing=no
|
|
enable_clientside_filters=no
|
|
fi
|
|
|
|
AM_CONDITIONAL(ENABLE_CLIENTSIDE_FILTERS, [test x$enable_clientside_filters = xyes])
|
|
AM_CONDITIONAL(ENABLE_FILTER_TESTING, [test x$enable_filter_testing = xyes])
|
|
|
|
if test "x$enable_shared" = xno ; then
|
|
AC_MSG_WARN([Shared libraries are disabled => --disable-filter-testing])
|
|
enable_filter_testing=no
|
|
fi
|
|
|
|
AC_SUBST(NC_LIBS,[$NC_LIBS])
|
|
AC_SUBST(HAS_DAP,[$enable_dap])
|
|
AC_SUBST(HAS_DAP2,[$enable_dap])
|
|
AC_SUBST(HAS_DAP4,[$enable_dap4])
|
|
AC_SUBST(HAS_NC2,[$nc_build_v2])
|
|
AC_SUBST(HAS_NC4,[$enable_netcdf_4])
|
|
AC_SUBST(HAS_CDF5,[$enable_cdf5])
|
|
AC_SUBST(HAS_HDF4,[$enable_hdf4])
|
|
AC_SUBST(HAS_HDF5,[$enable_hdf5])
|
|
AC_SUBST(HAS_PNETCDF,[$enable_pnetcdf])
|
|
AC_SUBST(HAS_LOGGING, [$enable_logging])
|
|
AC_SUBST(HAS_SZLIB,[$enable_szlib])
|
|
AC_SUBST(HAS_SZLIB_WRITE, [$enable_szlib])
|
|
AC_SUBST(HAS_PARALLEL,[$enable_parallel])
|
|
AC_SUBST(HAS_PARALLEL4,[$enable_parallel4])
|
|
AC_SUBST(HAS_DISKLESS,[yes])
|
|
AC_SUBST(HAS_MMAP,[$enable_mmap])
|
|
AC_SUBST(HAS_JNA,[$enable_jna])
|
|
AC_SUBST(HAS_ERANGE_FILL,[$enable_erange_fill])
|
|
AC_SUBST(HAS_BYTERANGE,[$enable_byterange])
|
|
AC_SUBST(RELAX_COORD_BOUND,[yes])
|
|
AC_SUBST([HAS_PAR_FILTERS], [$hdf5_supports_par_filters])
|
|
AC_SUBST(HAS_NCZARR,[$enable_nczarr])
|
|
AC_SUBST(DO_S3_TESTS,[$enable_s3_tests])
|
|
|
|
# Include some specifics for netcdf on windows.
|
|
#AH_VERBATIM([_WIN32_STRICMP],
|
|
AH_BOTTOM(
|
|
[/* Define strcasecmp, strncasecmp, snprintf on Win32 systems. */
|
|
#ifdef _WIN32
|
|
#define strcasecmp _stricmp
|
|
#define strncasecmp _strnicmp
|
|
#define snprintf _snprintf
|
|
#endif])
|
|
|
|
# Access netcdf specific version of config.h
|
|
AH_BOTTOM([#include "ncconfigure.h"])
|
|
|
|
##################################################
|
|
# Uncomment this to keep a copy of autoconf defines at this point, for
|
|
# debugging purposes.
|
|
# cp confdefs.h my_config.h
|
|
|
|
#####
|
|
# Create output variables from various
|
|
# shell variables, for use in generating
|
|
# libnetcdf.settings.
|
|
#####
|
|
AC_SUBST([enable_shared])
|
|
AC_SUBST([enable_static])
|
|
AC_SUBST([CFLAGS])
|
|
AC_SUBST([CPPFLAGS])
|
|
AC_SUBST([LDFLAGS])
|
|
AC_SUBST([AM_CFLAGS])
|
|
AC_SUBST([AM_CPPFLAGS])
|
|
AC_SUBST([AM_LDFLAGS])
|
|
AC_SUBST([NOUNDEFINED])
|
|
|
|
# Args:
|
|
# 1. netcdf_meta.h variable
|
|
# 2. conditional variable that is yes or no.
|
|
# 3. default condition
|
|
#
|
|
# example: AX_SET_META([NC_HAS_NC2],[$nc_build_v2],[]) # Because it checks for no.
|
|
# AX_SET_META([NC_HAS_HDF4],[$enable_hdf4],[yes])
|
|
AC_DEFUN([AX_SET_META],[
|
|
if [ test "x$2" = x$3 ]; then
|
|
AC_SUBST([$1]) $1=1
|
|
else
|
|
AC_SUBST([$1]) $1=0
|
|
fi
|
|
])
|
|
|
|
#####
|
|
# Define values used in include/netcdf_meta.h
|
|
#####
|
|
AC_SUBST([NC_VERSION]) NC_VERSION=$VERSION
|
|
AX_SET_META([NC_HAS_NC2],[$nc_build_v2],[yes])
|
|
AX_SET_META([NC_HAS_NC4],[$enable_netcdf_4],[yes])
|
|
AX_SET_META([NC_HAS_HDF4],[$enable_hdf4],[yes])
|
|
AX_SET_META([NC_HAS_HDF5],[$enable_hdf5],[yes])
|
|
AX_SET_META([NC_HAS_SZIP],[$ac_cv_func_H5Z_SZIP],[yes])
|
|
AX_SET_META([NC_HAS_DAP2],[$enable_dap],[yes])
|
|
AX_SET_META([NC_HAS_DAP4],[$enable_dap4],[yes])
|
|
AX_SET_META([NC_HAS_DISKLESS],[yes],[yes])
|
|
AX_SET_META([NC_HAS_MMAP],[$enable_mmap],[yes])
|
|
AX_SET_META([NC_HAS_JNA],[$enable_jna],[yes])
|
|
AX_SET_META([NC_HAS_PNETCDF],[$enable_pnetcdf],[yes])
|
|
AX_SET_META([NC_HAS_PARALLEL],[$enable_parallel],[yes])
|
|
AX_SET_META([NC_HAS_PARALLEL4],[$enable_parallel4],[yes])
|
|
AX_SET_META([NC_HAS_CDF5],[$enable_cdf5],[yes])
|
|
AX_SET_META([NC_HAS_ERANGE_FILL], [$enable_erange_fill],[yes])
|
|
AX_SET_META([NC_HAS_PAR_FILTERS], [$hdf5_supports_par_filters],[yes])
|
|
AX_SET_META([NC_HAS_BYTERANGE],[$enable_byterange],[yes])
|
|
AX_SET_META([NC_HAS_NCZARR],[$enable_nczarr],[yes])
|
|
|
|
# This is the version of the dispatch table. If the dispatch table is
|
|
# changed, this should be incremented, so that user-defined format
|
|
# applications like PIO can determine whether they have an appropriate
|
|
# dispatch table to submit. If this is changed, make sure the value in
|
|
# CMakeLists.txt also changes to match.
|
|
AC_SUBST([NC_DISPATCH_VERSION], [2])
|
|
|
|
#####
|
|
# End netcdf_meta.h definitions.
|
|
#####
|
|
|
|
# This would be true for a cmake build.
|
|
AC_SUBST([ISCMAKE], [])
|
|
|
|
# This would be true for a visual studio build.
|
|
AC_SUBST([MSVC], [])
|
|
|
|
AC_MSG_NOTICE([generating header files and makefiles])
|
|
AC_CONFIG_FILES(test_common.sh:test_common.in)
|
|
AC_CONFIG_FILES(nc_test4/findplugin.sh:nc_test4/findplugin.in)
|
|
AC_CONFIG_FILES(examples/C/findplugin.sh:nc_test4/findplugin.in)
|
|
AC_CONFIG_FILES(ncdap_test/findtestserver.c:ncdap_test/findtestserver.c.in)
|
|
AC_CONFIG_FILES(dap4_test/findtestserver4.c:ncdap_test/findtestserver.c.in)
|
|
AC_CONFIG_FILES(dap4_test/pingurl4.c:ncdap_test/pingurl.c)
|
|
AC_CONFIG_FILES([h5_test/run_par_tests.sh], [chmod ugo+x h5_test/run_par_tests.sh])
|
|
AC_CONFIG_FILES([nc_test4/run_par_test.sh], [chmod ugo+x nc_test4/run_par_test.sh])
|
|
AC_CONFIG_FILES([nc_perf/run_par_bm_test.sh], [chmod ugo+x nc_perf/run_par_bm_test.sh])
|
|
AC_CONFIG_FILES([nc_perf/run_gfs_test.sh], [chmod ugo+x nc_perf/run_gfs_test.sh])
|
|
AC_CONFIG_FILES([examples/C/run_par_test.sh], [chmod ugo+x examples/C/run_par_test.sh])
|
|
AC_CONFIG_FILES([nc-config], [chmod 755 nc-config])
|
|
AC_CONFIG_FILES([Makefile
|
|
netcdf.pc
|
|
libnetcdf.settings
|
|
postinstall.sh
|
|
include/netcdf_meta.h
|
|
include/Makefile
|
|
h5_test/Makefile
|
|
hdf4_test/Makefile
|
|
libsrc/Makefile
|
|
libsrc4/Makefile
|
|
libhdf5/Makefile
|
|
libsrcp/Makefile
|
|
ncdump/Makefile
|
|
ncgen3/Makefile
|
|
ncgen/Makefile
|
|
examples/Makefile
|
|
examples/C/Makefile
|
|
examples/CDL/Makefile
|
|
oc2/Makefile
|
|
libdap2/Makefile
|
|
libdap4/Makefile
|
|
libhdf4/Makefile
|
|
libnczarr/Makefile
|
|
libdispatch/Makefile
|
|
liblib/Makefile
|
|
ncdump/cdl/Makefile
|
|
ncdump/expected/Makefile
|
|
docs/Makefile
|
|
docs/images/Makefile
|
|
unit_test/Makefile
|
|
nctest/Makefile
|
|
nc_test4/Makefile
|
|
nc_perf/Makefile
|
|
nc_test/Makefile
|
|
ncdap_test/Makefile
|
|
ncdap_test/testdata3/Makefile
|
|
ncdap_test/expected3/Makefile
|
|
ncdap_test/expectremote3/Makefile
|
|
dap4_test/Makefile
|
|
plugins/Makefile
|
|
nczarr_test/Makefile
|
|
])
|
|
AC_OUTPUT()
|
|
|
|
cat libnetcdf.settings
|