mirror/netcdf-c
2
0
Fork 0
mirror of https://github.com/Unidata/netcdf-c.git synced 2024-11-21 03:13:42 +08:00
Code Issues Packages Projects Releases Wiki Activity
c5c2d931cc
netcdf-c/CMakeLists.txt
مهدي شينون (Mehdi Chinoune) 8d6ba9ffcb
CMake: Enable plugins on MinGW
2024-05-01 11:02:04 +01:00

1852 lines
62 KiB
CMake
Raw Blame History

## This is a CMake file, part of Unidata's netCDF package.
# Copyright 2012-2018, see the COPYRIGHT file for more information.
#
##################################
# Set Project Properties
##################################
cmake_minimum_required(VERSION 3.20.0)
#Project Name
project(netCDF
LANGUAGES C CXX
HOMEPAGE_URL "https://www.unidata.ucar.edu/software/netcdf/"
DESCRIPTION "NetCDF is a set of software libraries and machine-independent data formats that support the creation, access, and sharing of array-oriented scientific data."
VERSION 4.9.3
)
#Add custom CMake Module
set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules/;${PROJECT_SOURCE_DIR}/cmake"
CACHE INTERNAL "Location of our custom CMake modules.")
set(PACKAGE "netCDF" CACHE STRING "")
include(netcdf_functions_macros)
include(deprecated)
# Backport of built-in `PROJECT_IS_TOP_LEVEL` from CMake 3.21
if (NOT DEFINED NETCDF_IS_TOP_LEVEL)
set(NETCDF_IS_TOP_LEVEL OFF)
if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
set(NETCDF_IS_TOP_LEVEL ON)
endif ()
endif ()
################################
# The target
################################
##
# Default building shared libraries.
# BUILD_SHARED_LIBS is provided by/used by
# CMake directly.
##
option(BUILD_SHARED_LIBS "Configure netCDF as a shared library." ON)
if(BUILD_SHARED_LIBS)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
endif()
add_library(netcdf)
add_library(netCDF::netcdf ALIAS netcdf)
#####
# Version Info:
#
# Release Version
# Library Version
# SO Version
#
# SO Version is computed from library version. See:
# http://www.gnu.org/software/libtool/manual/libtool.html#Libtool-versioning
#####
set(NC_VERSION_NOTE "-development")
set(netCDF_VERSION ${PROJECT_VERSION}${NC_VERSION_NOTE})
set(VERSION ${netCDF_VERSION})
set(NC_VERSION ${netCDF_VERSION})
set(PACKAGE_VERSION ${VERSION})
# These values should match those in configure.ac
set(netCDF_LIB_VERSION 19)
set(netCDF_SO_VERSION 19)
# Version of the dispatch table. This must match the value in
# configure.ac.
set(NC_DISPATCH_VERSION 5)
# Get system configuration, Use it to determine osname, os release, cpu. These
# will be used when committing to CDash.
find_program(UNAME NAMES uname)
if(UNAME)
getuname(osname -s)
getuname(osrel -r)
getuname(cpu -m)
set(TMP_BUILDNAME "${osname}-${osrel}-${cpu}")
endif()
# Define some Platforms
if(osname MATCHES "CYGWIN.*")
set(ISCYGWIN yes)
endif()
if(osname MATCHES "Darwin.*")
set(ISOSX yes)
endif()
if(MSVC)
set(ISMSVC yes)
endif()
if(osname MATCHES "MINGW.*" OR osname MATCHES "MSYS.*")
set(ISMINGW yes)
set(MINGW yes)
endif()
###
# Allow for some customization of the buildname.
# This will make it easier to identify different builds,
# based on values passed from command line/shell scripts.
#
# For ctest scripts, we can use CTEST_BUILD_NAME.
###
set(BUILDNAME_PREFIX "" CACHE STRING "")
set(BUILDNAME_SUFFIX "" CACHE STRING "")
if(BUILDNAME_PREFIX)
set(TMP_BUILDNAME "${BUILDNAME_PREFIX}-${TMP_BUILDNAME}")
endif()
if(BUILDNAME_SUFFIX)
set(TMP_BUILDNAME "${TMP_BUILDNAME}-${BUILDNAME_SUFFIX}")
endif()
if(NOT BUILDNAME)
set(BUILDNAME "${TMP_BUILDNAME}" CACHE STRING "Build name variable for CDash")
endif()
###
# End BUILDNAME customization.
###
# For CMAKE_INSTALL_LIBDIR
include(GNUInstallDirs)
if(MSVC)
set(GLOBAL PROPERTY USE_FOLDERS ON)
target_compile_options(netcdf PUBLIC "/utf-8")
endif()
# auto-configure style checks, other CMake modules.
include(CheckLibraryExists)
include(CheckIncludeFile)
include(CheckIncludeFiles)
include(CheckTypeSize)
include(CheckFunctionExists)
include(CheckCXXSourceCompiles)
include(CheckCSourceCompiles)
include(TestBigEndian)
include(CheckSymbolExists)
include(GetPrerequisites)
include(CheckCCompilerFlag)
# A check to see if the system is big endian
TEST_BIG_ENDIAN(BIGENDIAN)
if(${BIGENDIAN})
set(WORDS_BIGENDIAN "1")
endif(${BIGENDIAN})
# Define a function to convert various true or false values
# to either TRUE|FALSE (uppercase).
# If value is not a recognized boolean, then return NOTFOUND
#1, ON, YES, TRUE, Y,
#0, OFF, NO, FALSE, N, IGNORE, NOTFOUND -NOTFOUND ""
set(TRUELIST "on;yes;y;true")
set(FALSELIST "off;no;n;false;0;ignore;notfound")
# Set the build type.
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE DEBUG CACHE STRING "Choose the type of build, options are: None, Debug, Release."
FORCE)
endif()
# Set build type uppercase
string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE)
# Determine the configure date.
if(DEFINED ENV{SOURCE_DATE_EPOCH})
execute_process(
COMMAND "date" "-u" "-d" "@$ENV{SOURCE_DATE_EPOCH}"
OUTPUT_VARIABLE CONFIG_DATE
)
else()
execute_process(
COMMAND date
OUTPUT_VARIABLE CONFIG_DATE
)
endif()
if(CONFIG_DATE)
string(STRIP ${CONFIG_DATE} CONFIG_DATE)
endif()
##
# Allow for extra dependencies.
##
set(EXTRA_DEPS "")
################################
# End Project Properties
################################
################################
# Set CTest Properties
################################
enable_testing()
include(CTest)
# Set Memory test program for non-MSVC based builds.
# Assume valgrind for now.
if((NOT MSVC) AND (NOT MINGW) AND (NOT ISCYGWIN))
set(CTEST_MEMORYCHECK_COMMAND valgrind CACHE STRING "")
endif()
# Set variable to define the build type.
include(GenerateExportHeader)
################################
# End CTest Properties
################################
################################
# Compiler and Linker Configuration
################################
option(NETCDF_FIND_SHARED_LIBS "Find dynamically-built versions of dependent libraries" ${BUILD_SHARED_LIBS})
##
# We've had a request to allow for non-versioned shared libraries.
# This seems reasonable enough to accommodate. See
# https://github.com/Unidata/netcdf-c/issues/228 for more info.
##
option(NETCDF_ENABLE_SHARED_LIBRARY_VERSION "Encode the library SO version in the file name of the generated library file." ON)
# Set some default linux gcc & apple compiler options for
# debug builds.
if(CMAKE_COMPILER_IS_GNUCC OR APPLE)
option(NETCDF_ENABLE_COVERAGE_TESTS "Enable compiler flags needed to perform coverage tests." OFF)
option(NETCDF_ENABLE_CONVERSION_WARNINGS "Enable warnings for implicit conversion from 64 to 32-bit datatypes." ON)
option(NETCDF_ENABLE_LARGE_FILE_TESTS "Enable large file tests." OFF)
# Debugging flags
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wall")
# Check to see if -Wl,--no-undefined is supported.
CHECK_C_LINKER_FLAG("-Wl,--no-undefined" LIBTOOL_HAS_NO_UNDEFINED)
if(LIBTOOL_HAS_NO_UNDEFINED)
set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} -Wl,--no-undefined")
endif()
set(CMAKE_REQUIRED_FLAGS "${TMP_CMAKE_REQUIRED_FLAGS}")
# Coverage tests need to have optimization turned off.
if(NETCDF_ENABLE_COVERAGE_TESTS)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -coverage -fprofile-arcs -ftest-coverage")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -coverage -fprofile-arcs -ftest-coverage")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
message(STATUS "Coverage Tests: On.")
endif()
# Warnings for 64-to-32 bit conversions.
if(NETCDF_ENABLE_CONVERSION_WARNINGS)
CHECK_C_COMPILER_FLAG(-Wconversion CC_HAS_WCONVERSION)
CHECK_C_COMPILER_FLAG(-Wshorten-64-to-32 CC_HAS_SHORTEN_64_32)
if(CC_HAS_SHORTEN_64_32)
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wshorten-64-to-32")
endif()
if(CC_HAS_WCONVERSION)
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wconversion")
endif()
endif(NETCDF_ENABLE_CONVERSION_WARNINGS)
endif(CMAKE_COMPILER_IS_GNUCC OR APPLE)
# End default linux gcc & apple compiler options.
# Use relative pathnames in __FILE__ macros on MINGW:
if(MINGW)
CHECK_C_COMPILER_FLAG("-fmacro-prefix-map='${CMAKE_SOURCE_DIR}'=." CC_HAS_MACRO_PREFIX_MAP)
if(CC_HAS_MACRO_PREFIX_MAP)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fmacro-prefix-map='${CMAKE_SOURCE_DIR}'=.")
endif()
endif()
# Suppress CRT Warnings.
# Only necessary for Windows
if(MSVC)
target_compile_definitions(netcdf PRIVATE _CRT_SECURE_NO_WARNINGS)
endif()
# Support ANSI format specifiers for *printf on MINGW:
if(MINGW)
target_compile_definitions(netcdf PRIVATE __USE_MINGW_ANSI_STDIO=1)
endif()
#####
# System inspection checks
#####
include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/oc2)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/libsrc)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}/libsrc)
################################
# End Compiler Configuration
################################
##
# Configuration for post-install RPath
# Adapted from http://www.cmake.org/Wiki/CMake_RPATH_handling
##
if(NOT WIN32 AND BUILD_SHARED_LIBS)
# use, i.e. don't skip the full RPATH for the build tree
set(CMAKE_SKIP_BUILD_RPATH FALSE)
# when building, don't use the install RPATH already
# (but later on when installing)
set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
if(APPLE)
set(CMAKE_MACOSX_RPATH ON)
endif(APPLE)
# add the automatically determined parts of the RPATH
# which point to directories outside the build tree to the install RPATH
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
# the RPATH to be used when installing,
# but only if it's not a system directory
list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}" isSystemDir)
if("${isSystemDir}" STREQUAL "-1")
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
endif("${isSystemDir}" STREQUAL "-1")
endif()
##
# End configuration for post-install RPath
##
################################
# Option checks
################################
# Default Cache variables.
set(DEFAULT_CHUNK_SIZE 16777216 CACHE STRING "Default Chunk Cache Size.")
set(DEFAULT_CHUNK_CACHE_SIZE 16777216U CACHE STRING "Default Chunk Cache Size.")
set(DEFAULT_CHUNKS_IN_CACHE 1000 CACHE STRING "Default number of chunks in cache.")
set(DEFAULT_CHUNK_CACHE_PREEMPTION 0.75 CACHE STRING "Default file chunk cache preemption policy (a number between 0 and 1, inclusive.")
# HDF5 default cache size values
set(CHUNK_CACHE_SIZE ${DEFAULT_CHUNK_CACHE_SIZE} CACHE STRING "Default HDF5 Chunk Cache Size.")
set(CHUNK_CACHE_NELEMS ${DEFAULT_CHUNKS_IN_CACHE} CACHE STRING "Default maximum number of elements in cache.")
set(CHUNK_CACHE_PREEMPTION ${DEFAULT_CHUNK_CACHE_PREEMPTION} CACHE STRING "Default file chunk cache preemption policy for HDf5 files(a number between 0 and 1, inclusive.")
set(NETCDF_LIB_NAME "" CACHE STRING "Default name of the netcdf library.")
set(TEMP_LARGE "." CACHE STRING "Where to put large temp files if large file tests are run.")
set(NCPROPERTIES_EXTRA "" CACHE STRING "Specify extra pairs for _NCProperties.")
if(NOT NETCDF_LIB_NAME STREQUAL "")
set(MOD_NETCDF_NAME ON)
endif()
# Set the appropriate compiler/architecture for universal OSX binaries.
if(${CMAKE_SYSTEM_NAME} EQUAL "Darwin")
set(CMAKE_OSX_ARCHITECTURES i386;x86_64)
endif(${CMAKE_SYSTEM_NAME} EQUAL "Darwin")
# Option to use Static Runtimes in MSVC
if(MSVC)
option(NETCDF_USE_STATIC_CRT "Use static CRT Libraries ('\\MT')." OFF)
if(NETCDF_USE_STATIC_CRT)
set(USE_STATIC_CRT ON)
specify_static_crt_flag()
endif()
endif()
# Option to build netCDF Version 2
OPTION (ENABLE_V2_API "Build netCDF Version 2." ON)
set(BUILD_V2 ${ENABLE_V2_API})
if(NOT ENABLE_V2_API)
set(NO_NETCDF_2 ON)
else(NOT ENABLE_V2_API)
set(USE_NETCDF_2 TRUE)
endif(NOT ENABLE_V2_API)
# Option to build utilities
option(NETCDF_BUILD_UTILITIES "Build ncgen, ncgen3, ncdump." ON)
option(NETCDF_GENERATE_NCGEN "Automatically regenerate ncgen C files if required" OFF)
# Option to use MMAP
option(NETCDF_ENABLE_MMAP "Use MMAP." ON)
# Option to use examples.
option(NETCDF_ENABLE_EXAMPLES "Build Examples" ON)
###
# Allow the user to specify libraries
# to link against, similar to automakes 'LIBS' variable.
###
set(NC_EXTRA_DEPS "" CACHE STRING "Additional libraries to link against.")
if(NC_EXTRA_DEPS)
string(REPLACE " " ";" DEPS_LIST ${NC_EXTRA_DEPS})
foreach(_DEP ${DEPS_LIST})
string(REGEX REPLACE "^-l" "" _LIB ${_DEP})
FIND_LIBRARY("${_LIB}_DEP" NAMES "${_LIB}" "lib${_LIB}")
message(${${_LIB}_DEP})
if("${${_LIB}_DEP}" STREQUAL "${_LIB}_DEP-NOTFOUND")
message(FATAL_ERROR "Error finding ${_LIB}.")
else()
message(STATUS "Found ${_LIB}: ${${_LIB}_DEP}")
endif()
set(EXTRA_DEPS ${EXTRA_DEPS} "${${_LIB}_DEP}")
endforeach()
message("Extra deps: ${EXTRA_DEPS}")
list(REMOVE_DUPLICATES EXTRA_DEPS)
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${EXTRA_DEPS})
endif()
###
# End user-specified dependent libraries.
###
################################
# Format Option checks
################################
# We need to now treat enable-netcdf4 and enable-hdf5 as separate,
# but for back compatability, we need to treat enable-netcdf4
# as equivalent to enable-hdf5.
# We detect this using these rules:
# 1. if NETCDF_ENABLE_HDF5 is off then disable hdf5
# 2. if NETCDF_ENABLE_NETCDF_4 is off then disable hdf5
# 3. else enable hdf5
option(NETCDF_ENABLE_NETCDF_4 "Use HDF5." ON)
option(NETCDF_ENABLE_HDF5 "Use HDF5." ON)
if(NOT NETCDF_ENABLE_HDF5 OR NOT NETCDF_ENABLE_NETCDF_4)
set(NETCDF_ENABLE_HDF5 OFF CACHE BOOL "Use HDF5" FORCE)
endif()
option(NETCDF_ENABLE_HDF4 "Build netCDF-4 with HDF4 read capability(HDF4, HDF5 and Zlib required)." OFF)
option(NETCDF_ENABLE_DAP "Enable DAP2 and DAP4 Client." ON)
option(NETCDF_ENABLE_NCZARR "Enable NCZarr Client." ON)
option(NETCDF_ENABLE_PNETCDF "Build with parallel I/O for CDF-1, 2, and 5 files using PnetCDF." OFF)
set(NETCDF_ENABLE_CDF5 AUTO CACHE STRING "AUTO")
option(NETCDF_ENABLE_CDF5 "Enable CDF5 support" ON)
if(DEFINED NETCDF_ENABLE_NETCDF4)
message(FATAL_ERROR "NETCDF_ENABLE_NETCDF4 is deprecated. Please use NETCDF_ENABLE_NETCDF_4 instead.")
endif()
# Netcdf-4 support (i.e. libsrc4) is required by more than just HDF5 (e.g. NCZarr)
# So depending on what above formats are enabled, enable netcdf-4
if(NETCDF_ENABLE_HDF5 OR NETCDF_ENABLE_HDF4 OR NETCDF_ENABLE_NCZARR)
set(NETCDF_ENABLE_NETCDF_4 ON CACHE BOOL "Enable netCDF-4 API" FORCE)
endif()
# enable|disable all forms of network access
option(NETCDF_ENABLE_REMOTE_FUNCTIONALITY "Enable|disable all forms remote data access (DAP, S3, etc)" ON)
message(">>> NETCDF_ENABLE_REMOTE_FUNCTIONALITY=${NETCDF_ENABLE_REMOTE_FUNCTIONALITY}")
if(NOT NETCDF_ENABLE_REMOTE_FUNCTIONALITY)
message(WARNING "NETCDF_ENABLE_REMOTE_FUNCTIONALITY=NO => NETCDF_ENABLE_DAP[4]=NO")
set(NETCDF_ENABLE_DAP OFF CACHE BOOL "NETCDF_ENABLE_REMOTE_FUNCTIONALITY=NO => NETCDF_ENABLE_DAP=NO" FORCE)
set(NETCDF_ENABLE_DAP2 OFF CACHE BOOL "NETCDF_ENABLE_REMOTE_FUNCTIONALITY=NO => NETCDF_ENABLE_DAP2=NO" FORCE)
set(NETCDF_ENABLE_DAP4 OFF CACHE BOOL "NETCDF_ENABLE_REMOTE_FUNCTIONALITY=NO => NETCDF_ENABLE_DAP4=NO" FORCE)
endif()
# Option to Build DLL
if(WIN32)
option(NETCDF_ENABLE_DLL "Build a Windows DLL." ${BUILD_SHARED_LIBS})
if(NETCDF_ENABLE_DLL)
set(BUILD_DLL ON CACHE BOOL "")
target_compile_definitions(netcdf PRIVATE DLL_EXPORT)
target_compile_definitions(netcdf PUBLIC DLL_NETCDF)
endif()
endif()
# Did the user specify a default minimum blocksize for posixio?
set(NCIO_MINBLOCKSIZE 256 CACHE STRING "Minimum I/O Blocksize for netCDF classic and 64-bit offset format files.")
if(NETCDF_ENABLE_NETCDF_4)
set(USE_NETCDF4 ON CACHE BOOL "")
set(NETCDF_ENABLE_NETCDF_4 ON CACHE BOOL "")
else()
set(USE_HDF4_FILE_TESTS OFF)
set(USE_HDF4 OFF)
set(NETCDF_ENABLE_HDF4_FILE_TESTS OFF)
set(NETCDF_ENABLE_HDF4 OFF)
endif()
# Option Logging, only valid for netcdf4.
option(NETCDF_ENABLE_LOGGING "Enable Logging." OFF)
if(NOT NETCDF_ENABLE_NETCDF_4)
set(NETCDF_ENABLE_LOGGING OFF)
endif()
if(NETCDF_ENABLE_LOGGING)
target_compile_definitions(netcdf PRIVATE LOGGING ENABLE_SET_LOG_LEVEL)
set(LOGGING ON)
set(ENABLE_SET_LOG_LEVEL ON)
endif()
option(NETCDF_ENABLE_SET_LOG_LEVEL_FUNC "Enable definition of nc_set_log_level()." ON)
if(NETCDF_ENABLE_NETCDF_4 AND NOT NETCDF_ENABLE_LOGGING AND NETCDF_ENABLE_SET_LOG_LEVEL_FUNC)
target_compile_definitions(netcdf PRIVATE -DENABLE_SET_LOG_LEVEL)
set(ENABLE_SET_LOG_LEVEL ON)
endif()
# Option to allow for strict null file padding.
# See https://github.com/Unidata/netcdf-c/issues/657 for more information
option(NETCDF_ENABLE_STRICT_NULL_BYTE_HEADER_PADDING "Enable strict null byte header padding." OFF)
if(NETCDF_ENABLE_STRICT_NULL_BYTE_HEADER_PADDING)
set(USE_STRICT_NULL_BYTE_HEADER_PADDING ON CACHE BOOL "")
endif(NETCDF_ENABLE_STRICT_NULL_BYTE_HEADER_PADDING)
# 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
set(USE_HDF5 ${NETCDF_ENABLE_HDF5})
if(NETCDF_ENABLE_DAP)
set(USE_DAP ON CACHE BOOL "")
set(NETCDF_ENABLE_DAP2 ON CACHE BOOL "")
if(NETCDF_ENABLE_HDF5)
message(STATUS "Enabling DAP4")
set(NETCDF_ENABLE_DAP4 ON CACHE BOOL "")
else()
message(STATUS "Disabling DAP4")
set(NETCDF_ENABLE_DAP4 OFF CACHE BOOL "")
endif(NETCDF_ENABLE_HDF5)
else()
set(NETCDF_ENABLE_DAP2 OFF CACHE BOOL "")
set(NETCDF_ENABLE_DAP4 OFF CACHE BOOL "")
endif()
# Option to support byte-range reading of remote datasets
option(NETCDF_ENABLE_BYTERANGE "Enable byte-range access to remote datasets.." ${NETCDF_ENABLE_DAP})
if(NOT NETCDF_ENABLE_REMOTE_FUNCTIONALITY)
message(WARNING "NETCDF_ENABLE_REMOTE_FUNCTIONALITY=NO => NETCDF_ENABLE_BYTERANGE=NO")
set(NETCDF_ENABLE_BYTERANGE OFF CACHE BOOL "NETCDF_ENABLE_REMOTE_FUNCTIONALITY=NO => NETCDF_ENABLE_BYTERANGE=NO" FORCE)
endif()
# Option to Enable DAP long tests, remote tests.
option(NETCDF_ENABLE_DAP_REMOTE_TESTS "Enable DAP remote tests." ON)
option(NETCDF_ENABLE_EXTERNAL_SERVER_TESTS "Enable external Server remote tests." OFF)
option(NETCDF_ENABLE_DAP_LONG_TESTS "Enable DAP long tests." OFF)
if(NOT NETCDF_ENABLE_DAP)
set(NETCDF_ENABLE_DAP_REMOTE_TESTS OFF CACHE BOOL "" FORCE)
set(NETCDF_ENABLE_EXTERNAL_SERVER_TESTS OFF CACHE BOOL "" FORCE)
set(NETCDF_ENABLE_DAP_LONG_TESTS OFF CACHE BOOL "" FORCE)
endif()
set(REMOTETESTSERVERS "remotetest.unidata.ucar.edu" CACHE STRING "test servers to use for remote test")
set(REMOTETESTSERVERS "remotetest.unidata.ucar.edu" CACHE STRING "test servers to use for remote test")
# Locate some compressors
option(NETCDF_ENABLE_FILTER_SZIP "Enable use of Szip compression library if it is available. Required if NETCDF_ENABLE_NCZARR is true." ON)
option(NETCDF_ENABLE_FILTER_BZ2 "Enable use of Bz2 compression library if it is available." ON)
option(NETCDF_ENABLE_FILTER_BLOSC "Enable use of blosc compression library if it is available." ON)
option(NETCDF_ENABLE_FILTER_ZSTD "Enable use of Zstd compression library if it is available." ON)
# If user wants, then install selected plugins (default on)
set(PLUGIN_INSTALL_DIR "NO" CACHE STRING "Whether and where we should install plugins; defaults to yes")
# This is ugly, but seems necessary because of CMake's boolean structure
set(boolval FALSE)
if(DEFINED PLUGIN_INSTALL_DIR)
booleanize(${PLUGIN_INSTALL_DIR} boolval)
if(boolval)
set(ENABLE_PLUGIN_INSTALL YES)
# No actual value was specified
unset(PLUGIN_INSTALL_DIR CACHE)
else()
if(boolval STREQUAL "NOTFOUND")
# Must be an actual value
set(ENABLE_PLUGIN_INSTALL YES)
else()
set(ENABLE_PLUGIN_INSTALL NO)
endif()
endif()
else()
set(ENABLE_PLUGIN_INSTALL NO)
endif()
# Ensure no defined plugin dir if not enabled
if(NOT ENABLE_PLUGIN_INSTALL)
unset(PLUGIN_INSTALL_DIR CACHE)
endif()
if(ENABLE_PLUGIN_INSTALL)
if(NOT DEFINED PLUGIN_INSTALL_DIR)
# Default to HDF5_PLUGIN_PATH or its default directories
if(DEFINED ENV{HDF5_PLUGIN_PATH})
set(PLUGIN_INSTALL_DIR "$ENV{HDF5_PLUGIN_PATH}")
else()
if(ISMSVC OR ISMINGW)
set(PLUGIN_INSTALL_DIR "$ENV{ALLUSERSPROFILE}\\hdf5\\lib\\plugin")
else()
set(PLUGIN_INSTALL_DIR "/usr/local/hdf5/lib/plugin")
endif()
endif()
message("Defaulting to -DPLUGIN_INSTALL_DIR=${PLUGIN_INSTALL_DIR}")
endif()
endif()
if(ENABLE_PLUGIN_INSTALL)
# Use the lowest priority dir in the path
if(NOT ISMSVC AND NOT ISMINGW)
string(REPLACE ":" ";" PATH_LIST ${PLUGIN_INSTALL_DIR})
else()
set(PATH_LIST ${PLUGIN_INSTALL_DIR})
endif()
# Get last element
list(GET PATH_LIST -1 PLUGIN_INSTALL_DIR)
set(PLUGIN_INSTALL_DIR_SETTING "${PLUGIN_INSTALL_DIR}")
message("Final value of-DPLUGIN_INSTALL_DIR=${PLUGIN_INSTALL_DIR}")
else() # No option specified
unset(PLUGIN_INSTALL_DIR)
unset(PLUGIN_INSTALL_DIR CACHE)
set(PLUGIN_INSTALL_DIR_SETTING "N.A.")
endif()
# Try to enable NCZarr zip support
option(NETCDF_ENABLE_NCZARR_ZIP "Enable NCZarr ZIP support." OFF)
include(CMakeDependentOption)
# libdl is always available; built-in in Windows and OSX
cmake_dependent_option(NETCDF_ENABLE_PLUGINS "Enable dynamically loaded plugins (default on)."
ON "BUILD_SHARED_LIBS" OFF)
MESSAGE(STATUS "NETCDF_ENABLE_PLUGINS: ${NETCDF_ENABLE_PLUGINS}")
if(NOT WIN32)
if(HAVE_DLFCN_H)
include_directories("dlfcn.h")
endif()
endif()
if(NETCDF_ENABLE_PLUGINS)
set(USEPLUGINS yes)
endif()
# Enable some developer-only tests
option(NETCDF_ENABLE_EXTRA_TESTS "Enable Extra tests. Some may not work because of known issues. Developers only." OFF)
if(NETCDF_ENABLE_EXTRA_TESTS)
set(EXTRA_TESTS ON)
endif()
# Option to use bundled XGetopt in place of getopt(). This is mostly useful
# for MSVC builds. If not building utilities or some tests,
# getopt() isn't required at all.
if(MSVC)
option(NETCDF_ENABLE_XGETOPT "Enable bundled XGetOpt instead of external getopt()." ON)
if(NETCDF_ENABLE_XGETOPT)
set(USE_X_GETOPT ON CACHE BOOL "")
endif()
endif()
set(MATH "")
if(NOT WIN32)
# STDIO instead of posixio.
option(NETCDF_ENABLE_STDIO "If true, use stdio instead of posixio (ex. on the Cray)" OFF)
if(NETCDF_ENABLE_STDIO)
set(USE_STDIO ON CACHE BOOL "")
endif()
# FFIO insteaad of PosixIO
option(NETCDF_ENABLE_FFIO "If true, use ffio instead of posixio" OFF)
if(NETCDF_ENABLE_FFIO)
set(USE_FFIO ON CACHE BOOL "")
endif()
endif()
# Options for S3 Support
option(NETCDF_ENABLE_S3 "Enable S3 support." OFF)
option(NETCDF_ENABLE_S3_INTERNAL "Enable S3 Internal support." OFF)
option(NETCDF_ENABLE_NCZARR_S3 "Enable NCZarr S3 support; Deprecated in favor of NETCDF_ENABLE_S3" OFF)
if(NOT NETCDF_ENABLE_REMOTE_FUNCTIONALITY)
set(NETCDF_ENABLE_S3 OFF CACHE BOOL "" FORCE)
set(NETCDF_ENABLE_S3_INTERNAL OFF CACHE BOOL "" FORCE)
set(NETCDF_ENABLE_NCZARR_S3 OFF CACHE BOOL "" FORCE)
endif()
# Control S3 Testing: Multi-valued option
set(WITH_S3_TESTING OFF CACHE STRING "Control S3 Testing: ON (i.e. all) OFF (i.e. none) PUBLIC")
SET_PROPERTY(CACHE WITH_S3_TESTING PROPERTY STRINGS ON OFF PUBLIC) #
if(WITH_S3_TESTING STREQUAL "")
set(WITH_S3_TESTING OFF CACHE STRING "") # Default
endif()
if(WITH_S3_TESTING)
message(WARNING "**** DO NOT USE WITH_S3_TESTING=ON UNLESS YOU HAVE ACCESS TO THE UNIDATA S3 BUCKET! ***")
endif()
# NETCDF_ENABLE_NCZARR_S3 is now an alias for NETCDF_ENABLE_S3 (but...)
if (NOT NETCDF_ENABLE_S3 AND NETCDF_ENABLE_NCZARR_S3)
set(NETCDF_ENABLE_S3 ON CACHE BOOL "NCARR S3" FORCE) # For back compatibility
endif()
unset(NETCDF_ENABLE_NCZARR_S3)
if(NOT NETCDF_ENABLE_REMOTE_FUNCTIONALITY)
message(WARNING "NETCDF_ENABLE_REMOTE_FUNCTIONALITY=NO => disable all s3 functionality")
set(NETCDF_ENABLE_S3 OFF CACHE BOOL "" FORCE)
set(NETCDF_ENABLE_S3_INTERNAL OFF CACHE BOOL "" FORCE)
set(NETCDF_ENABLE_NCZARR_S3 OFF CACHE BOOL "" FORCE)
set(NETCDF_ENABLE_HDF5_ROS3 OFF CACHE BOOL "Use ROS3" FORCE)
set(WITH_S3_TESTING OFF CACHE STRING "" FORCE)
endif()
if(NETCDF_ENABLE_S3)
if(NOT NETCDF_ENABLE_S3_AWS AND NOT NETCDF_ENABLE_S3_INTERNAL)
message(FATAL_ERROR "S3 support library not found; please specify option -DNETCDF_ENABLE_S3=NO")
set(NETCDF_ENABLE_S3 OFF CACHE BOOL "S3 support" FORCE)
endif()
if(NETCDF_ENABLE_S3_AWS AND NETCDF_ENABLE_S3_INTERNAL)
message(WARNING "Both aws-sdk-cpp and s3-internal enabled => use s3-internal")
set(NETCDF_ENABLE_S3_AWS OFF CACHE BOOL "S3 AWS" FORCE)
endif()
endif()
if(NOT NETCDF_ENABLE_S3)
if(WITH_S3_TESTING STREQUAL "PUBLIC" OR WITH_S3_TESTING)
message(WARNING "S3 support is disabled => WITH_S3_TESTING=OFF")
set(WITH_S3_TESTING OFF CACHE STRING "" FORCE)
endif()
endif()
option(NETCDF_ENABLE_LIBXML2 "Link against libxml2 if it is available, use the packaged tinyxml2 parser otherwise." ON)
set(XMLPARSER "tinyxml2 (bundled)")
if(NOT NETCDF_ENABLE_BYTERANGE AND NETCDF_ENABLE_HDF5_ROS3)
message(WARNING "ROS3 support requires NETCDF_ENABLE_BYTERANGE=TRUE; disabling ROS3 support")
set(NETCDF_ENABLE_HDF5_ROS3 OFF CACHE BOOL "ROS3 support" FORCE)
endif()
##
# Enable Tests
##
option(NETCDF_ENABLE_TESTS "Enable basic tests, run with 'make test'." ON)
if(NETCDF_ENABLE_TESTS)
set(BUILD_TESTSETS ON CACHE BOOL "")
# Options for CTest-based tests, dashboards.
set(NC_CTEST_PROJECT_NAME "netcdf-c" CACHE STRING "Project Name for CTest-based testing purposes.")
set(NC_CTEST_DROP_SITE "cdash.unidata.ucar.edu:443" CACHE STRING "Dashboard location for CTest-based testing purposes.")
set(NC_CTEST_DROP_LOC_PREFIX "" CACHE STRING "Prefix for Dashboard location on remote server when using CTest-based testing.")
set(SUBMIT_URL "https://cdash.unidata.ucar.edu:443")
find_program(HOSTNAME_CMD NAMES hostname)
if(NOT WIN32)
set(HOSTNAME_ARG "-s")
endif()
if(HOSTNAME_CMD)
execute_process(COMMAND ${HOSTNAME_CMD} "${HOSTNAME_ARG}" OUTPUT_VARIABLE HOSTNAME OUTPUT_STRIP_TRAILING_WHITESPACE)
set(NC_CTEST_SITE "${HOSTNAME}" CACHE STRING "Hostname of test machine.")
endif()
if(NC_CTEST_SITE)
set(SITE "${NC_CTEST_SITE}" CACHE STRING "")
endif()
###
# This option dictates whether or not to turn on
# tests which are known to fail. This is not the
# same thing as an 'expected failure'. Rather, these
# are tests that will need to be fixed eventually.
#
# By placing them here, we can occasionally turn this
# flag on and see if any known failures have been
# fixed in the course of code improvement/other bug
# fixes.
#
# To use this, simply add as a fencepost around tests
# which are known to fail.
###
option(NETCDF_ENABLE_FAILING_TESTS "Run tests which are known to fail, check to see if any have been fixed." OFF)
###
# Option to turn on unit testing. See
# https://github.com/Unidata/netcdf-c/pull/1472 for more information.
###
option(NETCDF_ENABLE_UNIT_TESTS "Run Unit Tests." ON)
###
# Option to turn on performance testing.
# See https://github.com/Unidata/netcdf-c/issues/2627 for more information.
###
option(NETCDF_ENABLE_BENCHMARKS "Run benchmark Tests." OFF)
###
# End known-failures.
###
MARK_AS_ADVANCED(NETCDF_ENABLE_FAILING_TESTS)
endif()
###
# Option to enable extreme numbers during testing.
###
option(NETCDF_ENABLE_EXTREME_NUMBERS "Enable extreme numbers during testing, such as MAX_INT-1" ON)
if(NETCDF_ENABLE_EXTREME_NUMBERS)
set(USE_EXTREME_NUMBERS ON)
endif()
# Enable Large file tests
if(NETCDF_ENABLE_LARGE_FILE_TESTS)
set(LARGE_FILE_TESTS ON)
endif()
option(NETCDF_ENABLE_METADATA_PERF_TESTS "Enable test of metadata performance." OFF)
if(NETCDF_ENABLE_METADATA_PERF_TESTS)
set(ENABLE_METADATA_PERF ON)
endif()
# Location for large file tests.
set(TEMP_LARGE "." CACHE STRING "Location to store large file tests.")
option(NETCDF_ENABLE_FSYNC "Enable experimental fsync code." OFF)
if(NETCDF_ENABLE_FSYNC)
set(USE_FSYNC ON)
endif()
# Temporary
OPTION (ENABLE_JNA "Enable jna bug fix code." OFF)
if(ENABLE_JNA)
set(JNA ON)
endif()
# Linux specific large file support flags.
# Modelled after check in CMakeLists.txt for hdf5.
option(NETCDF_ENABLE_LARGE_FILE_SUPPORT "Enable large file support." ON)
if(NETCDF_ENABLE_LARGE_FILE_SUPPORT)
if(MSVC)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LARGEADDRESSAWARE")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /LARGEADDRESSAWARE")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /LARGEADDRESSAWARE")
else()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64")
endif()
endif()
option(NETCDF_ENABLE_EXAMPLE_TESTS "Run extra example tests. Requires GNU Sed. Ignored if HDF5 is not Enabled" OFF)
if(NOT NETCDF_ENABLE_HDF5 AND NETCDF_ENABLE_EXAMPLE_TESTS)
set(NETCDF_ENABLE_EXAMPLE_TESTS OFF)
endif()
##################################
# Dependencies
##################################
include(cmake/dependencies.cmake)
################################
# End Dependencies
################################
# Enable Parallel IO with netCDF-4/HDF5 files using HDF5 parallel I/O.
set(STATUS_PARALLEL "OFF")
set(IMPORT_MPI "")
option(NETCDF_ENABLE_PARALLEL4 "Build netCDF-4 with parallel IO" "${HDF5_PARALLEL}")
if(NETCDF_ENABLE_PARALLEL4 AND NETCDF_ENABLE_HDF5)
if(NOT HDF5_PARALLEL)
set(USE_PARALLEL OFF CACHE BOOL "")
message(STATUS "Cannot find HDF5 library built with parallel support. Disabling parallel build.")
else()
set(HDF5_PARALLEL ON CACHE BOOL "")
set(USE_PARALLEL ON CACHE BOOL "")
set(USE_PARALLEL4 ON CACHE BOOL "")
set(STATUS_PARALLEL "ON")
configure_file("${netCDF_SOURCE_DIR}/nc_test4/run_par_test.sh.in"
"${netCDF_BINARY_DIR}/tmp/run_par_test.sh" @ONLY NEWLINE_STYLE LF)
file(COPY "${netCDF_BINARY_DIR}/tmp/run_par_test.sh"
DESTINATION ${netCDF_BINARY_DIR}/nc_test4
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
configure_file("${netCDF_SOURCE_DIR}/h5_test/run_par_tests.sh.in"
"${netCDF_BINARY_DIR}/tmp/run_par_tests.sh" @ONLY NEWLINE_STYLE LF)
file(COPY "${netCDF_BINARY_DIR}/tmp/run_par_tests.sh"
DESTINATION ${netCDF_BINARY_DIR}/h5_test
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
set(IMPORT_MPI "include(CMakeFindDependencyMacro)\nfind_dependency(MPI COMPONENTS C)")
endif()
endif()
# Options to enable parallel IO for classic formats with PnetCDF library.
set(STATUS_PNETCDF ${NETCDF_ENABLE_PNETCDF})
set(USE_PNETCDF ${NETCDF_ENABLE_PNETCDF})
if(NETCDF_ENABLE_PNETCDF)
set(STATUS_PARALLEL ON)
set(USE_PARALLEL ON CACHE BOOL "")
###
# Generate pnetcdf test
###
configure_file("${netCDF_SOURCE_DIR}/nc_test/run_pnetcdf_tests.sh.in"
"${netCDF_BINARY_DIR}/nc_test/run_pnetcdf_tests.sh")
endif()
# Options to enable use of fill values for elements causing NC_ERANGE
set(NETCDF_ENABLE_ERANGE_FILL AUTO CACHE STRING "AUTO")
option(NETCDF_ENABLE_ERANGE_FILL "Enable use of fill value when out-of-range type conversion causes NC_ERANGE error." OFF)
if(NETCDF_ENABLE_ERANGE_FILL) # enable or auto
string(TOUPPER ${NETCDF_ENABLE_ERANGE_FILL} NETCDF_ENABLE_ERANGE_FILL)
if(NETCDF_ENABLE_ERANGE_FILL AND NOT NETCDF_ENABLE_ERANGE_FILL STREQUAL "AUTO")
# explicitly enabled
set(NETCDF_ENABLE_ERANGE_FILL ON)
else()
if(NOT NETCDF_ENABLE_ERANGE_FILL STREQUAL "AUTO")
set(NETCDF_ENABLE_ERANGE_FILL OFF)
endif()
endif()
endif(NETCDF_ENABLE_ERANGE_FILL)
# Now NETCDF_ENABLE_ERANGE_FILL is either AUTO, ON, or OFF
# More relaxed coordinate check is now mandatory for all builds.
set(ENABLE_ZERO_LENGTH_COORD_BOUND ON)
# check and conform with PnetCDF settings on ERANGE_FILL and RELAX_COORD_BOUND
if(USE_PNETCDF)
if(NETCDF_ENABLE_ERANGE_FILL STREQUAL "AUTO") # not set on command line
set(NETCDF_ENABLE_ERANGE_FILL "${PNETCDF_HAS_ERANGE_FILL}")
else()
# user explicitly set this option on command line
if(NOT NETCDF_ENABLE_ERANGE_FILL STREQUAL "${PNETCDF_HAS_ERANGE_FILL}")
if(NETCDF_ENABLE_ERANGE_FILL)
message(FATAL_ERROR "Enabling erange-fill conflicts with PnetCDF setting")
else()
message(FATAL_ERROR "Disabling erange-fill conflicts with PnetCDF setting")
endif()
endif()
endif()
endif()
if(NETCDF_ENABLE_ERANGE_FILL)
message(STATUS "Enabling use of fill value when NC_ERANGE")
set(M4FLAGS "-DERANGE_FILL" CACHE STRING "")
endif()
if(ENABLE_ZERO_LENGTH_COORD_BOUND)
message(STATUS "Enabling a more relaxed check for NC_EINVALCOORDS")
target_compile_definitions(netcdf PRIVATE RELAX_COORD_BOUND)
endif()
# Enable Parallel Tests.
option(NETCDF_ENABLE_PARALLEL_TESTS "Enable Parallel IO Tests. Requires HDF5/NetCDF4 with parallel I/O Support." "${HDF5_PARALLEL}")
if(NETCDF_ENABLE_PARALLEL_TESTS AND USE_PARALLEL)
set(TEST_PARALLEL ON CACHE BOOL "")
if(USE_NETCDF4)
set(TEST_PARALLEL4 ON CACHE BOOL "")
endif()
endif()
IF (NETCDF_ENABLE_PARALLEL_TESTS AND NOT USE_PARALLEL)
message(FATAL_ERROR "Parallel tests requested, but no parallel HDF5 installation detected.")
endif()
# Enable special filter test; experimental when using cmake.
option(NETCDF_ENABLE_FILTER_TESTING "Enable filter testing. Ignored if shared libraries or netCDF4 are not enabled" ${NETCDF_ENABLE_PLUGINS})
if(NETCDF_ENABLE_FILTER_TESTING)
if(NOT NETCDF_ENABLE_HDF5 AND NOT NETCDF_ENABLE_NCZARR)
message(WARNING "NETCDF_ENABLE_FILTER_TESTING requires HDF5 and/or NCZarr. Disabling.")
set(NETCDF_ENABLE_FILTER_TESTING OFF CACHE BOOL "Enable Filter Testing" FORCE)
endif()
endif()
if(NOT BUILD_SHARED_LIBS)
message(WARNING "NETCDF_ENABLE_FILTER_TESTING requires shared libraries. Disabling.")
set(NETCDF_ENABLE_FILTER_TESTING OFF)
endif()
option(NETCDF_ENABLE_NCZARR_FILTERS "Enable NCZarr filters" ${NETCDF_ENABLE_PLUGINS})
option(NETCDF_ENABLE_NCZARR_FILTERS_TESTING "Enable NCZarr filter testing." ${NETCDF_ENABLE_NCZARR_FILTERS})
# Constraints
if (NOT NETCDF_ENABLE_PLUGINS AND NETCDF_ENABLE_NCZARR_FILTERS)
message(WARNING "NETCDF_ENABLE_NCZARR_FILTERS requires NETCDF_ENABLE_PLUGINS. Disabling.")
set(NETCDF_ENABLE_NCZARR_FILTERS OFF CACHE BOOL "Enable NCZarr Filters." FORCE)
endif()
IF (NOT NETCDF_ENABLE_NCZARR)
message(WARNING "NETCDF_ENABLE_NCZARR==NO => NETCDF_ENABLE_NCZARR_FILTERS==NO AND NETCDF_ENABLE_NCZARR_FILTER_TESTING==NO")
set(NETCDF_ENABLE_NCZARR_FILTERS OFF CACHE BOOL "Disable NCZARR_FILTERS" FORCE)
endif()
IF (NOT NETCDF_ENABLE_NCZARR_FILTERS)
set(NETCDF_ENABLE_NCZARR_FILTER_TESTING OFF CACHE BOOL "Enable NCZarr Filter Testing" FORCE)
endif()
set(ENABLE_CLIENTSIDE_FILTERS OFF)
# Determine whether or not to generate documentation.
option(NETCDF_ENABLE_DOXYGEN "Enable generation of doxygen-based documentation." OFF)
if(NETCDF_ENABLE_DOXYGEN)
# Offer the option to build internal documentation.
option(NETCDF_ENABLE_INTERNAL_DOCS "Build internal documentation. This is of interest to developers only." OFF)
if(NETCDF_ENABLE_INTERNAL_DOCS)
set(BUILD_INTERNAL_DOCS yes CACHE STRING "")
else()
set(BUILD_INTERNAL_DOCS no CACHE STRING "")
endif()
###
#
# If we are building release documentation, we need to set some
# variables that will be used in the Doxygen.in template.
###
option(NETCDF_ENABLE_DOXYGEN_BUILD_RELEASE_DOCS "Build release documentation. This is of interest only to the netCDF developers." OFF)
if(NETCDF_ENABLE_DOXYGEN_BUILD_RELEASE_DOCS)
set(DOXYGEN_CSS_FILE "${CMAKE_SOURCE_DIR}/docs/release.css" CACHE STRING "")
set(DOXYGEN_HEADER_FILE "${CMAKE_SOURCE_DIR}/docs/release_header.html" CACHE STRING "")
set(DOXYGEN_SEARCHENGINE "NO" CACHE STRING "")
set(NETCDF_ENABLE_DOXYGEN_SERVER_BASED_SEARCH NO CACHE STRING "")
else()
set(DOXYGEN_CSS_FILE "" CACHE STRING "")
set(DOXYGEN_HEADER_FILE "" CACHE STRING "")
set(DOXYGEN_SEARCHENGINE "YES" CACHE STRING "")
# If not using release document configuration,
# provide an option for server-based search.
option(NETCDF_ENABLE_DOXYGEN_SERVER_SIDE_SEARCH "Configure Doxygen with server-based search." OFF)
if(NETCDF_ENABLE_DOXYGEN_SERVER_SIDE_SEARCH)
set(DOXYGEN_SERVER_BASED_SEARCH "YES" CACHE STRING "")
else()
set(DOXYGEN_SERVER_BASED_SEARCH "NO" CACHE STRING "")
endif(NETCDF_ENABLE_DOXYGEN_SERVER_SIDE_SEARCH)
endif(NETCDF_ENABLE_DOXYGEN_BUILD_RELEASE_DOCS)
# Option to turn on the TODO list in the doxygen-generated documentation.
option(NETCDF_DOXYGEN_ENABLE_TASKS "Turn on test, todo, bug lists in documentation. This is of interest to developers only." OFF)
if(NETCDF_DOXYGEN_ENABLE_TASKS)
set(SHOW_DOXYGEN_TAG_LIST YES CACHE STRING "")
else(NETCDF_DOXYGEN_ENABLE_TASKS)
set(SHOW_DOXYGEN_TODO_LIST NO CACHE STRING "")
endif(NETCDF_DOXYGEN_ENABLE_TASKS)
option(NETCDF_ENABLE_DOXYGEN_PDF_OUTPUT "[EXPERIMENTAL] Turn on PDF output for Doxygen-generated documentation." OFF)
if(NETCDF_ENABLE_DOXYGEN_PDF_OUTPUT)
set(NC_NETCDF_ENABLE_DOXYGEN_PDF_OUTPUT "YES" CACHE STRING "")
else()
set(NC_NETCDF_ENABLE_DOXYGEN_PDF_OUTPUT "NO" CACHE STRING "")
endif()
find_program(NC_DOT NAMES dot)
# Specify whether or not 'dot' was found on the system path.
if(NC_DOT)
set(HAVE_DOT YES CACHE STRING "")
else(NC_DOT)
set(HAVE_DOT NO CACHE STRING "")
endif(NC_DOT)
endif()
# Always enable DISKLESS
option(NETCDF_ENABLE_DISKLESS "Enable in-memory files" ON)
# Always enable quantization.
option(NETCDF_ENABLE_QUANTIZE "Enable variable quantization" ON)
# By default, MSVC has a stack size of 1000000.
# Allow a user to override this.
if(MSVC)
set(NC_MSVC_STACK_SIZE 40000000 CACHE STRING "Default stack size for MSVC-based projects.")
# By default, CMake sets the stack to 1000000.
# Remove this limitation.
# See here for more details:
# http://www.cmake.org/pipermail/cmake/2009-April/028710.html
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:${NC_MSVC_STACK_SIZE}")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /STACK:${NC_MSVC_STACK_SIZE}")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /STACK:${NC_MSVC_STACK_SIZE}")
endif()
# Set some of the options as advanced.
MARK_AS_ADVANCED(NETCDF_ENABLE_INTERNAL_DOCS VALGRIND_TESTS NETCDF_ENABLE_COVERAGE_TESTS )
MARK_AS_ADVANCED(NETCDF_ENABLE_DAP_REMOTE_TESTS NETCDF_ENABLE_DAP_LONG_TESTS USE_REMOTE_CDASH NETCDF_ENABLE_EXTERNAL_SERVER_TESTS)
MARK_AS_ADVANCED(NETCDF_ENABLE_DOXYGEN_BUILD_RELEASE_DOCS NETCDF_DOXYGEN_ENABLE_TASKS NETCDF_ENABLE_DOXYGEN_SERVER_SIDE_SEARCH)
MARK_AS_ADVANCED(NETCDF_ENABLE_SHARED_LIBRARY_VERSION)
################################
# Option checks
################################
# Library include checks
CHECK_INCLUDE_file("math.h" HAVE_MATH_H)
CHECK_INCLUDE_file("unistd.h" HAVE_UNISTD_H)
# Solve a compatibility issue in ncgen/, which checks
# for NO_UNISTD_H
if(NOT HAVE_UNISTD_H)
set(YY_NO_UNISTD_H TRUE)
endif()
CHECK_INCLUDE_file("alloca.h" HAVE_ALLOCA_H)
CHECK_INCLUDE_file("malloc.h" HAVE_MALLOC_H)
CHECK_INCLUDE_file("fcntl.h" HAVE_FCNTL_H)
CHECK_INCLUDE_file("getopt.h" HAVE_GETOPT_H)
CHECK_INCLUDE_file("locale.h" HAVE_LOCALE_H)
CHECK_INCLUDE_file("stdint.h" HAVE_STDINT_H)
CHECK_INCLUDE_file("stdio.h" HAVE_STDIO_H)
if(MSVC)
CHECK_INCLUDE_file("io.h" HAVE_IO_H)
endif(MSVC)
CHECK_INCLUDE_file("stdlib.h" HAVE_STDLIB_H)
CHECK_INCLUDE_file("ctype.h" HAVE_CTYPE_H)
CHECK_INCLUDE_file("stdarg.h" HAVE_STDARG_H)
CHECK_INCLUDE_file("strings.h" HAVE_STRINGS_H)
CHECK_INCLUDE_file("signal.h" HAVE_SIGNAL_H)
CHECK_INCLUDE_file("sys/param.h" HAVE_SYS_PARAM_H)
CHECK_INCLUDE_file("sys/stat.h" HAVE_SYS_STAT_H)
CHECK_INCLUDE_file("sys/time.h" HAVE_SYS_TIME_H)
CHECK_INCLUDE_file("sys/types.h" HAVE_SYS_TYPES_H)
CHECK_INCLUDE_file("sys/mman.h" HAVE_SYS_MMAN_H)
CHECK_INCLUDE_file("sys/resource.h" HAVE_SYS_RESOURCE_H)
CHECK_INCLUDE_file("fcntl.h" HAVE_FCNTL_H)
CHECK_INCLUDE_file("inttypes.h" HAVE_INTTYPES_H)
CHECK_INCLUDE_file("pstdint.h" HAVE_PSTDINT_H)
CHECK_INCLUDE_file("endian.h" HAVE_ENDIAN_H)
CHECK_INCLUDE_file("BaseTsd.h" HAVE_BASETSD_H)
CHECK_INCLUDE_file("stddef.h" HAVE_STDDEF_H)
CHECK_INCLUDE_file("string.h" HAVE_STRING_H)
CHECK_INCLUDE_file("winsock2.h" HAVE_WINSOCK2_H)
CHECK_INCLUDE_file("ftw.h" HAVE_FTW_H)
CHECK_INCLUDE_file("libgen.h" HAVE_LIBGEN_H)
CHECK_INCLUDE_file("execinfo.h" HAVE_EXECINFO_H)
CHECK_INCLUDE_file("dirent.h" HAVE_DIRENT_H)
CHECK_INCLUDE_file("time.h" HAVE_TIME_H)
CHECK_INCLUDE_file("dlfcn.h" HAVE_DLFCN_H)
# Symbol Exists
CHECK_SYMBOL_EXISTS(isfinite "math.h" HAVE_DECL_ISFINITE)
CHECK_SYMBOL_EXISTS(isnan "math.h" HAVE_DECL_ISNAN)
CHECK_SYMBOL_EXISTS(isinf "math.h" HAVE_DECL_ISINF)
CHECK_SYMBOL_EXISTS(st_blksize "sys/stat.h" HAVE_STRUCT_STAT_ST_BLKSIZE)
CHECK_SYMBOL_EXISTS(alloca "alloca.h" HAVE_ALLOCA)
CHECK_SYMBOL_EXISTS(snprintf "stdio.h" HAVE_SNPRINTF)
# Type checks
# Aliases for automake consistency
set(SIZEOF_VOIDSTAR ${CMAKE_SIZEOF_VOID_P})
set(SIZEOF_VOIDP ${SIZEOF_VOIDSTAR})
CHECK_TYPE_SIZE("char" SIZEOF_CHAR)
CHECK_TYPE_SIZE("double" SIZEOF_DOUBLE)
CHECK_TYPE_SIZE("float" SIZEOF_FLOAT)
CHECK_TYPE_SIZE("int" SIZEOF_INT)
CHECK_TYPE_SIZE("uint" SIZEOF_UINT)
if(SIZEOF_UINT)
set(HAVE_UINT TRUE)
endif(SIZEOF_UINT)
CHECK_TYPE_SIZE("schar" SIZEOF_SCHAR)
if(SIZEOF_SCHAR)
set(HAVE_SCHAR TRUE)
endif(SIZEOF_SCHAR)
CHECK_TYPE_SIZE("long" SIZEOF_LONG)
CHECK_TYPE_SIZE("long long" SIZEOF_LONG_LONG)
if(SIZEOF_LONG_LONG)
set(HAVE_LONG_LONG_INT TRUE)
endif(SIZEOF_LONG_LONG)
CHECK_TYPE_SIZE("unsigned long long" SIZEOF_UNSIGNED_LONG_LONG)
CHECK_TYPE_SIZE("off_t" SIZEOF_OFF_T)
CHECK_TYPE_SIZE("off64_t" SIZEOF_OFF64_T)
CHECK_TYPE_SIZE("short" SIZEOF_SHORT)
CHECK_TYPE_SIZE("ushort" SIZEOF_USHORT)
if(SIZEOF_USHORT)
set(HAVE_USHORT TRUE)
endif(SIZEOF_USHORT)
CHECK_TYPE_SIZE("_Bool" SIZEOF__BOOL)
CHECK_TYPE_SIZE("size_t" SIZEOF_SIZE_T)
# Check whether to turn on or off CDF5 support.
if(SIZEOF_SIZE_T EQUAL 4)
if(NETCDF_ENABLE_CDF5) # enable or auto
string(TOUPPER ${NETCDF_ENABLE_CDF5} NETCDF_ENABLE_CDF5)
if(NETCDF_ENABLE_CDF5 AND NOT NETCDF_ENABLE_CDF5 STREQUAL "AUTO") # explicitly enabled
message(FATAL_ERROR "Unable to support CDF5 feature because size_t is less than 8 bytes")
endif(NETCDF_ENABLE_CDF5 AND NOT NETCDF_ENABLE_CDF5 STREQUAL "AUTO")
set(NETCDF_ENABLE_CDF5 OFF) # cannot support CDF5
set(USE_CDF5 OFF CACHE BOOL "") # cannot support CDF5
endif(NETCDF_ENABLE_CDF5)
else(SIZEOF_SIZE_T EQUAL 4)
if(NETCDF_ENABLE_CDF5) # explicitly set by user or not set
set(USE_CDF5 ON CACHE BOOL "")
else(NETCDF_ENABLE_CDF5) # explicitly disabled by user
set(USE_CDF5 OFF CACHE BOOL "")
endif(NETCDF_ENABLE_CDF5)
endif(SIZEOF_SIZE_T EQUAL 4)
CHECK_TYPE_SIZE("ssize_t" SIZEOF_SSIZE_T)
if(SIZEOF_SSIZE_T)
set(HAVE_SSIZE_T TRUE)
endif(SIZEOF_SSIZE_T)
CHECK_TYPE_SIZE("ptrdiff_t" SIZEOF_PTRDIFF_T)
if(SIZEOF_PTRDIFF_T)
set(HAVE_PTRDIFF_T TRUE)
endif(SIZEOF_PTRDIFF_T)
CHECK_TYPE_SIZE("uintptr_t" SIZEOF_UINTPTR_T)
if(SIZEOF_UINTPTR_T)
set(HAVE_UINTPTR_T TRUE)
endif(SIZEOF_UINTPTR_T)
CHECK_TYPE_SIZE("mode_t" SIZEOF_MODE_T)
if(SIZEOF_MODE_T)
set(HAVE_MODE_T TRUE)
endif(SIZEOF_MODE_T)
# __int64 is used on Windows for large file support.
CHECK_TYPE_SIZE("__int64" SIZEOF___INT_64)
CHECK_TYPE_SIZE("int64_t" SIZEOF_INT64_T)
CHECK_TYPE_SIZE("uint64" SIZEOF_UINT64)
CHECK_TYPE_SIZE("unsigned char" SIZEOF_UCHAR)
CHECK_TYPE_SIZE("unsigned short int" SIZEOF_UNSIGNED_SHORT_INT)
CHECK_TYPE_SIZE("unsigned int" SIZEOF_UNSIGNED_INT)
CHECK_TYPE_SIZE("long long" SIZEOF_LONGLONG)
CHECK_TYPE_SIZE("unsigned long long" SIZEOF_ULONGLONG)
CHECK_TYPE_SIZE("uint64_t" SIZEOF_UINT64_T)
if(SIZEOF_UINT64_T)
set(HAVE_UINT64_T TRUE)
endif(SIZEOF_UINT64_T)
# On windows systems, we redefine off_t as __int64
# to enable LFS. This is true on 32 and 64 bit system.s
# We must redefine SIZEOF_OFF_T to match.
if(MSVC AND SIZEOF___INT_64)
set(SIZEOF_OFF_T ${SIZEOF___INT_64})
endif()
# Check for various functions.
CHECK_FUNCTION_EXISTS(fsync HAVE_FSYNC)
CHECK_FUNCTION_EXISTS(strlcat HAVE_STRLCAT)
CHECK_FUNCTION_EXISTS(strlcpy HAVE_STRLCPY)
CHECK_FUNCTION_EXISTS(strdup HAVE_STRDUP)
CHECK_FUNCTION_EXISTS(strndup HAVE_STRNDUP)
CHECK_FUNCTION_EXISTS(strtoll HAVE_STRTOLL)
CHECK_FUNCTION_EXISTS(strcasecmp HAVE_STRCASECMP)
CHECK_FUNCTION_EXISTS(strtoull HAVE_STRTOULL)
CHECK_FUNCTION_EXISTS(mkstemp HAVE_MKSTEMP)
CHECK_FUNCTION_EXISTS(mktemp HAVE_MKTEMP)
CHECK_FUNCTION_EXISTS(random HAVE_RANDOM)
CHECK_FUNCTION_EXISTS(gettimeofday HAVE_GETTIMEOFDAY)
CHECK_FUNCTION_EXISTS(MPI_Comm_f2c HAVE_MPI_COMM_F2C)
CHECK_FUNCTION_EXISTS(MPI_Info_f2c HAVE_MPI_INFO_F2C)
CHECK_FUNCTION_EXISTS(memmove HAVE_MEMMOVE)
CHECK_FUNCTION_EXISTS(getpagesize HAVE_GETPAGESIZE)
CHECK_FUNCTION_EXISTS(sysconf HAVE_SYSCONF)
CHECK_FUNCTION_EXISTS(getrlimit HAVE_GETRLIMIT)
CHECK_FUNCTION_EXISTS(_filelengthi64 HAVE_FILE_LENGTH_I64)
CHECK_FUNCTION_EXISTS(mmap HAVE_MMAP)
CHECK_FUNCTION_EXISTS(mremap HAVE_MREMAP)
CHECK_FUNCTION_EXISTS(fileno HAVE_FILENO)
CHECK_FUNCTION_EXISTS(clock_gettime HAVE_CLOCK_GETTIME)
CHECK_SYMBOL_EXISTS("struct timespec" "time.h" HAVE_STRUCT_TIMESPEC)
CHECK_FUNCTION_EXISTS(atexit HAVE_ATEXIT)
# Control invoking nc_finalize at exit
option(NETCDF_ENABLE_ATEXIT_FINALIZE "Invoke nc_finalize at exit." ON)
if(NOT HAVE_ATEXIT)
if(NETCDF_ENABLE_ATEXIT_FINALIZE AND NOT HAVE_ATEXIT)
set(NETCDF_ENABLE_ATEXIT_FINALIZE OFF CACHE BOOL "Enable ATEXIT" FORCE)
message(WARNING "NETCDF_ENABLE_ATEXIT_FINALIZE set but atexit() function not defined")
endif()
endif()
# Check to see if MAP_ANONYMOUS is defined.
if(MSVC)
message(WARNING "mmap not supported under visual studio: disabling MMAP support.")
set(NETCDF_ENABLE_MMAP OFF)
else()
CHECK_C_SOURCE_COMPILES("
#include <sys/mman.h>
int main() {int x = MAP_ANONYMOUS;}" HAVE_MAPANON)
if(NOT HAVE_MMAP OR NOT HAVE_MAPANON)
message(WARNING "mmap or MAP_ANONYMOUS not found: disabling MMAP support.")
set(NETCDF_ENABLE_MMAP OFF)
endif()
endif()
if(NETCDF_ENABLE_MMAP)
# Aliases
set(BUILD_MMAP ON)
set(USE_MMAP ON)
endif(NETCDF_ENABLE_MMAP)
#CHECK_FUNCTION_EXISTS(alloca HAVE_ALLOCA)
# Used in the `configure_file` calls below
set(ISCMAKE "yes")
if(MSVC)
set(ISMSVC ON CACHE BOOL "" FORCE)
set(REGEDIT ON CACHE BOOL "" FORCE)
# Get windows major version and build number
execute_process(COMMAND "systeminfo" OUTPUT_VARIABLE WININFO)
if(WININFO STREQUAL "")
set(WVM 0)
set(WVB 0)
else()
string(REGEX MATCH "\nOS Version:[ \t]+[0-9.]+" WINVERLINE "${WININFO}")
string(REGEX REPLACE "[^0-9]*([0-9]+)[.]([0-9])+[.]([0-9]+)" "\\1" WVM "${WINVERLINE}")
string(REGEX REPLACE "[^0-9]*([0-9]+)[.]([0-9])+[.]([0-9]+)" "\\3" WVB "${WINVERLINE}")
endif()
set(WINVERMAJOR ${WVM} CACHE STRING "" FORCE)
set(WINVERBUILD ${WVB} CACHE STRING "" FORCE)
endif()
#####
# End system inspection checks.
#####
# A basic script used to convert m4 files
find_program(NC_M4 NAMES m4 m4.exe)
if(NC_M4)
message(STATUS "Found m4: ${NC_M4}")
set(HAVE_M4 TRUE)
else()
message(STATUS "m4 not found.")
set(HAVE_M4 FALSE)
endif()
##specific
# Shell script Macro
##
# Determine if 'bash' is on the system.
##
option(NETCDF_ENABLE_BASH_SCRIPT_TESTING "Detection is typically automatic, but this option can be used to force enable/disable bash-script based tests." ON)
if(NETCDF_ENABLE_BASH_SCRIPT_TESTING)
find_program(HAVE_BASH bash)
if(HAVE_BASH)
string(COMPARE EQUAL "${HAVE_BASH}" "C:/Windows/System32/bash.exe" IS_BASH_EXE)
if(NOT IS_BASH_EXE)
message(STATUS "Found bash: ${HAVE_BASH}")
else()
message(STATUS "Ignoring ${HAVE_BASH}")
set(HAVE_BASH "")
endif()
else()
message(STATUS "Bash shell not found; disabling shell script tests.")
endif()
else(NETCDF_ENABLE_BASH_SCRIPT_TESTING)
set(HAVE_BASH "")
endif(NETCDF_ENABLE_BASH_SCRIPT_TESTING)
# Create config.h file.
configure_file("${netCDF_SOURCE_DIR}/config.h.cmake.in"
"${netCDF_BINARY_DIR}/config.h")
add_definitions(-DHAVE_CONFIG_H)
include_directories(${netCDF_BINARY_DIR})
# End autotools-style checks for config.h
#####
# Set the true names of all the libraries, if customized by external project
#####
# Recurse into other subdirectories.
add_subdirectory("include")
add_subdirectory(libdispatch)
add_subdirectory(libsrc)
if(USE_PNETCDF)
add_subdirectory(libsrcp)
endif(USE_PNETCDF)
if(USE_NETCDF4)
add_subdirectory(libsrc4)
endif()
if(USE_HDF5)
add_subdirectory(libhdf5)
endif(USE_HDF5)
if(USE_HDF4)
add_subdirectory(libhdf4)
add_subdirectory(hdf4_test)
endif(USE_HDF4)
if(NETCDF_ENABLE_DAP2)
add_subdirectory(oc2)
add_subdirectory(libdap2)
endif()
if(NETCDF_ENABLE_DAP4)
add_subdirectory(libdap4)
add_subdirectory(libncxml)
else()
if(NETCDF_ENABLE_S3_INTERNAL)
add_subdirectory(libncxml)
endif()
endif()
if(NETCDF_ENABLE_PLUGINS)
add_subdirectory(libncpoco)
endif()
if(NETCDF_ENABLE_NCZARR)
add_subdirectory(libnczarr)
file(COPY ${netCDF_SOURCE_DIR}/unit_test/timer_utils.h
DESTINATION ${netCDF_BINARY_DIR}/nczarr_test/)
file(COPY ${netCDF_SOURCE_DIR}/unit_test/timer_utils.c
DESTINATION ${netCDF_BINARY_DIR}/nczarr_test/)
file(COPY ${netCDF_SOURCE_DIR}/nc_test4/test_filter.c
DESTINATION ${netCDF_BINARY_DIR}/nczarr_test/)
file(COPY ${netCDF_SOURCE_DIR}/nc_test4/test_filter_misc.c
DESTINATION ${netCDF_BINARY_DIR}/nczarr_test/)
file(COPY ${netCDF_SOURCE_DIR}/nc_test4/test_filter_repeat.c
DESTINATION ${netCDF_BINARY_DIR}/nczarr_test/)
file(COPY ${netCDF_SOURCE_DIR}/nc_test4/test_filter_order.c
DESTINATION ${netCDF_BINARY_DIR}/nczarr_test/)
file(COPY ${netCDF_SOURCE_DIR}/nc_test4/tst_multifilter.c
DESTINATION ${netCDF_BINARY_DIR}/nczarr_test/)
endif()
add_subdirectory(liblib)
if(NETCDF_ENABLE_PLUGINS)
add_subdirectory(plugins)
endif()
# Enable Utilities.
if(NETCDF_BUILD_UTILITIES)
include_directories(ncdump)
add_subdirectory(ncgen)
add_subdirectory(ncgen3)
add_subdirectory(ncdump)
endif()
# Enable tests
if(NETCDF_ENABLE_TESTS)
if(ENABLE_V2_API)
add_subdirectory(nctest)
endif()
add_subdirectory(nc_test)
if(USE_HDF5)
include_directories(h5_test)
add_subdirectory(nc_test4)
add_subdirectory(h5_test)
endif()
if(NETCDF_ENABLE_DAP2)
add_subdirectory(ncdap_test)
endif()
if(NETCDF_ENABLE_DAP4)
add_subdirectory(dap4_test)
endif()
if(NETCDF_ENABLE_EXAMPLES)
add_subdirectory(examples)
endif()
if(NETCDF_ENABLE_BENCHMARKS)
add_subdirectory(nc_perf)
endif(NETCDF_ENABLE_BENCHMARKS)
if(NETCDF_ENABLE_UNIT_TESTS)
add_subdirectory(unit_test)
endif(NETCDF_ENABLE_UNIT_TESTS)
if(NETCDF_ENABLE_NCZARR)
add_subdirectory(nczarr_test)
endif()
endif()
# Code to generate an export header
#GENERATE_EXPORT_HEADER(netcdf
# BASE_NAME netcdf
# EXPORT_MACRO_NAME netcdf_EXPORT
# EXPORT_FILE_NAME netcdf_Export.h
# STATIC_DEFINE netcdf_BUILT_AS_STATIC
#)
#####
# Build doxygen documentation, if need be.
#####
add_subdirectory(docs)
##
# Brute force, grab all of the dlls from the dependency directory,
# install them in the binary dir. Grab all of the .libs, put them
# in the libdir.
##
if(MSVC)
file(GLOB COPY_FILES ${CMAKE_PREFIX_PATH}/lib/*.lib)
install(FILES ${COPY_FILES}
DESTINATION ${CMAKE_INSTALL_LIBDIR}
COMPONENT dependencies)
file(GLOB COPY_FILES ${CMAKE_PREFIX_PATH}/bin/*.dll)
string(REGEX REPLACE "msv[.*].dll" "" COPY_FILES "${COPY_FILES}")
install(FILES ${COPY_FILES}
DESTINATION ${CMAKE_INSTALL_BINDIR}
COMPONENT dependencies)
endif()
# Subdirectory CMakeLists.txt files should specify their own
# 'install' files.
# Including 'CPack' kicks everything off.
include(InstallRequiredSystemLibraries)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/FixBundle.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/FixBundle.cmake
@ONLY
)
###
# Create pkgconfig files.
###
if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
set(CMAKE_INSTALL_LIBDIR lib)
endif(NOT DEFINED CMAKE_INSTALL_LIBDIR)
# Set
set(prefix ${CMAKE_INSTALL_PREFIX})
set(exec_prefix ${CMAKE_INSTALL_PREFIX})
set(libdir ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
set(includedir ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR})
set(CC ${CMAKE_C_COMPILER})
# Process all dependency libraries and create a string
# used when parsing netcdf.pc.in
set(NC_LIBS "")
foreach(_LIB ${ALL_TLL_LIBS})
get_filename_component(_LIB_NAME ${_LIB} NAME_WE)
string(REGEX REPLACE "^lib" "" _NAME ${_LIB_NAME})
list(APPEND NC_LIBS "-l${_NAME}")
get_filename_component(_LIB_DIR ${_LIB} PATH)
list(APPEND LINKFLAGS "-L${_LIB_DIR}")
endforeach()
if(NC_LIBS)
string(REPLACE ";" " " NC_LIBS "${NC_LIBS}")
endif()
string(REPLACE ";" " " LINKFLAGS "${LINKFLAGS}")
list(REMOVE_DUPLICATES NC_LIBS)
list(REMOVE_DUPLICATES LINKFLAGS)
set(LIBS ${NC_LIBS})
set(NC_LIBS "-lnetcdf")
configure_file(
${netCDF_SOURCE_DIR}/netcdf.pc.in
${netCDF_BINARY_DIR}/netcdf.pc @ONLY)
if(NOT IS_DIRECTORY ${netCDF_BINARY_DIR}/tmp)
file(MAKE_DIRECTORY ${netCDF_BINARY_DIR}/tmp)
endif()
configure_file("${netCDF_SOURCE_DIR}/nc-config.cmake.in"
"${netCDF_BINARY_DIR}/tmp/nc-config" @ONLY
NEWLINE_STYLE LF)
file(COPY "${netCDF_BINARY_DIR}/tmp/nc-config"
DESTINATION ${netCDF_BINARY_DIR}/
FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
install(FILES ${netCDF_BINARY_DIR}/netcdf.pc
DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
COMPONENT utilities)
install(PROGRAMS ${netCDF_BINARY_DIR}/nc-config
DESTINATION ${CMAKE_INSTALL_BINDIR}
COMPONENT utilities)
###
# End pkgconfig, nc-config file creation.
###
##
# Print the configuration summary
##
print_conf_summary()
# Enable Makedist files.
ADD_MAKEDIST()
ENABLE_MAKEDIST(README.md COPYRIGHT RELEASE_NOTES.md INSTALL INSTALL.cmake test_prog.c lib_flags.am cmake CMakeLists.txt COMPILE.cmake.txt config.h.cmake.in cmake_uninstall.cmake.in netcdf-config-version.cmake.in netcdf-config.cmake.in FixBundle.cmake.in nc-config.cmake.in configure configure.ac install-sh config.h.in config.sub CTestConfig.cmake.in)
#####
# Configure and print the libnetcdf.settings file.
#####
# Set variables to mirror those used by autoconf.
# This way we don't need to maintain two separate template
# files.
set(host_cpu "${cpu}")
set(host_vendor "${osname}")
set(host_os "${osrel}")
set(abs_top_builddir "${CMAKE_CURRENT_BINARY_DIR}")
set(abs_top_srcdir "${CMAKE_CURRENT_SOURCE_DIR}")
string(RANDOM LENGTH 3 ALPHABET "0123456789" PLATFORMUID)
math(EXPR PLATFORMUID "${PLATFORMUID} + 1" OUTPUT_FORMAT DECIMAL)
set(CC_VERSION "${CMAKE_C_COMPILER}")
# Build *FLAGS for libnetcdf.settings.
set(CFLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE}}")
set(CPPFLAGS "${CMAKE_CPP_FLAGS} ${CMAKE_CPP_FLAGS_${CMAKE_BUILD_TYPE}}")
set(LDFLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_${CMAKE_BUILD_TYPE}}")
is_disabled(BUILD_SHARED_LIBS enable_static)
is_enabled(BUILD_SHARED_LIBS enable_shared)
is_enabled(ENABLE_V2_API HAS_NC2)
is_enabled(NETCDF_ENABLE_NETCDF_4 HAS_NC4)
is_enabled(NETCDF_ENABLE_HDF4 HAS_HDF4)
is_enabled(USE_HDF5 HAS_HDF5)
is_enabled(OFF HAS_BENCHMARKS)
is_enabled(STATUS_PNETCDF HAS_PNETCDF)
is_enabled(STATUS_PARALLEL HAS_PARALLEL)
is_enabled(NETCDF_ENABLE_PARALLEL4 HAS_PARALLEL4)
is_enabled(NETCDF_ENABLE_DAP HAS_DAP)
is_enabled(NETCDF_ENABLE_DAP2 HAS_DAP2)
is_enabled(NETCDF_ENABLE_DAP4 HAS_DAP4)
is_enabled(NETCDF_ENABLE_BYTERANGE HAS_BYTERANGE)
is_enabled(NETCDF_ENABLE_DISKLESS HAS_DISKLESS)
is_enabled(USE_MMAP HAS_MMAP)
is_enabled(JNA HAS_JNA)
is_enabled(ENABLE_ZERO_LENGTH_COORD_BOUND RELAX_COORD_BOUND)
is_enabled(USE_CDF5 HAS_CDF5)
is_enabled(NETCDF_ENABLE_ERANGE_FILL HAS_ERANGE_FILL)
is_enabled(HDF5_HAS_PAR_FILTERS HAS_PAR_FILTERS)
is_enabled(NETCDF_ENABLE_S3 HAS_S3)
is_enabled(NETCDF_ENABLE_S3_AWS HAS_S3_AWS)
is_enabled(NETCDF_ENABLE_S3_INTERNAL HAS_S3_INTERNAL)
is_enabled(HAS_HDF5_ROS3 HAS_HDF5_ROS3)
is_enabled(NETCDF_ENABLE_NCZARR HAS_NCZARR)
is_enabled(NETCDF_ENABLE_NCZARR_ZIP HAS_NCZARR_ZIP)
is_enabled(NETCDF_ENABLE_NCZARR_ZIP DO_NCZARR_ZIP_TESTS)
is_enabled(NETCDF_ENABLE_QUANTIZE HAS_QUANTIZE)
is_enabled(NETCDF_ENABLE_LOGGING HAS_LOGGING)
is_enabled(NETCDF_ENABLE_FILTER_TESTING DO_FILTER_TESTS)
is_enabled(HAVE_SZ HAS_SZIP)
is_enabled(HAVE_SZ HAS_SZLIB_WRITE)
is_enabled(HAVE_ZSTD HAS_ZSTD)
is_enabled(HAVE_BLOSC HAS_BLOSC)
is_enabled(HAVE_BZ2 HAS_BZ2)
is_enabled(NETCDF_ENABLE_REMOTE_FUNCTIONALITY DO_REMOTE_FUNCTIONALITY)
if(NETCDF_ENABLE_S3_INTERNAL)
set(WHICH_S3_SDK "internal")
set(NC_WHICH_S3_SDK "internal")
elseif(NETCDF_ENABLE_S3_AWS)
set(WHICH_S3_SDK "aws-sdk-cpp")
set(NC_WHICH_S3_SDK "aws-sdk-cpp")
else()
set(WHICH_S3_SDK "none")
set(NC_WHICH_S3_SDK "none")
endif()
if(WITH_S3_TESTING STREQUAL PUBLIC)
set(NETCDF_ENABLE_S3_TESTING "public")
elseif(WITH_S3_TESTING)
set(NETCDF_ENABLE_S3_TESTING "yes")
set(NETCDF_ENABLE_S3_TESTALL "yes")
elseif(NOT WITH_S3_TESTING)
set(NETCDF_ENABLE_S3_TESTING "no")
else()
set(NETCDF_ENABLE_S3_TESTING "no")
endif()
# The Unidata testing S3 bucket
# WARNING: this must match the value in configure.ac
set(S3TESTBUCKET "unidata-zarr-test-data" CACHE STRING "S3 test bucket")
# The working S3 path tree within the Unidata bucket.
# WARNING: this must match the value in configure.ac
set(S3TESTSUBTREE "netcdf-c" CACHE STRING "Working S3 path.")
# Build a unique id based on the date
string(TIMESTAMP TESTUID "%s")
if(NETCDF_ENABLE_S3_TESTING)
file(APPEND "${CMAKE_CURRENT_BINARY_DIR}/s3cleanup_${PLATFORMUID}.uids" "${TESTUID}\n")
endif()
# Copy the CTest customization file into binary directory, as required.
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/CTestCustom.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.cmake")
# Generate file from template.
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/libnetcdf.settings.in"
"${CMAKE_CURRENT_BINARY_DIR}/libnetcdf.settings"
@ONLY)
# Read in settings file, print out.
# Avoid using system-specific calls so that this
# might also work on Windows.
file(READ "${CMAKE_CURRENT_BINARY_DIR}/libnetcdf.settings"
LIBNETCDF_SETTINGS)
message(STATUS ${LIBNETCDF_SETTINGS})
###
# Report deprecated options detected by
# cmake/deprecated.cmake. Added in support of
# https://github.com/Unidata/netcdf-c/pull/2895
###
if(DEFINED DEPR_OPT)
message(WARNING "Warning! Deprecated Options used. Please migrate your build system as follows:\n${DEPR_OPT}" )
endif()
# Install libnetcdf.settings file into same location
# as the libraries.
install(FILES "${netCDF_BINARY_DIR}/libnetcdf.settings"
DESTINATION "${CMAKE_INSTALL_LIBDIR}"
COMPONENT libraries)
#####
# End libnetcdf.settings section.
#####
#####
# Create 'netcdf_meta.h' include file.
#####
configure_file(
${netCDF_SOURCE_DIR}/include/netcdf_meta.h.in
${netCDF_BINARY_DIR}/include/netcdf_meta.h @ONLY)
#####
# Create 'netcdf_dispatch.h' include file.
#####
configure_file(
${netCDF_SOURCE_DIR}/include/netcdf_dispatch.h.in
${netCDF_BINARY_DIR}/include/netcdf_dispatch.h @ONLY NEWLINE_STYLE LF)
####
# Build test_common.sh
#####
set(EXTRA_DIST ${EXTRA_DIST} ${CMAKE_CURRENT_SOURCE_DIR}/test_common.in)
set(TOPSRCDIR "${CMAKE_CURRENT_SOURCE_DIR}")
set(TOPBUILDDIR "${CMAKE_CURRENT_BINARY_DIR}")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/test_common.in ${CMAKE_CURRENT_BINARY_DIR}/test_common.sh @ONLY NEWLINE_STYLE LF)
####
# Build s3cleanup.sh and s3gc.sh
#####
set(EXTRA_DIST ${EXTRA_DIST} ${CMAKE_CURRENT_SOURCE_DIR}/s3cleanup.in ${CMAKE_CURRENT_SOURCE_DIR}/s3gc.in)
set(TOPSRCDIR "${CMAKE_CURRENT_SOURCE_DIR}")
set(TOPBUILDDIR "${CMAKE_CURRENT_BINARY_DIR}")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/s3cleanup.in ${CMAKE_CURRENT_BINARY_DIR}/s3cleanup.sh @ONLY NEWLINE_STYLE LF)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/s3gc.in ${CMAKE_CURRENT_BINARY_DIR}/s3gc.sh @ONLY NEWLINE_STYLE LF)
#####
# Build and copy nc_test4/findplugin.sh to various places
#####
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/nc_test4/findplugin.in ${CMAKE_CURRENT_BINARY_DIR}/nc_test4/findplugin.sh @ONLY NEWLINE_STYLE LF)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/nc_test4/findplugin.in ${CMAKE_CURRENT_BINARY_DIR}/nczarr_test/findplugin.sh @ONLY NEWLINE_STYLE LF)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/nc_test4/findplugin.in ${CMAKE_CURRENT_BINARY_DIR}/plugins/findplugin.sh @ONLY NEWLINE_STYLE LF)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/nc_test4/findplugin.in ${CMAKE_CURRENT_BINARY_DIR}/examples/C/findplugin.sh @ONLY NEWLINE_STYLE LF)
if(NETCDF_ENABLE_BENCHMARKS)
if(NETCDF_ENABLE_PARALLEL4)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/nc_perf/run_par_bm_test.sh.in ${CMAKE_CURRENT_BINARY_DIR}/nc_perf/run_par_bm_test.sh @ONLY NEWLINE_STYLE LF)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/nc_perf/run_gfs_test.sh.in ${CMAKE_CURRENT_BINARY_DIR}/nc_perf/run_gfs_test.sh @ONLY NEWLINE_STYLE LF)
endif(NETCDF_ENABLE_PARALLEL4)
endif(NETCDF_ENABLE_BENCHMARKS)
if(NETCDF_ENABLE_TESTS)
#####
# Build ncdap_test|dap4_test/findtestserver[4].c
#####
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ncdap_test/findtestserver.c.in ${CMAKE_CURRENT_BINARY_DIR}/ncdap_test/findtestserver.c @ONLY NEWLINE_STYLE LF)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ncdap_test/findtestserver.c.in ${CMAKE_CURRENT_BINARY_DIR}/dap4_test/findtestserver4.c @ONLY NEWLINE_STYLE LF)
#####
# Build dap4_test/pingurl4.c
#####
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/ncdap_test/pingurl.c ${CMAKE_CURRENT_BINARY_DIR}/dap4_test/pingurl4.c @ONLY NEWLINE_STYLE LF)
#####
# Build CTestCustom.cmake to cleanup S3 after tests are done.
#####
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CTestCustom.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.cmake NEWLINE_STYLE LF)
endif()
if(DEFINED ENV{LIB_FUZZING_ENGINE})
add_subdirectory(fuzz)
endif(DEFINED ENV{LIB_FUZZING_ENGINE})
####
# Export files
####
# Create CMake package configuration files. With these, other packages using
# cmake should be able to find netcdf using find_package and find_library.
# The EXPORT call is paired with one in liblib.
set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/netCDF)
install(EXPORT netCDFTargets
DESTINATION ${ConfigPackageLocation}
COMPONENT headers
NAMESPACE netCDF::
)
export(EXPORT netCDFTargets FILE netCDFTargets.cmake NAMESPACE netCDF::)
include(CMakePackageConfigHelpers)
configure_package_config_file(
"${CMAKE_CURRENT_SOURCE_DIR}/netCDFConfig.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/netCDFConfig.cmake"
INSTALL_DESTINATION "${ConfigPackageLocation}"
)
target_include_directories(netcdf
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
# Create export configuration
write_basic_package_version_file(
netCDFConfigVersion.cmake
VERSION ${netCDF_VERSION}
COMPATIBILITY SameMajorVersion
)
install(
FILES
"${CMAKE_CURRENT_BINARY_DIR}/netCDFConfig.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/netCDFConfigVersion.cmake"
DESTINATION ${ConfigPackageLocation}
COMPONENT headers
)
####
# End export files
####
# CPack inclusion must come last.
option(NETCDF_PACKAGE "Create netCDF-C package " ${NETCDF_IS_TOP_LEVEL})
if (NETCDF_PACKAGE)
include(CMakeInstallation.cmake)
endif()
Reference in New Issue View Git Blame Copy Permalink