#                                               -*- 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.9.3],[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([netCDF_VERSION_MAJOR]) netCDF_VERSION_MAJOR=4
AC_SUBST([netCDF_VERSION_MINOR]) netCDF_VERSION_MINOR=9
AC_SUBST([netCDF_VERSION_PATCH]) netCDF_VERSION_PATCH=3
AC_SUBST([NC_VERSION_NOTE]) NC_VERSION_NOTE=""

##
# These linker flags specify libtool version info.
# See http://www.gnu.org/software/libtool/manual/libtool.html#Libtool-versioning
# for information regarding incrementing `-version-info`.
# These values should match those in CMakeLists.txt
AC_SUBST([netCDF_SO_VERSION]) netCDF_SO_VERSION=23:0:1

#####
# 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.
# This file is apparently unused. But see the bottom of Makefile.am
# 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])


##
# Check to see if the compiler supports -fno-strict-aliasing and, if so,
# add that to the C compiler flags.  This is in support of https://github.com/Unidata/netcdf-c/issues/1983.
##
SAVE_CFLAGS="${CFLAGS}"
AC_LANG_PUSH([C])
AC_LANG_COMPILER_REQUIRE
CFLAGS="${CFLAGS} -fno-strict-aliasing"

AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
        [int i = 0;]])],
        [have_no_strict_aliasing=yes],
        [have_no_strict_aliasing=no])
AC_MSG_CHECKING([whether compiler supports -fno-strict-aliasing])
AC_MSG_RESULT([$have_no_strict_aliasing])
AC_LANG_POP([C])
if test $have_no_strict_aliasing = no; then
   CFLAGS=$SAVE_CFLAGS
fi

## 
# Check to see if we have getfattr
##
AC_CHECK_PROGS([HAVE_GETFATTR], [getfattr])
if test -n "$HAVE_GETFATTR"; then
   AC_DEFINE_UNQUOTED([HAVE_GETFATTR],[1],[getfattr is available])
fi
##
# 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])
AM_MAINTAINER_MODE()
# Check for the existence of this file before proceeding.
AC_CONFIG_SRCDIR([include/netcdf.h])

# Figure out platforms of special interest
AC_CANONICAL_HOST
AS_CASE([$host],
    [*-*-cygwin], [ISCYGWIN=yes],
    [*-*-darwin*], [ISOSX=yes],
    [*-*-mingw*], [ISMINGW=yes],
    [*-*-msys], [ISMINGW=yes],
    [*-*-win*], [ISMSVC=yes],
    []
)

if test "x$MSYSTEM" != x ; then
ISMINGW=yes
ISMSYS=yes
fi

# Get windows version info
if test "x$ISMSVC" = xyes ; then
WINVER=`systeminfo | sed -e '/^OS Version:/p' -ed | sed -e 's|[^0-9]*\([0-9.]*\).*|\1|'`
else
WINVER="0.0.0"
fi
WINVERMAJOR=`echo $WVER | sed -e 's|\([^.]*\)[.]\([^.]*\)[.]\(.*\)|\1|'`
WINVERBUILD=`echo $WVER | sed -e 's|\([^.]*\)[.]\([^.]*\)[.]\(.*\)|\3|'`
if test "x$WINVERMAJOR" = x ; then WINVERMAJOR=0; fi
if test "x$WINVERBUILD" = x ; then WINVERBUILD=0; fi
AC_DEFINE_UNQUOTED([WINVERMAJOR], [$WINVERMAJOR], [windows version major])
AC_DEFINE_UNQUOTED([WINVERBUILD], [$WINVERBUILD], [windows version build])

AC_MSG_NOTICE([checking supported formats])

# As a long term goal, and because it is now the case that --enable-nczarr
# => USE_NETCDF4, make the external options --enable-netcdf-4 and
# --enable-netcdf4 obsolete in favor of --enable-hdf5
# We will do the following for one more release cycle.
# 1. Make --enable-netcdf-4 be an alias for --enable-netcdf4.
# 2. Make --enable-netcdf4 an alias for --enable-hdf5.
# 3. Internally, convert most uses of USE_NETCDF_4 ad USE_NETCDF4 to USE_HDF5

# Collect the values of --enable-netcdf-4, --enable-netcdf4, and --enable-hdf5.
# Also determine which have been explicitly set on the command line.

AC_ARG_ENABLE([netcdf-4], [AS_HELP_STRING([--enable-netcdf-4],
              [(Deprecated) Synonym for --enable-hdf5; default yes])])
AC_ARG_ENABLE([netcdf4], [AS_HELP_STRING([--enable-netcdf4],
              [(Deprecated) Synonym for --enable-hdf5; default yes])])
AC_ARG_ENABLE([hdf5], [AS_HELP_STRING([--enable-hdf5],[default yes])])

# Complain about the use of --enable-netcdf-4/--enable-netcdf4
if test "x$enable_netcdf_4" != x ; then
    AC_MSG_WARN([--enable-netcdf-4 is deprecated; please use --enable-hdf5])
fi
if test "x$enable_netcdf4" != x ; then
    AC_MSG_WARN([--enable-netcdf4 is deprecated; please use --enable-hdf5])
fi

# --enable-netcdf-4 overrides --enable-netcdf4 if latter not defined
if test "x$enable_netcdf_4" != x && test "x$enable_netcdf4" == x ; then
enable_netcdf4="$enable_netcdf_4"
fi
# --enable-netcdf4 overrides --enable-hdf5 if latter not defined
if test "x$enable_netcdf4" != x && test "x$enable_hdf5" == x ; then
enable_hdf5="$enable_netcdf4"
fi
# Otherwise, use --enable-hdf5
AC_MSG_CHECKING([whether we should build with HDF5])
test "x$enable_hdf5" = xno || enable_hdf5=yes
AC_MSG_RESULT([$enable_hdf5])

# Turn off enable_netcdf4 because it will be used
# as a shorthand for enable_hdf5|enable_hdf4|enable_nczarr
enable_netcdf4=no

# 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)

AC_MSG_CHECKING([whether any network access should be allowed])
AC_ARG_ENABLE([remote-functionality], [AS_HELP_STRING([--enable-remote-functionality],
              [enable|disable all forms of network access (default enabled)])])
test "x$enable_remote_functionality" = xno || enable_remote_functionality=yes
AC_MSG_RESULT($enable_remote_functionality)

# We need curl for remote operations
AC_MSG_CHECKING([whether we need to look for libcurl])
AC_ARG_ENABLE([curl],
   [AS_HELP_STRING([--enable-curl],
                   [look for and link against libcurl])])

## 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)

if test "x$enable_remote_functionality" = xno ; then
  AC_MSG_WARN([All network access is disabled => DAP support disabled.])
  enable_dap=no
  AC_MSG_WARN([All network access is disabled => NCZARR support disabled.])
  enable_nczarr=no
fi

AC_MSG_CHECKING([whether netcdf zarr storage format should be disabled])
AC_ARG_ENABLE([nczarr],
              [AS_HELP_STRING([--disable-nczarr],
                              [disable netcdf zarr storage support])])
test "x$enable_nczarr" = xno || enable_nczarr=yes
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_netcdf4=yes
fi

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.])])
AC_SUBST([NC_NETCDF_ENABLE_DOXYGEN_PDF_OUTPUT], [$enable_doxygen_pdf_output])
AM_CONDITIONAL([NC_NETCDF_ENABLE_DOXYGEN_PDF_OUTPUT], [test "x$enable_doxygen_pdf_output" = xyes])

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

# Does the user want to turn off unit tests (useful for test coverage
# analysis).
AC_MSG_CHECKING([if unit tests should be enabled])
AC_ARG_ENABLE([unit-tests],
  [AS_HELP_STRING([--enable-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 resources 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 resources 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 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 default cache size?
AC_MSG_CHECKING([whether a default cache size was specified])
AC_ARG_WITH([default-chunk-cache-size],
              [AS_HELP_STRING([--with-default-chunk-cache-size=<integer>],
                              [Specify default size (in bytes) for chunk cache.])],
            [DEFAULT_CHUNK_CACHE_SIZE=$with_default_chunk_cache_size], [DEFAULT_CHUNK_CACHE_SIZE=67108864U])
AC_MSG_RESULT([$DEFAULT_CHUNK_CACHE_SIZE])
AC_DEFINE_UNQUOTED([DEFAULT_CHUNK_CACHE_SIZE], [$DEFAULT_CHUNK_CACHE_SIZE], [default size of the chunk cache.])

# Did the user specify a max number of chunks in default per-var cache size?
AC_MSG_CHECKING([whether a default number of entries for the chunk cache was specified])
AC_ARG_WITH([default-chunks-in-cache],
              [AS_HELP_STRING([--with-default-chunks-in-cache=<integer>],
                              [Specify the max number of chunks to store in cache.])],
            [DEFAULT_CHUNKS_IN_CACHE=$with_default_chunks_in_cache], [DEFAULT_CHUNKS_IN_CACHE=1000])
AC_MSG_RESULT([$DEFAULT_CHUNKS_IN_CACHE])
AC_DEFINE_UNQUOTED([DEFAULT_CHUNKS_IN_CACHE], [$DEFAULT_CHUNKS_IN_CACHE], [default max num chunks in chunk cache.])

# Did the user specify a default cache preemption
AC_MSG_CHECKING([whether a default cache preemption was specified])
AC_ARG_WITH([default-chunk-cache-preemption],
              [AS_HELP_STRING([--with-chunk-cache-preemption=<float between 0 and 1 inclusive>],
                              [Specify default file chunk cache preemption policy (a number between 0 and 1, inclusive).])],
            [DEFAULT_CHUNK_CACHE_PREEMPTION=$with_chunk_cache_preemption], [DEFAULT_CHUNK_CACHE_PREEMPTION=0.75])
AC_MSG_RESULT([$DEFAULT_CHUNK_CACHE_PREEMPTION])
AC_DEFINE_UNQUOTED([DEFAULT_CHUNK_CACHE_PREEMPTION], [$DEFAULT_CHUNK_CACHE_PREEMPTION], [default file chunk cache preemption policy.])

# These three options are redundant over the --with-default... options above.
# Did the user specify a default cache size for HDF5?
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=DEFAULT_CHUNK_CACHE_SIZE])
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 max cache entries for HDF5
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=DEFAULT_CHUNKS_IN_CACHE])
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 for HDF5?
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=DEFAULT_CHUNK_CACHE_PREEMPTION])
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])
if test "x$enable_logging" = xyes; then
   enable_set_log_level_func=yes
   enable_set_log_level=yes
   AC_DEFINE([NETCDF_ENABLE_SET_LOG_LEVEL], 1, [If true, enable nc_set_log_level function.])
else
   enable_set_log_level_func=no
   enable_set_log_level=no
fi

# Do we want to enable unsafe macros, e.g. _FillValue in addition to NC_FillValue.
# See https://github.com/Unidata/netcdf-c/issues/3029
AC_MSG_CHECKING([whether to allow legacy macros])
AC_ARG_ENABLE([legacy-macros],
               [AS_HELP_STRING([--disable-legacy-macros],
                              [enable legacy macros for backwards compatibility purposes. Use with caution.\
                              This can lead to unexpected consequences/behavior.])])
test "x$enable_legacy_macros" = xno || enable_legacy_macros=yes
AC_MSG_RESULT($enable_legacy_macros)
if test "x$enable_legacy_macros" = xyes; then
   AC_DEFINE([NETCDF_ENABLE_LEGACY_MACROS], 1, [If true, enable legacy macros in netcdf.h])
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([--disable-byterange],
                              [allow byte-range I/O])])
test "x$enable_byterange" = xno || enable_byterange=yes
AC_MSG_RESULT($enable_byterange)

if test "x$enable_dap" = xno && test "x$enable_byterange" = xyes; then 
   AC_MSG_WARN([DAP required for byterange. Byterange support disabled.])
   enable_byterange=no
fi

###
# Stanza to check for functionality which requires linking against
# libcurl.
###

if test "x$enable_dap" = xyes || test "x$enable_nczarr" = xyes; then 
   enable_curl=yes
fi

if test "x$enable_curl" = xyes; then


   if test "x$enable_dap" = xyes && test "x$found_curl" = xno ; then
      AC_MSG_WARN([curl required for dap access. DAP support disabled.])
      enable_dap=no
   fi

   # Need curl for byte ranges
   if test "x$found_curl" = xno && test "x$enable_byterange" = xyes ; then
   AC_MSG_WARN([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([NETCDF_ENABLE_BYTERANGE], [1], [if true, support byte-range read of remote datasets.])
   fi

   AC_CHECK_LIB([curl],[curl_easy_setopt],[found_curl=yes],[found_curl=no])
   if test "x$found_curl" = "xyes" ; then
      AC_SEARCH_LIBS([curl_easy_setopt],[curl curl.dll cygcurl.dll], [],[])
   fi 

   if test "x$enable_dap" = xyes & test "x$found_curl" = xno ; then
   AC_MSG_WARN([curl required for dap access. DAP support disabled.])
   enable_dap=no
   fi

   # Save/restore CFLAGS
   SAVECFLAGS="$CFLAGS"
   CFLAGS="${curl_cflags}"

   # 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

   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 !CURL_AT_LEAST_VERSION(7,66,0)
   error "<7.66";
   #endif
   ]])], [libcurl766=yes], [libcurl766=no])
   AC_MSG_RESULT([$libcurl766])
   if test x$libcurl766 = xyes; then
   AC_DEFINE([HAVE_LIBCURL_766],[1],[libcurl version is 7.66 or later])
   fi

   CFLAGS="$SAVECFLAGS"
fi

###
# End libcurl-related stanza
###

###
# Libxml2 control block.
###

AC_MSG_CHECKING([whether to search for and use external libxml2])
AC_ARG_ENABLE([libxml2],
              [AS_HELP_STRING([--disable-libxml2],
                              [disable detection and use of libxml2 in favor of the bundled xml parser])])
test "x$enable_libxml2" = xno || enable_libxml2=yes
AC_MSG_RESULT([$enable_libxml2])

# We can optionally use libxml2 for DAP4 and nch5comms, if enabled
have_libxml2=no
if test "x$enable_libxml2" = xyes; then
   AC_CHECK_PROGS([NC_XML2_CONFIG], [xml2-config])
   if test -z "$NC_XML2_CONFIG"; then
      AC_MSG_ERROR([Cannot find xml2-config utility. Either install the libxml2 development package, or re-run configure with --disable-libxml2 to use the bundled xml2 parser])
   fi
  AC_CHECK_LIB([xml2],[xmlReadMemory],[have_libxml2=yes],[have_libxml2=no])
  if test "x$have_libxml2" = "xyes" ; then
      AC_SEARCH_LIBS([xmlReadMemory],[xml2 xml2.dll cygxml2.dll], [],[])
  fi
  if test "x$have_libxml2" = xyes; then
     XML2FLAGS=`xml2-config --cflags`
     AC_SUBST([XML2FLAGS],${XML2FLAGS})
     AC_DEFINE([HAVE_LIBXML2], [1], [if true, use libxml2])
  fi
fi

if test "x$enable_libxml2" = xyes; then
XMLPARSER="libxml2"
else
XMLPARSER="tinyxml2 (bundled)"
fi

# Need a condition and subst for this
AM_CONDITIONAL(NETCDF_ENABLE_LIBXML2, [test "x$enable_libxml2" = xyes])
AC_SUBST([XMLPARSER],[${XMLPARSER}])

###
# End Libxml2 block
###

##
# Should quantize be enabled?
# On by default, but for testing purposes we may want to 
# disable it.
##
AC_MSG_CHECKING([whether to enable quantize functionality])
AC_ARG_ENABLE([quantize],
               [AS_HELP_STRING([--disable-quantize],
                               [disable quantize support. It is safe to leave this on unless you specifically need to disable it.])])
test "x$enable_quantize" = xno || enable_quantize=yes

# If HDF5 and nczarr are disabled, there is no quantize.
if test "x${enable_hdf5}" = xno; then
   if test "x${enable_nczarr}" = xno; then
      enable_quantize=no
   fi
fi

AC_MSG_RESULT($enable_quantize)                               
if test "x${enable_quantize}" = xyes; then
   AC_DEFINE([NETCDF_ENABLE_QUANTIZE], [1], [if true, enable quantize support])
fi
AM_CONDITIONAL(NETCDF_ENABLE_QUANTIZE, [test x$enable_quantize = xyes])

# --enable-dap => enable-dap4
enable_dap4=$enable_dap
AC_MSG_CHECKING([whether dap use of remotetest server should be enabled])
AC_ARG_ENABLE([dap-remote-tests],
              [AS_HELP_STRING([--disable-dap-remote-tests],
                                 [disable dap remote tests])])
# Default on
test "x$enable_dap_remote_tests" = xno || enable_dap_remote_tests=yes
if test "x$enable_dap" = "xno" ; then
  enable_dap_remote_tests=no
fi
AC_MSG_RESULT($enable_dap_remote_tests)

# Provide a global control for remotetest.
if test "xREMOTETESTDOWN" = xyes ; then
  AC_MSG_WARN("ENV(REMOTETESTDOWN) => netcdf_enable_dap_remote_tests == no")
  enable_dap_remote_tests=no
fi

AC_MSG_CHECKING([whether use of external (non-unidata) servers should be enabled])
AC_ARG_ENABLE([external-server-tests],
              [AS_HELP_STRING([--enable-external-server-tests (default off)],
                                 [enable external server tests])])
test "x$enable_external_server_tests" = xyes || enable_external_server_tests=no
AC_MSG_RESULT($enable_external_server_tests)

if test "x$enable_dap_remote_tests" = "xno" ; then
  AC_MSG_NOTICE([--disable-dap_remote_tests => --disable-external-server-tests])
  enable_external_server_tests=no
fi

# Default is not to do the remote authorization tests.
AC_MSG_CHECKING([whether dap 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
AC_MSG_RESULT($enable_dap_auth_tests)

# dap must be enabled in order to use various other flags

if test "x$enable_dap" = "xno" ; then
  AC_MSG_NOTICE([--disable-dap => --disable-dap-remote-tests --disable-auth-tests --disable-external-server-tests])
  enable_dap_remote_tests=no
  enable_dap_auth_tests=no
  enable_external_server_tests=no  
fi

# 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])
if test "x$REMOTETESTSERVERS" = xno ; then
  dfaltsvc="remotetest.unidata.ucar.edu"
  REMOTETESTSERVERS="${dfaltsvc}"
fi
msg="${REMOTETESTSERVERS}"
if test "x$dfaltsvc" != x ; then
  msg="${msg} (default)"
fi
AC_MSG_RESULT([${msg}])
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([NETCDF_ENABLE_DAP], [1], [if true, build DAP Client])
fi

if test "x$enable_dap_remote_tests" = xyes; then
   AC_DEFINE([NETCDF_ENABLE_DAP_REMOTE_TESTS], [1], [if true, do remote tests])
fi
if test "x$enable_external_server_tests" = xyes; then
   AC_DEFINE([NETCDF_ENABLE_EXTERNAL_SERVER_TESTS], [1], [if true, do remote external 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
AC_MSG_RESULT([$enable_dap_long_tests])
if test "x$enable_dap_remote_tests" = "xno" || test "x$enable_external_server_tests" = "xno" ; then
  AC_MSG_NOTICE([--disable-dap-remote|external-server-tests => --disable_dap_long_tests])
  enable_dap_long_tests=no
fi

if test "x$enable_nczarr" = xyes; then
   AC_DEFINE([NETCDF_ENABLE_NCZARR], [1], [if true, build NCZarr Client])
   AC_SUBST(NETCDF_ENABLE_NCZARR)
fi
AM_CONDITIONAL(NETCDF_ENABLE_NCZARR, [test x$enable_nczarr = xyes])

##########
# Look for Standardized libraries
##########

##
# blosc checks
##

# See if we want to enable blosc, and if so, search for the library. 
AC_MSG_CHECKING([whether to search for and enable blosc filter support])
AC_ARG_ENABLE([filter-blosc],
               [AS_HELP_STRING([--disable-filter-blosc],
                               [disable blosc filter support.])])
test "x$enable_filter_blosc" = xno || enable_filter_blosc=yes
AC_MSG_RESULT($enable_filter_blosc)

if test "x$enable_filter_blosc" = "xyes" ; then
   # See if we have libblosc
   AC_CHECK_LIB([blosc],[blosc_init],[have_blosc=yes],[have_blosc=no])
   if test "x$have_blosc" = "xyes" ; then
      AC_SEARCH_LIBS([blosc_init],[blosc blosc.dll cygblosc.dll], [], [])
      AC_DEFINE([HAVE_BLOSC], [1], [if true, blosc library is available])
   fi
else
   have_blosc=no
fi
##
# End blosc checks
##

##
# libzstd checks
##

# See if we want to enable libzstd, and if so, search for the library. 
AC_MSG_CHECKING([whether to search for and enable libzstd filter support])
AC_ARG_ENABLE([filter-zstd],
               [AS_HELP_STRING([--disable-filter-zstd],
                               [disable zstd filter support.])])
test "x$enable_filter_zstd" = xno || enable_filter_zstd=yes
AC_MSG_RESULT($enable_filter_zstd)

if test "x$enable_filter_zstd" = "xyes" ; then
   # See if we have libzstd
   AC_CHECK_LIB([zstd],[ZSTD_compress],[have_zstd=yes],[have_zstd=no])
   if test "x$have_zstd" = "xyes" ; then
      AC_SEARCH_LIBS([ZSTD_compress],[zstd zstd.dll cygzstd.dll], [], [])
      AC_DEFINE([HAVE_ZSTD], [1], [if true, zstd library is available])

   fi
   AC_MSG_CHECKING([whether libzstd library is available])
   AC_MSG_RESULT([${have_zstd}])

   ##
   # Ensure that the zstd.h dev files are also available.
   ##
   if test "x$have_zstd" = "xyes" ; then
      AC_CHECK_HEADERS([zstd.h], [], [nc_zstd_h_missing=yes])
      if test "x$nc_zstd_h_missing" = xyes; then
            AC_MSG_WARN([zstd library detected, but zstd.h development file not found. Ensure that the zstd development files are installed in order to build zstd support.])
            AC_DEFINE([HAVE_ZSTD], [0], [if true, zstd library is available])
            have_zstd=no
      fi
   fi

else
   have_zstd=no
fi
AC_MSG_CHECKING([whether we are going to build with zstd])
AC_SUBST([HAS_ZSTD], [$have_zstd])
AC_MSG_RESULT([$have_zstd])

##
# End zstd checks
##

##
# Begin bz2 checks
##

# See if we want to enable BZ2, and if so, search for the library. 
AC_MSG_CHECKING([whether to search for and enable external bz2 filter support])
AC_ARG_ENABLE([filter-bz2],
               [AS_HELP_STRING([--disable-filter-bz2],
                               [disable external bz2 filter support. bz2 support defaults to internal implementation if this is disabled or if the external library is not found.])])
test "x$enable_filter_bz2" = xno || enable_filter_bz2=yes
AC_MSG_RESULT([$enable_filter_bz2])

if test "x$enable_filter_bz2" = "xyes" ; then

   AC_CHECK_LIB([bz2],[BZ2_bzCompress],[have_bz2=yes],[have_bz2=no])
   if test "x$have_bz2" = "xyes" ; then
      AC_SEARCH_LIBS([BZ2_bzCompress],[bz2 bz2.dll cygbz2.dll], [], [])
      AC_DEFINE([HAVE_BZ2], [1], [if true, bz2 library is installed])
   fi
   AC_MSG_CHECKING([whether libbz2 library is available])
   AC_MSG_RESULT([${have_bz2}])

fi

# How about bzip2

if test "x$have_bz2" = x ; then

   AC_CHECK_LIB([bzip2],[BZ2_bzCompress],[have_bz2=yes],[have_bz2=no])
   if test "x$have_bz2" = "xyes" ; then
      AC_SEARCH_LIBS([BZ2_bzCompress],[bzip2 bzip2.dll cygbzip2.dll], [], [])
      AC_DEFINE([HAVE_BZ2], [1], [if true, bzip2 library is installed])
   fi
   AC_MSG_CHECKING([whether libbzip2 library is available])
   AC_MSG_RESULT([${have_bz2}])

fi

if test "x$have_bz2" = "xno" ; then
  have_local_bz2=yes
  AC_MSG_NOTICE([Defaulting to internal libbz2])
else
  have_local_bz2=no
fi

AM_CONDITIONAL(HAVE_LOCAL_BZ2, [test "x$have_local_bz2" = xyes])
##
# End bz2 checks
##

# Note that szip management is tricky.
# This is because we have three things to consider:
# 1. is libsz available?
# 2. is szip enabled in HDF5?
# 3. is nczarr enabled?
# We need separate flags for cases 1 and 2

# See if we have libsz (usually via libaec)
AC_CHECK_LIB([sz],[SZ_BufftoBuffCompress],[have_sz=yes],[have_sz=no])
if test "x$have_sz" = "xyes" ; then
   AC_SEARCH_LIBS([SZ_BufftoBuffCompress],[sz sz.dll cygsz.dll], [], [])
   AC_DEFINE([HAVE_SZ], [1], [if true, libsz (==szip) is available])
fi
AC_MSG_CHECKING([whether libsz library is available])
AC_MSG_RESULT([${have_sz}])

##########

## 
# Check to see if we're using NCZarr. If not, we don't need to check for dependencies and such.
##

if test "x$enable_nczarr" = xno ; then
   enable_nczarr_zip=no
else

   # See if we have libzip for NCZarr
   AC_SEARCH_LIBS([zip_open],[zip zip.dll cygzip.dll],[have_zip=yes],[have_zip=no])
   AC_MSG_CHECKING([whether libzip library is available])
   AC_MSG_RESULT([${have_zip}])
   enable_nczarr_zip=${have_zip} # alias

   AC_MSG_CHECKING([whether nczarr zip support is enabled])
   AC_MSG_RESULT([${enable_nczarr_zip}])

   if test "x$enable_nczarr_zip" = xyes ; then
   AC_DEFINE([NETCDF_ENABLE_NCZARR_ZIP], [1], [If true, then libzip found])
   fi

   # Check for enabling of S3 support
   AC_MSG_CHECKING([whether netcdf S3 support should be enabled])
   AC_ARG_ENABLE([s3],
               [AS_HELP_STRING([--enable-s3],
                                 [enable netcdf S3 support (default off)])])
   test "x$enable_s3" = xyes || enable_s3=no
   AC_MSG_RESULT($enable_s3)

   # --enable-nczarr-s3 is synonym for --enable-s3 (but...)
   AC_MSG_CHECKING([whether netcdf NCZarr S3 support should be enabled])
   AC_ARG_ENABLE([nczarr-s3],
               [AS_HELP_STRING([--enable-nczarr-s3],
                                 [(Deprecated) enable netcdf NCZarr S3 support; Deprecated in favor of --enable-s3])])
   AC_MSG_RESULT([$enable_nczarr_s3 (Deprecated) Please use --enable-s3)])

   # Set enable_s3 instead of enable_nczarr_s3
   if test "x$enable_s3" = xno && test "x$enable_nczarr_s3" = xyes ; then
   enable_s3=yes # back compatibility
   fi
   unset enable_nczarr_s3

   if test "x$enable_remote_functionality" = xno ; then
   AC_MSG_WARN([--disable-remote-functionality => --disable-s3])
   enable_s3=no
   fi

   # Note we check for the library after checking for enable_s3
   # because for some reason this fails if we unconditionally test for sdk
   # and it is not available. Fix someday
   S3LIBS=""
   if test "x$enable_s3" = xyes ; then
   # See if we have the s3 aws library
   # Check for the AWS S3 SDK library
      AC_LANG_PUSH([C++])
      AC_CHECK_LIB([aws-c-common], [aws_string_destroy], [enable_s3_aws=yes],[enable_s3_aws=no])
      if test "x$enable_s3_aws" = "xyes" ; then
         S3LIBS="-laws-cpp-sdk-core -laws-cpp-sdk-s3"
      fi
      AC_LANG_POP
   else
      enable_s3_aws=no
   fi

   AC_MSG_CHECKING([whether AWS S3 SDK library is available])
   AC_MSG_RESULT([$enable_s3_aws])

   # Check for enabling forced use of Internal S3 library
   AC_MSG_CHECKING([whether internal S3 support should be used])
   AC_ARG_ENABLE([s3-internal],
               [AS_HELP_STRING([--enable-s3-internal],
                                 [enable internal S3 support])])
   test "x$enable_s3_internal" = xyes || enable_s3_internal=no
   AC_MSG_RESULT($enable_s3_internal)

   if test "x$enable_s3_aws" = xno && test "x$enable_s3_internal" = xno ; then
   AC_MSG_WARN([No S3 library available => S3 support disabled])
   enable_s3=no
   fi

   if test "x$enable_s3_aws" = xyes && test "x$enable_s3_internal" = xyes ; then
   AC_MSG_WARN([Both aws-sdk-cpp and s3-internal enabled => use s3-internal.])
   enable_s3_aws=no
   fi

   if test "x$enable_s3_internal" = xyes ; then
   if test "x$ISOSX" != xyes && test "x$ISMINGW" != xyes && test "x$ISMSVC" != xyes ; then
   # Find crypto libraries if using ssl
   AC_CHECK_LIB([ssl],[ssl_create_cipher_list])
   AC_CHECK_LIB([crypto],[SHA256])
   fi
   fi

   # Check for enabling S3 testing
   AC_MSG_CHECKING([what level of netcdf S3 testing should be enabled])
   AC_ARG_WITH([s3-testing],
               [AS_HELP_STRING([--with-s3-testing=yes|no|public],
                                 [control netcdf S3 testing])],
               [], [with_s3_testing=public])
   AC_MSG_RESULT($with_s3_testing)

   # Disable S3 tests if S3 support is disabled
   if test "x$enable_s3" = xno ; then
   if test "x$with_s3_testing" != xno ; then
      AC_MSG_WARN([S3 support is disabled => no testing])
      with_s3_testing=no
   fi
   fi

   if test "x$enable_s3" = xyes ; then
   AC_DEFINE([NETCDF_ENABLE_S3], [1], [if true, build netcdf-c with S3 support enabled])
   fi

   if test "x$enable_s3_aws" = xyes ; then
      LIBS="$LIBS$S3LIBS"
      AC_DEFINE([NETCDF_ENABLE_S3_AWS], [1], [If true, then use aws S3 library])
   fi

   if test "x$enable_s3_internal" = xyes ; then
      AC_DEFINE([NETCDF_ENABLE_S3_INTERNAL], [1], [If true, then use internal S3 library])
   fi

   AC_DEFINE_UNQUOTED([WITH_S3_TESTING], [$with_s3_testing], [control S3 testing.])

   if test "x$with_s3_testing" = xyes ; then
   AC_MSG_WARN([*** DO NOT SPECIFY WITH_S3_TESTING=YES UNLESS YOU HAVE ACCESS TO THE UNIDATA S3 BUCKET! ***])
   AC_DEFINE([NETCDF_ENABLE_S3_TESTALL], [yes], [control S3 testing.])
   fi
fi

# 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(NETCDF_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 resources
                              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

# 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

if test "x$enable_doxygen" != xno; then
   # Is doxygen installed? If so, have configure construct the Doxyfile.
   AC_CHECK_PROGS([DOXYGEN], [doxygen])
   if test -z "$DOXYGEN"; then
      AC_MSG_ERROR([Doxygen not found - install doxygen or build without --enable-doxygen])
   fi
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_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 time.h dirent.h stdint.h ctype.h sys/xattr_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])

# 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 strlcpy])

# See if clock_gettime is available and its arg types.
AC_CHECK_FUNCS([clock_gettime])
AC_CHECK_TYPES([struct timespec])

# disable dap4 if hdf5 is disabled
if test "x$enable_hdf5" = "xno" ; then
    AC_MSG_WARN([hdf5 not enabled; disabling DAP4])
    enable_dap4=no
fi

if test "x$enable_dap4" = xyes; then
   AC_DEFINE([NETCDF_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
  if test "x$enable_mmap" = xyes ; then
     AC_MSG_WARN([mmap functionality is not available: disabling mmap])
  else
     AC_MSG_NOTICE([mmap functionality is not available: disabling mmap])
  fi
  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



if test "x$enable_remote_functionality" = xno ; then
  AC_MSG_WARN([--disable-remote-functionality => --disable-byterange])
  enable_byterange=no
fi


# Does the user want to disable atexit?
AC_MSG_CHECKING([whether nc_finalize should be invoked at exit])
AC_ARG_ENABLE([atexit-finalize],
               [AS_HELP_STRING([--disable-atexit-finalize],
                               [disable invoking nc_finalize at exit])])
test "x$enable_atexit_finalize" = xno || enable_atexit_finalize=yes
AC_MSG_RESULT($enable_atexit_finalize)

# Check for atexit
AC_CHECK_FUNCS([atexit])

# If no atexit, then disable atexit finalize
if test "x$enable_atexit_finalize" = xyes ; then
  if test "x$ac_cv_func_function" = xno ; then
    enable_atexit_finalize=no
    AC_MSG_ERROR([atexit() required for enable-atexit-finalize.])
  fi
fi

if test "x$enable_atexit_finalize" = xyes ; then
  AC_DEFINE([NETCDF_ENABLE_ATEXIT_FINALIZE], [1], [If true, enable nc_finalize via atexit()])
fi

# Need libdl(d) for plugins
AC_CHECK_LIB([dl],[dlopen],[have_libdld=yes],[have_libdld=no])
if test "x$have_libdld" = "xyes" ; then
   AC_SEARCH_LIBS([dlopen],[dl dld], [],[])
fi

# Does the user want plugins?
AC_MSG_CHECKING([whether dynamically loaded plugins is enabled])
AC_ARG_ENABLE([plugins],
              [AS_HELP_STRING([--disable-plugins],
                              [disallow dynamically loaded plugins])])
test "x$enable_plugins" = xno || enable_plugins=yes
AC_MSG_RESULT([$enable_plugins])
if test "x$have_libdld" = xno && test "x$ISMSVC" = xno; then
  enable_plugins=no
  AC_MSG_WARN([libdld required for enable-plugins.])
fi
if test "x$enable_plugins" = xyes && test "x$enable_shared" = xno; then
    AC_MSG_WARN([--disable-shared => --disable-plugins])
    enable_plugins=no
fi

if test "x$enable_plugins" = xyes; then
    AC_DEFINE([NETCDF_ENABLE_PLUGINS], [1], [if true, support dynamically loaded plugins])
fi
AM_CONDITIONAL(NETCDF_ENABLE_PLUGINS, [test "x$enable_plugins" = xyes])
AC_SUBST(USEPLUGINS, [${enable_plugins}])

AC_FUNC_ALLOCA
AC_CHECK_DECLS([isnan, isinf, isfinite],,,[#include <math.h>])
AC_CHECK_MEMBERS([struct stat.st_blksize])
AC_CHECK_TYPES([size_t, ssize_t, schar, uchar, longlong, ushort, uint, int64, uint64, size64_t, ssize64_t, _off64_t, uint64_t, ptrdiff_t])
AC_TYPE_OFF_T
AC_TYPE_UINTPTR_T
AC_C_CHAR_UNSIGNED
AC_C_BIGENDIAN

AC_CHECK_TYPES([mode_t])

AM_CONDITIONAL(ISCYGWIN, [test "x$ISCYGWIN" = xyes])
AM_CONDITIONAL(ISMSVC, [test "x$ISMSVC" = xyes])
AM_CONDITIONAL(ISOSX, [test "x$ISOSX" = xyes])
AM_CONDITIONAL(ISMINGW, [test "x$ISMINGW" = xyes])
AM_CONDITIONAL(ISMSYS, [test "x$ISMSYS" = xyes])

AC_SUBST([ISMSVC], [${ISMSVC}])
  AC_SUBST([WINVERMAJOR], [${WINVERMAJOR}])
  AC_SUBST([WINVERBUILD], [${WINVERBUILD}])
AC_SUBST([ISCYGWIN], [${ISCYGWIN}])
AC_SUBST([ISOSX], [${ISOSX}])
AC_SUBST([ISMINGW], [${ISMINGW}])
AC_SUBST([ISMSYS], [${ISMSYS}])

if test "x$ISMSVC" != x ; then REGEDIT=yes; fi
if test "x$ISMSYS" != x ; then REGEDIT=yes; fi
if test "x$ISCYGWIN" != x ; then REGEDIT=yes; fi
if test "x$REGEDIT" = xyes; then
  AC_DEFINE([REGEDIT], 1, [dreg.c usable])
fi
AM_CONDITIONAL(REGEDIT, [test "x$REGEDIT" = xyes])
AC_SUBST([ISREGEDIT], [yes])

###
# Crude hack to work around an issue
# in Cygwin.
###
SLEEPCMD=""
if test "x$ISCYGWIN" = "xyes"; then
   SLEEPCMD="sleep 5"
   AC_MSG_NOTICE([Pausing between sizeof() checks to mitigate a Cygwin issue.])
fi

$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([NETCDF_ENABLE_CDF5], [1], [if true, enable CDF5 Support])
fi
AM_CONDITIONAL(NETCDF_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*])

# Check for deflate library
AC_SEARCH_LIBS([deflate], [zlibwapi zlibstat zlib zlib1 z], [have_deflate=yes], [have_deflate=no])
AC_MSG_CHECKING([whether deflate library is available])
AC_MSG_RESULT([${have_deflate}])

if test "x$have_deflate" = xno ; then
  AC_MSG_ERROR([Can't find or link to the z library. Turn off netCDF-4 and \
                DAP and NCZarr clients with --disable-hdf5 --disable-dap --disable-nczarr, or see config.log for errors.])
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_netcdf4" = xyes; then
   AC_DEFINE([USE_NETCDF4], [1], [if true, build netCDF-4])
fi

# Set defaults
hdf5_parallel=no
hdf5_supports_par_filters=no
enable_hdf5_szip=no
has_hdf5_ros3=no

if test "x$enable_hdf5" = xyes; then
   AC_DEFINE([NETCDF_ENABLE_HDF5], [1], [if true, use HDF5])
   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], [hdf5 hdf5.dll], [],
   [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_hl hdf5_hl.dll], [],
   [AC_MSG_ERROR([Can't find or link to the hdf5 library. 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 H5Pset_all_coll_metadata_ops H5Literate H5Literate2])

   # 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])

   # See if H5Dread_chunk is available
   AC_SEARCH_LIBS([H5Dread_chunk],[hdf5_hldll hdf5_hl], [has_readchunks=yes], [has_readdhunks=no])

   # See if hdf5 library supports Read-Only S3 (byte-range) driver
   AC_SEARCH_LIBS([H5Pset_fapl_ros3],[hdf5_hldll hdf5_hl], [has_hdf5_ros3=yes], [has_hdf5_ros3=no])
   if test "x$has_hdf5_ros3" = xyes && test "x$enable_byterange" = xyes; then
    AC_DEFINE([NETCDF_ENABLE_HDF5_ROS3], [1], [if true, support byte-range using hdf5 virtual file driver.])
   fi

   # 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$has_readchunks" = 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([$has_readchunks])

   # 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_hdf5_szip=yes
      AC_DEFINE([HAVE_H5Z_SZIP], [1], [if true, compile in szip compression in netCDF-4 variables])
   fi
   AC_MSG_RESULT([$enable_hdf5_szip])

   # Check to see if HDF5 library is 1.10.6 or greater.
   # Used to control path name conversion
   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <H5public.h>]], [[
#if (H5_VERS_MAJOR*10000 + H5_VERS_MINOR*100 + H5_VERS_RELEASE < 11006)
      choke me
#endif
  ]])], [hdf5_version_1106=yes], [hdf5_version_1106=no])
  AC_MSG_CHECKING([whether HDF5 library is version 1.10.6 or later])
  AC_MSG_RESULT([$hdf5_version_1106])
  if test "x$hdf5_version_1106" = xyes; then
      AC_DEFINE([HDF5_UTF8_PATHS], [1], [if true, HDF5 paths can be utf-8])
   fi

fi

AM_CONDITIONAL(ENABLE_NCDUMPCHUNKS, [test "x$has_readchunks" = xyes ])

# 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(NETCDF_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)

# No logging for netcdf-3.
if test "x$enable_netcdf4" = xno; then
   enable_logging=no
fi
if test "x$enable_logging" = xyes; then
   AC_DEFINE([LOGGING], 1, [If true, turn on logging.])
fi

# Control NCZarr filters
# Does the user want to use NCZarr filters?
AC_MSG_CHECKING([whether we should enable NCZarr filters])
AC_ARG_ENABLE([nczarr-filters], [AS_HELP_STRING([--disable-nczarr-filters],
              [disable NCZarr filters])])
test "x$enable_nczarr_filters" = xno || enable_nczarr_filters=yes
AC_MSG_RESULT([$enable_nczarr_filters])

# 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 HDF5|NCZarr])])
test "x$enable_filter_testing" = xno || enable_filter_testing=yes
AC_MSG_RESULT($enable_filter_testing)

# Apply constraints
if test "x$enable_plugins" = xno ; then
AC_MSG_WARN([--disable-plugins => --disable-nczarr-filters])
enable_nczarr_filters=no
fi

if test "x$enable_plugins" = xno ; then
AC_MSG_WARN([--disable-plugins => --disable-filter-testing])
enable_filter_testing=no
fi

if test "x$enable_nczarr" = xno; then
AC_MSG_WARN([--disable-nczarr => --disable-nczarr-filters])
enable_nczarr_filters=no
fi

if test "x$enable_nczarr_filters" = xyes; then
   AC_DEFINE([NETCDF_ENABLE_NCZARR_FILTERS], [1], [if true, enable NCZarr filters])
fi

AM_CONDITIONAL(NETCDF_ENABLE_FILTER_TESTING, [test x$enable_filter_testing = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_NCZARR_FILTERS, [test x$enable_nczarr_filters = xyes])

# 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(NETCDF_ENABLE_DAP, [test "x$enable_dap" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_DAP4, [test "x$enable_dap4" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_LEGACY_MACROS, [test "x$netcdf_enable_legacy_macros" = xyes])
AM_CONDITIONAL(USE_STRICT_NULL_BYTE_HEADER_PADDING, [test x$enable_strict_null_byte_header_padding = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_CDF5, [test "x$enable_cdf5" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_DAP_REMOTE_TESTS, [test "x$enable_dap_remote_tests" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_EXTERNAL_SERVER_TESTS, [test "x$enable_external_server_tests" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_DAP_AUTH_TESTS, [test "x$enable_dap_auth_tests" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_DAP_LONG_TESTS, [test "x$enable_dap_long_tests" = 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_netcdf4 = 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_netcdf4 = xyes -o x$enable_dap = 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(NETCDF_ENABLE_METADATA_PERF, [test x$enable_metadata_perf = xyes])
AM_CONDITIONAL(NETCDF_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(NETCDF_ENABLE_NCZARR_FILTERS, [test x$enable_nczarr_filters = xyes])
# We need to simplify the set of S3 and Zarr flag combinations
AM_CONDITIONAL(NETCDF_ENABLE_S3, [test "x$enable_s3" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_S3_AWS, [test "x$enable_s3_aws" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_S3_INTERNAL, [test "x$enable_s3_internal" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_NCZARR, [test "x$enable_nczarr" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_S3_TESTPUB, [test "x$with_s3_testing" != xno]) # all => public
AM_CONDITIONAL(NETCDF_ENABLE_S3_TESTALL, [test "x$with_s3_testing" = xyes])
AM_CONDITIONAL(NETCDF_ENABLE_NCZARR_ZIP, [test "x$enable_nczarr_zip" = xyes])
AM_CONDITIONAL(HAVE_DEFLATE, [test "x$have_deflate" = xyes])
AM_CONDITIONAL(HAVE_SZ, [test "x$have_sz" = xyes])
AM_CONDITIONAL(HAVE_H5Z_SZIP, [test "x$enable_hdf5_szip" = xyes])
AM_CONDITIONAL(HAVE_BLOSC, [test "x$have_blosc" = xyes])
AM_CONDITIONAL(HAVE_BZ2, [test "x$have_bz2" = xyes])
AM_CONDITIONAL(HAVE_ZSTD, [test "x$have_zstd" = xyes])

# If the machine doesn't have a long long, and we want netCDF-4, then
# we've got problems!
if test "x$enable_netcdf4" = 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_netcdf4" = 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])
NOUNDEFINED=""
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"
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"


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_LEGACY_MACROS,[$enable_legacy_macros])
AC_SUBST(HAS_NC2,[$nc_build_v2])
AC_SUBST(HAS_NC4,[$enable_netcdf4])
AC_SUBST(HAS_CDF5,[$enable_cdf5])
AC_SUBST(HAS_HDF4,[$enable_hdf4])
AC_SUBST(HAS_BENCHMARKS,[$enable_benchmarks])
AC_SUBST(HAS_HDF5,[$enable_hdf5])
AC_SUBST(HAS_PNETCDF,[$enable_pnetcdf])
AC_SUBST(HAS_LOGGING, [$enable_logging])
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_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_S3,[$enable_s3])
AC_SUBST(HAS_S3_AWS,[$enable_s3_aws])
AC_SUBST(HAS_S3_INTERNAL,[$enable_s3_internal])
AC_SUBST(HAS_HDF5_ROS3,[$has_hdf5_ros3])
AC_SUBST(HAS_NCZARR,[$enable_nczarr])
AC_SUBST(NETCDF_ENABLE_S3_TESTING,[$with_s3_testing])
AC_SUBST(HAS_NCZARR_ZIP,[$enable_nczarr_zip])
AC_SUBST(HAS_PLUGINS, [$enable_plugins])
AC_SUBST(HAS_QUANTIZE,[$enable_quantize])
AC_SUBST(HAS_LOGGING,[$enable_logging])
AC_SUBST(DO_FILTER_TESTS,[$enable_filter_testing])
AC_SUBST(HAS_DEFLATE,[$have_deflate])
AC_SUBST(HAS_SZLIB,[$have_sz])
AC_SUBST(HAS_SZLIB_WRITE, [$have_sz])
AC_SUBST(HAS_ZSTD,[$have_zstd])
AC_SUBST(DO_LARGE_TESTS,[$enable_large_file_tests])
AC_SUBST(DO_REMOTE_FUNCTIONALITY,[$enable_remote_functionality])

if test "x$enable_s3_aws" = xyes ; then
AC_SUBST(WHICH_S3_SDK,[aws-sdk-cpp])
fi
if test "x$enable_s3_internal" = xyes; then
AC_SUBST(WHICH_S3_SDK,[internal])
fi
if test "x$enable_s3_aws" = xno && test "x$enable_s3_internal" = xno; then
AC_SUBST(WHICH_S3_SDK,[none])
fi

# The Unidata testing S3 bucket
# WARNING: this must match the value in CMakeLists.txt
AC_DEFINE([S3TESTBUCKET], ["unidata-zarr-test-data"], [S3 test bucket])
AC_SUBST([S3TESTBUCKET],["unidata-zarr-test-data"])

# The working S3 path tree within the Unidata bucket.
# WARNING: this must match the value in CMakeLists.txt
AC_DEFINE([S3TESTSUBTREE], ["netcdf-c"], [S3 test path prefix])
AC_SUBST([S3TESTSUBTREE],[netcdf-c])

# Build a small unique id to avoid interference on same platform
PLATFORMUID="$RANDOM"
# Make sure uid > 0
PLATFORMUID=$((PLATFORMUID % 1000 + 1))
# Build a unique id based on the date
TESTUID=`date +%s`
AC_DEFINE_UNQUOTED([TESTUID], [${TESTUID}], [S3 working path])
AC_SUBST([TESTUID],${TESTUID})
AC_SUBST([PLATFORMUID],${PLATFORMUID})

# Always available
std_filters="bz2"
if test "x$have_deflate" = xyes ; then
std_filters="${std_filters} deflate"
fi
if test "x$have_sz" = xyes ; then
std_filters="${std_filters} szip"
fi
if test "x$have_blosc" = xyes ; then
std_filters="${std_filters} blosc"
fi
if test "x$have_zstd" = xyes ; then
std_filters="${std_filters} zstd"
fi

AC_SUBST(STD_FILTERS,[$std_filters])

# The --with-plugin-dir option gives the user control of the plugin install
# directory. This also used as one of the default plugin directory when
# searching for plugins.
# If a specific directory is provided, it will be used.
# If not defined or defined with the value no, or --without-plugin-dir, then
# plugin installation will be suppressed (but see below).
AC_MSG_CHECKING([whether and where we should install plugins])
AC_ARG_WITH([plugin-dir], [AS_HELP_STRING([--with-plugin-dir=<absolute directory>|no|--without-plugin-dir],
              [Install selected standard filters in specified or default directory])],
	      [],[with_plugin_dir=no])
AC_MSG_RESULT([$with_plugin_dir])

# Using selected filter options forces installation
if test "x$have_zstd" = xyes; then
    AC_MSG_WARN([--enable_filter-zstd => --enable-plugins.])
    enable_plugins=yes
fi

# Note: the term PLATFORMDEFAULT stands for:
# -- /usr/loca/hdf5/lib/plugin If on a *nix* machine
# -- %ALLUSERSPROFILE%/hdf5/lib/plugins If on a windows or Mingw platform
if test "x$ISMSVC" = xyes || test "x$ISMINGW" = xyes; then
    PLATFORMDEFAULT="${ALLUSERSPROFILE}\\hdf5\\lib\\plugin"
    PLATFORMSEP=";"
else
    PLATFORMDEFAULT="/usr/local/hdf5/lib/plugin"
    PLATFORMSEP=":"
fi

# Internally, the variable DEFAULT_PLUGIN_INSTALL_DIR is the default
# directory into which plugins are installed; this may be undefined if
# plugin installation is disabled (the usual case). It is exported as
# NETCDF_PLUGIN_INSTALL_DIR.
#
# Similarly the variable DEFAULT_PLUGIN_SEARCH_PATH is the default list
# of directories to search to locate plugins. It is exported as
# NETCDF_PLUGIN_SEARCH_PATH
#
# See the document docs/pluginpath.md for a more detailed discussion
# of how NETCDF_PLUGIN_INSTALL_DIR and NETCDF_PLUGIN_SEARCH_PATH are
# computed.

# Canonicalize --with-prefix-dir and --prefix
if test "x$with_plugin_dir" = xno ; then unset with_plugin_dir ; fi
if test "xprefix" = x ; then prefix=NONE ; fi
if test "x$with_plugin_dir" != x ; then  # Table row 3
    DEFAULT_PLUGIN_INSTALL_DIR="${with_plugin_dir}"
    DEFAULT_PLUGIN_SEARCH_PATH="${with_plugin_dir}${PLATFORMSEP}${PLATFORMDEFAULT}"
elif test "x$prefix" != xNONE ; then  # Table row 2
    DEFAULT_PLUGIN_INSTALL_DIR="${prefix}/hdf5/lib/plugin"
    DEFAULT_PLUGIN_SEARCH_PATH="${prefix}/hdf5/lib/plugin${PLATFORMSEP}${PLATFORMDEFAULT}"
else # Table row 1
    unset DEFAULT_PLUGIN_INSTALL_DIR
    DEFAULT_PLUGIN_SEARCH_PATH="${PLATFORMDEFAULT}"
fi
# canonical form is all forward slashes
DEFAULT_PLUGIN_INSTALL_DIR=`echo "$DEFAULT_PLUGIN_INSTALL_DIR" | tr '\\\\' '/'`
DEFAULT_PLUGIN_SEARCH_PATH=`echo "$DEFAULT_PLUGIN_SEARCH_PATH" | tr '\\\\' '/'`

# Inferences
if test "x$DEFAULT_PLUGIN_INSTALL_DIR" = x ; then # option missing|disabled
    enable_plugin_dir=no
else
    enable_plugin_dir=yes
fi

if test "x$enable_plugin_dir" = xyes ; then
  AC_DEFINE([ENABLE_PLUGIN_DIR], [1], [If true, enable filter installation])
fi

AM_CONDITIONAL([ENABLE_PLUGIN_DIR], [test "x$enable_plugin_dir" = xyes])
AC_DEFINE_UNQUOTED([NETCDF_PLUGIN_INSTALL_DIR], ["${DEFAULT_PLUGIN_INSTALL_DIR}"], [Final Install Dir])
AC_DEFINE_UNQUOTED([NETCDF_PLUGIN_SEARCH_PATH], ["${DEFAULT_PLUGIN_SEARCH_PATH}"], [Final Search Path])
AC_SUBST([NETCDF_PLUGIN_INSTALL_DIR], [${DEFAULT_PLUGIN_INSTALL_DIR}])
AC_SUBST([NETCDF_PLUGIN_SEARCH_PATH], [${DEFAULT_PLUGIN_SEARCH_PATH}])

# 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_HDF4],[$enable_hdf4],[yes])
AX_SET_META([NC_HAS_BENCHMARKS],[$enable_benchmarks],[yes])
AX_SET_META([NC_HAS_HDF5],[$enable_hdf5],[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_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_S3],[$enable_s3],[yes])
AX_SET_META([NC_HAS_S3_AWS],[$enable_s3_aws],[yes])
AX_SET_META([NC_HAS_S3_INTERNAL],[$enable_s3_internal],[yes])
AX_SET_META([NC_HAS_HDF5_ROS3],[$has_hdf5_ros3],[yes])
AX_SET_META([NC_HAS_NCZARR],[$enable_nczarr],[yes])
AX_SET_META([NC_HAS_LOGGING],[$enable_logging],[yes])
AX_SET_META([NC_HAS_QUANTIZE],[$enable_quantize],[yes])
AX_SET_META([NC_HAS_SZIP],[$enable_hdf5_szip],[yes])
AX_SET_META([NC_HAS_ZSTD],[$have_zstd],[yes])
AX_SET_META([NC_HAS_BLOSC],[$have_blosc],[yes])
AX_SET_META([NC_HAS_BZ2],[$have_bz2],[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], [5])
AC_DEFINE_UNQUOTED([NC_DISPATCH_VERSION], [${NC_DISPATCH_VERSION}], [Dispatch table version.])

#####
# End netcdf_meta.h definitions.
#####

# This would be true for a cmake build.
AC_SUBST([ISCMAKE], [])

# Provide  true/false conditionals to temporarily suppress tests and such
AM_CONDITIONAL([AX_DISABLE], [test xno = xyes])
AM_CONDITIONAL([AX_ENABLE], [test xyes = xyes])
# Provide  conditional to identify tests that must be run manually
AM_CONDITIONAL([AX_MANUAL], [test xno = xyes])

AC_MSG_NOTICE([generating header files and makefiles])
AC_CONFIG_FILES(test_common.sh:test_common.in)
AC_CONFIG_FILES(s3cleanup.sh:s3cleanup.in, [chmod ugo+x s3cleanup.sh])
AC_CONFIG_FILES(s3gc.sh:s3gc.in, [chmod ugo+x s3gc.sh])
for FP in plugins nc_test4 nczarr_test h5_test examples/C ; do
AC_CONFIG_FILES(${FP}/findplugin.sh:plugins/findplugin.in, [chmod ugo+x ${FP}/findplugin.sh])
done
AC_CONFIG_FILES(ncdap_test/findtestserver.c:ncdap_test/findtestserver.c.in, [chmod ugo+x ncdap_test/findtestserver.c])
AC_CONFIG_FILES([nc_test/run_pnetcdf_tests.sh:nc_test/run_pnetcdf_tests.sh.in],[chmod ugo+x nc_test/run_pnetcdf_tests.sh])
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_test4/run_par_warn_test.sh], [chmod ugo+x nc_test4/run_par_warn_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(nczarr_test/timer_utils.h:unit_test/timer_utils.h)
AC_CONFIG_FILES(nczarr_test/timer_utils.c:unit_test/timer_utils.c)
AC_CONFIG_FILES(nczarr_test/test_filter.c:nc_test4/test_filter.c)
AC_CONFIG_FILES(nczarr_test/test_filter_misc.c:nc_test4/test_filter_misc.c)
AC_CONFIG_FILES(nczarr_test/tst_multifilter.c:nc_test4/tst_multifilter.c)
AC_CONFIG_FILES(nczarr_test/test_filter_repeat.c:nc_test4/test_filter_repeat.c)
AC_CONFIG_FILES(nczarr_test/test_filter_order.c:nc_test4/test_filter_order.c)
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
                 include/netcdf_meta.h
                 include/netcdf_dispatch.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
                 libncpoco/Makefile
                 libncxml/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
                 ncdap_test/expectedhyrax/Makefile
                 dap4_test/Makefile
                 plugins/Makefile
		 nczarr_test/Makefile
                 ])
AC_OUTPUT()

cat libnetcdf.settings
