diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
| commit | 19fcec84d8d7d21e796c7624e521b60d28ee21ed (patch) | |
| tree | 42d26aa27d1e3f7c0b8bd3fd14e7d7082f5008dc /cmake | |
| parent | Initial commit. (diff) | |
| download | ceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.tar.xz ceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.zip | |
Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'cmake')
75 files changed, 7655 insertions, 0 deletions
diff --git a/cmake/modules/AddCephTest.cmake b/cmake/modules/AddCephTest.cmake new file mode 100644 index 000000000..cd661be16 --- /dev/null +++ b/cmake/modules/AddCephTest.cmake @@ -0,0 +1,98 @@ +#AddCephTest is a module for adding tests to the "make check" target which runs CTest + +#adds makes target/script into a test, test to check target, sets necessary environment variables +function(add_ceph_test test_name test_path) + add_test(NAME ${test_name} COMMAND ${test_path} ${ARGN}) + if(TARGET ${test_name}) + add_dependencies(tests ${test_name}) + set_property(TARGET ${test_name} + PROPERTY EXCLUDE_FROM_ALL TRUE) + endif() + set_property(TEST ${test_name} + PROPERTY ENVIRONMENT + CEPH_ROOT=${CMAKE_SOURCE_DIR} + CEPH_BIN=${CMAKE_RUNTIME_OUTPUT_DIRECTORY} + CEPH_LIB=${CMAKE_LIBRARY_OUTPUT_DIRECTORY} + CEPH_BUILD_DIR=${CMAKE_BINARY_DIR} + LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/lib + PATH=${CMAKE_RUNTIME_OUTPUT_DIRECTORY}:${CMAKE_SOURCE_DIR}/src:$ENV{PATH} + PYTHONPATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/cython_modules/lib.3:${CMAKE_SOURCE_DIR}/src/pybind + CEPH_BUILD_VIRTUALENV=${CEPH_BUILD_VIRTUALENV}) + # none of the tests should take more than 1 hour to complete + set_property(TEST ${test_name} + PROPERTY TIMEOUT ${CEPH_TEST_TIMEOUT}) +endfunction() + +option(WITH_GTEST_PARALLEL "Enable running gtest based tests in parallel" OFF) +if(WITH_GTEST_PARALLEL) + if(NOT TARGET gtest-parallel_ext) + set(gtest_parallel_source_dir ${CMAKE_CURRENT_BINARY_DIR}/gtest-parallel) + include(ExternalProject) + ExternalProject_Add(gtest-parallel_ext + SOURCE_DIR "${gtest_parallel_source_dir}" + GIT_REPOSITORY "https://github.com/google/gtest-parallel.git" + GIT_TAG "master" + GIT_SHALLOW TRUE + CONFIGURE_COMMAND "" + BUILD_COMMAND "" + INSTALL_COMMAND "") + add_dependencies(tests gtest-parallel_ext) + set(GTEST_PARALLEL_COMMAND + ${Python3_EXECUTABLE} ${gtest_parallel_source_dir}/gtest-parallel) + endif() +endif() + +#sets uniform compiler flags and link libraries +function(add_ceph_unittest unittest_name) + set(UNITTEST "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${unittest_name}") + cmake_parse_arguments(UT "PARALLEL" "" "" ${ARGN}) + if(WITH_GTEST_PARALLEL AND UT_PARALLEL) + set(UNITTEST ${GTEST_PARALLEL_COMMAND} ${UNITTEST}) + endif() + add_ceph_test(${unittest_name} "${UNITTEST}" ${UT_UNPARSED_ARGUMENTS}) + target_link_libraries(${unittest_name} ${UNITTEST_LIBS}) +endfunction() + +function(add_tox_test name) + set(test_name run-tox-${name}) + set(venv_path ${CEPH_BUILD_VIRTUALENV}/${name}-virtualenv) + cmake_parse_arguments(TOXTEST "" "TOX_PATH" "TOX_ENVS" ${ARGN}) + if(DEFINED TOXTEST_TOX_PATH) + set(tox_path ${TOXTEST_TOX_PATH}) + else() + set(tox_path ${CMAKE_CURRENT_SOURCE_DIR}) + endif() + if(DEFINED TOXTEST_TOX_ENVS) + list(APPEND tox_envs ${TOXTEST_TOX_ENVS}) + else() + list(APPEND tox_envs py3) + endif() + string(REPLACE ";" "," tox_envs "${tox_envs}") + add_custom_command( + OUTPUT ${venv_path}/bin/activate + COMMAND ${CMAKE_SOURCE_DIR}/src/tools/setup-virtualenv.sh --python="${Python3_EXECUTABLE}" ${venv_path} + WORKING_DIRECTORY ${tox_path} + COMMENT "preparing venv for ${name}") + add_custom_target(${name}-venv + DEPENDS ${venv_path}/bin/activate) + add_dependencies(tests ${name}-venv) + add_test( + NAME ${test_name} + COMMAND ${CMAKE_SOURCE_DIR}/src/script/run_tox.sh + --source-dir ${CMAKE_SOURCE_DIR} + --build-dir ${CMAKE_BINARY_DIR} + --tox-path ${tox_path} + --tox-envs ${tox_envs} + --venv-path ${venv_path}) + set_property( + TEST ${test_name} + PROPERTY ENVIRONMENT + CEPH_ROOT=${CMAKE_SOURCE_DIR} + CEPH_BIN=${CMAKE_RUNTIME_OUTPUT_DIRECTORY} + CEPH_LIB=${CMAKE_LIBRARY_OUTPUT_DIRECTORY} + CEPH_BUILD_VIRTUALENV=${CEPH_BUILD_VIRTUALENV} + LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/lib + PATH=${CMAKE_RUNTIME_OUTPUT_DIRECTORY}:${CMAKE_SOURCE_DIR}/src:$ENV{PATH} + PYTHONPATH=${CMAKE_SOURCE_DIR}/src/pybind) + list(APPEND tox_test run-tox-${name}) +endfunction() diff --git a/cmake/modules/BuildBoost.cmake b/cmake/modules/BuildBoost.cmake new file mode 100644 index 000000000..f84428921 --- /dev/null +++ b/cmake/modules/BuildBoost.cmake @@ -0,0 +1,292 @@ +# This module builds Boost +# executables are. It sets the following variables: +# +# Boost_FOUND : boolean - system has Boost +# Boost_LIBRARIES : list(filepath) - the libraries needed to use Boost +# Boost_INCLUDE_DIRS : list(path) - the Boost include directories +# +# Following hints are respected +# +# Boost_USE_STATIC_LIBS : boolean (default: OFF) +# Boost_USE_MULTITHREADED : boolean (default: OFF) +# BOOST_J: integer (defanult 1) + +# CMAKE_CURRENT_FUNCTION_LIST_DIR is introduced by cmake 3.17, but ubuntu comes with 3.16 +set(_build_boost_list_dir "${CMAKE_CURRENT_LIST_DIR}") + +function(check_boost_version source_dir expected_version) + set(version_hpp "${source_dir}/boost/version.hpp") + if(NOT EXISTS ${version_hpp}) + message(FATAL_ERROR "${version_hpp} not found. Please either \"rm -rf ${source_dir}\" " + "so I can download Boost v${expected_version} for you, or make sure ${source_dir} " + "contains a full copy of Boost v${expected_version}.") + endif() + file(STRINGS "${version_hpp}" BOOST_VERSION_LINE + REGEX "^#define[ \t]+BOOST_VERSION[ \t]+[0-9]+$") + string(REGEX REPLACE "^#define[ \t]+BOOST_VERSION[ \t]+([0-9]+)$" + "\\1" BOOST_VERSION "${BOOST_VERSION_LINE}") + math(EXPR BOOST_VERSION_PATCH "${BOOST_VERSION} % 100") + math(EXPR BOOST_VERSION_MINOR "${BOOST_VERSION} / 100 % 1000") + math(EXPR BOOST_VERSION_MAJOR "${BOOST_VERSION} / 100000") + set(version "${BOOST_VERSION_MAJOR}.${BOOST_VERSION_MINOR}.${BOOST_VERSION_PATCH}") + if(version VERSION_LESS expected_version) + message(FATAL_ERROR "Boost v${version} in ${source_dir} is not new enough. " + "Please either \"rm -rf ${source_dir}\" so I can download Boost v${expected_version} " + "for you, or make sure ${source_dir} contains a copy of Boost v${expected_version}.") + else() + message(STATUS "boost (${version} >= ${expected_version}) already in ${source_dir}") + endif() +endfunction() + +macro(list_replace list old new) + list(FIND ${list} ${old} where) + if(where GREATER -1) + list(REMOVE_AT ${list} ${where}) + list(INSERT ${list} ${where} ${new}) + endif() + unset(where) +endmacro() + +function(do_build_boost version) + cmake_parse_arguments(Boost_BUILD "" "" COMPONENTS ${ARGN}) + set(boost_features "variant=release") + if(Boost_USE_MULTITHREADED) + list(APPEND boost_features "threading=multi") + else() + list(APPEND boost_features "threading=single") + endif() + if(Boost_USE_STATIC_LIBS) + list(APPEND boost_features "link=static") + else() + list(APPEND boost_features "link=shared") + endif() + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + list(APPEND boost_features "address-model=64") + else() + list(APPEND boost_features "address-model=32") + endif() + set(BOOST_CXXFLAGS "-fPIC -w") # check on arm, etc <---XXX + list(APPEND boost_features "cxxflags=${BOOST_CXXFLAGS}") + + set(boost_with_libs) + foreach(c ${Boost_BUILD_COMPONENTS}) + if(c MATCHES "^python([0-9])\$") + set(with_python_version "${CMAKE_MATCH_1}") + list(APPEND boost_with_libs "python") + elseif(c MATCHES "^python([0-9])\\.?([0-9]+)\$") + set(with_python_version "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}") + list(APPEND boost_with_libs "python") + else() + list(APPEND boost_with_libs ${c}) + endif() + endforeach() + list_replace(boost_with_libs "unit_test_framework" "test") + string(REPLACE ";" "," boost_with_libs "${boost_with_libs}") + # build b2 and prepare the project-config.jam for boost + set(configure_command + ./bootstrap.sh --prefix=<INSTALL_DIR> + --with-libraries=${boost_with_libs}) + + set(b2 ./b2) + if(BOOST_J) + message(STATUS "BUILDING Boost Libraries at j ${BOOST_J}") + list(APPEND b2 -j${BOOST_J}) + endif() + # suppress all debugging levels for b2 + list(APPEND b2 -d0) + + if(CMAKE_CXX_COMPILER_ID STREQUAL GNU) + set(toolset gcc) + elseif(CMAKE_CXX_COMPILER_ID STREQUAL Clang) + set(toolset clang) + else() + message(SEND_ERROR "unknown compiler: ${CMAKE_CXX_COMPILER_ID}") + endif() + + set(user_config ${CMAKE_BINARY_DIR}/user-config.jam) + # edit the user-config.jam so b2 will be able to use the specified + # toolset and python + file(WRITE ${user_config} + "using ${toolset}" + " : " + " : ${CMAKE_CXX_COMPILER}" + " ;\n") + if(with_python_version) + find_package(Python3 ${with_python_version} QUIET REQUIRED + COMPONENTS Development) + string(REPLACE ";" " " python3_includes "${Python3_INCLUDE_DIRS}") + file(APPEND ${user_config} + "using python" + " : ${with_python_version}" + " : ${Python3_EXECUTABLE}" + " : ${python3_includes}" + " : ${Python3_LIBRARIES}" + " ;\n") + endif() + list(APPEND b2 --user-config=${user_config}) + + list(APPEND b2 toolset=${toolset}) + if(with_python_version) + list(APPEND b2 python=${with_python_version}) + endif() + if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM") + list(APPEND b2 abi=aapcs) + list(APPEND b2 architecture=arm) + list(APPEND b2 binary-format=elf) + endif() + if(WITH_BOOST_VALGRIND) + list(APPEND b2 valgrind=on) + endif() + set(build_command + ${b2} headers stage + #"--buildid=ceph" # changes lib names--can omit for static + ${boost_features}) + set(install_command + ${b2} install) + set(boost_root_dir "${CMAKE_BINARY_DIR}/boost") + if(EXISTS "${PROJECT_SOURCE_DIR}/src/boost/bootstrap.sh") + check_boost_version("${PROJECT_SOURCE_DIR}/src/boost" ${version}) + set(source_dir + SOURCE_DIR "${PROJECT_SOURCE_DIR}/src/boost") + elseif(version VERSION_GREATER 1.73) + message(FATAL_ERROR "Unknown BOOST_REQUESTED_VERSION: ${version}") + else() + message(STATUS "boost will be downloaded...") + # NOTE: If you change this version number make sure the package is available + # at the three URLs below (may involve uploading to download.ceph.com) + set(boost_version 1.73.0) + set(boost_sha256 4eb3b8d442b426dc35346235c8733b5ae35ba431690e38c6a8263dce9fcbb402) + string(REPLACE "." "_" boost_version_underscore ${boost_version} ) + set(boost_url + https://boostorg.jfrog.io/artifactory/main/release/${boost_version}/source/boost_${boost_version_underscore}.tar.bz2) + if(CMAKE_VERSION VERSION_GREATER 3.7) + set(boost_url + "${boost_url} http://downloads.sourceforge.net/project/boost/boost/${boost_version}/boost_${boost_version_underscore}.tar.bz2") + set(boost_url + "${boost_url} https://download.ceph.com/qa/boost_${boost_version_underscore}.tar.bz2") + endif() + set(source_dir + URL ${boost_url} + URL_HASH SHA256=${boost_sha256} + DOWNLOAD_NO_PROGRESS 1) + endif() + find_program(PATCH_EXECUTABLE patch) + # build all components in a single shot + include(ExternalProject) + ExternalProject_Add(Boost + ${source_dir} + PATCH_COMMAND ${PATCH_EXECUTABLE} -p3 -i ${_build_boost_list_dir}/boost-python-use-public-api-for-filename.patch + CONFIGURE_COMMAND CC=${CMAKE_C_COMPILER} CXX=${CMAKE_CXX_COMPILER} ${configure_command} + BUILD_COMMAND CC=${CMAKE_C_COMPILER} CXX=${CMAKE_CXX_COMPILER} ${build_command} + BUILD_IN_SOURCE 1 + INSTALL_COMMAND ${install_command} + PREFIX "${boost_root_dir}") +endfunction() + +set(Boost_context_DEPENDENCIES thread chrono system date_time) +set(Boost_coroutine_DEPENDENCIES context system) +set(Boost_filesystem_DEPENDENCIES system) +set(Boost_iostreams_DEPENDENCIES regex) +set(Boost_thread_DEPENDENCIES chrono system date_time atomic) + +macro(build_boost version) + do_build_boost(${version} ${ARGN}) + ExternalProject_Get_Property(Boost install_dir) + set(Boost_INCLUDE_DIRS ${install_dir}/include) + set(Boost_INCLUDE_DIR ${install_dir}/include) + set(Boost_VERSION ${version}) + # create the directory so cmake won't complain when looking at the imported + # target + file(MAKE_DIRECTORY ${Boost_INCLUDE_DIRS}) + cmake_parse_arguments(Boost_BUILD "" "" COMPONENTS ${ARGN}) + foreach(c ${Boost_BUILD_COMPONENTS}) + list(APPEND components ${c}) + if(Boost_${c}_DEPENDENCIES) + list(APPEND components ${Boost_${c}_DEPENDENCIES}) + list(REMOVE_DUPLICATES components) + endif() + endforeach() + set(Boost_BUILD_COMPONENTS ${components}) + unset(components) + + foreach(c ${Boost_BUILD_COMPONENTS}) + string(TOUPPER ${c} upper_c) + if(Boost_USE_STATIC_LIBS) + add_library(Boost::${c} STATIC IMPORTED) + else() + add_library(Boost::${c} SHARED IMPORTED) + endif() + add_dependencies(Boost::${c} Boost) + if(c MATCHES "^python") + set(c "python${Python3_VERSION_MAJOR}${Python3_VERSION_MINOR}") + endif() + if(Boost_USE_STATIC_LIBS) + set(Boost_${upper_c}_LIBRARY + ${install_dir}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}boost_${c}${CMAKE_STATIC_LIBRARY_SUFFIX}) + else() + set(Boost_${upper_c}_LIBRARY + ${install_dir}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}boost_${c}${CMAKE_SHARED_LIBRARY_SUFFIX}) + endif() + unset(buildid) + set_target_properties(Boost::${c} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}" + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LOCATION "${Boost_${upper_c}_LIBRARY}") + if((c MATCHES "coroutine|context") AND (WITH_BOOST_VALGRIND)) + set_target_properties(Boost::${c} PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "BOOST_USE_VALGRIND") + endif() + list(APPEND Boost_LIBRARIES ${Boost_${upper_c}_LIBRARY}) + endforeach() + foreach(c ${Boost_BUILD_COMPONENTS}) + if(Boost_${c}_DEPENDENCIES) + foreach(dep ${Boost_${c}_DEPENDENCIES}) + list(APPEND dependencies Boost::${dep}) + endforeach() + set_target_properties(Boost::${c} PROPERTIES + INTERFACE_LINK_LIBRARIES "${dependencies}") + unset(dependencies) + endif() + set(Boost_${c}_FOUND "TRUE") + endforeach() + + # for header-only libraries + add_library(Boost::boost INTERFACE IMPORTED) + set_target_properties(Boost::boost PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}") + add_dependencies(Boost::boost Boost) + find_package_handle_standard_args(Boost DEFAULT_MSG + Boost_INCLUDE_DIRS Boost_LIBRARIES) + mark_as_advanced(Boost_LIBRARIES BOOST_INCLUDE_DIRS) +endmacro() + +function(maybe_add_boost_dep target) + get_target_property(type ${target} TYPE) + if(NOT type MATCHES "OBJECT_LIBRARY|STATIC_LIBRARY|SHARED_LIBRARY|EXECUTABLE") + return() + endif() + get_target_property(sources ${target} SOURCES) + string(GENEX_STRIP "${sources}" sources) + foreach(src ${sources}) + get_filename_component(ext ${src} EXT) + # assuming all cxx source files include boost header(s) + if(ext MATCHES ".cc|.cpp|.cxx") + add_dependencies(${target} Boost::boost) + return() + endif() + endforeach() +endfunction() + +# override add_library() to add Boost headers dependency +function(add_library target) + _add_library(${target} ${ARGN}) + # can't add dependencies to aliases or imported libraries + if (NOT ";${ARGN};" MATCHES ";(ALIAS|IMPORTED);") + maybe_add_boost_dep(${target}) + endif() +endfunction() + +function(add_executable target) + _add_executable(${target} ${ARGN}) + maybe_add_boost_dep(${target}) +endfunction() diff --git a/cmake/modules/BuildDPDK.cmake b/cmake/modules/BuildDPDK.cmake new file mode 100644 index 000000000..cb418b48e --- /dev/null +++ b/cmake/modules/BuildDPDK.cmake @@ -0,0 +1,187 @@ +function(do_build_dpdk dpdk_dir) + # mk/machine/native/rte.vars.mk + # rte_cflags are extracted from mk/machine/${machine}/rte.vars.mk + # only 3 of them have -march=<arch> defined, so copying them here. + # we need to pass the -march=<arch> to ${cc} as some headers in dpdk + # require it to compile. for instance, dpdk/include/rte_memcpy.h. + if(CMAKE_SYSTEM_PROCESSOR MATCHES "i386") + set(arch "x86_64") + set(machine "default") + set(machine_tmpl "native") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686") + set(arch "i686") + set(machine "default") + set(machine_tmpl "native") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|AMD64") + set(arch "x86_64") + set(machine "default") + set(machine_tmpl "native") + set(rte_cflags "-march=core2") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM") + set(arch "arm") + set(machine "armv7a") + set(machine_tmpl "armv7a") + set(rte_cflags "-march=armv7-a") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|AARCH64") + set(arch "arm64") + set(machine "armv8a") + set(machine_tmpl "armv8a") + set(rte_cflags "-march=armv8-a+crc") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(powerpc|ppc)64") + set(arch "ppc_64") + set(machine "power8") + set(machine_tmpl "power8") + else() + message(FATAL_ERROR "not able to build DPDK support: " + "unknown arch \"${CMAKE_SYSTEM_PROCESSOR}\"") + endif() + set(dpdk_rte_CFLAGS "${rte_cflags}" CACHE INTERNAL "") + if(CMAKE_SYSTEM_NAME MATCHES "Linux") + set(execenv "linux") + elseif(CMAKE_SYSTEM_NAME MATCHES "FreeBSD") + set(execenv "freebsd") + else() + message(FATAL_ERROR "not able to build DPDK support: " + "unsupported OS \"${CMAKE_SYSTEM_NAME}\"") + endif() + + if(CMAKE_C_COMPILER_ID STREQUAL GNU) + set(toolchain "gcc") + elseif(CMAKE_C_COMPILER_ID STREQUAL Clang) + set(toolchain "clang") + elseif(CMAKE_C_COMPILER_ID STREQUAL Intel) + set(toolchain "icc") + else() + message(FATAL_ERROR "not able to build DPDK support: " + "unknown compiler \"${CMAKE_C_COMPILER_ID}\"") + endif() + + set(target "${arch}-${machine_tmpl}-${execenv}-${toolchain}") + + include(FindMake) + find_make("MAKE_EXECUTABLE" "make_cmd") + execute_process( + COMMAND ${MAKE_EXECUTABLE} showconfigs + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/src/spdk/dpdk + OUTPUT_VARIABLE supported_targets + OUTPUT_STRIP_TRAILING_WHITESPACE) + string(REPLACE "\n" ";" supported_targets "${supported_targets}") + list(FIND supported_targets ${target} found) + if(found EQUAL -1) + message(FATAL_ERROR "not able to build DPDK support: " + "unsupported target. " + "\"${target}\" not listed in ${supported_targets}") + endif() + + if(Seastar_DPDK AND WITH_SPDK) + message(FATAL_ERROR "not able to build DPDK with " + "both Seastar_DPDK and WITH_SPDK enabled") + elseif(Seastar_DPDK) + set(dpdk_source_dir ${CMAKE_SOURCE_DIR}/src/seastar/dpdk) + else() # WITH_SPDK or WITH_DPDK is enabled + set(dpdk_source_dir ${CMAKE_SOURCE_DIR}/src/spdk/dpdk) + endif() + + include(ExternalProject) + ExternalProject_Add(dpdk-ext + SOURCE_DIR ${dpdk_source_dir} + CONFIGURE_COMMAND ${make_cmd} config O=${dpdk_dir} T=${target} + BUILD_COMMAND ${make_cmd} O=${dpdk_dir} CC=${CMAKE_C_COMPILER} EXTRA_CFLAGS=-fPIC RTE_DEVEL_BUILD=n + BUILD_IN_SOURCE 1 + INSTALL_COMMAND "true") + if(NUMA_FOUND) + set(numa "y") + else() + set(numa "n") + endif() + ExternalProject_Add_Step(dpdk-ext patch-config + COMMAND ${CMAKE_MODULE_PATH}/patch-dpdk-conf.sh ${dpdk_dir} ${machine} ${arch} ${numa} + DEPENDEES configure + DEPENDERS build) + # easier to adjust the config + ExternalProject_Add_StepTargets(dpdk-ext configure patch-config build) +endfunction() + +function(do_export_dpdk dpdk_dir) + set(DPDK_INCLUDE_DIR ${dpdk_dir}/include) + # create the directory so cmake won't complain when looking at the imported + # target + file(MAKE_DIRECTORY ${DPDK_INCLUDE_DIR}) + + if(NOT TARGET dpdk::cflags) + add_library(dpdk::cflags INTERFACE IMPORTED) + if (dpdk_rte_CFLAGS) + set_target_properties(dpdk::cflags PROPERTIES + INTERFACE_COMPILE_OPTIONS "${dpdk_rte_CFLAGS}") + endif() + endif() + + list(APPEND dpdk_components + bus_pci + eal + kvargs + mbuf + mempool + mempool_ring + pci + ring + telemetry) + if(Seastar_DPDK) + list(APPEND dpdk_components + bus_vdev + cfgfile + hash + net + pmd_bnxt + pmd_cxgbe + pmd_e1000 + pmd_ena + pmd_enic + pmd_i40e + pmd_ixgbe + pmd_nfp + pmd_qede + pmd_ring + pmd_sfc_efx + timer) + endif() + + foreach(c ${dpdk_components}) + add_library(dpdk::${c} STATIC IMPORTED) + add_dependencies(dpdk::${c} dpdk-ext) + set(dpdk_${c}_LIBRARY + "${dpdk_dir}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}rte_${c}${CMAKE_STATIC_LIBRARY_SUFFIX}") + set_target_properties(dpdk::${c} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES ${DPDK_INCLUDE_DIR} + INTERFACE_LINK_LIBRARIES dpdk::cflags + IMPORTED_LOCATION "${dpdk_${c}_LIBRARY}") + list(APPEND DPDK_LIBRARIES dpdk::${c}) + list(APPEND DPDK_ARCHIVES "${dpdk_${c}_LIBRARY}") + endforeach() + + if(NUMA_FOUND) + set(dpdk_numa " -Wl,-lnuma") + endif() + add_library(dpdk::dpdk INTERFACE IMPORTED) + add_dependencies(dpdk::dpdk + ${DPDK_LIBRARIES}) + # workaround for https://gitlab.kitware.com/cmake/cmake/issues/16947 + set_target_properties(dpdk::dpdk PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES ${DPDK_INCLUDE_DIR} + INTERFACE_LINK_LIBRARIES + "-Wl,--whole-archive $<JOIN:${DPDK_ARCHIVES}, > -Wl,--no-whole-archive ${dpdk_numa} -Wl,-lpthread,-ldl") + if(dpdk_rte_CFLAGS) + set_target_properties(dpdk::dpdk PROPERTIES + INTERFACE_COMPILE_OPTIONS "${dpdk_rte_CFLAGS}") + endif() +endfunction() + +function(build_dpdk dpdk_dir) + find_package(NUMA QUIET) + if(NOT TARGET dpdk-ext) + do_build_dpdk(${dpdk_dir}) + endif() + if(NOT TARGET dpdk::dpdk) + do_export_dpdk(${dpdk_dir}) + endif() +endfunction() diff --git a/cmake/modules/BuildFIO.cmake b/cmake/modules/BuildFIO.cmake new file mode 100644 index 000000000..a64d63922 --- /dev/null +++ b/cmake/modules/BuildFIO.cmake @@ -0,0 +1,31 @@ +function(build_fio) + # we use an external project and copy the sources to bin directory to ensure + # that object files are built outside of the source tree. + include(ExternalProject) + if(ALLOCATOR) + set(FIO_EXTLIBS EXTLIBS=-l${ALLOCATOR}) + endif() + + include(FindMake) + find_make("MAKE_EXECUTABLE" "make_cmd") + + set(source_dir ${CMAKE_BINARY_DIR}/src/fio) + file(MAKE_DIRECTORY ${source_dir}) + ExternalProject_Add(fio_ext + UPDATE_COMMAND "" # this disables rebuild on each run + GIT_REPOSITORY "https://github.com/ceph/fio.git" + GIT_CONFIG advice.detachedHead=false + GIT_SHALLOW 1 + GIT_TAG "fio-3.27-cxx" + SOURCE_DIR ${source_dir} + BUILD_IN_SOURCE 1 + CONFIGURE_COMMAND <SOURCE_DIR>/configure + BUILD_COMMAND ${make_cmd} fio EXTFLAGS=-Wno-format-truncation ${FIO_EXTLIBS} + INSTALL_COMMAND cp <BINARY_DIR>/fio ${CMAKE_BINARY_DIR}/bin) + + add_library(fio INTERFACE IMPORTED) + add_dependencies(fio fio_ext) + set_target_properties(fio PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES ${source_dir} + INTERFACE_COMPILE_OPTIONS "-include;${source_dir}/config-host.h;$<$<COMPILE_LANGUAGE:C>:-std=gnu99>$<$<COMPILE_LANGUAGE:CXX>:-std=gnu++17>") +endfunction() diff --git a/cmake/modules/BuildJaeger.cmake b/cmake/modules/BuildJaeger.cmake new file mode 100644 index 000000000..6a7d41208 --- /dev/null +++ b/cmake/modules/BuildJaeger.cmake @@ -0,0 +1,65 @@ +# This module builds Jaeger after it's dependencies are installed and discovered +# opentracing: is built using cmake/modules/Buildopentracing.cmake +# Thrift: build using cmake/modules/Buildthrift.cmake +# yaml-cpp, nlhomann-json: are installed locally and then discovered using +# Find<package>.cmake +# Boost Libraries used for building thrift are build and provided by +# cmake/modules/BuildBoost.cmake + +function(build_jaeger) + set(Jaeger_SOURCE_DIR "${CMAKE_SOURCE_DIR}/src/jaegertracing/jaeger-client-cpp") + set(Jaeger_INSTALL_DIR "${CMAKE_BINARY_DIR}/external") + set(Jaeger_BINARY_DIR "${Jaeger_INSTALL_DIR}/Jaeger") + + file(MAKE_DIRECTORY "${Jaeger_INSTALL_DIR}") + set(Jaeger_CMAKE_ARGS -DCMAKE_POSITION_INDEPENDENT_CODE=ON + -DBUILD_SHARED_LIBS=ON + -DHUNTER_ENABLED=OFF + -DBUILD_TESTING=OFF + -DJAEGERTRACING_BUILD_EXAMPLES=OFF + -DCMAKE_PREFIX_PATH="${CMAKE_BINARY_DIR}/external;${CMAKE_BINARY_DIR}/boost" + -DCMAKE_INSTALL_RPATH=${CMAKE_BINARY_DIR}/external + -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE + -DOpenTracing_DIR=${CMAKE_SOURCE_DIR}/src/jaegertracing/opentracing-cpp + -Dnlohmann_json_DIR=/usr/lib + -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/boost\;${CMAKE_BINARY_DIR}/boost/include\;${CMAKE_BINARY_DIR}/external + -DCMAKE_FIND_ROOT_PATH=${CMAKE_BINARY_DIR}/boost\;${CMAKE_BINARY_DIR}/boost/include\;${CMAKE_BINARY_DIR}/external + -DCMAKE_INSTALL_LIBDIR=${CMAKE_BINARY_DIR}/external/lib + -Dthrift_HOME=${CMAKE_BINARY_DIR}/external + -DOpenTracing_HOME=${CMAKE_BINARY_DIR}/external) + + set(dependencies opentracing thrift) + include(BuildOpenTracing) + build_opentracing() + include(Buildthrift) + build_thrift() + if(NOT yaml-cpp_FOUND) + include(Buildyaml-cpp) + build_yamlcpp() + add_library(yaml-cpp::yaml-cpp SHARED IMPORTED) + add_dependencies(yaml-cpp::yaml-cpp yaml-cpp) + set_library_properties_for_external_project(yaml-cpp::yaml-cpp yaml-cpp) + list(APPEND dependencies "yaml-cpp") + endif() + + if(CMAKE_MAKE_PROGRAM MATCHES "make") + # try to inherit command line arguments passed by parent "make" job + set(make_cmd $(MAKE)) + else() + set(make_cmd ${CMAKE_COMMAND} --build <BINARY_DIR> --config $<CONFIG> --target Jaeger) + endif() + set(install_cmd $(MAKE) install DESTDIR=) + + include(ExternalProject) + ExternalProject_Add(Jaeger + SOURCE_DIR ${Jaeger_SOURCE_DIR} + UPDATE_COMMAND "" + INSTALL_DIR "external" + PREFIX ${Jaeger_INSTALL_DIR} + CMAKE_ARGS ${Jaeger_CMAKE_ARGS} + BINARY_DIR ${Jaeger_BINARY_DIR} + BUILD_COMMAND ${make_cmd} + INSTALL_COMMAND ${install_cmd} + DEPENDS "${dependencies}" + ) +endfunction() diff --git a/cmake/modules/BuildOpenTracing.cmake b/cmake/modules/BuildOpenTracing.cmake new file mode 100644 index 000000000..d9c716a23 --- /dev/null +++ b/cmake/modules/BuildOpenTracing.cmake @@ -0,0 +1,35 @@ +function(build_opentracing) + set(opentracing_SOURCE_DIR "${CMAKE_SOURCE_DIR}/src/jaegertracing/opentracing-cpp") + set(opentracing_BINARY_DIR "${CMAKE_BINARY_DIR}/external/opentracing-cpp") + + set(opentracing_CMAKE_ARGS -DCMAKE_POSITION_INDEPENDENT_CODE=ON + -DBUILD_MOCKTRACER=OFF + -DENABLE_LINTING=OFF + -DBUILD_STATIC_LIBS=OFF + -DBUILD_TESTING=OFF + -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/external + -DCMAKE_INSTALL_RPATH=${CMAKE_BINARY_DIR}/external + -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE + -DCMAKE_INSTALL_LIBDIR=${CMAKE_BINARY_DIR}/external/lib + -DCMAKE_PREFIX_PATH=${CMAKE_BINARY_DIR}/external) + + if(CMAKE_MAKE_PROGRAM MATCHES "make") + # try to inherit command line arguments passed by parent "make" job + set(make_cmd $(MAKE) ) + else() + set(make_cmd ${CMAKE_COMMAND} --build <BINARY_DIR> --target opentracing) + endif() + set(install_cmd $(MAKE) install DESTDIR=) + + include(ExternalProject) + ExternalProject_Add(opentracing + SOURCE_DIR ${opentracing_SOURCE_DIR} + UPDATE_COMMAND "" + INSTALL_DIR "external" + PREFIX "external/opentracing-cpp" + CMAKE_ARGS ${opentracing_CMAKE_ARGS} + BUILD_IN_SOURCE 1 + BUILD_COMMAND ${make_cmd} + INSTALL_COMMAND ${install_cmd} + ) +endfunction() diff --git a/cmake/modules/BuildQatDrv.cmake b/cmake/modules/BuildQatDrv.cmake new file mode 100644 index 000000000..ebf33d646 --- /dev/null +++ b/cmake/modules/BuildQatDrv.cmake @@ -0,0 +1,33 @@ +## +# Make file for QAT linux driver project +## + +set(qatdrv_root_dir "${CMAKE_BINARY_DIR}/qatdrv") +set(qatdrv_url "https://01.org/sites/default/files/downloads/intelr-quickassist-technology/qat1.7.l.4.2.0-00012.tar.gz") +set(qatdrv_url_hash "SHA256=47990b3283ded748799dba42d4b0e1bdc0be3cf3978bd587533cd12788b03856") +set(qatdrv_config_args "--enable-qat-uio") + +include(ExternalProject) +ExternalProject_Add(QatDrv + URL ${qatdrv_url} + URL_HASH ${qatdrv_url_hash} + CONFIGURE_COMMAND ${qatdrv_env} ./configure ${qatdrv_config_args} + +# Temporarily forcing single thread as multi-threaded make is causing build +# failues. + BUILD_COMMAND make -j1 quickassist-all + BUILD_IN_SOURCE 1 + INSTALL_COMMAND "" + TEST_COMMAND "" + PREFIX ${qatdrv_root_dir}) + +set(QatDrv_INCLUDE_DIRS + ${qatdrv_root_dir}/src/QatDrv/quickassist/include + ${qatdrv_root_dir}/src/QatDrv/quickassist/lookaside/access_layer/include + ${qatdrv_root_dir}/src/QatDrv/quickassist/include/lac + ${qatdrv_root_dir}/src/QatDrv/quickassist/utilities/libusdm_drv + ${qatdrv_root_dir}/src/QatDrv/quickassist/utilities/libusdm_drv/linux/include) + +set(QatDrv_LIBRARIES + ${qatdrv_root_dir}/src/QatDrv/build/libqat_s.so + ${qatdrv_root_dir}/src/QatDrv/build/libusdm_drv_s.so) diff --git a/cmake/modules/BuildRocksDB.cmake b/cmake/modules/BuildRocksDB.cmake new file mode 100644 index 000000000..58ce26a6a --- /dev/null +++ b/cmake/modules/BuildRocksDB.cmake @@ -0,0 +1,109 @@ +function(build_rocksdb) + set(rocksdb_CMAKE_ARGS -DCMAKE_POSITION_INDEPENDENT_CODE=ON) + list(APPEND rocksdb_CMAKE_ARGS -DWITH_GFLAGS=OFF) + + # cmake doesn't properly handle arguments containing ";", such as + # CMAKE_PREFIX_PATH, for which reason we'll have to use some other separator. + string(REPLACE ";" "!" CMAKE_PREFIX_PATH_ALT_SEP "${CMAKE_PREFIX_PATH}") + list(APPEND rocksdb_CMAKE_ARGS -DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH_ALT_SEP}) + if(CMAKE_TOOLCHAIN_FILE) + list(APPEND rocksdb_CMAKE_ARGS + -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}) + endif() + + if(ALLOCATOR STREQUAL "jemalloc") + list(APPEND rocksdb_CMAKE_ARGS -DWITH_JEMALLOC=ON) + list(APPEND rocksdb_INTERFACE_LINK_LIBRARIES JeMalloc::JeMalloc) + endif() + + if (WITH_CCACHE AND CCACHE_FOUND) + list(APPEND rocksdb_CMAKE_ARGS -DCMAKE_CXX_COMPILER_LAUNCHER=ccache) + endif() + list(APPEND rocksdb_CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}) + + list(APPEND rocksdb_CMAKE_ARGS -DWITH_SNAPPY=${SNAPPY_FOUND}) + if(SNAPPY_FOUND) + list(APPEND rocksdb_INTERFACE_LINK_LIBRARIES snappy::snappy) + endif() + # libsnappy is a C++ library, we need to force rocksdb to link against + # libsnappy statically. + if(SNAPPY_FOUND AND WITH_STATIC_LIBSTDCXX) + list(APPEND rocksdb_CMAKE_ARGS -DWITH_SNAPPY_STATIC_LIB=ON) + endif() + + list(APPEND rocksdb_CMAKE_ARGS -DWITH_LZ4=${LZ4_FOUND}) + if(LZ4_FOUND) + list(APPEND rocksdb_INTERFACE_LINK_LIBRARIES LZ4::LZ4) + # When cross compiling, cmake may fail to locate lz4. + list(APPEND rocksdb_CMAKE_ARGS -Dlz4_INCLUDE_DIRS=${LZ4_INCLUDE_DIR}) + list(APPEND rocksdb_CMAKE_ARGS -Dlz4_LIBRARIES=${LZ4_LIBRARY}) + endif() + + list(APPEND rocksdb_CMAKE_ARGS -DWITH_ZLIB=${ZLIB_FOUND}) + if(ZLIB_FOUND) + list(APPEND rocksdb_INTERFACE_LINK_LIBRARIES ZLIB::ZLIB) + endif() + + list(APPEND rocksdb_CMAKE_ARGS -DPORTABLE=ON) + list(APPEND rocksdb_CMAKE_ARGS -DCMAKE_AR=${CMAKE_AR}) + list(APPEND rocksdb_CMAKE_ARGS -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}) + list(APPEND rocksdb_CMAKE_ARGS -DFAIL_ON_WARNINGS=OFF) + list(APPEND rocksdb_CMAKE_ARGS -DUSE_RTTI=1) + list(APPEND rocksdb_CMAKE_ARGS -G${CMAKE_GENERATOR}) + CHECK_C_COMPILER_FLAG("-Wno-stringop-truncation" HAS_WARNING_STRINGOP_TRUNCATION) + if(HAS_WARNING_STRINGOP_TRUNCATION) + list(APPEND rocksdb_CMAKE_ARGS -DCMAKE_C_FLAGS=-Wno-stringop-truncation) + endif() + include(CheckCXXCompilerFlag) + check_cxx_compiler_flag("-Wno-deprecated-copy" HAS_WARNING_DEPRECATED_COPY) + if(HAS_WARNING_DEPRECATED_COPY) + set(rocksdb_CXX_FLAGS -Wno-deprecated-copy) + endif() + check_cxx_compiler_flag("-Wno-pessimizing-move" HAS_WARNING_PESSIMIZING_MOVE) + if(HAS_WARNING_PESSIMIZING_MOVE) + set(rocksdb_CXX_FLAGS "${rocksdb_CXX_FLAGS} -Wno-pessimizing-move") + endif() + if(rocksdb_CXX_FLAGS) + list(APPEND rocksdb_CMAKE_ARGS -DCMAKE_CXX_FLAGS='${rocksdb_CXX_FLAGS}') + endif() + # we use an external project and copy the sources to bin directory to ensure + # that object files are built outside of the source tree. + include(ExternalProject) + set(rocksdb_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/rocksdb") + set(rocksdb_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/rocksdb") + set(rocksdb_LIBRARY "${rocksdb_BINARY_DIR}/librocksdb.a") + if(CMAKE_MAKE_PROGRAM MATCHES "make") + # try to inherit command line arguments passed by parent "make" job + set(make_cmd $(MAKE) rocksdb) + else() + set(make_cmd ${CMAKE_COMMAND} --build <BINARY_DIR> --target rocksdb) + endif() + + ExternalProject_Add(rocksdb_ext + SOURCE_DIR "${rocksdb_SOURCE_DIR}" + CMAKE_ARGS ${rocksdb_CMAKE_ARGS} + BINARY_DIR "${rocksdb_BINARY_DIR}" + BUILD_COMMAND "${make_cmd}" + BUILD_BYPRODUCTS "${rocksdb_LIBRARY}" + INSTALL_COMMAND "true" + LIST_SEPARATOR !) + + add_library(RocksDB::RocksDB STATIC IMPORTED) + add_dependencies(RocksDB::RocksDB rocksdb_ext) + set(rocksdb_INCLUDE_DIR "${rocksdb_SOURCE_DIR}/include") + foreach(ver "MAJOR" "MINOR" "PATCH") + file(STRINGS "${rocksdb_INCLUDE_DIR}/rocksdb/version.h" ROCKSDB_VER_${ver}_LINE + REGEX "^#define[ \t]+ROCKSDB_${ver}[ \t]+[0-9]+$") + string(REGEX REPLACE "^#define[ \t]+ROCKSDB_${ver}[ \t]+([0-9]+)$" + "\\1" ROCKSDB_VERSION_${ver} "${ROCKSDB_VER_${ver}_LINE}") + unset(ROCKDB_VER_${ver}_LINE) + endforeach() + set(rocksdb_VERSION_STRING + "${ROCKSDB_VERSION_MAJOR}.${ROCKSDB_VERSION_MINOR}.${ROCKSDB_VERSION_PATCH}") + set_target_properties(RocksDB::RocksDB PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${rocksdb_INCLUDE_DIR}" + INTERFACE_LINK_LIBRARIES "${rocksdb_INTERFACE_LINK_LIBRARIES}" + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LOCATION "${rocksdb_LIBRARY}" + VERSION "${rocksdb_VERSION_STRING}") +endfunction() diff --git a/cmake/modules/BuildSPDK.cmake b/cmake/modules/BuildSPDK.cmake new file mode 100644 index 000000000..05a6b2370 --- /dev/null +++ b/cmake/modules/BuildSPDK.cmake @@ -0,0 +1,61 @@ +macro(build_spdk) + set(DPDK_DIR ${CMAKE_BINARY_DIR}/src/dpdk) + if(NOT TARGET dpdk-ext) + include(BuildDPDK) + build_dpdk(${DPDK_DIR}) + endif() + find_package(CUnit REQUIRED) + if(LINUX) + find_package(aio REQUIRED) + find_package(uuid REQUIRED) + endif() + include(FindMake) + find_make("MAKE_EXECUTABLE" "make_cmd") + + set(spdk_CFLAGS "-fPIC") + include(CheckCCompilerFlag) + check_c_compiler_flag("-Wno-address-of-packed-member" HAS_WARNING_ADDRESS_OF_PACKED_MEMBER) + if(HAS_WARNING_ADDRESS_OF_PACKED_MEMBER) + set(spdk_CFLAGS "${spdk_CFLAGS} -Wno-address-of-packed-member") + endif() + include(ExternalProject) + if(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|AMD64") + # a safer option than relying on the build host's arch + set(target_arch core2) + else() + # default arch used by SPDK + set(target_arch native) + endif() + ExternalProject_Add(spdk-ext + DEPENDS dpdk-ext + SOURCE_DIR ${CMAKE_SOURCE_DIR}/src/spdk + CONFIGURE_COMMAND ./configure + --with-dpdk=${DPDK_DIR} + --without-isal + --without-vhost + --target-arch=${target_arch} + # unset $CFLAGS, otherwise it will interfere with how SPDK sets + # its include directory. + # unset $LDFLAGS, otherwise SPDK will fail to mock some functions. + BUILD_COMMAND env -i PATH=$ENV{PATH} CC=${CMAKE_C_COMPILER} ${make_cmd} EXTRA_CFLAGS="${spdk_CFLAGS}" + BUILD_IN_SOURCE 1 + INSTALL_COMMAND "true") + unset(make_cmd) + ExternalProject_Get_Property(spdk-ext source_dir) + foreach(c lvol env_dpdk sock nvmf bdev nvme conf thread trace notify accel event_accel blob vmd event_vmd event_bdev sock_posix event_sock event rpc jsonrpc json util log) + add_library(spdk::${c} STATIC IMPORTED) + add_dependencies(spdk::${c} spdk-ext) + set_target_properties(spdk::${c} PROPERTIES + IMPORTED_LOCATION "${source_dir}/build/lib/${CMAKE_STATIC_LIBRARY_PREFIX}spdk_${c}${CMAKE_STATIC_LIBRARY_SUFFIX}" + INTERFACE_INCLUDE_DIRECTORIES "${source_dir}/include") + list(APPEND SPDK_LIBRARIES spdk::${c}) + endforeach() + set_target_properties(spdk::env_dpdk PROPERTIES + INTERFACE_LINK_LIBRARIES "dpdk::dpdk;rt") + set_target_properties(spdk::lvol PROPERTIES + INTERFACE_LINK_LIBRARIES spdk::util) + set_target_properties(spdk::util PROPERTIES + INTERFACE_LINK_LIBRARIES ${UUID_LIBRARIES}) + set(SPDK_INCLUDE_DIR "${source_dir}/include") + unset(source_dir) +endmacro() diff --git a/cmake/modules/Buildc-ares.cmake b/cmake/modules/Buildc-ares.cmake new file mode 100644 index 000000000..ff9452095 --- /dev/null +++ b/cmake/modules/Buildc-ares.cmake @@ -0,0 +1,22 @@ +function(build_c_ares) + include(ExternalProject) + set(C-ARES_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/c-ares") + set(C-ARES_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/c-ares") + ExternalProject_Add(c-ares_ext + SOURCE_DIR "${C-ARES_SOURCE_DIR}" + CMAKE_ARGS + -DCARES_STATIC=ON + -DCARES_SHARED=OFF + -DCARES_INSTALL=OFF + BINARY_DIR "${C-ARES_BINARY_DIR}" + BUILD_COMMAND ${CMAKE_COMMAND} --build <BINARY_DIR> + INSTALL_COMMAND "") + add_library(c-ares::c-ares STATIC IMPORTED) + add_dependencies(c-ares::c-ares c-ares_ext) + set_target_properties(c-ares::c-ares PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${C-ARES_SOURCE_DIR};${C-ARES_BINARY_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${C-ARES_BINARY_DIR}/lib/libcares.a") + # to appease find_package() + add_custom_target(c-ares DEPENDS c-ares::c-ares) +endfunction() diff --git a/cmake/modules/Buildpmem.cmake b/cmake/modules/Buildpmem.cmake new file mode 100644 index 000000000..61c5ba601 --- /dev/null +++ b/cmake/modules/Buildpmem.cmake @@ -0,0 +1,61 @@ +function(build_pmem) + include(FindMake) + find_make("MAKE_EXECUTABLE" "make_cmd") + + if(EXISTS "${PROJECT_SOURCE_DIR}/src/pmdk/Makefile") + set(source_dir_args + SOURCE_DIR "${PROJECT_SOURCE_DIR}/src/pmdk") + else() + set(source_dir_args + SOURCE_DIR ${CMAKE_BINARY_DIR}/src/pmdk + GIT_REPOSITORY https://github.com/ceph/pmdk.git + GIT_TAG "1.10" + GIT_SHALLOW TRUE + GIT_CONFIG advice.detachedHead=false) + endif() + + # Use debug PMDK libs in debug lib/rbd builds + if(CMAKE_BUILD_TYPE STREQUAL Debug) + set(PMDK_LIB_DIR "debug") + else() + set(PMDK_LIB_DIR "nondebug") + endif() + + set(pmdk_cflags "-Wno-error -fno-lto") + include(ExternalProject) + ExternalProject_Add(pmdk_ext + ${source_dir_args} + CONFIGURE_COMMAND "" + # Explicitly built w/o NDCTL, otherwise if ndtcl is present on the + # build system tests statically linking to librbd (which uses + # libpmemobj) will not link (because we don't build the ndctl + # static library here). + BUILD_COMMAND ${make_cmd} CC=${CMAKE_C_COMPILER} "EXTRA_CFLAGS=${pmdk_cflags}" NDCTL_ENABLE=n BUILD_EXAMPLES=n BUILD_BENCHMARKS=n DOC=n + BUILD_IN_SOURCE 1 + BUILD_BYPRODUCTS "<SOURCE_DIR>/src/${PMDK_LIB_DIR}/libpmem.a" "<SOURCE_DIR>/src/${PMDK_LIB_DIR}/libpmemobj.a" + INSTALL_COMMAND "") + unset(make_cmd) + + ExternalProject_Get_Property(pmdk_ext source_dir) + set(PMDK_SRC "${source_dir}/src") + set(PMDK_INCLUDE "${source_dir}/src/include") + set(PMDK_LIB "${source_dir}/src/${PMDK_LIB_DIR}") + + # libpmem + add_library(pmem::pmem STATIC IMPORTED GLOBAL) + add_dependencies(pmem::pmem pmdk_ext) + file(MAKE_DIRECTORY ${PMDK_INCLUDE}) + find_package(Threads) + set_target_properties(pmem::pmem PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES ${PMDK_INCLUDE} + IMPORTED_LOCATION "${PMDK_LIB}/libpmem.a" + INTERFACE_LINK_LIBRARIES Threads::Threads) + + # libpmemobj + add_library(pmem::pmemobj STATIC IMPORTED GLOBAL) + add_dependencies(pmem::pmemobj pmdk_ext) + set_target_properties(pmem::pmemobj PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES ${PMDK_INCLUDE} + IMPORTED_LOCATION "${PMDK_LIB}/libpmemobj.a" + INTERFACE_LINK_LIBRARIES "pmem::pmem;${CMAKE_THREAD_LIBS_INIT}") +endfunction() diff --git a/cmake/modules/Buildthrift.cmake b/cmake/modules/Buildthrift.cmake new file mode 100644 index 000000000..6601b943a --- /dev/null +++ b/cmake/modules/Buildthrift.cmake @@ -0,0 +1,54 @@ +function(build_thrift) + set(thrift_SOURCE_DIR "${CMAKE_SOURCE_DIR}/src/jaegertracing/thrift") + set(thrift_BINARY_DIR "${CMAKE_BINARY_DIR}/external/thrift") + + set(thrift_CMAKE_ARGS -DCMAKE_BUILD_TYPE=Release + -DCMAKE_POSITION_INDEPENDENT_CODE=ON + -DBUILD_JAVA=OFF + -DBUILD_PYTHON=OFF + -DBUILD_TESTING=OFF + -DBUILD_TUTORIALS=OFF + -DBUILD_C_GLIB=OFF + -DBUILD_HASKELL=OFF + -DWITH_LIBEVENT=OFF + -DWITH_ZLIB=OFF + -DBoost_INCLUDE_DIRS=${CMAKE_BINARY_DIR}/boost/include + -DCMAKE_INSTALL_PREFIX="${CMAKE_BINARY_DIR}/boost;${CMAKE_BINARY_DIR}/boost/include;${CMAKE_BINARY_DIR}/external" + -DCMAKE_FIND_ROOT_PATH="${CMAKE_BINARY_DIR}/boost;${CMAKE_BINARY_DIR}/boost/include;${CMAKE_BINARY_DIR}/external" + -DCMAKE_INSTALL_RPATH=${CMAKE_BINARY_DIR}/external/lib + -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE + -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/external + -DCMAKE_INSTALL_LIBDIR=${CMAKE_BINARY_DIR}/external/lib) + + if(WITH_SYSTEM_BOOST) + message(STATUS "thrift will be using system boost") + set(dependencies "") + list(APPEND thrift_CMAKE_ARGS -DBOOST_ROOT=/opt/ceph) + list(APPEND thrift_CMAKE_ARGS -DCMAKE_FIND_ROOT_PATH=/opt/ceph) + else() + message(STATUS "thrift will be using external build boost") + set(dependencies Boost) + list(APPEND thrift_CMAKE_ARGS -DCMAKE_FIND_ROOT_PATH=${CMAKE_BINARY_DIR}/boost) + list(APPEND thrift_CMAKE_ARGS -DCMAKE_PREFIX_PATH=${CMAKE_BINARY_DIR}/external) + endif() + + if(CMAKE_MAKE_PROGRAM MATCHES "make") + # try to inherit command line arguments passed by parent "make" job + set(make_cmd $(MAKE)) + else() + set(make_cmd ${CMAKE_COMMAND} --build <BINARY_DIR> --target thrift) + endif() + + set(install_cmd $(MAKE) install DESTDIR=) + + include(ExternalProject) + ExternalProject_Add(thrift + SOURCE_DIR ${thrift_SOURCE_DIR} + PREFIX "${CMAKE_BINARY_DIR}/external/thrift" + CMAKE_ARGS ${thrift_CMAKE_ARGS} + BINARY_DIR ${thrift_BINARY_DIR} + BUILD_COMMAND ${make_cmd} + INSTALL_COMMAND ${install_cmd} + DEPENDS ${dependencies} + ) +endfunction() diff --git a/cmake/modules/Builduring.cmake b/cmake/modules/Builduring.cmake new file mode 100644 index 000000000..328aa5ac7 --- /dev/null +++ b/cmake/modules/Builduring.cmake @@ -0,0 +1,39 @@ +function(build_uring) + include(FindMake) + find_make("MAKE_EXECUTABLE" "make_cmd") + + if(EXISTS "${PROJECT_SOURCE_DIR}/src/liburing/configure") + set(source_dir_args + SOURCE_DIR "${PROJECT_SOURCE_DIR}/src/liburing") + else() + set(source_dir_args + SOURCE_DIR ${CMAKE_BINARY_DIR}/src/liburing + GIT_REPOSITORY https://github.com/axboe/liburing.git + GIT_TAG "liburing-0.7" + GIT_SHALLOW TRUE + GIT_CONFIG advice.detachedHead=false) + endif() + + include(ExternalProject) + ExternalProject_Add(liburing_ext + ${source_dir_args} + CONFIGURE_COMMAND <SOURCE_DIR>/configure + BUILD_COMMAND env CC=${CMAKE_C_COMPILER} "CFLAGS=${CMAKE_C_FLAGS} -fPIC" ${make_cmd} -C src -s + BUILD_IN_SOURCE 1 + BUILD_BYPRODUCTS "<SOURCE_DIR>/src/liburing.a" + INSTALL_COMMAND "" + UPDATE_COMMAND "") + unset(make_cmd) + + ExternalProject_Get_Property(liburing_ext source_dir) + set(URING_INCLUDE_DIR "${source_dir}/src/include") + set(URING_LIBRARY_DIR "${source_dir}/src") + + add_library(uring::uring STATIC IMPORTED GLOBAL) + add_dependencies(uring::uring liburing_ext) + file(MAKE_DIRECTORY ${URING_INCLUDE_DIR}) + set_target_properties(uring::uring PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES ${URING_INCLUDE_DIR} + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${URING_LIBRARY_DIR}/liburing.a") +endfunction() diff --git a/cmake/modules/Buildyaml-cpp.cmake b/cmake/modules/Buildyaml-cpp.cmake new file mode 100644 index 000000000..f559c4d4d --- /dev/null +++ b/cmake/modules/Buildyaml-cpp.cmake @@ -0,0 +1,36 @@ +function(build_yamlcpp) + set(yaml-cpp_DOWNLOAD_DIR "${CMAKE_SOURCE_DIR}/src/jaegertracing") + set(yaml-cpp_SOURCE_DIR "${CMAKE_SOURCE_DIR}/src/jaegertracing/yaml-cpp") + set(yaml-cpp_BINARY_DIR "${CMAKE_BINARY_DIR}/external/yaml-cpp") + + set(yaml-cpp_CMAKE_ARGS -DBUILD_SHARED_LIBS=ON + -DYAML_CPP_BUILD_TESTS=OFF + -DYAML_CPP_BUILD_CONTRIB=OFF + -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/external + -DCMAKE_INSTALL_RPATH=${CMAKE_BINARY_DIR}/external/lib + -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE + -DCMAKE_INSTALL_LIBDIR=${CMAKE_BINARY_DIR}/external/lib + -DCMAKE_PREFIX_PATH=${CMAKE_BINARY_DIR}/external) + + if(CMAKE_MAKE_PROGRAM MATCHES "make") + # try to inherit command line arguments passed by parent "make" job + set(make_cmd "$(MAKE)") + else() + set(make_cmd ${CMAKE_COMMAND} --build <BINARY_DIR> --target yaml-cpp) + endif() +set(install_cmd $(MAKE) install DESTDIR=) + + include(ExternalProject) + ExternalProject_Add(yaml-cpp + GIT_REPOSITORY "https://github.com/jbeder/yaml-cpp.git" + GIT_TAG "yaml-cpp-0.6.2" + UPDATE_COMMAND "" + INSTALL_DIR "${CMAKE_BINARY_DIR}/external" + DOWNLOAD_DIR ${yaml-cpp_DOWNLOAD_DIR} + SOURCE_DIR ${yaml-cpp_SOURCE_DIR} + PREFIX "${CMAKE_BINARY_DIR}/external/yaml-cpp" + CMAKE_ARGS ${yaml-cpp_CMAKE_ARGS} + BUILD_COMMAND ${make_cmd} + INSTALL_COMMAND ${install_cmd} + ) +endfunction() diff --git a/cmake/modules/CTags.cmake b/cmake/modules/CTags.cmake new file mode 100644 index 000000000..c3e1b3799 --- /dev/null +++ b/cmake/modules/CTags.cmake @@ -0,0 +1,40 @@ +find_program(CTAGS_EXECUTABLE ctags) + +function(add_tags name) + cmake_parse_arguments(TAGS "" "SRC_DIR;TAG_FILE" "EXCLUDE_OPTS;EXCLUDES" ${ARGN}) + set(excludes ${TAGS_EXCLUDES}) + if(TAGS_EXCLUDE_OPTS) + # always respect EXCLUDES_OPTS + list(APPEND excludes ${TAGS_EXCLUDE_OPTS}) + else() + # exclude the submodules under SRC_DIR by default + execute_process( + COMMAND git config --file .gitmodules --get-regexp path + COMMAND awk "/${TAGS_SRC_DIR}/ { print $2 }" + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} + RESULT_VARIABLE result_code + OUTPUT_VARIABLE submodules + OUTPUT_STRIP_TRAILING_WHITESPACE) + if(${result_code} EQUAL 0) + string(REPLACE "${TAGS_SRC_DIR}/" "" submodules ${submodules}) + # cmake list uses ";" as the delimiter, so split the string manually + # before iterating in it. + string(REPLACE "\n" ";" submodules ${submodules}) + list(APPEND excludes ${submodules}) + endif() + endif() + message(STATUS "exclude following files under ${TAGS_SRC_DIR}: ${excludes}") + # add_custom_target() accepts a list after "COMMAND" keyword, so we should + # make exclude_arg a list, otherwise cmake will quote it. and ctags will + # take it as as a single argument. + foreach(exclude ${excludes}) + list(APPEND exclude_args --exclude=${exclude}) + endforeach() + add_custom_target(${name} + COMMAND ${CTAGS_EXECUTABLE} -R --python-kinds=-i --c++-kinds=+p --fields=+iaS --extra=+q ${exclude_args} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/${TAGS_SRC_DIR} + COMMENT "Building ctags file ${TAGS_TAG_FILE}" + VERBATIM) + set_source_files_properties(${CMAKE_SOURCE_DIR}/${TAGS_TAG_FILE} PROPERTIES + GENERATED true) +endfunction() diff --git a/cmake/modules/CephCheck_link.c b/cmake/modules/CephCheck_link.c new file mode 100644 index 000000000..0c87b3780 --- /dev/null +++ b/cmake/modules/CephCheck_link.c @@ -0,0 +1,2 @@ +int main() +{} diff --git a/cmake/modules/CephCheck_link.map b/cmake/modules/CephCheck_link.map new file mode 100644 index 000000000..333a9b3c0 --- /dev/null +++ b/cmake/modules/CephCheck_link.map @@ -0,0 +1 @@ +{};
\ No newline at end of file diff --git a/cmake/modules/CephChecks.cmake b/cmake/modules/CephChecks.cmake new file mode 100644 index 000000000..701ecb47c --- /dev/null +++ b/cmake/modules/CephChecks.cmake @@ -0,0 +1,184 @@ +if(CMAKE_CXX_COMPILER_ID STREQUAL GNU) + if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7) + message(FATAL_ERROR "GCC 7+ required due to C++17 requirements") + endif() +endif() + +#Check Includes +include(CheckIncludeFiles) +include(CheckIncludeFileCXX) +include(CheckFunctionExists) + +check_function_exists(fallocate CEPH_HAVE_FALLOCATE) +check_function_exists(posix_fadvise HAVE_POSIX_FADVISE) +check_function_exists(posix_fallocate HAVE_POSIX_FALLOCATE) +check_function_exists(syncfs HAVE_SYS_SYNCFS) +check_function_exists(sync_file_range HAVE_SYNC_FILE_RANGE) +check_function_exists(pwritev HAVE_PWRITEV) +check_function_exists(splice CEPH_HAVE_SPLICE) +check_function_exists(getgrouplist HAVE_GETGROUPLIST) +if(NOT APPLE) + check_function_exists(fdatasync HAVE_FDATASYNC) +endif() +check_function_exists(strerror_r HAVE_Strerror_R) +check_function_exists(name_to_handle_at HAVE_NAME_TO_HANDLE_AT) +check_function_exists(pipe2 HAVE_PIPE2) +check_function_exists(accept4 HAVE_ACCEPT4) +check_function_exists(sigdescr_np HAVE_SIGDESCR_NP) + +include(CMakePushCheckState) +cmake_push_check_state(RESET) +set(CMAKE_REQUIRED_LIBRARIES pthread) +check_function_exists(pthread_spin_init HAVE_PTHREAD_SPINLOCK) +check_function_exists(pthread_set_name_np HAVE_PTHREAD_SET_NAME_NP) +check_function_exists(pthread_get_name_np HAVE_PTHREAD_GET_NAME_NP) +check_function_exists(pthread_setname_np HAVE_PTHREAD_SETNAME_NP) +check_function_exists(pthread_getname_np HAVE_PTHREAD_GETNAME_NP) +check_function_exists(pthread_rwlockattr_setkind_np HAVE_PTHREAD_RWLOCKATTR_SETKIND_NP) +cmake_pop_check_state() + +check_function_exists(eventfd HAVE_EVENTFD) +check_function_exists(getprogname HAVE_GETPROGNAME) +check_function_exists(gettid HAVE_GETTID) + +CHECK_INCLUDE_FILES("linux/types.h" HAVE_LINUX_TYPES_H) +CHECK_INCLUDE_FILES("linux/version.h" HAVE_LINUX_VERSION_H) +CHECK_INCLUDE_FILES("arpa/nameser_compat.h" HAVE_ARPA_NAMESER_COMPAT_H) +CHECK_INCLUDE_FILES("sys/mount.h" HAVE_SYS_MOUNT_H) +CHECK_INCLUDE_FILES("sys/param.h" HAVE_SYS_PARAM_H) +CHECK_INCLUDE_FILES("sys/types.h" HAVE_SYS_TYPES_H) +CHECK_INCLUDE_FILES("sys/vfs.h" HAVE_SYS_VFS_H) +CHECK_INCLUDE_FILES("sys/prctl.h" HAVE_SYS_PRCTL_H) +CHECK_INCLUDE_FILES("execinfo.h" HAVE_EXECINFO_H) +if(LINUX) + CHECK_INCLUDE_FILES("sched.h" HAVE_SCHED) +endif() +CHECK_INCLUDE_FILES("valgrind/helgrind.h" HAVE_VALGRIND_HELGRIND_H) + +include(CheckTypeSize) +set(CMAKE_EXTRA_INCLUDE_FILES "linux/types.h" "netinet/in.h") +CHECK_TYPE_SIZE(__u8 __U8) +CHECK_TYPE_SIZE(__u16 __U16) +CHECK_TYPE_SIZE(__u32 __U32) +CHECK_TYPE_SIZE(__u64 __U64) +CHECK_TYPE_SIZE(__s8 __S8) +CHECK_TYPE_SIZE(__s16 __S16) +CHECK_TYPE_SIZE(__s32 __S32) +CHECK_TYPE_SIZE(__s64 __S64) +CHECK_TYPE_SIZE(in_addr_t IN_ADDR_T) +unset(CMAKE_EXTRA_INCLUDE_FILES) + +include(CheckSymbolExists) +cmake_push_check_state(RESET) +set(CMAKE_REQUIRED_LIBRARIES rt) +check_symbol_exists(_POSIX_TIMERS "unistd.h;time.h" HAVE_POSIX_TIMERS) +cmake_pop_check_state() +if(HAVE_POSIX_TIMERS) + find_library(RT_LIBRARY NAMES rt) +endif() +check_symbol_exists(res_nquery "resolv.h" HAVE_RES_NQUERY) +check_symbol_exists(F_SETPIPE_SZ "linux/fcntl.h" CEPH_HAVE_SETPIPE_SZ) +check_symbol_exists(__func__ "" HAVE_FUNC) +check_symbol_exists(__PRETTY_FUNCTION__ "" HAVE_PRETTY_FUNC) +check_symbol_exists(getentropy "unistd.h" HAVE_GETENTROPY) + +include(CheckCXXSourceCompiles) +check_cxx_source_compiles(" + #include <string.h> + int main() { char x = *strerror_r(0, &x, sizeof(x)); return 0; } + " STRERROR_R_CHAR_P) + +include(CheckStructHasMember) +CHECK_STRUCT_HAS_MEMBER("struct stat" st_mtim.tv_nsec sys/stat.h + HAVE_STAT_ST_MTIM_TV_NSEC LANGUAGE C) +CHECK_STRUCT_HAS_MEMBER("struct stat" st_mtimespec.tv_nsec sys/stat.h + HAVE_STAT_ST_MTIMESPEC_TV_NSEC LANGUAGE C) + +if(NOT CMAKE_CROSSCOMPILING) + include(CheckCXXSourceRuns) + cmake_push_check_state() + set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++17") + if(WIN32) + set(CMAKE_REQUIRED_LIBRARIES ws2_32) + endif() + + check_cxx_source_runs(" +#include <cstdint> +#include <iterator> + +#ifdef _WIN32 +#include <winsock2.h> +#else +#include <arpa/inet.h> +#endif + +uint32_t load(char* p, size_t offset) +{ + return *reinterpret_cast<uint32_t*>(p + offset); +} + +bool good(uint32_t lhs, uint32_t big_endian) +{ + return lhs == ntohl(big_endian); +} + +int main(int argc, char **argv) +{ + char a1[] = \"ABCDEFG\"; + uint32_t a2[] = {0x41424344, + 0x42434445, + 0x43444546, + 0x44454647}; + for (size_t i = 0; i < std::size(a2); i++) { + if (!good(load(a1, i), a2[i])) { + return 1; + } + } +}" + HAVE_UNALIGNED_ACCESS) + cmake_pop_check_state() + if(NOT HAVE_UNALIGNED_ACCESS) + message(FATAL_ERROR "Unaligned access is required") + endif() +else(NOT CMAKE_CROSSCOMPILING) + message(STATUS "Assuming unaligned access is supported") +endif(NOT CMAKE_CROSSCOMPILING) + +set(version_script_source "v1 { }; v2 { } v1;") +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/version_script.txt "${version_script_source}") +cmake_push_check_state(RESET) +set(CMAKE_REQUIRED_FLAGS "-Werror -Wl,--version-script=${CMAKE_CURRENT_BINARY_DIR}/version_script.txt") +check_c_source_compiles(" +__attribute__((__symver__ (\"func@v1\"))) void func_v1() {}; +__attribute__((__symver__ (\"func@v2\"))) void func_v2() {}; + +int main() {}" + HAVE_ATTR_SYMVER) + if(NOT HAVE_ATTR_SYMVER) + if(CMAKE_CXX_FLAGS MATCHES "-flto" AND NOT CMAKE_CXX_FLAGS MATCHES "-flto-partition=none") + # https://tracker.ceph.com/issues/40060 + message(FATAL_ERROR "please pass -flto-partition=none as part of CXXFLAGS") + endif() + endif() +set(CMAKE_REQUIRED_FLAGS -Wl,--version-script=${CMAKE_CURRENT_BINARY_DIR}/version_script.txt) +check_c_source_compiles(" +void func_v1() {} +__asm__(\".symver func_v1, func@v1\"); +void func_v2() {} +__asm__(\".symver func_v2, func@v2\"); + +int main() {}" + HAVE_ASM_SYMVER) +file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/version_script.txt) +cmake_pop_check_state() + +# should use LINK_OPTIONS instead of LINK_LIBRARIES, if we can use cmake v3.14+ +try_compile(HAVE_LINK_VERSION_SCRIPT + ${CMAKE_CURRENT_BINARY_DIR} + SOURCES ${CMAKE_CURRENT_LIST_DIR}/CephCheck_link.c + LINK_LIBRARIES "-Wl,--version-script=${CMAKE_CURRENT_LIST_DIR}/CephCheck_link.map") + +try_compile(HAVE_LINK_EXCLUDE_LIBS + ${CMAKE_CURRENT_BINARY_DIR} + SOURCES ${CMAKE_CURRENT_LIST_DIR}/CephCheck_link.c + LINK_LIBRARIES "-Wl,--exclude-libs,ALL") diff --git a/cmake/modules/CheckCxxAtomic.cmake b/cmake/modules/CheckCxxAtomic.cmake new file mode 100644 index 000000000..f2d89cf3e --- /dev/null +++ b/cmake/modules/CheckCxxAtomic.cmake @@ -0,0 +1,55 @@ +# some platforms do not offer support for atomic primitive for all integer +# types, in that case we need to link against libatomic + +include(CheckCXXSourceCompiles) +include(CMakePushCheckState) + + +function(check_cxx_atomics var) + set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++11") + check_cxx_source_compiles(" +#include <atomic> +#include <cstdint> + +#if __s390x__ +// Boost needs 16-byte atomics for tagged pointers. +// These are implemented via inline instructions on the platform +// if 16-byte alignment can be proven, and are delegated to libatomic +// library routines otherwise. Whether or not alignment is provably +// OK for a std::atomic unfortunately depends on compiler version and +// optimization levels, and also on the details of the expression. +// We specifically test access via an otherwise unknown pointer here +// to ensure we get the most complex case. If this access can be +// done without libatomic, then all accesses can be done. +bool atomic16(std::atomic<unsigned __int128> *ptr) +{ + return *ptr != 0; +} +#endif + +int main() { + std::atomic<uint8_t> w1; + std::atomic<uint16_t> w2; + std::atomic<uint32_t> w4; + std::atomic<uint64_t> w8; + return w1 + w2 + w4 + w8; +} +" ${var}) +endfunction(check_cxx_atomics) + +cmake_push_check_state() +check_cxx_atomics(HAVE_CXX11_ATOMIC) +cmake_pop_check_state() + +if(NOT HAVE_CXX11_ATOMIC) + cmake_push_check_state() + set(CMAKE_REQUIRED_LIBRARIES "atomic") + check_cxx_atomics(HAVE_LIBATOMIC) + cmake_pop_check_state() + if(HAVE_LIBATOMIC) + set(LIBATOMIC_LINK_FLAGS "-Wl,--as-needed -latomic") + else() + message(FATAL_ERROR + "Host compiler ${CMAKE_CXX_COMPILER} requires libatomic, but it is not found") + endif() +endif() diff --git a/cmake/modules/CheckNasm.cmake b/cmake/modules/CheckNasm.cmake new file mode 100644 index 000000000..8a45bf38b --- /dev/null +++ b/cmake/modules/CheckNasm.cmake @@ -0,0 +1,54 @@ +macro(check_nasm_support _object_format _support_x64 _support_x64_and_avx2 _support_x64_and_avx512) + execute_process( + COMMAND which nasm + RESULT_VARIABLE no_nasm + OUTPUT_QUIET + ERROR_QUIET) + if(NOT no_nasm) + if(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64") + set(save_quiet ${CMAKE_REQUIRED_QUIET}) + set(CMAKE_REQUIRED_QUIET true) + include(CheckCXXSourceCompiles) + check_cxx_source_compiles(" + #if defined(__x86_64__) && defined(__ILP32__) + #error x32 + #endif + int main() {} + " ${_support_x64}) + set(CMAKE_REQUIRED_QUIET ${save_quiet}) + if(${_support_x64}) + execute_process(COMMAND nasm -f ${object_format} -i + ${CMAKE_SOURCE_DIR}/src/isa-l/include/ + ${CMAKE_SOURCE_DIR}/src/isa-l/erasure_code/gf_vect_dot_prod_avx2.asm + -o /dev/null + RESULT_VARIABLE rc + OUTPUT_QUIET + ERROR_QUIET) + if(NOT rc) + set(${_support_x64_and_avx2} TRUE) + endif() + execute_process(COMMAND nasm -D HAVE_AS_KNOWS_AVX512 -f ${object_format} + -i ${CMAKE_SOURCE_DIR}/src/isa-l/include/ + ${CMAKE_SOURCE_DIR}/src/isa-l/erasure_code/gf_vect_dot_prod_avx512.asm + -o /dev/null + RESULT_VARIABLE rt + OUTPUT_QUIET + ERROR_QUIET) + if(NOT rt) + set(${_support_x64_and_avx512} TRUE) + endif() + endif(${_support_x64}) + endif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64") + endif(NOT no_nasm) + if(no_nasm) + message(STATUS "Could NOT find nasm") + elseif(NOT ${_support_x64}) + message(STATUS "Found nasm: but x86_64 with x32 ABI is not supported") + elseif(${_support_x64_and_avx512}) + message(STATUS "Found nasm: best -- capable of assembling AVX512") + elseif(${_support_x64_and_avx2}) + message(STATUS "Found nasm: better -- capable of assembling AVX2") + elseif(${_support_x64}) + message(STATUS "Found nasm: good -- capable of assembling x86_64") + endif() +endmacro() diff --git a/cmake/modules/Distutils.cmake b/cmake/modules/Distutils.cmake new file mode 100644 index 000000000..fe3ca410e --- /dev/null +++ b/cmake/modules/Distutils.cmake @@ -0,0 +1,144 @@ +include(CMakeParseArguments) + +# ensure that we are using the exact python version specified by +# 'WITH_PYTHON3', in case some included 3rd party libraries call +# 'find_package(Python3 ...) without specifying the exact version number. if +# the building host happens to have a higher version of python3, that version +# would be picked up instead by find_package(Python3). and that is not want we +# expect. +find_package(Python3 ${WITH_PYTHON3} EXACT + QUIET + REQUIRED + COMPONENTS Interpreter) + +function(distutils_install_module name) + set(py_srcs setup.py README.rst requirements.txt test-requirements.txt bin ${name}) + foreach(src ${py_srcs}) + if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${src}) + list(APPEND py_clone ${CMAKE_CURRENT_BINARY_DIR}/${src}) + add_custom_command( + OUTPUT ${src} + DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${src} + COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_CURRENT_SOURCE_DIR}/${src} ${src}) + endif() + endforeach() + if(NOT TARGET ${name}-clone) + add_custom_target(${name}-clone ALL + DEPENDS ${py_clone}) + endif() + cmake_parse_arguments(DU "" "INSTALL_SCRIPT" "" ${ARGN}) + install(CODE " + set(options --prefix=${CMAKE_INSTALL_PREFIX}) + if(DEFINED ENV{DESTDIR}) + if(EXISTS /etc/debian_version) + list(APPEND options --install-layout=deb) + endif() + list(APPEND options + --root=\$ENV{DESTDIR} + --single-version-externally-managed) + endif() + if(NOT \"${DU_INSTALL_SCRIPT}\" STREQUAL \"\") + list(APPEND options --install-script=${DU_INSTALL_SCRIPT}) + endif() + execute_process( + COMMAND ${Python3_EXECUTABLE} + setup.py install \${options} + WORKING_DIRECTORY \"${CMAKE_CURRENT_BINARY_DIR}\")") +endfunction(distutils_install_module) + +function(distutils_add_cython_module target name src) + get_property(compiler_launcher GLOBAL PROPERTY RULE_LAUNCH_COMPILE) + get_property(link_launcher GLOBAL PROPERTY RULE_LAUNCH_LINK) + # When using ccache, CMAKE_C_COMPILER is ccache executable absolute path + # and the actual C compiler is CMAKE_C_COMPILER_ARG1. + # However with a naive + # set(PY_CC ${compiler_launcher} ${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}) + # distutils tries to execve something like "/usr/bin/cmake gcc" and fails. + # Removing the leading whitespace from CMAKE_C_COMPILER_ARG1 helps to avoid + # the failure. + string(STRIP "${CMAKE_C_COMPILER_ARG1}" c_compiler_arg1) + string(STRIP "${CMAKE_CXX_COMPILER_ARG1}" cxx_compiler_arg1) + # Note: no quotes, otherwise distutils will execute "/usr/bin/ccache gcc" + # CMake's implicit conversion between strings and lists is wonderful, isn't it? + set(cflags ${COMPILE_OPTIONS}) + list(APPEND cflags -iquote${CMAKE_SOURCE_DIR}/src/include -w) + # This little bit of magic wipes out __Pyx_check_single_interpreter() + # Note: this is reproduced in distutils_install_cython_module + list(APPEND cflags -D'void0=dead_function\(void\)') + list(APPEND cflags -D'__Pyx_check_single_interpreter\(ARG\)=ARG\#\#0') + set(PY_CC ${compiler_launcher} ${CMAKE_C_COMPILER} ${c_compiler_arg1} ${cflags}) + set(PY_CXX ${compiler_launcher} ${CMAKE_CXX_COMPILER} ${cxx_compiler_arg1}) + set(PY_LDSHARED ${link_launcher} ${CMAKE_C_COMPILER} ${c_compiler_arg1} "-shared") + + execute_process(COMMAND "${Python3_EXECUTABLE}" -c + "import sysconfig; print(sysconfig.get_config_var('EXT_SUFFIX'))" + RESULT_VARIABLE result + OUTPUT_VARIABLE ext_suffix + ERROR_VARIABLE error + OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT result EQUAL 0) + message(FATAL_ERROR "Unable to tell python extension's suffix: ${error}") + endif() + set(output_dir "${CYTHON_MODULE_DIR}/lib.3") + set(setup_py ${CMAKE_CURRENT_SOURCE_DIR}/setup.py) + add_custom_command( + OUTPUT ${output_dir}/${name}${ext_suffix} + COMMAND + env + CC="${PY_CC}" + CXX="${PY_CXX}" + LDSHARED="${PY_LDSHARED}" + OPT=\"-DNDEBUG -g -fwrapv -O2 -w\" + LDFLAGS=-L${CMAKE_LIBRARY_OUTPUT_DIRECTORY} + CYTHON_BUILD_DIR=${CMAKE_CURRENT_BINARY_DIR} + CEPH_LIBDIR=${CMAKE_LIBRARY_OUTPUT_DIRECTORY} + ${Python3_EXECUTABLE} ${setup_py} + build --verbose --build-base ${CYTHON_MODULE_DIR} + --build-platlib ${output_dir} + MAIN_DEPENDENCY ${src} + DEPENDS ${setup_py} + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) + add_custom_target(${target} ALL + DEPENDS ${output_dir}/${name}${ext_suffix}) +endfunction(distutils_add_cython_module) + +function(distutils_install_cython_module name) + get_property(compiler_launcher GLOBAL PROPERTY RULE_LAUNCH_COMPILE) + get_property(link_launcher GLOBAL PROPERTY RULE_LAUNCH_LINK) + set(PY_CC "${compiler_launcher} ${CMAKE_C_COMPILER}") + set(PY_LDSHARED "${link_launcher} ${CMAKE_C_COMPILER} -shared") + install(CODE " + set(ENV{CC} \"${PY_CC}\") + set(ENV{LDSHARED} \"${PY_LDSHARED}\") + set(ENV{CPPFLAGS} \"-iquote${CMAKE_SOURCE_DIR}/src/include + -D'void0=dead_function\(void\)' \ + -D'__Pyx_check_single_interpreter\(ARG\)=ARG\#\#0'\") + set(ENV{LDFLAGS} \"-L${CMAKE_LIBRARY_OUTPUT_DIRECTORY}\") + set(ENV{CYTHON_BUILD_DIR} \"${CMAKE_CURRENT_BINARY_DIR}\") + set(ENV{CEPH_LIBDIR} \"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}\") + + set(options --prefix=${CMAKE_INSTALL_PREFIX}) + if(DEFINED ENV{DESTDIR}) + if(EXISTS /etc/debian_version) + list(APPEND options --install-layout=deb) + endif() + list(APPEND options --root=\$ENV{DESTDIR}) + else() + list(APPEND options --root=/) + endif() + execute_process( + COMMAND + ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/setup.py + build --verbose --build-base ${CYTHON_MODULE_DIR} + --build-platlib ${CYTHON_MODULE_DIR}/lib.3 + build_ext --cython-c-in-temp --build-temp ${CMAKE_CURRENT_BINARY_DIR} --cython-include-dirs ${PROJECT_SOURCE_DIR}/src/pybind/rados + install \${options} --single-version-externally-managed --record /dev/null + egg_info --egg-base ${CMAKE_CURRENT_BINARY_DIR} + --verbose + WORKING_DIRECTORY \"${CMAKE_CURRENT_SOURCE_DIR}\" + RESULT_VARIABLE install_res) + if(NOT \"\${install_res}\" STREQUAL 0) + message(FATAL_ERROR \"Failed to build and install ${name} python module\") + endif() + ") +endfunction(distutils_install_cython_module) diff --git a/cmake/modules/ExternalProjectHelper.cmake b/cmake/modules/ExternalProjectHelper.cmake new file mode 100644 index 000000000..42beab197 --- /dev/null +++ b/cmake/modules/ExternalProjectHelper.cmake @@ -0,0 +1,17 @@ +function (set_library_properties_for_external_project _target _lib) + # Manually create the directory, it will be created as part of the build, + # but this runs in the configuration phase, and CMake generates an error if + # we add an include directory that does not exist yet. + set(_libfullname "${CMAKE_SHARED_LIBRARY_PREFIX}${_lib}${CMAKE_SHARED_LIBRARY_SUFFIX}") + set(_libpath "${CMAKE_BINARY_DIR}/external/lib/${_libfullname}") + set(_includepath "${CMAKE_BINARY_DIR}/external/include") + message(STATUS "Configuring ${_target} with ${_libpath}") + + file(MAKE_DIRECTORY "${_includepath}") + set_target_properties(${_target} PROPERTIES + INTERFACE_LINK_LIBRARIES "${_libpath}" + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LOCATION "${_libpath}" + INTERFACE_INCLUDE_DIRECTORIES "${_includepath}") + # set_property(TARGET ${_target} APPEND PROPERTY IMPORTED_LINK_INTERFACE_LIBRARIES "CXX") +endfunction () diff --git a/cmake/modules/FindBacktrace.cmake b/cmake/modules/FindBacktrace.cmake new file mode 100644 index 000000000..936875c84 --- /dev/null +++ b/cmake/modules/FindBacktrace.cmake @@ -0,0 +1,101 @@ +#.rst: +# FindBacktrace +# ------------- +# +# Find provider for backtrace(3). +# +# Checks if OS supports backtrace(3) via either libc or custom library. +# This module defines the following variables: +# +# ``Backtrace_HEADER`` +# The header file needed for backtrace(3). Cached. +# Could be forcibly set by user. +# ``Backtrace_INCLUDE_DIRS`` +# The include directories needed to use backtrace(3) header. +# ``Backtrace_LIBRARIES`` +# The libraries (linker flags) needed to use backtrace(3), if any. +# ``Backtrace_FOUND`` +# Is set if and only if backtrace(3) support detected. +# +# The following cache variables are also available to set or use: +# +# ``Backtrace_LIBRARY`` +# The external library providing backtrace, if any. +# ``Backtrace_INCLUDE_DIR`` +# The directory holding the backtrace(3) header. +# +# Typical usage is to generate of header file using configure_file() with the +# contents like the following:: +# +# #cmakedefine01 Backtrace_FOUND +# #if Backtrace_FOUND +# # include <${Backtrace_HEADER}> +# #endif +# +# And then reference that generated header file in actual source. + +#============================================================================= +# Copyright 2013 Vadim Zhukov +# +# Distributed under the OSI-approved BSD License (the "License"); +# see accompanying file Copyright.txt for details. +# +# This software is distributed WITHOUT ANY WARRANTY; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the License for more information. +#============================================================================= +# (To distribute this file outside of CMake, substitute the full +# License text for the above reference.) + + +include(CMakePushCheckState) +include(CheckSymbolExists) +include(FindPackageHandleStandardArgs) + +# List of variables to be provided to find_package_handle_standard_args() +set(_Backtrace_STD_ARGS Backtrace_INCLUDE_DIR) + +if(Backtrace_HEADER) + set(_Backtrace_HEADER_TRY "${Backtrace_HEADER}") +else(Backtrace_HEADER) + set(_Backtrace_HEADER_TRY "execinfo.h") +endif(Backtrace_HEADER) + +find_path(Backtrace_INCLUDE_DIR "${_Backtrace_HEADER_TRY}") +set(Backtrace_INCLUDE_DIRS ${Backtrace_INCLUDE_DIR}) + +if (NOT DEFINED Backtrace_LIBRARY) + # First, check if we already have backtrace(), e.g., in libc + cmake_push_check_state(RESET) + set(CMAKE_REQUIRED_INCLUDES ${Backtrace_INCLUDE_DIRS}) + set(CMAKE_REQUIRED_QUIET ${Backtrace_FIND_QUIETLY}) + check_symbol_exists("backtrace" "${_Backtrace_HEADER_TRY}" _Backtrace_SYM_FOUND) + cmake_pop_check_state() +endif() + +if(_Backtrace_SYM_FOUND) + # Avoid repeating the message() call below each time CMake is run. + if(NOT Backtrace_FIND_QUIETLY AND NOT DEFINED Backtrace_LIBRARY) + message(STATUS "backtrace facility detected in default set of libraries") + endif() + set(Backtrace_LIBRARY "" CACHE FILEPATH "Library providing backtrace(3), empty for default set of libraries") +else() + # Check for external library, for non-glibc systems + if(Backtrace_INCLUDE_DIR) + # OpenBSD has libbacktrace renamed to libexecinfo + find_library(Backtrace_LIBRARY "execinfo") + elseif() # respect user wishes + set(_Backtrace_HEADER_TRY "backtrace.h") + find_path(Backtrace_INCLUDE_DIR ${_Backtrace_HEADER_TRY}) + find_library(Backtrace_LIBRARY "backtrace") + endif() + + # Prepend list with library path as it's more common practice + set(_Backtrace_STD_ARGS Backtrace_LIBRARY ${_Backtrace_STD_ARGS}) +endif() + +set(Backtrace_LIBRARIES ${Backtrace_LIBRARY}) +set(Backtrace_HEADER "${_Backtrace_HEADER_TRY}" CACHE STRING "Header providing backtrace(3) facility") + +find_package_handle_standard_args(Backtrace FOUND_VAR Backtrace_FOUND REQUIRED_VARS ${_Backtrace_STD_ARGS}) +mark_as_advanced(Backtrace_HEADER Backtrace_INCLUDE_DIR Backtrace_LIBRARY) diff --git a/cmake/modules/FindBoost.cmake b/cmake/modules/FindBoost.cmake new file mode 100644 index 000000000..824e5fdb7 --- /dev/null +++ b/cmake/modules/FindBoost.cmake @@ -0,0 +1,2410 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindBoost +--------- + +Find Boost include dirs and libraries + +Use this module by invoking find_package with the form:: + + find_package(Boost + [version] [EXACT] # Minimum or EXACT version e.g. 1.67.0 + [REQUIRED] # Fail with error if Boost is not found + [COMPONENTS <libs>...] # Boost libraries by their canonical name + # e.g. "date_time" for "libboost_date_time" + [OPTIONAL_COMPONENTS <libs>...] + # Optional Boost libraries by their canonical name) + ) # e.g. "date_time" for "libboost_date_time" + +This module finds headers and requested component libraries OR a CMake +package configuration file provided by a "Boost CMake" build. For the +latter case skip to the "Boost CMake" section below. For the former +case results are reported in variables:: + + Boost_FOUND - True if headers and requested libraries were found + Boost_INCLUDE_DIRS - Boost include directories + Boost_LIBRARY_DIRS - Link directories for Boost libraries + Boost_LIBRARIES - Boost component libraries to be linked + Boost_<C>_FOUND - True if component <C> was found (<C> is upper-case) + Boost_<C>_LIBRARY - Libraries to link for component <C> (may include + target_link_libraries debug/optimized keywords) + Boost_VERSION_MACRO - BOOST_VERSION value from boost/version.hpp + Boost_VERSION_STRING - Boost version number in x.y.z format + Boost_VERSION - if CMP0093 NEW => same as Boost_VERSION_STRING + if CMP0093 OLD or unset => same as Boost_VERSION_MACRO + Boost_LIB_VERSION - Version string appended to library filenames + Boost_VERSION_MAJOR - Boost major version number (X in X.y.z) + alias: Boost_MAJOR_VERSION + Boost_VERSION_MINOR - Boost minor version number (Y in x.Y.z) + alias: Boost_MINOR_VERSION + Boost_VERSION_PATCH - Boost subminor version number (Z in x.y.Z) + alias: Boost_SUBMINOR_VERSION + Boost_VERSION_COUNT - Amount of version components (3) + Boost_LIB_DIAGNOSTIC_DEFINITIONS (Windows) + - Pass to add_definitions() to have diagnostic + information about Boost's automatic linking + displayed during compilation + +Note that Boost Python components require a Python version suffix +(Boost 1.67 and later), e.g. ``python36`` or ``python27`` for the +versions built against Python 3.6 and 2.7, respectively. This also +applies to additional components using Python including +``mpi_python`` and ``numpy``. Earlier Boost releases may use +distribution-specific suffixes such as ``2``, ``3`` or ``2.7``. +These may also be used as suffixes, but note that they are not +portable. + +This module reads hints about search locations from variables:: + + BOOST_ROOT - Preferred installation prefix + (or BOOSTROOT) + BOOST_INCLUDEDIR - Preferred include directory e.g. <prefix>/include + BOOST_LIBRARYDIR - Preferred library directory e.g. <prefix>/lib + Boost_NO_SYSTEM_PATHS - Set to ON to disable searching in locations not + specified by these hint variables. Default is OFF. + Boost_ADDITIONAL_VERSIONS + - List of Boost versions not known to this module + (Boost install locations may contain the version) + +and saves search results persistently in CMake cache entries:: + + Boost_INCLUDE_DIR - Directory containing Boost headers + Boost_LIBRARY_DIR_RELEASE - Directory containing release Boost libraries + Boost_LIBRARY_DIR_DEBUG - Directory containing debug Boost libraries + Boost_<C>_LIBRARY_DEBUG - Component <C> library debug variant + Boost_<C>_LIBRARY_RELEASE - Component <C> library release variant + +The following :prop_tgt:`IMPORTED` targets are also defined:: + + Boost::headers - Target for header-only dependencies + (Boost include directory) + alias: Boost::boost + Boost::<C> - Target for specific component dependency + (shared or static library); <C> is lower- + case + Boost::diagnostic_definitions - interface target to enable diagnostic + information about Boost's automatic linking + during compilation (adds BOOST_LIB_DIAGNOSTIC) + Boost::disable_autolinking - interface target to disable automatic + linking with MSVC (adds BOOST_ALL_NO_LIB) + Boost::dynamic_linking - interface target to enable dynamic linking + linking with MSVC (adds BOOST_ALL_DYN_LINK) + +Implicit dependencies such as ``Boost::filesystem`` requiring +``Boost::system`` will be automatically detected and satisfied, even +if system is not specified when using :command:`find_package` and if +``Boost::system`` is not added to :command:`target_link_libraries`. If using +``Boost::thread``, then ``Threads::Threads`` will also be added automatically. + +It is important to note that the imported targets behave differently +than variables created by this module: multiple calls to +:command:`find_package(Boost)` in the same directory or sub-directories with +different options (e.g. static or shared) will not override the +values of the targets created by the first call. + +Users may set these hints or results as ``CACHE`` entries. Projects +should not read these entries directly but instead use the above +result variables. Note that some hint names start in upper-case +"BOOST". One may specify these as environment variables if they are +not specified as CMake variables or cache entries. + +This module first searches for the ``Boost`` header files using the above +hint variables (excluding ``BOOST_LIBRARYDIR``) and saves the result in +``Boost_INCLUDE_DIR``. Then it searches for requested component libraries +using the above hints (excluding ``BOOST_INCLUDEDIR`` and +``Boost_ADDITIONAL_VERSIONS``), "lib" directories near ``Boost_INCLUDE_DIR``, +and the library name configuration settings below. It saves the +library directories in ``Boost_LIBRARY_DIR_DEBUG`` and +``Boost_LIBRARY_DIR_RELEASE`` and individual library +locations in ``Boost_<C>_LIBRARY_DEBUG`` and ``Boost_<C>_LIBRARY_RELEASE``. +When one changes settings used by previous searches in the same build +tree (excluding environment variables) this module discards previous +search results affected by the changes and searches again. + +Boost libraries come in many variants encoded in their file name. +Users or projects may tell this module which variant to find by +setting variables:: + + Boost_USE_DEBUG_LIBS - Set to ON or OFF to specify whether to search + and use the debug libraries. Default is ON. + Boost_USE_RELEASE_LIBS - Set to ON or OFF to specify whether to search + and use the release libraries. Default is ON. + Boost_USE_MULTITHREADED - Set to OFF to use the non-multithreaded + libraries ('mt' tag). Default is ON. + Boost_USE_STATIC_LIBS - Set to ON to force the use of the static + libraries. Default is OFF. + Boost_USE_STATIC_RUNTIME - Set to ON or OFF to specify whether to use + libraries linked statically to the C++ runtime + ('s' tag). Default is platform dependent. + Boost_USE_DEBUG_RUNTIME - Set to ON or OFF to specify whether to use + libraries linked to the MS debug C++ runtime + ('g' tag). Default is ON. + Boost_USE_DEBUG_PYTHON - Set to ON to use libraries compiled with a + debug Python build ('y' tag). Default is OFF. + Boost_USE_STLPORT - Set to ON to use libraries compiled with + STLPort ('p' tag). Default is OFF. + Boost_USE_STLPORT_DEPRECATED_NATIVE_IOSTREAMS + - Set to ON to use libraries compiled with + STLPort deprecated "native iostreams" + ('n' tag). Default is OFF. + Boost_COMPILER - Set to the compiler-specific library suffix + (e.g. "-gcc43"). Default is auto-computed + for the C++ compiler in use. A list may be + used if multiple compatible suffixes should + be tested for, in decreasing order of + preference. + Boost_LIB_PREFIX - Set to the platform-specific library name + prefix (e.g. "lib") used by Boost static libs. + This is needed only on platforms where CMake + does not know the prefix by default. + Boost_ARCHITECTURE - Set to the architecture-specific library suffix + (e.g. "-x64"). Default is auto-computed for the + C++ compiler in use. + Boost_THREADAPI - Suffix for "thread" component library name, + such as "pthread" or "win32". Names with + and without this suffix will both be tried. + Boost_NAMESPACE - Alternate namespace used to build boost with + e.g. if set to "myboost", will search for + myboost_thread instead of boost_thread. + +Other variables one may set to control this module are:: + + Boost_DEBUG - Set to ON to enable debug output from FindBoost. + Please enable this before filing any bug report. + Boost_REALPATH - Set to ON to resolve symlinks for discovered + libraries to assist with packaging. For example, + the "system" component library may be resolved to + "/usr/lib/libboost_system.so.1.67.0" instead of + "/usr/lib/libboost_system.so". This does not + affect linking and should not be enabled unless + the user needs this information. + Boost_LIBRARY_DIR - Default value for Boost_LIBRARY_DIR_RELEASE and + Boost_LIBRARY_DIR_DEBUG. + +On Visual Studio and Borland compilers Boost headers request automatic +linking to corresponding libraries. This requires matching libraries +to be linked explicitly or available in the link library search path. +In this case setting ``Boost_USE_STATIC_LIBS`` to ``OFF`` may not achieve +dynamic linking. Boost automatic linking typically requests static +libraries with a few exceptions (such as ``Boost.Python``). Use:: + + add_definitions(${Boost_LIB_DIAGNOSTIC_DEFINITIONS}) + +to ask Boost to report information about automatic linking requests. + +Example to find Boost headers only:: + + find_package(Boost 1.36.0) + if(Boost_FOUND) + include_directories(${Boost_INCLUDE_DIRS}) + add_executable(foo foo.cc) + endif() + +Example to find Boost libraries and use imported targets:: + + find_package(Boost 1.56 REQUIRED COMPONENTS + date_time filesystem iostreams) + add_executable(foo foo.cc) + target_link_libraries(foo Boost::date_time Boost::filesystem + Boost::iostreams) + +Example to find Boost Python 3.6 libraries and use imported targets:: + + find_package(Boost 1.67 REQUIRED COMPONENTS + python36 numpy36) + add_executable(foo foo.cc) + target_link_libraries(foo Boost::python36 Boost::numpy36) + +Example to find Boost headers and some *static* (release only) libraries:: + + set(Boost_USE_STATIC_LIBS ON) # only find static libs + set(Boost_USE_DEBUG_LIBS OFF) # ignore debug libs and + set(Boost_USE_RELEASE_LIBS ON) # only find release libs + set(Boost_USE_MULTITHREADED ON) + set(Boost_USE_STATIC_RUNTIME OFF) + find_package(Boost 1.66.0 COMPONENTS date_time filesystem system ...) + if(Boost_FOUND) + include_directories(${Boost_INCLUDE_DIRS}) + add_executable(foo foo.cc) + target_link_libraries(foo ${Boost_LIBRARIES}) + endif() + +Boost CMake +^^^^^^^^^^^ + +If Boost was built using the boost-cmake project or from Boost 1.70.0 on +it provides a package configuration file for use with find_package's config mode. +This module looks for the package configuration file called +``BoostConfig.cmake`` or ``boost-config.cmake`` and stores the result in +``CACHE`` entry "Boost_DIR". If found, the package configuration file is loaded +and this module returns with no further action. See documentation of +the Boost CMake package configuration for details on what it provides. + +Set ``Boost_NO_BOOST_CMAKE`` to ``ON``, to disable the search for boost-cmake. +#]=======================================================================] + +# The FPHSA helper provides standard way of reporting final search results to +# the user including the version and component checks. +include(FindPackageHandleStandardArgs) + +# Save project's policies +cmake_policy(PUSH) +cmake_policy(SET CMP0057 NEW) # if IN_LIST +if(POLICY CMP0102) + cmake_policy(SET CMP0102 NEW) # if mark_as_advanced(non_cache_var) +endif() + +function(_boost_get_existing_target component target_var) + set(names "${component}") + if(component MATCHES "^([a-z_]*)(python|numpy)([1-9])\\.?([0-9])?$") + # handle pythonXY and numpyXY versioned components and also python X.Y, mpi_python etc. + list(APPEND names + "${CMAKE_MATCH_1}${CMAKE_MATCH_2}" # python + "${CMAKE_MATCH_1}${CMAKE_MATCH_2}${CMAKE_MATCH_3}" # pythonX + "${CMAKE_MATCH_1}${CMAKE_MATCH_2}${CMAKE_MATCH_3}${CMAKE_MATCH_4}" #pythonXY + ) + endif() + # https://github.com/boost-cmake/boost-cmake uses boost::file_system etc. + # So handle similar constructions of target names + string(TOLOWER "${component}" lower_component) + list(APPEND names "${lower_component}") + foreach(prefix Boost boost) + foreach(name IN LISTS names) + if(TARGET "${prefix}::${name}") + # The target may be an INTERFACE library that wraps around a single other + # target for compatibility. Unwrap this layer so we can extract real info. + if("${name}" MATCHES "^(python|numpy|mpi_python)([1-9])([0-9])$") + set(name_nv "${CMAKE_MATCH_1}") + if(TARGET "${prefix}::${name_nv}") + get_property(type TARGET "${prefix}::${name}" PROPERTY TYPE) + if(type STREQUAL "INTERFACE_LIBRARY") + get_property(lib TARGET "${prefix}::${name}" PROPERTY INTERFACE_LINK_LIBRARIES) + if("${lib}" STREQUAL "${prefix}::${name_nv}") + set(${target_var} "${prefix}::${name_nv}" PARENT_SCOPE) + return() + endif() + endif() + endif() + endif() + set(${target_var} "${prefix}::${name}" PARENT_SCOPE) + return() + endif() + endforeach() + endforeach() + set(${target_var} "" PARENT_SCOPE) +endfunction() + +function(_boost_get_canonical_target_name component target_var) + string(TOLOWER "${component}" component) + if(component MATCHES "^([a-z_]*)(python|numpy)([1-9])\\.?([0-9])?$") + # handle pythonXY and numpyXY versioned components and also python X.Y, mpi_python etc. + set(${target_var} "Boost::${CMAKE_MATCH_1}${CMAKE_MATCH_2}" PARENT_SCOPE) + else() + set(${target_var} "Boost::${component}" PARENT_SCOPE) + endif() +endfunction() + +macro(_boost_set_in_parent_scope name value) + # Set a variable in parent scope and make it visibile in current scope + set(${name} "${value}" PARENT_SCOPE) + set(${name} "${value}") +endmacro() + +macro(_boost_set_if_unset name value) + if(NOT ${name}) + _boost_set_in_parent_scope(${name} "${value}") + endif() +endmacro() + +macro(_boost_set_cache_if_unset name value) + if(NOT ${name}) + set(${name} "${value}" CACHE STRING "" FORCE) + endif() +endmacro() + +macro(_boost_append_include_dir target) + get_target_property(inc "${target}" INTERFACE_INCLUDE_DIRECTORIES) + if(inc) + list(APPEND include_dirs "${inc}") + endif() +endmacro() + +function(_boost_set_legacy_variables_from_config) + # Set legacy variables for compatibility if not set + set(include_dirs "") + set(library_dirs "") + set(libraries "") + # Header targets Boost::headers or Boost::boost + foreach(comp headers boost) + _boost_get_existing_target(${comp} target) + if(target) + _boost_append_include_dir("${target}") + endif() + endforeach() + # Library targets + foreach(comp IN LISTS Boost_FIND_COMPONENTS) + string(TOUPPER ${comp} uppercomp) + # Overwrite if set + _boost_set_in_parent_scope(Boost_${uppercomp}_FOUND "${Boost_${comp}_FOUND}") + if(Boost_${comp}_FOUND) + _boost_get_existing_target(${comp} target) + if(NOT target) + if(Boost_DEBUG OR Boost_VERBOSE) + message(WARNING "Could not find imported target for required component '${comp}'. Legacy variables for this component might be missing. Refer to the documentation of your Boost installation for help on variables to use.") + endif() + continue() + endif() + _boost_append_include_dir("${target}") + _boost_set_if_unset(Boost_${uppercomp}_LIBRARY "${target}") + _boost_set_if_unset(Boost_${uppercomp}_LIBRARIES "${target}") # Very old legacy variable + list(APPEND libraries "${target}") + get_property(type TARGET "${target}" PROPERTY TYPE) + if(NOT type STREQUAL "INTERFACE_LIBRARY") + foreach(cfg RELEASE DEBUG) + get_target_property(lib ${target} IMPORTED_LOCATION_${cfg}) + if(lib) + get_filename_component(lib_dir "${lib}" DIRECTORY) + list(APPEND library_dirs ${lib_dir}) + _boost_set_cache_if_unset(Boost_${uppercomp}_LIBRARY_${cfg} "${lib}") + endif() + endforeach() + elseif(Boost_DEBUG OR Boost_VERBOSE) + # For projects using only the Boost::* targets this warning can be safely ignored. + message(WARNING "Imported target '${target}' for required component '${comp}' has no artifact. Legacy variables for this component might be missing. Refer to the documentation of your Boost installation for help on variables to use.") + endif() + _boost_get_canonical_target_name("${comp}" canonical_target) + if(NOT TARGET "${canonical_target}") + add_library("${canonical_target}" INTERFACE IMPORTED) + target_link_libraries("${canonical_target}" INTERFACE "${target}") + endif() + endif() + endforeach() + list(REMOVE_DUPLICATES include_dirs) + list(REMOVE_DUPLICATES library_dirs) + _boost_set_if_unset(Boost_INCLUDE_DIRS "${include_dirs}") + _boost_set_if_unset(Boost_LIBRARY_DIRS "${library_dirs}") + _boost_set_if_unset(Boost_LIBRARIES "${libraries}") + _boost_set_if_unset(Boost_VERSION_STRING "${Boost_VERSION_MAJOR}.${Boost_VERSION_MINOR}.${Boost_VERSION_PATCH}") + find_path(Boost_INCLUDE_DIR + NAMES boost/version.hpp boost/config.hpp + HINTS ${Boost_INCLUDE_DIRS} + NO_DEFAULT_PATH + ) + if(NOT Boost_VERSION_MACRO OR NOT Boost_LIB_VERSION) + set(version_file ${Boost_INCLUDE_DIR}/boost/version.hpp) + if(EXISTS "${version_file}") + file(STRINGS "${version_file}" contents REGEX "#define BOOST_(LIB_)?VERSION ") + if(contents MATCHES "#define BOOST_VERSION ([0-9]+)") + _boost_set_if_unset(Boost_VERSION_MACRO "${CMAKE_MATCH_1}") + endif() + if(contents MATCHES "#define BOOST_LIB_VERSION \"([0-9_]+)\"") + _boost_set_if_unset(Boost_LIB_VERSION "${CMAKE_MATCH_1}") + endif() + endif() + endif() + _boost_set_if_unset(Boost_MAJOR_VERSION ${Boost_VERSION_MAJOR}) + _boost_set_if_unset(Boost_MINOR_VERSION ${Boost_VERSION_MINOR}) + _boost_set_if_unset(Boost_SUBMINOR_VERSION ${Boost_VERSION_PATCH}) + if(WIN32) + _boost_set_if_unset(Boost_LIB_DIAGNOSTIC_DEFINITIONS "-DBOOST_LIB_DIAGNOSTIC") + endif() + if(NOT TARGET Boost::headers) + add_library(Boost::headers INTERFACE IMPORTED) + target_include_directories(Boost::headers INTERFACE ${Boost_INCLUDE_DIRS}) + endif() + # Legacy targets w/o functionality as all handled by defined targets + foreach(lib diagnostic_definitions disable_autolinking dynamic_linking) + if(NOT TARGET Boost::${lib}) + add_library(Boost::${lib} INTERFACE IMPORTED) + endif() + endforeach() + if(NOT TARGET Boost::boost) + add_library(Boost::boost INTERFACE IMPORTED) + target_link_libraries(Boost::boost INTERFACE Boost::headers) + endif() +endfunction() + +#------------------------------------------------------------------------------- +# Before we go searching, check whether a boost cmake package is available, unless +# the user specifically asked NOT to search for one. +# +# If Boost_DIR is set, this behaves as any find_package call would. If not, +# it looks at BOOST_ROOT and BOOSTROOT to find Boost. +# +if (NOT Boost_NO_BOOST_CMAKE) + # If Boost_DIR is not set, look for BOOSTROOT and BOOST_ROOT as alternatives, + # since these are more conventional for Boost. + if ("$ENV{Boost_DIR}" STREQUAL "") + if (NOT "$ENV{BOOST_ROOT}" STREQUAL "") + set(ENV{Boost_DIR} $ENV{BOOST_ROOT}) + elseif (NOT "$ENV{BOOSTROOT}" STREQUAL "") + set(ENV{Boost_DIR} $ENV{BOOSTROOT}) + endif() + endif() + + set(_boost_FIND_PACKAGE_ARGS "") + if(Boost_NO_SYSTEM_PATHS) + list(APPEND _boost_FIND_PACKAGE_ARGS NO_CMAKE_SYSTEM_PATH NO_SYSTEM_ENVIRONMENT_PATH) + endif() + + # Do the same find_package call but look specifically for the CMake version. + # Note that args are passed in the Boost_FIND_xxxxx variables, so there is no + # need to delegate them to this find_package call. + cmake_policy(PUSH) + if(BOOST_ROOT AND NOT Boost_ROOT) + if(POLICY CMP0074) + cmake_policy(SET CMP0074 NEW) + endif() + set(Boost_ROOT "${BOOST_ROOT}") + endif() + find_package(Boost QUIET NO_MODULE ${_boost_FIND_PACKAGE_ARGS}) + cmake_policy(POP) + if (DEFINED Boost_DIR) + mark_as_advanced(Boost_DIR) + endif () + + # If we found a boost cmake package, then we're done. Print out what we found. + # Otherwise let the rest of the module try to find it. + if(Boost_FOUND) + # Convert component found variables to standard variables if required + # Necessary for legacy boost-cmake and 1.70 builtin BoostConfig + if(Boost_FIND_COMPONENTS) + # Ignore the meta-component "ALL", introduced by Boost 1.73 + list(REMOVE_ITEM Boost_FIND_COMPONENTS "ALL") + + foreach(_comp IN LISTS Boost_FIND_COMPONENTS) + if(DEFINED Boost_${_comp}_FOUND) + continue() + endif() + string(TOUPPER ${_comp} _uppercomp) + if(DEFINED Boost${_comp}_FOUND) # legacy boost-cmake project + set(Boost_${_comp}_FOUND ${Boost${_comp}_FOUND}) + elseif(DEFINED Boost_${_uppercomp}_FOUND) # Boost 1.70 + set(Boost_${_comp}_FOUND ${Boost_${_uppercomp}_FOUND}) + endif() + endforeach() + endif() + + find_package_handle_standard_args(Boost HANDLE_COMPONENTS CONFIG_MODE) + _boost_set_legacy_variables_from_config() + + # Restore project's policies + cmake_policy(POP) + return() + endif() +endif() + + +#------------------------------------------------------------------------------- +# FindBoost functions & macros +# + +# +# Print debug text if Boost_DEBUG is set. +# Call example: +# _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "debug message") +# +function(_Boost_DEBUG_PRINT file line text) + if(Boost_DEBUG) + message(STATUS "[ ${file}:${line} ] ${text}") + endif() +endfunction() + +# +# _Boost_DEBUG_PRINT_VAR(file line variable_name [ENVIRONMENT] +# [SOURCE "short explanation of origin of var value"]) +# +# ENVIRONMENT - look up environment variable instead of CMake variable +# +# Print variable name and its value if Boost_DEBUG is set. +# Call example: +# _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" BOOST_ROOT) +# +function(_Boost_DEBUG_PRINT_VAR file line name) + if(Boost_DEBUG) + cmake_parse_arguments(_args "ENVIRONMENT" "SOURCE" "" ${ARGN}) + + unset(source) + if(_args_SOURCE) + set(source " (${_args_SOURCE})") + endif() + + if(_args_ENVIRONMENT) + if(DEFINED ENV{${name}}) + set(value "\"$ENV{${name}}\"") + else() + set(value "<unset>") + endif() + set(_name "ENV{${name}}") + else() + if(DEFINED "${name}") + set(value "\"${${name}}\"") + else() + set(value "<unset>") + endif() + set(_name "${name}") + endif() + + _Boost_DEBUG_PRINT("${file}" "${line}" "${_name} = ${value}${source}") + endif() +endfunction() + +############################################ +# +# Check the existence of the libraries. +# +############################################ +# This macro was taken directly from the FindQt4.cmake file that is included +# with the CMake distribution. This is NOT my work. All work was done by the +# original authors of the FindQt4.cmake file. Only minor modifications were +# made to remove references to Qt and make this file more generally applicable +# And ELSE/ENDIF pairs were removed for readability. +######################################################################### + +macro(_Boost_ADJUST_LIB_VARS basename) + if(Boost_INCLUDE_DIR ) + if(Boost_${basename}_LIBRARY_DEBUG AND Boost_${basename}_LIBRARY_RELEASE) + # if the generator is multi-config or if CMAKE_BUILD_TYPE is set for + # single-config generators, set optimized and debug libraries + get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(_isMultiConfig OR CMAKE_BUILD_TYPE) + set(Boost_${basename}_LIBRARY optimized ${Boost_${basename}_LIBRARY_RELEASE} debug ${Boost_${basename}_LIBRARY_DEBUG}) + else() + # For single-config generators where CMAKE_BUILD_TYPE has no value, + # just use the release libraries + set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_RELEASE} ) + endif() + # FIXME: This probably should be set for both cases + set(Boost_${basename}_LIBRARIES optimized ${Boost_${basename}_LIBRARY_RELEASE} debug ${Boost_${basename}_LIBRARY_DEBUG}) + endif() + + # if only the release version was found, set the debug variable also to the release version + if(Boost_${basename}_LIBRARY_RELEASE AND NOT Boost_${basename}_LIBRARY_DEBUG) + set(Boost_${basename}_LIBRARY_DEBUG ${Boost_${basename}_LIBRARY_RELEASE}) + set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_RELEASE}) + set(Boost_${basename}_LIBRARIES ${Boost_${basename}_LIBRARY_RELEASE}) + endif() + + # if only the debug version was found, set the release variable also to the debug version + if(Boost_${basename}_LIBRARY_DEBUG AND NOT Boost_${basename}_LIBRARY_RELEASE) + set(Boost_${basename}_LIBRARY_RELEASE ${Boost_${basename}_LIBRARY_DEBUG}) + set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_DEBUG}) + set(Boost_${basename}_LIBRARIES ${Boost_${basename}_LIBRARY_DEBUG}) + endif() + + # If the debug & release library ends up being the same, omit the keywords + if("${Boost_${basename}_LIBRARY_RELEASE}" STREQUAL "${Boost_${basename}_LIBRARY_DEBUG}") + set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_RELEASE} ) + set(Boost_${basename}_LIBRARIES ${Boost_${basename}_LIBRARY_RELEASE} ) + endif() + + if(Boost_${basename}_LIBRARY AND Boost_${basename}_HEADER) + set(Boost_${basename}_FOUND ON) + if("x${basename}" STREQUAL "xTHREAD" AND NOT TARGET Threads::Threads) + string(APPEND Boost_ERROR_REASON_THREAD " (missing dependency: Threads)") + set(Boost_THREAD_FOUND OFF) + endif() + endif() + + endif() + # Make variables changeable to the advanced user + mark_as_advanced( + Boost_${basename}_LIBRARY_RELEASE + Boost_${basename}_LIBRARY_DEBUG + ) +endmacro() + +# Detect changes in used variables. +# Compares the current variable value with the last one. +# In short form: +# v != v_LAST -> CHANGED = 1 +# v is defined, v_LAST not -> CHANGED = 1 +# v is not defined, but v_LAST is -> CHANGED = 1 +# otherwise -> CHANGED = 0 +# CHANGED is returned in variable named ${changed_var} +macro(_Boost_CHANGE_DETECT changed_var) + set(${changed_var} 0) + foreach(v ${ARGN}) + if(DEFINED _Boost_COMPONENTS_SEARCHED) + if(${v}) + if(_${v}_LAST) + string(COMPARE NOTEQUAL "${${v}}" "${_${v}_LAST}" _${v}_CHANGED) + else() + set(_${v}_CHANGED 1) + endif() + elseif(_${v}_LAST) + set(_${v}_CHANGED 1) + endif() + if(_${v}_CHANGED) + set(${changed_var} 1) + endif() + else() + set(_${v}_CHANGED 0) + endif() + endforeach() +endmacro() + +# +# Find the given library (var). +# Use 'build_type' to support different lib paths for RELEASE or DEBUG builds +# +macro(_Boost_FIND_LIBRARY var build_type) + + find_library(${var} ${ARGN}) + + if(${var}) + # If this is the first library found then save Boost_LIBRARY_DIR_[RELEASE,DEBUG]. + if(NOT Boost_LIBRARY_DIR_${build_type}) + get_filename_component(_dir "${${var}}" PATH) + set(Boost_LIBRARY_DIR_${build_type} "${_dir}" CACHE PATH "Boost library directory ${build_type}" FORCE) + endif() + elseif(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT) + # Try component-specific hints but do not save Boost_LIBRARY_DIR_[RELEASE,DEBUG]. + find_library(${var} HINTS ${_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT} ${ARGN}) + endif() + + # If Boost_LIBRARY_DIR_[RELEASE,DEBUG] is known then search only there. + if(Boost_LIBRARY_DIR_${build_type}) + set(_boost_LIBRARY_SEARCH_DIRS_${build_type} ${Boost_LIBRARY_DIR_${build_type}} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "Boost_LIBRARY_DIR_${build_type}") + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "_boost_LIBRARY_SEARCH_DIRS_${build_type}") + endif() +endmacro() + +#------------------------------------------------------------------------------- + +# Convert CMAKE_CXX_COMPILER_VERSION to boost compiler suffix version. +function(_Boost_COMPILER_DUMPVERSION _OUTPUT_VERSION _OUTPUT_VERSION_MAJOR _OUTPUT_VERSION_MINOR) + string(REGEX REPLACE "([0-9]+)\\.([0-9]+)(\\.[0-9]+)?" "\\1" + _boost_COMPILER_VERSION_MAJOR "${CMAKE_CXX_COMPILER_VERSION}") + string(REGEX REPLACE "([0-9]+)\\.([0-9]+)(\\.[0-9]+)?" "\\2" + _boost_COMPILER_VERSION_MINOR "${CMAKE_CXX_COMPILER_VERSION}") + + set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}${_boost_COMPILER_VERSION_MINOR}") + + set(${_OUTPUT_VERSION} ${_boost_COMPILER_VERSION} PARENT_SCOPE) + set(${_OUTPUT_VERSION_MAJOR} ${_boost_COMPILER_VERSION_MAJOR} PARENT_SCOPE) + set(${_OUTPUT_VERSION_MINOR} ${_boost_COMPILER_VERSION_MINOR} PARENT_SCOPE) +endfunction() + +# +# Take a list of libraries with "thread" in it +# and prepend duplicates with "thread_${Boost_THREADAPI}" +# at the front of the list +# +function(_Boost_PREPEND_LIST_WITH_THREADAPI _output) + set(_orig_libnames ${ARGN}) + string(REPLACE "thread" "thread_${Boost_THREADAPI}" _threadapi_libnames "${_orig_libnames}") + set(${_output} ${_threadapi_libnames} ${_orig_libnames} PARENT_SCOPE) +endfunction() + +# +# If a library is found, replace its cache entry with its REALPATH +# +function(_Boost_SWAP_WITH_REALPATH _library _docstring) + if(${_library}) + get_filename_component(_boost_filepathreal ${${_library}} REALPATH) + unset(${_library} CACHE) + set(${_library} ${_boost_filepathreal} CACHE FILEPATH "${_docstring}") + endif() +endfunction() + +function(_Boost_CHECK_SPELLING _var) + if(${_var}) + string(TOUPPER ${_var} _var_UC) + message(FATAL_ERROR "ERROR: ${_var} is not the correct spelling. The proper spelling is ${_var_UC}.") + endif() +endfunction() + +# Guesses Boost's compiler prefix used in built library names +# Returns the guess by setting the variable pointed to by _ret +function(_Boost_GUESS_COMPILER_PREFIX _ret) + if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntel") + if(WIN32) + set (_boost_COMPILER "-iw") + else() + set (_boost_COMPILER "-il") + endif() + elseif (GHSMULTI) + set(_boost_COMPILER "-ghs") + elseif("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC" OR "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") + if(MSVC_TOOLSET_VERSION GREATER_EQUAL 150) + # Not yet known. + set(_boost_COMPILER "") + elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 140) + # MSVC toolset 14.x versions are forward compatible. + set(_boost_COMPILER "") + foreach(v 9 8 7 6 5 4 3 2 1 0) + if(MSVC_TOOLSET_VERSION GREATER_EQUAL 14${v}) + list(APPEND _boost_COMPILER "-vc14${v}") + endif() + endforeach() + elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 80) + set(_boost_COMPILER "-vc${MSVC_TOOLSET_VERSION}") + elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.10) + set(_boost_COMPILER "-vc71") + elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13) # Good luck! + set(_boost_COMPILER "-vc7") # yes, this is correct + else() # VS 6.0 Good luck! + set(_boost_COMPILER "-vc6") # yes, this is correct + endif() + + if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang") + string(REPLACE "." ";" VERSION_LIST "${CMAKE_CXX_COMPILER_VERSION}") + list(GET VERSION_LIST 0 CLANG_VERSION_MAJOR) + set(_boost_COMPILER "-clangw${CLANG_VERSION_MAJOR};${_boost_COMPILER}") + endif() + elseif (BORLAND) + set(_boost_COMPILER "-bcb") + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "SunPro") + set(_boost_COMPILER "-sw") + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "XL") + set(_boost_COMPILER "-xlc") + elseif (MINGW) + if(Boost_VERSION_STRING VERSION_LESS 1.34) + set(_boost_COMPILER "-mgw") # no GCC version encoding prior to 1.34 + else() + _Boost_COMPILER_DUMPVERSION(_boost_COMPILER_VERSION _boost_COMPILER_VERSION_MAJOR _boost_COMPILER_VERSION_MINOR) + if(Boost_VERSION_STRING VERSION_GREATER_EQUAL 1.73 AND _boost_COMPILER_VERSION_MAJOR VERSION_GREATER_EQUAL 5) + set(_boost_COMPILER "-mgw${_boost_COMPILER_VERSION_MAJOR}") + else() + set(_boost_COMPILER "-mgw${_boost_COMPILER_VERSION}") + endif() + endif() + elseif (UNIX) + _Boost_COMPILER_DUMPVERSION(_boost_COMPILER_VERSION _boost_COMPILER_VERSION_MAJOR _boost_COMPILER_VERSION_MINOR) + if(NOT Boost_VERSION_STRING VERSION_LESS 1.69.0) + # From GCC 5 and clang 4, versioning changes and minor becomes patch. + # For those compilers, patch is exclude from compiler tag in Boost 1.69+ library naming. + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND _boost_COMPILER_VERSION_MAJOR VERSION_GREATER 4) + set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}") + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND _boost_COMPILER_VERSION_MAJOR VERSION_GREATER 3) + set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}") + endif() + endif() + + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + if(Boost_VERSION_STRING VERSION_LESS 1.34) + set(_boost_COMPILER "-gcc") # no GCC version encoding prior to 1.34 + else() + # Determine which version of GCC we have. + if(APPLE) + if(Boost_VERSION_STRING VERSION_LESS 1.36.0) + # In Boost <= 1.35.0, there is no mangled compiler name for + # the macOS/Darwin version of GCC. + set(_boost_COMPILER "") + else() + # In Boost 1.36.0 and newer, the mangled compiler name used + # on macOS/Darwin is "xgcc". + set(_boost_COMPILER "-xgcc${_boost_COMPILER_VERSION}") + endif() + else() + set(_boost_COMPILER "-gcc${_boost_COMPILER_VERSION}") + endif() + endif() + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + # TODO: Find out any Boost version constraints vs clang support. + set(_boost_COMPILER "-clang${_boost_COMPILER_VERSION}") + endif() + else() + set(_boost_COMPILER "") + endif() + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "_boost_COMPILER" SOURCE "guessed") + set(${_ret} ${_boost_COMPILER} PARENT_SCOPE) +endfunction() + +# +# Get component dependencies. Requires the dependencies to have been +# defined for the Boost release version. +# +# component - the component to check +# _ret - list of library dependencies +# +function(_Boost_COMPONENT_DEPENDENCIES component _ret) + # Note: to add a new Boost release, run + # + # % cmake -DBOOST_DIR=/path/to/boost/source -P Utilities/Scripts/BoostScanDeps.cmake + # + # The output may be added in a new block below. If it's the same as + # the previous release, simply update the version range of the block + # for the previous release. Also check if any new components have + # been added, and add any new components to + # _Boost_COMPONENT_HEADERS. + # + # This information was originally generated by running + # BoostScanDeps.cmake against every boost release to date supported + # by FindBoost: + # + # % for version in /path/to/boost/sources/* + # do + # cmake -DBOOST_DIR=$version -P Utilities/Scripts/BoostScanDeps.cmake + # done + # + # The output was then updated by search and replace with these regexes: + # + # - Strip message(STATUS) prefix dashes + # s;^-- ;; + # - Indent + # s;^set(; set(;; + # - Add conditionals + # s;Scanning /path/to/boost/sources/boost_\(.*\)_\(.*\)_\(.*); elseif(NOT Boost_VERSION_STRING VERSION_LESS \1\.\2\.\3 AND Boost_VERSION_STRING VERSION_LESS xxxx); + # + # This results in the logic seen below, but will require the xxxx + # replacing with the following Boost release version (or the next + # minor version to be released, e.g. 1.59 was the latest at the time + # of writing, making 1.60 the next. Identical consecutive releases + # were then merged together by updating the end range of the first + # block and removing the following redundant blocks. + # + # Running the script against all historical releases should be + # required only if the BoostScanDeps.cmake script logic is changed. + # The addition of a new release should only require it to be run + # against the new release. + + # Handle Python version suffixes + if(component MATCHES "^(python|mpi_python|numpy)([0-9][0-9]?|[0-9]\\.[0-9])\$") + set(component "${CMAKE_MATCH_1}") + set(component_python_version "${CMAKE_MATCH_2}") + endif() + + set(_Boost_IMPORTED_TARGETS TRUE) + if(Boost_VERSION_STRING) + if(Boost_VERSION_STRING VERSION_LESS 1.33.0) + message(WARNING "Imported targets and dependency information not available for Boost version ${Boost_VERSION_STRING} (all versions older than 1.33)") + set(_Boost_IMPORTED_TARGETS FALSE) + elseif(Boost_VERSION_STRING VERSION_LESS 1.35.0) + set(_Boost_IOSTREAMS_DEPENDENCIES regex thread) + set(_Boost_REGEX_DEPENDENCIES thread) + set(_Boost_WAVE_DEPENDENCIES filesystem thread) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.36.0) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_WAVE_DEPENDENCIES filesystem system thread) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.38.0) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_WAVE_DEPENDENCIES filesystem system thread) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.43.0) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_THREAD_DEPENDENCIES date_time) + set(_Boost_WAVE_DEPENDENCIES filesystem system thread date_time) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.44.0) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_THREAD_DEPENDENCIES date_time) + set(_Boost_WAVE_DEPENDENCIES filesystem system thread date_time) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.45.0) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random serialization) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_THREAD_DEPENDENCIES date_time) + set(_Boost_WAVE_DEPENDENCIES serialization filesystem system thread date_time) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.47.0) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_THREAD_DEPENDENCIES date_time) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread date_time) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.48.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_THREAD_DEPENDENCIES date_time) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread date_time) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.50.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_THREAD_DEPENDENCIES date_time) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread date_time) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.53.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.54.0) + set(_Boost_ATOMIC_DEPENDENCIES thread chrono system date_time) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.55.0) + set(_Boost_ATOMIC_DEPENDENCIES thread chrono system date_time) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.56.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_COROUTINE_DEPENDENCIES context system) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.59.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_COROUTINE_DEPENDENCIES context system) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_RANDOM_DEPENDENCIES system) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.60.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_COROUTINE_DEPENDENCIES context system) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_RANDOM_DEPENDENCIES system) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.61.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_COROUTINE_DEPENDENCIES context system) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_RANDOM_DEPENDENCIES system) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.62.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time) + set(_Boost_COROUTINE_DEPENDENCIES context system) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_RANDOM_DEPENDENCIES system) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.63.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time) + set(_Boost_COROUTINE_DEPENDENCIES context system) + set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_RANDOM_DEPENDENCIES system) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.65.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time) + set(_Boost_COROUTINE_DEPENDENCIES context system) + set(_Boost_COROUTINE2_DEPENDENCIES context fiber thread chrono system date_time) + set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_RANDOM_DEPENDENCIES system) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.67.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time) + set(_Boost_COROUTINE_DEPENDENCIES context system) + set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_NUMPY_DEPENDENCIES python${component_python_version}) + set(_Boost_RANDOM_DEPENDENCIES system) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.68.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time) + set(_Boost_COROUTINE_DEPENDENCIES context system) + set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_NUMPY_DEPENDENCIES python${component_python_version}) + set(_Boost_RANDOM_DEPENDENCIES system) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.69.0) + set(_Boost_CHRONO_DEPENDENCIES system) + set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time) + set(_Boost_CONTRACT_DEPENDENCIES thread chrono system date_time) + set(_Boost_COROUTINE_DEPENDENCIES context system) + set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time) + set(_Boost_FILESYSTEM_DEPENDENCIES system) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_NUMPY_DEPENDENCIES python${component_python_version}) + set(_Boost_RANDOM_DEPENDENCIES system) + set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.70.0) + set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time) + set(_Boost_COROUTINE_DEPENDENCIES context) + set(_Boost_FIBER_DEPENDENCIES context) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_NUMPY_DEPENDENCIES python${component_python_version}) + set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono system) + set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.72.0) + set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time) + set(_Boost_COROUTINE_DEPENDENCIES context) + set(_Boost_FIBER_DEPENDENCIES context) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_NUMPY_DEPENDENCIES python${component_python_version}) + set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono) + set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + elseif(Boost_VERSION_STRING VERSION_LESS 1.73.0) + set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time) + set(_Boost_COROUTINE_DEPENDENCIES context) + set(_Boost_FIBER_DEPENDENCIES context) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l chrono atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_NUMPY_DEPENDENCIES python${component_python_version}) + set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono) + set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + else() + set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time) + set(_Boost_COROUTINE_DEPENDENCIES context) + set(_Boost_FIBER_DEPENDENCIES context) + set(_Boost_IOSTREAMS_DEPENDENCIES regex) + set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic) + set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic) + set(_Boost_MPI_DEPENDENCIES serialization) + set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization) + set(_Boost_NUMPY_DEPENDENCIES python${component_python_version}) + set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic) + set(_Boost_TIMER_DEPENDENCIES chrono) + set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic) + set(_Boost_WSERIALIZATION_DEPENDENCIES serialization) + if(Boost_VERSION_STRING VERSION_GREATER_EQUAL 1.75.0) + message(WARNING "New Boost version may have incorrect or missing dependencies and imported targets") + endif() + endif() + endif() + + string(TOUPPER ${component} uppercomponent) + set(${_ret} ${_Boost_${uppercomponent}_DEPENDENCIES} PARENT_SCOPE) + set(_Boost_IMPORTED_TARGETS ${_Boost_IMPORTED_TARGETS} PARENT_SCOPE) + + string(REGEX REPLACE ";" " " _boost_DEPS_STRING "${_Boost_${uppercomponent}_DEPENDENCIES}") + if (NOT _boost_DEPS_STRING) + set(_boost_DEPS_STRING "(none)") + endif() + # message(STATUS "Dependencies for Boost::${component}: ${_boost_DEPS_STRING}") +endfunction() + +# +# Get component headers. This is the primary header (or headers) for +# a given component, and is used to check that the headers are present +# as well as the library itself as an extra sanity check of the build +# environment. +# +# component - the component to check +# _hdrs +# +function(_Boost_COMPONENT_HEADERS component _hdrs) + # Handle Python version suffixes + if(component MATCHES "^(python|mpi_python|numpy)([0-9][0-9]?|[0-9]\\.[0-9])\$") + set(component "${CMAKE_MATCH_1}") + set(component_python_version "${CMAKE_MATCH_2}") + endif() + + # Note: new boost components will require adding here. The header + # must be present in all versions of Boost providing a library. + set(_Boost_ATOMIC_HEADERS "boost/atomic.hpp") + set(_Boost_CHRONO_HEADERS "boost/chrono.hpp") + set(_Boost_CONTAINER_HEADERS "boost/container/container_fwd.hpp") + set(_Boost_CONTRACT_HEADERS "boost/contract.hpp") + if(Boost_VERSION_STRING VERSION_LESS 1.61.0) + set(_Boost_CONTEXT_HEADERS "boost/context/all.hpp") + else() + set(_Boost_CONTEXT_HEADERS "boost/context/detail/fcontext.hpp") + endif() + set(_Boost_COROUTINE_HEADERS "boost/coroutine/all.hpp") + set(_Boost_DATE_TIME_HEADERS "boost/date_time/date.hpp") + set(_Boost_EXCEPTION_HEADERS "boost/exception/exception.hpp") + set(_Boost_FIBER_HEADERS "boost/fiber/all.hpp") + set(_Boost_FILESYSTEM_HEADERS "boost/filesystem/path.hpp") + set(_Boost_GRAPH_HEADERS "boost/graph/adjacency_list.hpp") + set(_Boost_GRAPH_PARALLEL_HEADERS "boost/graph/adjacency_list.hpp") + set(_Boost_IOSTREAMS_HEADERS "boost/iostreams/stream.hpp") + set(_Boost_LOCALE_HEADERS "boost/locale.hpp") + set(_Boost_LOG_HEADERS "boost/log/core.hpp") + set(_Boost_LOG_SETUP_HEADERS "boost/log/detail/setup_config.hpp") + set(_Boost_MATH_HEADERS "boost/math_fwd.hpp") + set(_Boost_MATH_C99_HEADERS "boost/math/tr1.hpp") + set(_Boost_MATH_C99F_HEADERS "boost/math/tr1.hpp") + set(_Boost_MATH_C99L_HEADERS "boost/math/tr1.hpp") + set(_Boost_MATH_TR1_HEADERS "boost/math/tr1.hpp") + set(_Boost_MATH_TR1F_HEADERS "boost/math/tr1.hpp") + set(_Boost_MATH_TR1L_HEADERS "boost/math/tr1.hpp") + set(_Boost_MPI_HEADERS "boost/mpi.hpp") + set(_Boost_MPI_PYTHON_HEADERS "boost/mpi/python/config.hpp") + set(_Boost_NUMPY_HEADERS "boost/python/numpy.hpp") + set(_Boost_NOWIDE_HEADERS "boost/nowide/cstdlib.hpp") + set(_Boost_PRG_EXEC_MONITOR_HEADERS "boost/test/prg_exec_monitor.hpp") + set(_Boost_PROGRAM_OPTIONS_HEADERS "boost/program_options.hpp") + set(_Boost_PYTHON_HEADERS "boost/python.hpp") + set(_Boost_RANDOM_HEADERS "boost/random.hpp") + set(_Boost_REGEX_HEADERS "boost/regex.hpp") + set(_Boost_SERIALIZATION_HEADERS "boost/serialization/serialization.hpp") + set(_Boost_SIGNALS_HEADERS "boost/signals.hpp") + set(_Boost_STACKTRACE_ADDR2LINE_HEADERS "boost/stacktrace.hpp") + set(_Boost_STACKTRACE_BACKTRACE_HEADERS "boost/stacktrace.hpp") + set(_Boost_STACKTRACE_BASIC_HEADERS "boost/stacktrace.hpp") + set(_Boost_STACKTRACE_NOOP_HEADERS "boost/stacktrace.hpp") + set(_Boost_STACKTRACE_WINDBG_CACHED_HEADERS "boost/stacktrace.hpp") + set(_Boost_STACKTRACE_WINDBG_HEADERS "boost/stacktrace.hpp") + set(_Boost_SYSTEM_HEADERS "boost/system/config.hpp") + set(_Boost_TEST_EXEC_MONITOR_HEADERS "boost/test/test_exec_monitor.hpp") + set(_Boost_THREAD_HEADERS "boost/thread.hpp") + set(_Boost_TIMER_HEADERS "boost/timer.hpp") + set(_Boost_TYPE_ERASURE_HEADERS "boost/type_erasure/config.hpp") + set(_Boost_UNIT_TEST_FRAMEWORK_HEADERS "boost/test/framework.hpp") + set(_Boost_WAVE_HEADERS "boost/wave.hpp") + set(_Boost_WSERIALIZATION_HEADERS "boost/archive/text_wiarchive.hpp") + set(_Boost_BZIP2_HEADERS "boost/iostreams/filter/bzip2.hpp") + set(_Boost_ZLIB_HEADERS "boost/iostreams/filter/zlib.hpp") + + string(TOUPPER ${component} uppercomponent) + set(${_hdrs} ${_Boost_${uppercomponent}_HEADERS} PARENT_SCOPE) + + string(REGEX REPLACE ";" " " _boost_HDRS_STRING "${_Boost_${uppercomponent}_HEADERS}") + if (NOT _boost_HDRS_STRING) + set(_boost_HDRS_STRING "(none)") + endif() + # message(STATUS "Headers for Boost::${component}: ${_boost_HDRS_STRING}") +endfunction() + +# +# Determine if any missing dependencies require adding to the component list. +# +# Sets _Boost_${COMPONENT}_DEPENDENCIES for each required component, +# plus _Boost_IMPORTED_TARGETS (TRUE if imported targets should be +# defined; FALSE if dependency information is unavailable). +# +# componentvar - the component list variable name +# extravar - the indirect dependency list variable name +# +# +function(_Boost_MISSING_DEPENDENCIES componentvar extravar) + # _boost_unprocessed_components - list of components requiring processing + # _boost_processed_components - components already processed (or currently being processed) + # _boost_new_components - new components discovered for future processing + # + list(APPEND _boost_unprocessed_components ${${componentvar}}) + + while(_boost_unprocessed_components) + list(APPEND _boost_processed_components ${_boost_unprocessed_components}) + foreach(component ${_boost_unprocessed_components}) + string(TOUPPER ${component} uppercomponent) + set(${_ret} ${_Boost_${uppercomponent}_DEPENDENCIES} PARENT_SCOPE) + _Boost_COMPONENT_DEPENDENCIES("${component}" _Boost_${uppercomponent}_DEPENDENCIES) + set(_Boost_${uppercomponent}_DEPENDENCIES ${_Boost_${uppercomponent}_DEPENDENCIES} PARENT_SCOPE) + set(_Boost_IMPORTED_TARGETS ${_Boost_IMPORTED_TARGETS} PARENT_SCOPE) + foreach(componentdep ${_Boost_${uppercomponent}_DEPENDENCIES}) + if (NOT ("${componentdep}" IN_LIST _boost_processed_components OR "${componentdep}" IN_LIST _boost_new_components)) + list(APPEND _boost_new_components ${componentdep}) + endif() + endforeach() + endforeach() + set(_boost_unprocessed_components ${_boost_new_components}) + unset(_boost_new_components) + endwhile() + set(_boost_extra_components ${_boost_processed_components}) + if(_boost_extra_components AND ${componentvar}) + list(REMOVE_ITEM _boost_extra_components ${${componentvar}}) + endif() + set(${componentvar} ${_boost_processed_components} PARENT_SCOPE) + set(${extravar} ${_boost_extra_components} PARENT_SCOPE) +endfunction() + +# +# Some boost libraries may require particular set of compler features. +# The very first one was `boost::fiber` introduced in Boost 1.62. +# One can check required compiler features of it in +# - `${Boost_ROOT}/libs/fiber/build/Jamfile.v2`; +# - `${Boost_ROOT}/libs/context/build/Jamfile.v2`. +# +# TODO (Re)Check compiler features on (every?) release ??? +# One may use the following command to get the files to check: +# +# $ find . -name Jamfile.v2 | grep build | xargs grep -l cxx1 +# +function(_Boost_COMPILER_FEATURES component _ret) + # Boost >= 1.62 + if(NOT Boost_VERSION_STRING VERSION_LESS 1.62.0) + set(_Boost_FIBER_COMPILER_FEATURES + cxx_alias_templates + cxx_auto_type + cxx_constexpr + cxx_defaulted_functions + cxx_final + cxx_lambdas + cxx_noexcept + cxx_nullptr + cxx_rvalue_references + cxx_thread_local + cxx_variadic_templates + ) + # Compiler feature for `context` same as for `fiber`. + set(_Boost_CONTEXT_COMPILER_FEATURES ${_Boost_FIBER_COMPILER_FEATURES}) + endif() + + # Boost Contract library available in >= 1.67 + if(NOT Boost_VERSION_STRING VERSION_LESS 1.67.0) + # From `libs/contract/build/boost_contract_build.jam` + set(_Boost_CONTRACT_COMPILER_FEATURES + cxx_lambdas + cxx_variadic_templates + ) + endif() + + string(TOUPPER ${component} uppercomponent) + set(${_ret} ${_Boost_${uppercomponent}_COMPILER_FEATURES} PARENT_SCOPE) +endfunction() + +# +# Update library search directory hint variable with paths used by prebuilt boost binaries. +# +# Prebuilt windows binaries (https://sourceforge.net/projects/boost/files/boost-binaries/) +# have library directories named using MSVC compiler version and architecture. +# This function would append corresponding directories if MSVC is a current compiler, +# so having `BOOST_ROOT` would be enough to specify to find everything. +# +function(_Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS componentlibvar basedir) + if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC") + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(_arch_suffix 64) + else() + set(_arch_suffix 32) + endif() + if(MSVC_TOOLSET_VERSION GREATER_EQUAL 150) + # Not yet known. + elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 140) + # MSVC toolset 14.x versions are forward compatible. + foreach(v 9 8 7 6 5 4 3 2 1 0) + if(MSVC_TOOLSET_VERSION GREATER_EQUAL 14${v}) + list(APPEND ${componentlibvar} ${basedir}/lib${_arch_suffix}-msvc-14.${v}) + endif() + endforeach() + elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 80) + math(EXPR _toolset_major_version "${MSVC_TOOLSET_VERSION} / 10") + list(APPEND ${componentlibvar} ${basedir}/lib${_arch_suffix}-msvc-${_toolset_major_version}.0) + endif() + set(${componentlibvar} ${${componentlibvar}} PARENT_SCOPE) + endif() +endfunction() + +# +# End functions/macros +# +#------------------------------------------------------------------------------- + +#------------------------------------------------------------------------------- +# main. +#------------------------------------------------------------------------------- + + +# If the user sets Boost_LIBRARY_DIR, use it as the default for both +# configurations. +if(NOT Boost_LIBRARY_DIR_RELEASE AND Boost_LIBRARY_DIR) + set(Boost_LIBRARY_DIR_RELEASE "${Boost_LIBRARY_DIR}") +endif() +if(NOT Boost_LIBRARY_DIR_DEBUG AND Boost_LIBRARY_DIR) + set(Boost_LIBRARY_DIR_DEBUG "${Boost_LIBRARY_DIR}") +endif() + +if(NOT DEFINED Boost_USE_DEBUG_LIBS) + set(Boost_USE_DEBUG_LIBS TRUE) +endif() +if(NOT DEFINED Boost_USE_RELEASE_LIBS) + set(Boost_USE_RELEASE_LIBS TRUE) +endif() +if(NOT DEFINED Boost_USE_MULTITHREADED) + set(Boost_USE_MULTITHREADED TRUE) +endif() +if(NOT DEFINED Boost_USE_DEBUG_RUNTIME) + set(Boost_USE_DEBUG_RUNTIME TRUE) +endif() + +# Check the version of Boost against the requested version. +if(Boost_FIND_VERSION AND NOT Boost_FIND_VERSION_MINOR) + message(SEND_ERROR "When requesting a specific version of Boost, you must provide at least the major and minor version numbers, e.g., 1.34") +endif() + +if(Boost_FIND_VERSION_EXACT) + # The version may appear in a directory with or without the patch + # level, even when the patch level is non-zero. + set(_boost_TEST_VERSIONS + "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}.${Boost_FIND_VERSION_PATCH}" + "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}") +else() + # The user has not requested an exact version. Among known + # versions, find those that are acceptable to the user request. + # + # Note: When adding a new Boost release, also update the dependency + # information in _Boost_COMPONENT_DEPENDENCIES and + # _Boost_COMPONENT_HEADERS. See the instructions at the top of + # _Boost_COMPONENT_DEPENDENCIES. + set(_Boost_KNOWN_VERSIONS ${Boost_ADDITIONAL_VERSIONS} + "1.74.0" "1.74" + "1.73.0" "1.73" "1.72.0" "1.72" "1.71.0" "1.71" "1.70.0" "1.70" "1.69.0" "1.69" + "1.68.0" "1.68" "1.67.0" "1.67" "1.66.0" "1.66" "1.65.1" "1.65.0" "1.65" + "1.64.0" "1.64" "1.63.0" "1.63" "1.62.0" "1.62" "1.61.0" "1.61" "1.60.0" "1.60" + "1.59.0" "1.59" "1.58.0" "1.58" "1.57.0" "1.57" "1.56.0" "1.56" "1.55.0" "1.55" + "1.54.0" "1.54" "1.53.0" "1.53" "1.52.0" "1.52" "1.51.0" "1.51" + "1.50.0" "1.50" "1.49.0" "1.49" "1.48.0" "1.48" "1.47.0" "1.47" "1.46.1" + "1.46.0" "1.46" "1.45.0" "1.45" "1.44.0" "1.44" "1.43.0" "1.43" "1.42.0" "1.42" + "1.41.0" "1.41" "1.40.0" "1.40" "1.39.0" "1.39" "1.38.0" "1.38" "1.37.0" "1.37" + "1.36.1" "1.36.0" "1.36" "1.35.1" "1.35.0" "1.35" "1.34.1" "1.34.0" + "1.34" "1.33.1" "1.33.0" "1.33") + + set(_boost_TEST_VERSIONS) + if(Boost_FIND_VERSION) + set(_Boost_FIND_VERSION_SHORT "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}") + # Select acceptable versions. + foreach(version ${_Boost_KNOWN_VERSIONS}) + if(NOT "${version}" VERSION_LESS "${Boost_FIND_VERSION}") + # This version is high enough. + list(APPEND _boost_TEST_VERSIONS "${version}") + elseif("${version}.99" VERSION_EQUAL "${_Boost_FIND_VERSION_SHORT}.99") + # This version is a short-form for the requested version with + # the patch level dropped. + list(APPEND _boost_TEST_VERSIONS "${version}") + endif() + endforeach() + else() + # Any version is acceptable. + set(_boost_TEST_VERSIONS "${_Boost_KNOWN_VERSIONS}") + endif() +endif() + +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_TEST_VERSIONS") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_USE_MULTITHREADED") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_USE_STATIC_LIBS") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_USE_STATIC_RUNTIME") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_ADDITIONAL_VERSIONS") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_NO_SYSTEM_PATHS") + +if(POLICY CMP0074) + cmake_policy(GET CMP0074 _Boost_CMP0074) + if(NOT "x${_Boost_CMP0074}x" STREQUAL "xNEWx") + _Boost_CHECK_SPELLING(Boost_ROOT) + endif() + unset(_Boost_CMP0074) +endif() +_Boost_CHECK_SPELLING(Boost_LIBRARYDIR) +_Boost_CHECK_SPELLING(Boost_INCLUDEDIR) + +# Collect environment variable inputs as hints. Do not consider changes. +foreach(v BOOSTROOT BOOST_ROOT BOOST_INCLUDEDIR BOOST_LIBRARYDIR) + set(_env $ENV{${v}}) + if(_env) + file(TO_CMAKE_PATH "${_env}" _ENV_${v}) + else() + set(_ENV_${v} "") + endif() +endforeach() +if(NOT _ENV_BOOST_ROOT AND _ENV_BOOSTROOT) + set(_ENV_BOOST_ROOT "${_ENV_BOOSTROOT}") +endif() + +# Collect inputs and cached results. Detect changes since the last run. +if(NOT BOOST_ROOT AND BOOSTROOT) + set(BOOST_ROOT "${BOOSTROOT}") +endif() +set(_Boost_VARS_DIR + BOOST_ROOT + Boost_NO_SYSTEM_PATHS + ) + +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_ROOT") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_ROOT" ENVIRONMENT) +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_INCLUDEDIR") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_INCLUDEDIR" ENVIRONMENT) +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_LIBRARYDIR") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_LIBRARYDIR" ENVIRONMENT) + +# ------------------------------------------------------------------------ +# Search for Boost include DIR +# ------------------------------------------------------------------------ + +set(_Boost_VARS_INC BOOST_INCLUDEDIR Boost_INCLUDE_DIR Boost_ADDITIONAL_VERSIONS) +_Boost_CHANGE_DETECT(_Boost_CHANGE_INCDIR ${_Boost_VARS_DIR} ${_Boost_VARS_INC}) +# Clear Boost_INCLUDE_DIR if it did not change but other input affecting the +# location did. We will find a new one based on the new inputs. +if(_Boost_CHANGE_INCDIR AND NOT _Boost_INCLUDE_DIR_CHANGED) + unset(Boost_INCLUDE_DIR CACHE) +endif() + +if(NOT Boost_INCLUDE_DIR) + set(_boost_INCLUDE_SEARCH_DIRS "") + if(BOOST_INCLUDEDIR) + list(APPEND _boost_INCLUDE_SEARCH_DIRS ${BOOST_INCLUDEDIR}) + elseif(_ENV_BOOST_INCLUDEDIR) + list(APPEND _boost_INCLUDE_SEARCH_DIRS ${_ENV_BOOST_INCLUDEDIR}) + endif() + + if( BOOST_ROOT ) + list(APPEND _boost_INCLUDE_SEARCH_DIRS ${BOOST_ROOT}/include ${BOOST_ROOT}) + elseif( _ENV_BOOST_ROOT ) + list(APPEND _boost_INCLUDE_SEARCH_DIRS ${_ENV_BOOST_ROOT}/include ${_ENV_BOOST_ROOT}) + endif() + + if( Boost_NO_SYSTEM_PATHS) + list(APPEND _boost_INCLUDE_SEARCH_DIRS NO_CMAKE_SYSTEM_PATH NO_SYSTEM_ENVIRONMENT_PATH) + else() + if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC") + foreach(ver ${_boost_TEST_VERSIONS}) + string(REPLACE "." "_" ver "${ver}") + list(APPEND _boost_INCLUDE_SEARCH_DIRS PATHS "C:/local/boost_${ver}") + endforeach() + endif() + list(APPEND _boost_INCLUDE_SEARCH_DIRS PATHS + C:/boost/include + C:/boost + /sw/local/include + ) + endif() + + # Try to find Boost by stepping backwards through the Boost versions + # we know about. + # Build a list of path suffixes for each version. + set(_boost_PATH_SUFFIXES) + foreach(_boost_VER ${_boost_TEST_VERSIONS}) + # Add in a path suffix, based on the required version, ideally + # we could read this from version.hpp, but for that to work we'd + # need to know the include dir already + set(_boost_BOOSTIFIED_VERSION) + + # Transform 1.35 => 1_35 and 1.36.0 => 1_36_0 + if(_boost_VER MATCHES "([0-9]+)\\.([0-9]+)\\.([0-9]+)") + set(_boost_BOOSTIFIED_VERSION + "${CMAKE_MATCH_1}_${CMAKE_MATCH_2}_${CMAKE_MATCH_3}") + elseif(_boost_VER MATCHES "([0-9]+)\\.([0-9]+)") + set(_boost_BOOSTIFIED_VERSION + "${CMAKE_MATCH_1}_${CMAKE_MATCH_2}") + endif() + + list(APPEND _boost_PATH_SUFFIXES + "boost-${_boost_BOOSTIFIED_VERSION}" + "boost_${_boost_BOOSTIFIED_VERSION}" + "boost/boost-${_boost_BOOSTIFIED_VERSION}" + "boost/boost_${_boost_BOOSTIFIED_VERSION}" + ) + + endforeach() + + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_INCLUDE_SEARCH_DIRS") + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_PATH_SUFFIXES") + + # Look for a standard boost header file. + find_path(Boost_INCLUDE_DIR + NAMES boost/config.hpp + HINTS ${_boost_INCLUDE_SEARCH_DIRS} + PATH_SUFFIXES ${_boost_PATH_SUFFIXES} + ) +endif() + +# ------------------------------------------------------------------------ +# Extract version information from version.hpp +# ------------------------------------------------------------------------ + +if(Boost_INCLUDE_DIR) + _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "location of version.hpp: ${Boost_INCLUDE_DIR}/boost/version.hpp") + + # Extract Boost_VERSION_MACRO and Boost_LIB_VERSION from version.hpp + set(Boost_VERSION_MACRO 0) + set(Boost_LIB_VERSION "") + file(STRINGS "${Boost_INCLUDE_DIR}/boost/version.hpp" _boost_VERSION_HPP_CONTENTS REGEX "#define BOOST_(LIB_)?VERSION ") + if("${_boost_VERSION_HPP_CONTENTS}" MATCHES "#define BOOST_VERSION ([0-9]+)") + set(Boost_VERSION_MACRO "${CMAKE_MATCH_1}") + endif() + if("${_boost_VERSION_HPP_CONTENTS}" MATCHES "#define BOOST_LIB_VERSION \"([0-9_]+)\"") + set(Boost_LIB_VERSION "${CMAKE_MATCH_1}") + endif() + unset(_boost_VERSION_HPP_CONTENTS) + + # Calculate version components + math(EXPR Boost_VERSION_MAJOR "${Boost_VERSION_MACRO} / 100000") + math(EXPR Boost_VERSION_MINOR "${Boost_VERSION_MACRO} / 100 % 1000") + math(EXPR Boost_VERSION_PATCH "${Boost_VERSION_MACRO} % 100") + set(Boost_VERSION_COUNT 3) + + # Define alias variables for backwards compat. + set(Boost_MAJOR_VERSION ${Boost_VERSION_MAJOR}) + set(Boost_MINOR_VERSION ${Boost_VERSION_MINOR}) + set(Boost_SUBMINOR_VERSION ${Boost_VERSION_PATCH}) + + # Define Boost version in x.y.z format + set(Boost_VERSION_STRING "${Boost_VERSION_MAJOR}.${Boost_VERSION_MINOR}.${Boost_VERSION_PATCH}") + + # Define final Boost_VERSION + if(POLICY CMP0093) + cmake_policy(GET CMP0093 _Boost_CMP0093 + PARENT_SCOPE # undocumented, do not use outside of CMake + ) + if("x${_Boost_CMP0093}x" STREQUAL "xNEWx") + set(Boost_VERSION ${Boost_VERSION_STRING}) + else() + set(Boost_VERSION ${Boost_VERSION_MACRO}) + endif() + unset(_Boost_CMP0093) + else() + set(Boost_VERSION ${Boost_VERSION_MACRO}) + endif() + + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION") + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_STRING") + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_MACRO") + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_MAJOR") + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_MINOR") + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_PATCH") + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_COUNT") +endif() + +# ------------------------------------------------------------------------ +# Prefix initialization +# ------------------------------------------------------------------------ + +if ( NOT DEFINED Boost_LIB_PREFIX ) + # Boost's static libraries use a "lib" prefix on DLL platforms + # to distinguish them from the DLL import libraries. + if (Boost_USE_STATIC_LIBS AND ( + (WIN32 AND NOT CYGWIN) + OR GHSMULTI + )) + set(Boost_LIB_PREFIX "lib") + else() + set(Boost_LIB_PREFIX "") + endif() +endif() + +if ( NOT Boost_NAMESPACE ) + set(Boost_NAMESPACE "boost") +endif() + +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_LIB_PREFIX") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_NAMESPACE") + +# ------------------------------------------------------------------------ +# Suffix initialization and compiler suffix detection. +# ------------------------------------------------------------------------ + +set(_Boost_VARS_NAME + Boost_NAMESPACE + Boost_COMPILER + Boost_THREADAPI + Boost_USE_DEBUG_PYTHON + Boost_USE_MULTITHREADED + Boost_USE_STATIC_LIBS + Boost_USE_STATIC_RUNTIME + Boost_USE_STLPORT + Boost_USE_STLPORT_DEPRECATED_NATIVE_IOSTREAMS + ) +_Boost_CHANGE_DETECT(_Boost_CHANGE_LIBNAME ${_Boost_VARS_NAME}) + +# Setting some more suffixes for the library +if (Boost_COMPILER) + set(_boost_COMPILER ${Boost_COMPILER}) + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "_boost_COMPILER" SOURCE "user-specified via Boost_COMPILER") +else() + # Attempt to guess the compiler suffix + # NOTE: this is not perfect yet, if you experience any issues + # please report them and use the Boost_COMPILER variable + # to work around the problems. + _Boost_GUESS_COMPILER_PREFIX(_boost_COMPILER) +endif() + +set (_boost_MULTITHREADED "-mt") +if( NOT Boost_USE_MULTITHREADED ) + set (_boost_MULTITHREADED "") +endif() +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_MULTITHREADED") + +#====================== +# Systematically build up the Boost ABI tag for the 'tagged' and 'versioned' layouts +# http://boost.org/doc/libs/1_66_0/more/getting_started/windows.html#library-naming +# http://boost.org/doc/libs/1_66_0/boost/config/auto_link.hpp +# http://boost.org/doc/libs/1_66_0/tools/build/src/tools/common.jam +# http://boost.org/doc/libs/1_66_0/boostcpp.jam +set( _boost_RELEASE_ABI_TAG "-") +set( _boost_DEBUG_ABI_TAG "-") +# Key Use this library when: +# s linking statically to the C++ standard library and +# compiler runtime support libraries. +if(Boost_USE_STATIC_RUNTIME) + set( _boost_RELEASE_ABI_TAG "${_boost_RELEASE_ABI_TAG}s") + set( _boost_DEBUG_ABI_TAG "${_boost_DEBUG_ABI_TAG}s") +endif() +# g using debug versions of the standard and runtime +# support libraries +if(WIN32 AND Boost_USE_DEBUG_RUNTIME) + if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC" + OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang" + OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntel") + string(APPEND _boost_DEBUG_ABI_TAG "g") + endif() +endif() +# y using special debug build of python +if(Boost_USE_DEBUG_PYTHON) + string(APPEND _boost_DEBUG_ABI_TAG "y") +endif() +# d using a debug version of your code +string(APPEND _boost_DEBUG_ABI_TAG "d") +# p using the STLport standard library rather than the +# default one supplied with your compiler +if(Boost_USE_STLPORT) + string(APPEND _boost_RELEASE_ABI_TAG "p") + string(APPEND _boost_DEBUG_ABI_TAG "p") +endif() +# n using the STLport deprecated "native iostreams" feature +# removed from the documentation in 1.43.0 but still present in +# boost/config/auto_link.hpp +if(Boost_USE_STLPORT_DEPRECATED_NATIVE_IOSTREAMS) + string(APPEND _boost_RELEASE_ABI_TAG "n") + string(APPEND _boost_DEBUG_ABI_TAG "n") +endif() + +# -x86 Architecture and address model tag +# First character is the architecture, then word-size, either 32 or 64 +# Only used in 'versioned' layout, added in Boost 1.66.0 +if(DEFINED Boost_ARCHITECTURE) + set(_boost_ARCHITECTURE_TAG "${Boost_ARCHITECTURE}") + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "_boost_ARCHITECTURE_TAG" SOURCE "user-specified via Boost_ARCHITECTURE") +else() + set(_boost_ARCHITECTURE_TAG "") + # {CMAKE_CXX_COMPILER_ARCHITECTURE_ID} is not currently set for all compilers + if(NOT "x${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "x" AND NOT Boost_VERSION_STRING VERSION_LESS 1.66.0) + string(APPEND _boost_ARCHITECTURE_TAG "-") + # This needs to be kept in-sync with the section of CMakePlatformId.h.in + # inside 'defined(_WIN32) && defined(_MSC_VER)' + if(CMAKE_CXX_COMPILER_ARCHITECTURE_ID STREQUAL "IA64") + string(APPEND _boost_ARCHITECTURE_TAG "i") + elseif(CMAKE_CXX_COMPILER_ARCHITECTURE_ID STREQUAL "X86" + OR CMAKE_CXX_COMPILER_ARCHITECTURE_ID STREQUAL "x64") + string(APPEND _boost_ARCHITECTURE_TAG "x") + elseif(CMAKE_CXX_COMPILER_ARCHITECTURE_ID MATCHES "^ARM") + string(APPEND _boost_ARCHITECTURE_TAG "a") + elseif(CMAKE_CXX_COMPILER_ARCHITECTURE_ID STREQUAL "MIPS") + string(APPEND _boost_ARCHITECTURE_TAG "m") + endif() + + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + string(APPEND _boost_ARCHITECTURE_TAG "64") + else() + string(APPEND _boost_ARCHITECTURE_TAG "32") + endif() + endif() + _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "_boost_ARCHITECTURE_TAG" SOURCE "detected") +endif() + +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_RELEASE_ABI_TAG") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_DEBUG_ABI_TAG") + +# ------------------------------------------------------------------------ +# Begin finding boost libraries +# ------------------------------------------------------------------------ + +set(_Boost_VARS_LIB "") +foreach(c DEBUG RELEASE) + set(_Boost_VARS_LIB_${c} BOOST_LIBRARYDIR Boost_LIBRARY_DIR_${c}) + list(APPEND _Boost_VARS_LIB ${_Boost_VARS_LIB_${c}}) + _Boost_CHANGE_DETECT(_Boost_CHANGE_LIBDIR_${c} ${_Boost_VARS_DIR} ${_Boost_VARS_LIB_${c}} Boost_INCLUDE_DIR) + # Clear Boost_LIBRARY_DIR_${c} if it did not change but other input affecting the + # location did. We will find a new one based on the new inputs. + if(_Boost_CHANGE_LIBDIR_${c} AND NOT _Boost_LIBRARY_DIR_${c}_CHANGED) + unset(Boost_LIBRARY_DIR_${c} CACHE) + endif() + + # If Boost_LIBRARY_DIR_[RELEASE,DEBUG] is set, prefer its value. + if(Boost_LIBRARY_DIR_${c}) + set(_boost_LIBRARY_SEARCH_DIRS_${c} ${Boost_LIBRARY_DIR_${c}} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) + else() + set(_boost_LIBRARY_SEARCH_DIRS_${c} "") + if(BOOST_LIBRARYDIR) + list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} ${BOOST_LIBRARYDIR}) + elseif(_ENV_BOOST_LIBRARYDIR) + list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} ${_ENV_BOOST_LIBRARYDIR}) + endif() + + if(BOOST_ROOT) + list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} ${BOOST_ROOT}/lib ${BOOST_ROOT}/stage/lib) + _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "${BOOST_ROOT}") + elseif(_ENV_BOOST_ROOT) + list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} ${_ENV_BOOST_ROOT}/lib ${_ENV_BOOST_ROOT}/stage/lib) + _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "${_ENV_BOOST_ROOT}") + endif() + + list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} + ${Boost_INCLUDE_DIR}/lib + ${Boost_INCLUDE_DIR}/../lib + ${Boost_INCLUDE_DIR}/stage/lib + ) + _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "${Boost_INCLUDE_DIR}/..") + _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "${Boost_INCLUDE_DIR}") + if( Boost_NO_SYSTEM_PATHS ) + list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} NO_CMAKE_SYSTEM_PATH NO_SYSTEM_ENVIRONMENT_PATH) + else() + foreach(ver ${_boost_TEST_VERSIONS}) + string(REPLACE "." "_" ver "${ver}") + _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "C:/local/boost_${ver}") + endforeach() + _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "C:/boost") + list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} PATHS + C:/boost/lib + C:/boost + /sw/local/lib + ) + endif() + endif() +endforeach() + +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_LIBRARY_SEARCH_DIRS_RELEASE") +_Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_LIBRARY_SEARCH_DIRS_DEBUG") + +# Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES +if( Boost_USE_STATIC_LIBS ) + set( _boost_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) + if(WIN32) + list(INSERT CMAKE_FIND_LIBRARY_SUFFIXES 0 .lib .a) + else() + set(CMAKE_FIND_LIBRARY_SUFFIXES .a) + endif() +endif() + +# We want to use the tag inline below without risking double dashes +if(_boost_RELEASE_ABI_TAG) + if(${_boost_RELEASE_ABI_TAG} STREQUAL "-") + set(_boost_RELEASE_ABI_TAG "") + endif() +endif() +if(_boost_DEBUG_ABI_TAG) + if(${_boost_DEBUG_ABI_TAG} STREQUAL "-") + set(_boost_DEBUG_ABI_TAG "") + endif() +endif() + +# The previous behavior of FindBoost when Boost_USE_STATIC_LIBS was enabled +# on WIN32 was to: +# 1. Search for static libs compiled against a SHARED C++ standard runtime library (use if found) +# 2. Search for static libs compiled against a STATIC C++ standard runtime library (use if found) +# We maintain this behavior since changing it could break people's builds. +# To disable the ambiguous behavior, the user need only +# set Boost_USE_STATIC_RUNTIME either ON or OFF. +set(_boost_STATIC_RUNTIME_WORKAROUND false) +if(WIN32 AND Boost_USE_STATIC_LIBS) + if(NOT DEFINED Boost_USE_STATIC_RUNTIME) + set(_boost_STATIC_RUNTIME_WORKAROUND TRUE) + endif() +endif() + +# On versions < 1.35, remove the System library from the considered list +# since it wasn't added until 1.35. +if(Boost_VERSION_STRING AND Boost_FIND_COMPONENTS) + if(Boost_VERSION_STRING VERSION_LESS 1.35.0) + list(REMOVE_ITEM Boost_FIND_COMPONENTS system) + endif() +endif() + +# Additional components may be required via component dependencies. +# Add any missing components to the list. +_Boost_MISSING_DEPENDENCIES(Boost_FIND_COMPONENTS _Boost_EXTRA_FIND_COMPONENTS) + +# If thread is required, get the thread libs as a dependency +if("thread" IN_LIST Boost_FIND_COMPONENTS) + if(Boost_FIND_QUIETLY) + set(_Boost_find_quiet QUIET) + else() + set(_Boost_find_quiet "") + endif() + find_package(Threads ${_Boost_find_quiet}) + unset(_Boost_find_quiet) +endif() + +# If the user changed any of our control inputs flush previous results. +if(_Boost_CHANGE_LIBDIR_DEBUG OR _Boost_CHANGE_LIBDIR_RELEASE OR _Boost_CHANGE_LIBNAME) + foreach(COMPONENT ${_Boost_COMPONENTS_SEARCHED}) + string(TOUPPER ${COMPONENT} UPPERCOMPONENT) + foreach(c DEBUG RELEASE) + set(_var Boost_${UPPERCOMPONENT}_LIBRARY_${c}) + unset(${_var} CACHE) + set(${_var} "${_var}-NOTFOUND") + endforeach() + endforeach() + set(_Boost_COMPONENTS_SEARCHED "") +endif() + +foreach(COMPONENT ${Boost_FIND_COMPONENTS}) + string(TOUPPER ${COMPONENT} UPPERCOMPONENT) + + set( _boost_docstring_release "Boost ${COMPONENT} library (release)") + set( _boost_docstring_debug "Boost ${COMPONENT} library (debug)") + + # Compute component-specific hints. + set(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT "") + if(${COMPONENT} STREQUAL "mpi" OR ${COMPONENT} STREQUAL "mpi_python" OR + ${COMPONENT} STREQUAL "graph_parallel") + foreach(lib ${MPI_CXX_LIBRARIES} ${MPI_C_LIBRARIES}) + if(IS_ABSOLUTE "${lib}") + get_filename_component(libdir "${lib}" PATH) + string(REPLACE "\\" "/" libdir "${libdir}") + list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT ${libdir}) + endif() + endforeach() + endif() + + # Handle Python version suffixes + unset(COMPONENT_PYTHON_VERSION_MAJOR) + unset(COMPONENT_PYTHON_VERSION_MINOR) + if(${COMPONENT} MATCHES "^(python|mpi_python|numpy)([0-9])\$") + set(COMPONENT_UNVERSIONED "${CMAKE_MATCH_1}") + set(COMPONENT_PYTHON_VERSION_MAJOR "${CMAKE_MATCH_2}") + elseif(${COMPONENT} MATCHES "^(python|mpi_python|numpy)([0-9])\\.?([0-9])\$") + set(COMPONENT_UNVERSIONED "${CMAKE_MATCH_1}") + set(COMPONENT_PYTHON_VERSION_MAJOR "${CMAKE_MATCH_2}") + set(COMPONENT_PYTHON_VERSION_MINOR "${CMAKE_MATCH_3}") + endif() + + unset(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME) + if (COMPONENT_PYTHON_VERSION_MINOR) + # Boost >= 1.67 + list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}${COMPONENT_PYTHON_VERSION_MAJOR}${COMPONENT_PYTHON_VERSION_MINOR}") + # Debian/Ubuntu (Some versions omit the 2 and/or 3 from the suffix) + list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}${COMPONENT_PYTHON_VERSION_MAJOR}-py${COMPONENT_PYTHON_VERSION_MAJOR}${COMPONENT_PYTHON_VERSION_MINOR}") + list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}-py${COMPONENT_PYTHON_VERSION_MAJOR}${COMPONENT_PYTHON_VERSION_MINOR}") + # Gentoo + list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}-${COMPONENT_PYTHON_VERSION_MAJOR}.${COMPONENT_PYTHON_VERSION_MINOR}") + # RPMs + list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}-${COMPONENT_PYTHON_VERSION_MAJOR}${COMPONENT_PYTHON_VERSION_MINOR}") + endif() + if (COMPONENT_PYTHON_VERSION_MAJOR AND NOT COMPONENT_PYTHON_VERSION_MINOR) + # Boost < 1.67 + list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}${COMPONENT_PYTHON_VERSION_MAJOR}") + endif() + + # Consolidate and report component-specific hints. + if(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME) + list(REMOVE_DUPLICATES _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME) + _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "Component-specific library search names for ${COMPONENT_NAME}: ${_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME}") + endif() + if(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT) + list(REMOVE_DUPLICATES _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT) + _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "Component-specific library search paths for ${COMPONENT}: ${_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT}") + endif() + + # + # Find headers + # + _Boost_COMPONENT_HEADERS("${COMPONENT}" Boost_${UPPERCOMPONENT}_HEADER_NAME) + # Look for a standard boost header file. + if(Boost_${UPPERCOMPONENT}_HEADER_NAME) + if(EXISTS "${Boost_INCLUDE_DIR}/${Boost_${UPPERCOMPONENT}_HEADER_NAME}") + set(Boost_${UPPERCOMPONENT}_HEADER ON) + else() + set(Boost_${UPPERCOMPONENT}_HEADER OFF) + endif() + else() + set(Boost_${UPPERCOMPONENT}_HEADER ON) + message(WARNING "No header defined for ${COMPONENT}; skipping header check " + "(note: header-only libraries have no designated component)") + endif() + + # + # Find RELEASE libraries + # + unset(_boost_RELEASE_NAMES) + foreach(component IN LISTS _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME COMPONENT) + foreach(compiler IN LISTS _boost_COMPILER) + list(APPEND _boost_RELEASE_NAMES + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG} ) + endforeach() + list(APPEND _boost_RELEASE_NAMES + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component} ) + if(_boost_STATIC_RUNTIME_WORKAROUND) + set(_boost_RELEASE_STATIC_ABI_TAG "-s${_boost_RELEASE_ABI_TAG}") + foreach(compiler IN LISTS _boost_COMPILER) + list(APPEND _boost_RELEASE_NAMES + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG} ) + endforeach() + list(APPEND _boost_RELEASE_NAMES + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG} ) + endif() + endforeach() + if(Boost_THREADAPI AND ${COMPONENT} STREQUAL "thread") + _Boost_PREPEND_LIST_WITH_THREADAPI(_boost_RELEASE_NAMES ${_boost_RELEASE_NAMES}) + endif() + _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "Searching for ${UPPERCOMPONENT}_LIBRARY_RELEASE: ${_boost_RELEASE_NAMES}") + + # if Boost_LIBRARY_DIR_RELEASE is not defined, + # but Boost_LIBRARY_DIR_DEBUG is, look there first for RELEASE libs + if(NOT Boost_LIBRARY_DIR_RELEASE AND Boost_LIBRARY_DIR_DEBUG) + list(INSERT _boost_LIBRARY_SEARCH_DIRS_RELEASE 0 ${Boost_LIBRARY_DIR_DEBUG}) + endif() + + # Avoid passing backslashes to _Boost_FIND_LIBRARY due to macro re-parsing. + string(REPLACE "\\" "/" _boost_LIBRARY_SEARCH_DIRS_tmp "${_boost_LIBRARY_SEARCH_DIRS_RELEASE}") + + if(Boost_USE_RELEASE_LIBS) + _Boost_FIND_LIBRARY(Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE RELEASE + NAMES ${_boost_RELEASE_NAMES} + HINTS ${_boost_LIBRARY_SEARCH_DIRS_tmp} + NAMES_PER_DIR + DOC "${_boost_docstring_release}" + ) + endif() + + # + # Find DEBUG libraries + # + unset(_boost_DEBUG_NAMES) + foreach(component IN LISTS _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME COMPONENT) + foreach(compiler IN LISTS _boost_COMPILER) + list(APPEND _boost_DEBUG_NAMES + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG} ) + endforeach() + list(APPEND _boost_DEBUG_NAMES + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component} ) + if(_boost_STATIC_RUNTIME_WORKAROUND) + set(_boost_DEBUG_STATIC_ABI_TAG "-s${_boost_DEBUG_ABI_TAG}") + foreach(compiler IN LISTS _boost_COMPILER) + list(APPEND _boost_DEBUG_NAMES + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG} ) + endforeach() + list(APPEND _boost_DEBUG_NAMES + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG} + ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG} ) + endif() + endforeach() + if(Boost_THREADAPI AND ${COMPONENT} STREQUAL "thread") + _Boost_PREPEND_LIST_WITH_THREADAPI(_boost_DEBUG_NAMES ${_boost_DEBUG_NAMES}) + endif() + _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" + "Searching for ${UPPERCOMPONENT}_LIBRARY_DEBUG: ${_boost_DEBUG_NAMES}") + + # if Boost_LIBRARY_DIR_DEBUG is not defined, + # but Boost_LIBRARY_DIR_RELEASE is, look there first for DEBUG libs + if(NOT Boost_LIBRARY_DIR_DEBUG AND Boost_LIBRARY_DIR_RELEASE) + list(INSERT _boost_LIBRARY_SEARCH_DIRS_DEBUG 0 ${Boost_LIBRARY_DIR_RELEASE}) + endif() + + # Avoid passing backslashes to _Boost_FIND_LIBRARY due to macro re-parsing. + string(REPLACE "\\" "/" _boost_LIBRARY_SEARCH_DIRS_tmp "${_boost_LIBRARY_SEARCH_DIRS_DEBUG}") + + if(Boost_USE_DEBUG_LIBS) + _Boost_FIND_LIBRARY(Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG DEBUG + NAMES ${_boost_DEBUG_NAMES} + HINTS ${_boost_LIBRARY_SEARCH_DIRS_tmp} + NAMES_PER_DIR + DOC "${_boost_docstring_debug}" + ) + endif () + + if(Boost_REALPATH) + _Boost_SWAP_WITH_REALPATH(Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE "${_boost_docstring_release}") + _Boost_SWAP_WITH_REALPATH(Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG "${_boost_docstring_debug}" ) + endif() + + _Boost_ADJUST_LIB_VARS(${UPPERCOMPONENT}) + + # Check if component requires some compiler features + _Boost_COMPILER_FEATURES(${COMPONENT} _Boost_${UPPERCOMPONENT}_COMPILER_FEATURES) + +endforeach() + +# Restore the original find library ordering +if( Boost_USE_STATIC_LIBS ) + set(CMAKE_FIND_LIBRARY_SUFFIXES ${_boost_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES}) +endif() + +# ------------------------------------------------------------------------ +# End finding boost libraries +# ------------------------------------------------------------------------ + +set(Boost_INCLUDE_DIRS ${Boost_INCLUDE_DIR}) +set(Boost_LIBRARY_DIRS) +if(Boost_LIBRARY_DIR_RELEASE) + list(APPEND Boost_LIBRARY_DIRS ${Boost_LIBRARY_DIR_RELEASE}) +endif() +if(Boost_LIBRARY_DIR_DEBUG) + list(APPEND Boost_LIBRARY_DIRS ${Boost_LIBRARY_DIR_DEBUG}) +endif() +if(Boost_LIBRARY_DIRS) + list(REMOVE_DUPLICATES Boost_LIBRARY_DIRS) +endif() + +# ------------------------------------------------------------------------ +# Call FPHSA helper, see https://cmake.org/cmake/help/latest/module/FindPackageHandleStandardArgs.html +# ------------------------------------------------------------------------ + +# Define aliases as needed by the component handler in the FPHSA helper below +foreach(_comp IN LISTS Boost_FIND_COMPONENTS) + string(TOUPPER ${_comp} _uppercomp) + if(DEFINED Boost_${_uppercomp}_FOUND) + set(Boost_${_comp}_FOUND ${Boost_${_uppercomp}_FOUND}) + endif() +endforeach() + +find_package_handle_standard_args(Boost + REQUIRED_VARS Boost_INCLUDE_DIR + VERSION_VAR Boost_VERSION_STRING + HANDLE_COMPONENTS) + +if(Boost_FOUND) + if( NOT Boost_LIBRARY_DIRS ) + # Compatibility Code for backwards compatibility with CMake + # 2.4's FindBoost module. + + # Look for the boost library path. + # Note that the user may not have installed any libraries + # so it is quite possible the Boost_LIBRARY_DIRS may not exist. + set(_boost_LIB_DIR ${Boost_INCLUDE_DIR}) + + if("${_boost_LIB_DIR}" MATCHES "boost-[0-9]+") + get_filename_component(_boost_LIB_DIR ${_boost_LIB_DIR} PATH) + endif() + + if("${_boost_LIB_DIR}" MATCHES "/include$") + # Strip off the trailing "/include" in the path. + get_filename_component(_boost_LIB_DIR ${_boost_LIB_DIR} PATH) + endif() + + if(EXISTS "${_boost_LIB_DIR}/lib") + string(APPEND _boost_LIB_DIR /lib) + elseif(EXISTS "${_boost_LIB_DIR}/stage/lib") + string(APPEND _boost_LIB_DIR "/stage/lib") + else() + set(_boost_LIB_DIR "") + endif() + + if(_boost_LIB_DIR AND EXISTS "${_boost_LIB_DIR}") + set(Boost_LIBRARY_DIRS ${_boost_LIB_DIR}) + endif() + + endif() +else() + # Boost headers were not found so no components were found. + foreach(COMPONENT ${Boost_FIND_COMPONENTS}) + string(TOUPPER ${COMPONENT} UPPERCOMPONENT) + set(Boost_${UPPERCOMPONENT}_FOUND 0) + endforeach() +endif() + +# ------------------------------------------------------------------------ +# Add imported targets +# ------------------------------------------------------------------------ + +if(Boost_FOUND) + # The builtin CMake package in Boost 1.70+ introduces a new name + # for the header-only lib, let's provide the same UI in module mode + if(NOT TARGET Boost::headers) + add_library(Boost::headers INTERFACE IMPORTED) + if(Boost_INCLUDE_DIRS) + set_target_properties(Boost::headers PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}") + endif() + endif() + + # Define the old target name for header-only libraries for backwards + # compat. + if(NOT TARGET Boost::boost) + add_library(Boost::boost INTERFACE IMPORTED) + set_target_properties(Boost::boost + PROPERTIES INTERFACE_LINK_LIBRARIES Boost::headers) + endif() + + foreach(COMPONENT ${Boost_FIND_COMPONENTS}) + if(_Boost_IMPORTED_TARGETS AND NOT TARGET Boost::${COMPONENT}) + string(TOUPPER ${COMPONENT} UPPERCOMPONENT) + if(Boost_${UPPERCOMPONENT}_FOUND) + if(Boost_USE_STATIC_LIBS) + add_library(Boost::${COMPONENT} STATIC IMPORTED) + else() + # Even if Boost_USE_STATIC_LIBS is OFF, we might have static + # libraries as a result. + add_library(Boost::${COMPONENT} UNKNOWN IMPORTED) + endif() + if(Boost_INCLUDE_DIRS) + set_target_properties(Boost::${COMPONENT} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}") + endif() + if(EXISTS "${Boost_${UPPERCOMPONENT}_LIBRARY}") + set_target_properties(Boost::${COMPONENT} PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LOCATION "${Boost_${UPPERCOMPONENT}_LIBRARY}") + endif() + if(EXISTS "${Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE}") + set_property(TARGET Boost::${COMPONENT} APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE) + set_target_properties(Boost::${COMPONENT} PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX" + IMPORTED_LOCATION_RELEASE "${Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE}") + endif() + if(EXISTS "${Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG}") + set_property(TARGET Boost::${COMPONENT} APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + set_target_properties(Boost::${COMPONENT} PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG}") + endif() + if(_Boost_${UPPERCOMPONENT}_DEPENDENCIES) + unset(_Boost_${UPPERCOMPONENT}_TARGET_DEPENDENCIES) + foreach(dep ${_Boost_${UPPERCOMPONENT}_DEPENDENCIES}) + list(APPEND _Boost_${UPPERCOMPONENT}_TARGET_DEPENDENCIES Boost::${dep}) + endforeach() + if(COMPONENT STREQUAL "thread") + list(APPEND _Boost_${UPPERCOMPONENT}_TARGET_DEPENDENCIES Threads::Threads) + endif() + set_target_properties(Boost::${COMPONENT} PROPERTIES + INTERFACE_LINK_LIBRARIES "${_Boost_${UPPERCOMPONENT}_TARGET_DEPENDENCIES}") + endif() + if(_Boost_${UPPERCOMPONENT}_COMPILER_FEATURES) + set_target_properties(Boost::${COMPONENT} PROPERTIES + INTERFACE_COMPILE_FEATURES "${_Boost_${UPPERCOMPONENT}_COMPILER_FEATURES}") + endif() + endif() + endif() + endforeach() + + # Supply Boost_LIB_DIAGNOSTIC_DEFINITIONS as a convenience target. It + # will only contain any interface definitions on WIN32, but is created + # on all platforms to keep end user code free from platform dependent + # code. Also provide convenience targets to disable autolinking and + # enable dynamic linking. + if(NOT TARGET Boost::diagnostic_definitions) + add_library(Boost::diagnostic_definitions INTERFACE IMPORTED) + add_library(Boost::disable_autolinking INTERFACE IMPORTED) + add_library(Boost::dynamic_linking INTERFACE IMPORTED) + set_target_properties(Boost::dynamic_linking PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "BOOST_ALL_DYN_LINK") + endif() + if(WIN32) + # In windows, automatic linking is performed, so you do not have + # to specify the libraries. If you are linking to a dynamic + # runtime, then you can choose to link to either a static or a + # dynamic Boost library, the default is to do a static link. You + # can alter this for a specific library "whatever" by defining + # BOOST_WHATEVER_DYN_LINK to force Boost library "whatever" to be + # linked dynamically. Alternatively you can force all Boost + # libraries to dynamic link by defining BOOST_ALL_DYN_LINK. + + # This feature can be disabled for Boost library "whatever" by + # defining BOOST_WHATEVER_NO_LIB, or for all of Boost by defining + # BOOST_ALL_NO_LIB. + + # If you want to observe which libraries are being linked against + # then defining BOOST_LIB_DIAGNOSTIC will cause the auto-linking + # code to emit a #pragma message each time a library is selected + # for linking. + set(Boost_LIB_DIAGNOSTIC_DEFINITIONS "-DBOOST_LIB_DIAGNOSTIC") + set_target_properties(Boost::diagnostic_definitions PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "BOOST_LIB_DIAGNOSTIC") + set_target_properties(Boost::disable_autolinking PROPERTIES + INTERFACE_COMPILE_DEFINITIONS "BOOST_ALL_NO_LIB") + endif() +endif() + +# ------------------------------------------------------------------------ +# Finalize +# ------------------------------------------------------------------------ + +# Report Boost_LIBRARIES +set(Boost_LIBRARIES "") +foreach(_comp IN LISTS Boost_FIND_COMPONENTS) + string(TOUPPER ${_comp} _uppercomp) + if(Boost_${_uppercomp}_FOUND) + list(APPEND Boost_LIBRARIES ${Boost_${_uppercomp}_LIBRARY}) + if(_comp STREQUAL "thread") + list(APPEND Boost_LIBRARIES ${CMAKE_THREAD_LIBS_INIT}) + endif() + endif() +endforeach() + +# Configure display of cache entries in GUI. +foreach(v BOOSTROOT BOOST_ROOT ${_Boost_VARS_INC} ${_Boost_VARS_LIB}) + get_property(_type CACHE ${v} PROPERTY TYPE) + if(_type) + set_property(CACHE ${v} PROPERTY ADVANCED 1) + if("x${_type}" STREQUAL "xUNINITIALIZED") + if("x${v}" STREQUAL "xBoost_ADDITIONAL_VERSIONS") + set_property(CACHE ${v} PROPERTY TYPE STRING) + else() + set_property(CACHE ${v} PROPERTY TYPE PATH) + endif() + endif() + endif() +endforeach() + +# Record last used values of input variables so we can +# detect on the next run if the user changed them. +foreach(v + ${_Boost_VARS_INC} ${_Boost_VARS_LIB} + ${_Boost_VARS_DIR} ${_Boost_VARS_NAME} + ) + if(DEFINED ${v}) + set(_${v}_LAST "${${v}}" CACHE INTERNAL "Last used ${v} value.") + else() + unset(_${v}_LAST CACHE) + endif() +endforeach() + +# Maintain a persistent list of components requested anywhere since +# the last flush. +set(_Boost_COMPONENTS_SEARCHED "${_Boost_COMPONENTS_SEARCHED}") +list(APPEND _Boost_COMPONENTS_SEARCHED ${Boost_FIND_COMPONENTS}) +list(REMOVE_DUPLICATES _Boost_COMPONENTS_SEARCHED) +list(SORT _Boost_COMPONENTS_SEARCHED) +set(_Boost_COMPONENTS_SEARCHED "${_Boost_COMPONENTS_SEARCHED}" + CACHE INTERNAL "Components requested for this build tree.") + +# Restore project's policies +cmake_policy(POP) diff --git a/cmake/modules/FindCUnit.cmake b/cmake/modules/FindCUnit.cmake new file mode 100644 index 000000000..26fea552e --- /dev/null +++ b/cmake/modules/FindCUnit.cmake @@ -0,0 +1,23 @@ +# Try to find CUnit +# +# Once done, this will define +# +# CUNIT_FOUND + +find_path(CUNIT_INCLUDE_DIR NAMES CUnit/CUnit.h) + +find_library(CUNIT_LIBRARY NAMES + cunit + libcunit + cunitlib) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(CUnit + DEFAULT_MSG CUNIT_LIBRARY CUNIT_INCLUDE_DIR) + +if(CUNIT_FOUND) + set(CUNIT_LIBRARIES ${CUNIT_LIBRARY}) + set(CUNIT_INCLUDE_DIRS ${CUNIT_INCLUDE_DIR}) +endif() + +mark_as_advanced(CUNIT_INCLUDE_DIR CUNIT_LIBRARY) diff --git a/cmake/modules/FindCython.cmake b/cmake/modules/FindCython.cmake new file mode 100644 index 000000000..8eb9e42f4 --- /dev/null +++ b/cmake/modules/FindCython.cmake @@ -0,0 +1,16 @@ +# +# Cython +# + +# Try to run Cython, to make sure it works: +execute_process( + COMMAND ${Python3_EXECUTABLE} -m cython --version + RESULT_VARIABLE cython_result + ERROR_VARIABLE cython_output) +if(cython_result EQUAL 0) + string(REGEX REPLACE "^Cython version ([0-9]+\\.[0-9]+).*" "\\1" CYTHON_VERSION "${cython_output}") +else() + message(SEND_ERROR "Could not find cython${PYTHON_VERSION}: ${cython_output}") +endif() +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Cython${PYTHON_VERSION} DEFAULT_MSG CYTHON_VERSION) diff --git a/cmake/modules/FindFUSE.cmake b/cmake/modules/FindFUSE.cmake new file mode 100644 index 000000000..b55a2d36f --- /dev/null +++ b/cmake/modules/FindFUSE.cmake @@ -0,0 +1,81 @@ +# This module can find FUSE Library +# +# The following variables will be defined for your use: +# - FUSE_FOUND : was FUSE found? +# - FUSE_INCLUDE_DIRS : FUSE include directory +# - FUSE_LIBRARIES : FUSE library +# - FUSE_VERSION : the version of the FUSE library found + +if(PACKAGE_FIND_VERSION AND PACKAGE_FIND_VERSION VERSION_LESS "3.0") + set(fuse_names fuse) + set(fuse_suffixes fuse) +else() + set(fuse_names fuse3 fuse) + set(fuse_suffixes fuse3 fuse) +endif() + +if(APPLE) + list(APPEND fuse_names libosxfuse.dylib) + list(APPEND fuse_suffixes osxfuse) +endif() + +find_package(PkgConfig QUIET) +if(PKG_CONFIG_FOUND) + pkg_search_module(PKG_FUSE QUIET ${fuse_names}) + + string(REGEX REPLACE "([0-9]+)\.([0-9]+)\.([0-9]+)" + "\\1" FUSE_MAJOR_VERSION "${PKG_FUSE_VERSION}") + string(REGEX REPLACE "([0-9]+)\.([0-9]+)\.([0-9]+)" + "\\2" FUSE_MINOR_VERSION "${PKG_FUSE_VERSION}") + + find_path( + FUSE_INCLUDE_DIR + NAMES fuse_common.h fuse_lowlevel.h fuse.h + HINTS ${PKG_FUSE_INCLUDE_DIRS} + PATH_SUFFIXES ${fuse_suffixes} + NO_DEFAULT_PATH) + + find_library(FUSE_LIBRARIES + NAMES ${fuse_names} + HINTS ${PKG_FUSE_LIBDIR} + NO_DEFAULT_PATH) +else() + find_path( + FUSE_INCLUDE_DIR + NAMES fuse_common.h fuse_lowlevel.h fuse.h + PATH_SUFFIXES ${fuse_suffixes}) + + find_library(FUSE_LIBRARIES + NAMES ${fuse_names} + PATHS /usr/local/lib64 /usr/local/lib) + + foreach(ver "MAJOR" "MINOR") + file(STRINGS "${FUSE_INCLUDE_DIR}/fuse_common.h" fuse_ver_${ver}_line + REGEX "^#define[\t ]+FUSE_${ver}_VERSION[\t ]+[0-9]+$") + string(REGEX REPLACE ".*#define[\t ]+FUSE_${ver}_VERSION[\t ]+([0-9]+)$" + "\\1" FUSE_${ver}_VERSION "${fuse_ver_${ver}_line}") + endforeach() +endif() + +set(FUSE_VERSION + "${FUSE_MAJOR_VERSION}.${FUSE_MINOR_VERSION}") + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(FUSE + REQUIRED_VARS FUSE_LIBRARIES FUSE_INCLUDE_DIR + VERSION_VAR FUSE_VERSION) + +mark_as_advanced( + FUSE_INCLUDE_DIR) + +if(FUSE_FOUND) + set(FUSE_INCLUDE_DIRS ${FUSE_INCLUDE_DIR}) + if(NOT TARGET FUSE::FUSE) + add_library(FUSE::FUSE UNKNOWN IMPORTED) + set_target_properties(FUSE::FUSE PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${FUSE_INCLUDE_DIRS}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${FUSE_LIBRARIES}" + VERSION "${FUSE_VERSION}") + endif() +endif() diff --git a/cmake/modules/FindGMock.cmake b/cmake/modules/FindGMock.cmake new file mode 100644 index 000000000..ea53f6481 --- /dev/null +++ b/cmake/modules/FindGMock.cmake @@ -0,0 +1,21 @@ +find_path(GMock_INCLUDE_DIR NAMES gmock/gmock.h) +find_library(GMock_GMock_LIBRARY NAMES gmock) +find_library(GMock_Main_LIBRARY NAMES gmock_main) + +find_package_handle_standard_args(GMock + REQUIRED_VARS + GMock_GMock_LIBRARY + GMock_Main_LIBRARY + GMock_INCLUDE_DIR) + +if(GMock_FOUND) + foreach(c GMock Main) + if(NOT TARGET GMock::${c}) + add_library(GMock::${c} UNKNOWN IMPORTED) + set_target_properties(GMock::${c} PROPERTIES + IMPORTED_LOCATION "${GMock_${c}_LIBRARY}" + INTERFACE_INCLUDE_DIRECTORIES "${GMock_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX") + endif() + endforeach() +endif() diff --git a/cmake/modules/FindGSSApi.cmake b/cmake/modules/FindGSSApi.cmake new file mode 100644 index 000000000..0377180c6 --- /dev/null +++ b/cmake/modules/FindGSSApi.cmake @@ -0,0 +1,22 @@ +# - Find KRB5/GSSAPI C Libraries +# +# GSSAPI_FOUND - True if found. +# GSSAPI_INCLUDE_DIR - Path to the KRB5/gssapi include directory +# GSSAPI_LIBRARIES - Paths to the KRB5/gssapi libraries + +find_path(GSSAPI_INCLUDE_DIR gssapi.h PATHS + /usr/include + /opt/local/include + /usr/local/include) + +find_library(GSSAPI_KRB5_LIBRARY gssapi_krb5) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(GSSApi DEFAULT_MSG + GSSAPI_INCLUDE_DIR GSSAPI_KRB5_LIBRARY) + +set(GSSAPI_LIBRARIES ${GSSAPI_KRB5_LIBRARY}) + +mark_as_advanced( + GSSAPI_INCLUDE_DIR GSSAPI_KRB5_LIBRARY) + diff --git a/cmake/modules/FindJeMalloc.cmake b/cmake/modules/FindJeMalloc.cmake new file mode 100644 index 000000000..2b6234cc5 --- /dev/null +++ b/cmake/modules/FindJeMalloc.cmake @@ -0,0 +1,28 @@ +# Find the native JeMalloc includes and library +# This module defines +# JEMALLOC_INCLUDE_DIRS, where to find jemalloc.h, Set when +# JEMALLOC_INCLUDE_DIR is found. +# JEMALLOC_LIBRARIES, libraries to link against to use JeMalloc. +# JeMalloc_FOUND, If false, do not try to use JeMalloc. +# + +find_path(JEMALLOC_INCLUDE_DIR jemalloc/jemalloc.h) + +find_library(JEMALLOC_LIBRARIES jemalloc) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(JeMalloc + FOUND_VAR JeMalloc_FOUND + REQUIRED_VARS JEMALLOC_LIBRARIES JEMALLOC_INCLUDE_DIR) + +mark_as_advanced( + JEMALLOC_INCLUDE_DIR + JEMALLOC_LIBRARIES) + +if(JeMalloc_FOUND AND NOT (TARGET JeMalloc::JeMalloc)) + add_library(JeMalloc::JeMalloc UNKNOWN IMPORTED) + set_target_properties(JeMalloc::JeMalloc PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${JEMALLOC_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${JEMALLOC_LIBRARIES}") +endif() diff --git a/cmake/modules/FindLTTngUST.cmake b/cmake/modules/FindLTTngUST.cmake new file mode 100644 index 000000000..ac8f14c64 --- /dev/null +++ b/cmake/modules/FindLTTngUST.cmake @@ -0,0 +1,111 @@ +#.rst: +# FindLTTngUST +# ------------ +# +# This module finds the `LTTng-UST <http://lttng.org/>`__ library. +# +# Imported target +# ^^^^^^^^^^^^^^^ +# +# This module defines the following :prop_tgt:`IMPORTED` target: +# +# ``LTTng::UST`` +# The LTTng-UST library, if found +# +# Result variables +# ^^^^^^^^^^^^^^^^ +# +# This module sets the following +# +# ``LTTNGUST_FOUND`` +# ``TRUE`` if system has LTTng-UST +# ``LTTNGUST_INCLUDE_DIRS`` +# The LTTng-UST include directories +# ``LTTNGUST_LIBRARIES`` +# The libraries needed to use LTTng-UST +# ``LTTNGUST_VERSION_STRING`` +# The LTTng-UST version +# ``LTTNGUST_HAS_TRACEF`` +# ``TRUE`` if the ``tracef()`` API is available in the system's LTTng-UST +# ``LTTNGUST_HAS_TRACELOG`` +# ``TRUE`` if the ``tracelog()`` API is available in the system's LTTng-UST + +#============================================================================= +# Copyright 2016 Kitware, Inc. +# Copyright 2016 Philippe Proulx <pproulx@efficios.com> +# +# Distributed under the OSI-approved BSD License (the "License"); +# see accompanying file Copyright.txt for details. +# +# This software is distributed WITHOUT ANY WARRANTY; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the License for more information. +#============================================================================= +# (To distribute this file outside of CMake, substitute the full +# License text for the above reference.) + +find_path(LTTNGUST_INCLUDE_DIRS NAMES lttng/tracepoint.h) +find_library(LTTNGUST_LIBRARIES NAMES lttng-ust) + +if(LTTNGUST_INCLUDE_DIRS AND LTTNGUST_LIBRARIES) + # find tracef() and tracelog() support + set(LTTNGUST_HAS_TRACEF 0) + set(LTTNGUST_HAS_TRACELOG 0) + + if(EXISTS "${LTTNGUST_INCLUDE_DIRS}/lttng/tracef.h") + set(LTTNGUST_HAS_TRACEF TRUE) + endif() + + if(EXISTS "${LTTNGUST_INCLUDE_DIRS}/lttng/tracelog.h") + set(LTTNGUST_HAS_TRACELOG TRUE) + endif() + + # get version + set(lttngust_version_file "${LTTNGUST_INCLUDE_DIRS}/lttng/ust-version.h") + + if(EXISTS "${lttngust_version_file}") + file(STRINGS "${lttngust_version_file}" lttngust_version_major_string + REGEX "^[\t ]*#define[\t ]+LTTNG_UST_MAJOR_VERSION[\t ]+[0-9]+[\t ]*$") + file(STRINGS "${lttngust_version_file}" lttngust_version_minor_string + REGEX "^[\t ]*#define[\t ]+LTTNG_UST_MINOR_VERSION[\t ]+[0-9]+[\t ]*$") + file(STRINGS "${lttngust_version_file}" lttngust_version_patch_string + REGEX "^[\t ]*#define[\t ]+LTTNG_UST_PATCHLEVEL_VERSION[\t ]+[0-9]+[\t ]*$") + string(REGEX REPLACE ".*([0-9]+).*" "\\1" + lttngust_v_major "${lttngust_version_major_string}") + string(REGEX REPLACE ".*([0-9]+).*" "\\1" + lttngust_v_minor "${lttngust_version_minor_string}") + string(REGEX REPLACE ".*([0-9]+).*" "\\1" + lttngust_v_patch "${lttngust_version_patch_string}") + set(LTTNGUST_VERSION_STRING + "${lttngust_v_major}.${lttngust_v_minor}.${lttngust_v_patch}") + unset(lttngust_version_major_string) + unset(lttngust_version_minor_string) + unset(lttngust_version_patch_string) + unset(lttngust_v_major) + unset(lttngust_v_minor) + unset(lttngust_v_patch) + endif() + + unset(lttngust_version_file) + + if(NOT TARGET LTTng::UST) + add_library(LTTng::UST UNKNOWN IMPORTED) + set_target_properties(LTTng::UST PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${LTTNGUST_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES ${CMAKE_DL_LIBS} + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${LTTNGUST_LIBRARIES}") + endif() + + # add libdl to required libraries + set(LTTNGUST_LIBRARIES ${LTTNGUST_LIBRARIES} ${CMAKE_DL_LIBS}) +endif() + +# handle the QUIETLY and REQUIRED arguments and set LTTNGUST_FOUND to +# TRUE if all listed variables are TRUE +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(LTTngUST FOUND_VAR LTTNGUST_FOUND + REQUIRED_VARS LTTNGUST_LIBRARIES + LTTNGUST_INCLUDE_DIRS + VERSION_VAR LTTNGUST_VERSION_STRING) +mark_as_advanced(LTTNGUST_LIBRARIES LTTNGUST_INCLUDE_DIRS) diff --git a/cmake/modules/FindLZ4.cmake b/cmake/modules/FindLZ4.cmake new file mode 100644 index 000000000..6c94f66cc --- /dev/null +++ b/cmake/modules/FindLZ4.cmake @@ -0,0 +1,43 @@ +# Try to find liblz4 +# +# Once done, this will define +# +# LZ4_FOUND +# LZ4_INCLUDE_DIR +# LZ4_LIBRARY +# LZ4_VERSION_STRING +# LZ4_VERSION_MAJOR +# LZ4_VERSION_MINOR +# LZ4_VERSION_RELEASE + +find_path(LZ4_INCLUDE_DIR NAMES lz4.h) + +if(LZ4_INCLUDE_DIR AND EXISTS "${LZ4_INCLUDE_DIR}/lz4.h") + foreach(ver "MAJOR" "MINOR" "RELEASE") + file(STRINGS "${LZ4_INCLUDE_DIR}/lz4.h" LZ4_VER_${ver}_LINE + REGEX "^#define[ \t]+LZ4_VERSION_${ver}[ \t]+[0-9]+[ \t]+.*$") + string(REGEX REPLACE "^#define[ \t]+LZ4_VERSION_${ver}[ \t]+([0-9]+)[ \t]+.*$" + "\\1" LZ4_VERSION_${ver} "${LZ4_VER_${ver}_LINE}") + unset(${LZ4_VER_${ver}_LINE}) + endforeach() + set(LZ4_VERSION_STRING + "${LZ4_VERSION_MAJOR}.${LZ4_VERSION_MINOR}.${LZ4_VERSION_RELEASE}") +endif() + +find_library(LZ4_LIBRARY NAMES lz4) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(LZ4 + REQUIRED_VARS LZ4_LIBRARY LZ4_INCLUDE_DIR + VERSION_VAR LZ4_VERSION_STRING) + +mark_as_advanced(LZ4_INCLUDE_DIR LZ4_LIBRARY) + +if(LZ4_FOUND AND NOT (TARGET LZ4::LZ4)) + add_library(LZ4::LZ4 UNKNOWN IMPORTED) + set_target_properties(LZ4::LZ4 PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${LZ4_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${LZ4_LIBRARY}" + VERSION "${LZ4_VERSION_STRING}") +endif() diff --git a/cmake/modules/FindMake.cmake b/cmake/modules/FindMake.cmake new file mode 100644 index 000000000..2a57a8df7 --- /dev/null +++ b/cmake/modules/FindMake.cmake @@ -0,0 +1,17 @@ +function(find_make make_exe make_cmd) + # make_exe the name of the variable whose value will be the path to "make" + # executable + # make_cmd the name of the variable whose value will be the command to + # used in the generated build script executed by the cmake generator + find_program(MAKE_EXECUTABLE NAMES gmake make) + if(NOT MAKE_EXECUTABLE) + message(FATAL_ERROR "Can't find make") + endif() + set(${make_exe} "${MAKE_EXECUTABLE}" PARENT_SCOPE) + if(CMAKE_MAKE_PROGRAM MATCHES "make") + # try to inherit command line arguments passed by parent "make" job + set(${make_cmd} "$(MAKE)" PARENT_SCOPE) + else() + set(${make_cmd} "${MAKE_EXECUTABLE}" PARENT_SCOPE) + endif() +endfunction() diff --git a/cmake/modules/FindNUMA.cmake b/cmake/modules/FindNUMA.cmake new file mode 100644 index 000000000..482061c64 --- /dev/null +++ b/cmake/modules/FindNUMA.cmake @@ -0,0 +1,16 @@ +# - Find libnuma +# Find the numa library and includes +# +# NUMA_INCLUDE_DIR - where to find numa.h, etc. +# NUMA_LIBRARIES - List of libraries when using numa. +# NUMA_FOUND - True if numa found. + +find_path(NUMA_INCLUDE_DIR numa.h) +find_library(NUMA_LIBRARIES numa) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(numa DEFAULT_MSG NUMA_LIBRARIES NUMA_INCLUDE_DIR) + +mark_as_advanced( + NUMA_LIBRARIES + NUMA_INCLUDE_DIR) diff --git a/cmake/modules/FindOATH.cmake b/cmake/modules/FindOATH.cmake new file mode 100644 index 000000000..d9821fe3f --- /dev/null +++ b/cmake/modules/FindOATH.cmake @@ -0,0 +1,31 @@ +# CMake module to search for liboath headers +# +# If it's found it sets OATH_FOUND to TRUE +# and following variables are set: +# OATH_INCLUDE_DIRS +# OATH_LIBRARIES +find_path(OATH_INCLUDE_DIR + liboath/oath.h + PATHS + /usr/include + /usr/local/include) +find_library(OATH_LIBRARY NAMES oath liboath PATHS + /usr/local/lib + /usr/lib) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(OATH DEFAULT_MSG OATH_LIBRARY OATH_INCLUDE_DIR) + +mark_as_advanced(OATH_LIBRARY OATH_INCLUDE_DIR) + +if(OATH_FOUND) + set(OATH_INCLUDE_DIRS "${OATH_INCLUDE_DIR}") + set(OATH_LIBRARIES "${OATH_LIBRARY}") + if(NOT TARGET OATH::OATH) + add_library(OATH::OATH UNKNOWN IMPORTED) + endif() + set_target_properties(OATH::OATH PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${OATH_INCLUDE_DIRS}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${OATH_LIBRARIES}") +endif() diff --git a/cmake/modules/FindOpenLdap.cmake b/cmake/modules/FindOpenLdap.cmake new file mode 100644 index 000000000..35b711d6b --- /dev/null +++ b/cmake/modules/FindOpenLdap.cmake @@ -0,0 +1,22 @@ +# - Find OpenLDAP C Libraries +# +# OPENLDAP_FOUND - True if found. +# OPENLDAP_INCLUDE_DIR - Path to the openldap include directory +# OPENLDAP_LIBRARIES - Paths to the ldap and lber libraries + +find_path(OPENLDAP_INCLUDE_DIR ldap.h PATHS + /usr/include + /opt/local/include + /usr/local/include) + +find_library(LDAP_LIBRARY ldap) +find_library(LBER_LIBRARY lber) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(OpenLdap DEFAULT_MSG + OPENLDAP_INCLUDE_DIR LDAP_LIBRARY LBER_LIBRARY) + +set(OPENLDAP_LIBRARIES ${LDAP_LIBRARY} ${LBER_LIBRARY}) + +mark_as_advanced( + OPENLDAP_INCLUDE_DIR LDAP_LIBRARY LBER_LIBRARY) diff --git a/cmake/modules/FindPython/Support.cmake b/cmake/modules/FindPython/Support.cmake new file mode 100644 index 000000000..c05bbe330 --- /dev/null +++ b/cmake/modules/FindPython/Support.cmake @@ -0,0 +1,1328 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +# +# This file is a "template" file used by various FindPython modules. +# + +cmake_policy (VERSION 3.5) + +# +# Initial configuration +# +if (NOT DEFINED _PYTHON_PREFIX) + message (FATAL_ERROR "FindPython: INTERNAL ERROR") +endif() +if (NOT DEFINED _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR) + message (FATAL_ERROR "FindPython: INTERNAL ERROR") +endif() +if (_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR EQUAL 3) + set(_${_PYTHON_PREFIX}_VERSIONS 3.9 3.8 3.7 3.6 3.5 3.4 3.3 3.2 3.1 3.0) +elseif (_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR EQUAL 2) + set(_${_PYTHON_PREFIX}_VERSIONS 2.7 2.6 2.5 2.4 2.3 2.2 2.1 2.0) +else() + message (FATAL_ERROR "FindPython: INTERNAL ERROR") +endif() + +get_property(_${_PYTHON_PREFIX}_CMAKE_ROLE GLOBAL PROPERTY CMAKE_ROLE) +if (NOT DEFINED _${_PYTHON_PREFIX}_CMAKE_ROLE) + # CMake 3.14 introduced CMAKE_ROLE + set(_${_PYTHON_PREFIX}_CMAKE_ROLE "PROJECT") +endif() + + +# +# helper commands +# +macro (_PYTHON_DISPLAY_FAILURE _PYTHON_MSG) + if (${_PYTHON_PREFIX}_FIND_REQUIRED) + message (FATAL_ERROR "${_PYTHON_MSG}") + else() + if (NOT ${_PYTHON_PREFIX}_FIND_QUIETLY) + message(STATUS "${_PYTHON_MSG}") + endif () + endif() + + set (${_PYTHON_PREFIX}_FOUND FALSE) + string (TOUPPER "${_PYTHON_PREFIX}" _${_PYTHON_PREFIX}_UPPER_PREFIX) + set (${_PYTHON_UPPER_PREFIX}_FOUND FALSE) + return() +endmacro() + + +macro (_PYTHON_FIND_FRAMEWORKS) + set (${_PYTHON_PREFIX}_FRAMEWORKS) + if (APPLE) + set (_pff_frameworks ${CMAKE_FRAMEWORK_PATH} + $ENV{CMAKE_FRAMEWORK_PATH} + ~/Library/Frameworks + /usr/local/Frameworks + ${CMAKE_SYSTEM_FRAMEWORK_PATH}) + list (REMOVE_DUPLICATES _pff_frameworks) + foreach (_pff_framework IN LISTS _pff_frameworks) + if (EXISTS ${_pff_framework}/Python.framework) + list (APPEND ${_PYTHON_PREFIX}_FRAMEWORKS ${_pff_framework}/Python.framework) + endif() + endforeach() + unset (_pff_frameworks) + unset (_pff_framework) + endif() +endmacro() + +function (_PYTHON_GET_FRAMEWORKS _PYTHON_PGF_FRAMEWORK_PATHS _PYTHON_VERSION) + set (_PYTHON_FRAMEWORK_PATHS) + foreach (_PYTHON_FRAMEWORK IN LISTS ${_PYTHON_PREFIX}_FRAMEWORKS) + list (APPEND _PYTHON_FRAMEWORK_PATHS + "${_PYTHON_FRAMEWORK}/Versions/${_PYTHON_VERSION}") + endforeach() + set (${_PYTHON_PGF_FRAMEWORK_PATHS} ${_PYTHON_FRAMEWORK_PATHS} PARENT_SCOPE) +endfunction() + + +function (_PYTHON_VALIDATE_INTERPRETER) + if (NOT ${_PYTHON_PREFIX}_EXECUTABLE) + return() + endif() + + if (ARGC EQUAL 1) + set (expected_version ${ARGV0}) + else() + unset (expected_version) + endif() + + get_filename_component (python_name "${${_PYTHON_PREFIX}_EXECUTABLE}" NAME) + + if (expected_version AND NOT python_name STREQUAL "python${expected_version}${CMAKE_EXECUTABLE_SUFFIX}") + # executable found must have a specific version + execute_process (COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c + "import sys; sys.stdout.write('.'.join([str(x) for x in sys.version_info[:2]]))" + RESULT_VARIABLE result + OUTPUT_VARIABLE version + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (result OR NOT version EQUAL expected_version) + # interpreter not usable or has wrong major version + set (${_PYTHON_PREFIX}_EXECUTABLE ${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND CACHE INTERNAL "" FORCE) + return() + endif() + else() + if (NOT python_name STREQUAL "python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}${CMAKE_EXECUTABLE_SUFFIX}") + # executable found do not have version in name + # ensure major version is OK + execute_process (COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c + "import sys; sys.stdout.write(str(sys.version_info[0]))" + RESULT_VARIABLE result + OUTPUT_VARIABLE version + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (result OR NOT version EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR) + # interpreter not usable or has wrong major version + set (${_PYTHON_PREFIX}_EXECUTABLE ${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND CACHE INTERNAL "" FORCE) + return() + endif() + endif() + endif() + + if (CMAKE_SIZEOF_VOID_P AND "Development" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS + AND NOT CMAKE_CROSSCOMPILING) + # In this case, interpreter must have same architecture as environment + execute_process (COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c + "import sys, struct; sys.stdout.write(str(struct.calcsize(\"P\")))" + RESULT_VARIABLE result + OUTPUT_VARIABLE size + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (result OR NOT size EQUAL CMAKE_SIZEOF_VOID_P) + # interpreter not usable or has wrong architecture + set (${_PYTHON_PREFIX}_EXECUTABLE ${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND CACHE INTERNAL "" FORCE) + return() + endif() + endif() +endfunction() + + +function (_PYTHON_VALIDATE_COMPILER expected_version) + if (NOT ${_PYTHON_PREFIX}_COMPILER) + return() + endif() + + # retrieve python environment version from compiler + set (working_dir "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/PythonCompilerVersion.dir") + file (WRITE "${working_dir}/version.py" "import sys; sys.stdout.write('.'.join([str(x) for x in sys.version_info[:2]]))\n") + execute_process (COMMAND "${${_PYTHON_PREFIX}_COMPILER}" /target:exe /embed "${working_dir}/version.py" + WORKING_DIRECTORY "${working_dir}" + OUTPUT_QUIET + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + execute_process (COMMAND "${working_dir}/version" + WORKING_DIRECTORY "${working_dir}" + RESULT_VARIABLE result + OUTPUT_VARIABLE version + ERROR_QUIET) + file (REMOVE_RECURSE "${_${_PYTHON_PREFIX}_VERSION_DIR}") + + if (result OR NOT version EQUAL expected_version) + # Compiler not usable or has wrong major version + set (${_PYTHON_PREFIX}_COMPILER ${_PYTHON_PREFIX}_COMPILER-NOTFOUND CACHE INTERNAL "" FORCE) + endif() +endfunction() + + +function (_PYTHON_FIND_RUNTIME_LIBRARY _PYTHON_LIB) + string (REPLACE "_RUNTIME" "" _PYTHON_LIB "${_PYTHON_LIB}") + # look at runtime part on systems supporting it + if (CMAKE_SYSTEM_NAME STREQUAL "Windows" OR + (CMAKE_SYSTEM_NAME MATCHES "MSYS|CYGWIN" + AND ${_PYTHON_LIB} MATCHES "${CMAKE_IMPORT_LIBRARY_SUFFIX}$")) + set (CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_SHARED_LIBRARY_SUFFIX}) + # MSYS has a special syntax for runtime libraries + if (CMAKE_SYSTEM_NAME MATCHES "MSYS") + list (APPEND CMAKE_FIND_LIBRARY_PREFIXES "msys-") + endif() + find_library (${ARGV}) + endif() +endfunction() + + +function (_PYTHON_SET_LIBRARY_DIRS _PYTHON_SLD_RESULT) + unset (_PYTHON_DIRS) + set (_PYTHON_LIBS ${ARGV}) + list (REMOVE_AT _PYTHON_LIBS 0) + foreach (_PYTHON_LIB IN LISTS _PYTHON_LIBS) + if (${_PYTHON_LIB}) + get_filename_component (_PYTHON_DIR "${${_PYTHON_LIB}}" DIRECTORY) + list (APPEND _PYTHON_DIRS "${_PYTHON_DIR}") + endif() + endforeach() + if (_PYTHON_DIRS) + list (REMOVE_DUPLICATES _PYTHON_DIRS) + endif() + set (${_PYTHON_SLD_RESULT} ${_PYTHON_DIRS} PARENT_SCOPE) +endfunction() + + +# If major version is specified, it must be the same as internal major version +if (DEFINED ${_PYTHON_PREFIX}_FIND_VERSION_MAJOR + AND NOT ${_PYTHON_PREFIX}_FIND_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR) + _python_display_failure ("Could NOT find ${_PYTHON_PREFIX}: Wrong major version specified is \"${${_PYTHON_PREFIX}_FIND_VERSION_MAJOR}\", but expected major version is \"${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}\"") +endif() + + +# handle components +if (NOT ${_PYTHON_PREFIX}_FIND_COMPONENTS) + set (${_PYTHON_PREFIX}_FIND_COMPONENTS Interpreter) + set (${_PYTHON_PREFIX}_FIND_REQUIRED_Interpreter TRUE) +endif() +if ("NumPy" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS) + list (APPEND ${_PYTHON_PREFIX}_FIND_COMPONENTS "Interpreter" "Development") + list (REMOVE_DUPLICATES ${_PYTHON_PREFIX}_FIND_COMPONENTS) +endif() +foreach (_${_PYTHON_PREFIX}_COMPONENT IN LISTS ${_PYTHON_PREFIX}_FIND_COMPONENTS) + set (${_PYTHON_PREFIX}_${_${_PYTHON_PREFIX}_COMPONENT}_FOUND FALSE) +endforeach() +unset (_${_PYTHON_PREFIX}_FIND_VERSIONS) + +# Set versions to search +## default: search any version +set (_${_PYTHON_PREFIX}_FIND_VERSIONS ${_${_PYTHON_PREFIX}_VERSIONS}) + +if (${_PYTHON_PREFIX}_FIND_VERSION_COUNT GREATER 1) + if (${_PYTHON_PREFIX}_FIND_VERSION_EXACT) + set (_${_PYTHON_PREFIX}_FIND_VERSIONS ${${_PYTHON_PREFIX}_FIND_VERSION_MAJOR}.${${_PYTHON_PREFIX}_FIND_VERSION_MINOR}) + else() + unset (_${_PYTHON_PREFIX}_FIND_VERSIONS) + # add all compatible versions + foreach (_${_PYTHON_PREFIX}_VERSION IN LISTS _${_PYTHON_PREFIX}_VERSIONS) + if (NOT _${_PYTHON_PREFIX}_VERSION VERSION_LESS ${_PYTHON_PREFIX}_FIND_VERSION) + list (APPEND _${_PYTHON_PREFIX}_FIND_VERSIONS ${_${_PYTHON_PREFIX}_VERSION}) + endif() + endforeach() + endif() +endif() + +# Python and Anaconda distributions: define which architectures can be used +if (CMAKE_SIZEOF_VOID_P) + # In this case, search only for 64bit or 32bit + math (EXPR _${_PYTHON_PREFIX}_ARCH "${CMAKE_SIZEOF_VOID_P} * 8") + set (_${_PYTHON_PREFIX}_ARCH2 ${_${_PYTHON_PREFIX}_ARCH}) +else() + # architecture unknown, search for both 64bit and 32bit + set (_${_PYTHON_PREFIX}_ARCH 64) + set (_${_PYTHON_PREFIX}_ARCH2 32) +endif() + +# IronPython support +if (CMAKE_SIZEOF_VOID_P) + # In this case, search only for 64bit or 32bit + math (EXPR _${_PYTHON_PREFIX}_ARCH "${CMAKE_SIZEOF_VOID_P} * 8") + set (_${_PYTHON_PREFIX}_IRON_PYTHON_NAMES ipy${_${_PYTHON_PREFIX}_ARCH} ipy) +else() + # architecture unknown, search for natural interpreter + set (_${_PYTHON_PREFIX}_IRON_PYTHON_NAMES ipy) +endif() +set (_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES net45 net40) + +# Apple frameworks handling +_python_find_frameworks () + +# Save CMAKE_FIND_APPBUNDLE +if (DEFINED CMAKE_FIND_APPBUNDLE) + set (_${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE ${CMAKE_FIND_APPBUNDLE}) +else() + unset (_${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE) +endif() +# To avoid app bundle lookup +set (CMAKE_FIND_APPBUNDLE "NEVER") + +# Save CMAKE_FIND_FRAMEWORK +if (DEFINED CMAKE_FIND_FRAMEWORK) + set (_${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK}) + if (CMAKE_FIND_FRAMEWORK STREQUAL "ONLY") + message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: CMAKE_FIND_FRAMEWORK: 'ONLY' value is not supported. 'FIRST' will be used instead.") + set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK "FIRST") + else() + set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK}) + endif() +else() + unset (_${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK) + set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK "FIRST") +endif() +# To avoid framework lookup +set (CMAKE_FIND_FRAMEWORK "NEVER") + +# Windows Registry handling +if (DEFINED ${_PYTHON_PREFIX}_FIND_REGISTRY) + if (NOT ${_PYTHON_PREFIX}_FIND_REGISTRY MATCHES "^(FIRST|LAST|NEVER)$") + message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_REGISTRY}: invalid value for '${_PYTHON_PREFIX}_FIND_REGISTRY'. 'FIRST', 'LAST' or 'NEVER' expected.") + set (_${_PYTHON_PREFIX}_FIND_REGISTRY "FIRST") + else() + set (_${_PYTHON_PREFIX}_FIND_REGISTRY ${${_PYTHON_PREFIX}_FIND_REGISTRY}) + endif() +else() + set (_${_PYTHON_PREFIX}_FIND_REGISTRY "FIRST") +endif() + + +unset (_${_PYTHON_PREFIX}_REQUIRED_VARS) +unset (_${_PYTHON_PREFIX}_CACHED_VARS) + + +# first step, search for the interpreter +if ("Interpreter" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS) + list (APPEND _${_PYTHON_PREFIX}_CACHED_VARS ${_PYTHON_PREFIX}_EXECUTABLE) + if (${_PYTHON_PREFIX}_FIND_REQUIRED_Interpreter) + list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_EXECUTABLE) + endif() + + set (_${_PYTHON_PREFIX}_HINTS "${${_PYTHON_PREFIX}_ROOT_DIR}" ENV ${_PYTHON_PREFIX}_ROOT_DIR) + + # look-up for various versions and locations + foreach (_${_PYTHON_PREFIX}_VERSION IN LISTS _${_PYTHON_PREFIX}_FIND_VERSIONS) + string (REPLACE "." "" _${_PYTHON_PREFIX}_VERSION_NO_DOTS ${_${_PYTHON_PREFIX}_VERSION}) + + _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS ${_${_PYTHON_PREFIX}_VERSION}) + + # Apple frameworks handling + if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST") + find_program (${_PYTHON_PREFIX}_EXECUTABLE + NAMES python${_${_PYTHON_PREFIX}_VERSION} + python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR} + NAMES_PER_DIR + PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS} + PATH_SUFFIXES bin + NO_CMAKE_PATH + NO_CMAKE_ENVIRONMENT_PATH + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + + # Windows registry + if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST") + find_program (${_PYTHON_PREFIX}_EXECUTABLE + NAMES python${_${_PYTHON_PREFIX}_VERSION} + python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR} + python + ${_${_PYTHON_PREFIX}_IRON_PYTHON_NAMES} + NAMES_PER_DIR + HINTS ${_${_PYTHON_PREFIX}_HINTS} + PATHS [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\IronPython\\${_${_PYTHON_PREFIX}_VERSION}\\InstallPath] + PATH_SUFFIXES bin ${_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES} + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + + # try using HINTS + find_program (${_PYTHON_PREFIX}_EXECUTABLE + NAMES python${_${_PYTHON_PREFIX}_VERSION} + python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR} + python + ${_${_PYTHON_PREFIX}_IRON_PYTHON_NAMES} + NAMES_PER_DIR + HINTS ${_${_PYTHON_PREFIX}_HINTS} + PATH_SUFFIXES bin ${_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES} + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + # try using standard paths. + if (WIN32) + find_program (${_PYTHON_PREFIX}_EXECUTABLE + NAMES python${_${_PYTHON_PREFIX}_VERSION} + python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR} + python + ${_${_PYTHON_PREFIX}_IRON_PYTHON_NAMES} + NAMES_PER_DIR) + else() + find_program (${_PYTHON_PREFIX}_EXECUTABLE + NAMES python${_${_PYTHON_PREFIX}_VERSION} + python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR} + NAMES_PER_DIR) + endif() + + # Apple frameworks handling + if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST") + find_program (${_PYTHON_PREFIX}_EXECUTABLE + NAMES python${_${_PYTHON_PREFIX}_VERSION} + python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR} + NAMES_PER_DIR + PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS} + PATH_SUFFIXES bin + NO_DEFAULT_PATH) + endif() + + # Windows registry + if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "LAST") + find_program (${_PYTHON_PREFIX}_EXECUTABLE + NAMES python${_${_PYTHON_PREFIX}_VERSION} + python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR} + python + ${_${_PYTHON_PREFIX}_IRON_PYTHON_NAMES} + NAMES_PER_DIR + PATHS [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\IronPython\\${_${_PYTHON_PREFIX}_VERSION}\\InstallPath] + PATH_SUFFIXES bin ${_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES} + NO_DEFAULT_PATH) + endif() + + _python_validate_interpreter (${_${_PYTHON_PREFIX}_VERSION}) + if (${_PYTHON_PREFIX}_EXECUTABLE) + break() + endif() + endforeach() + + if (NOT ${_PYTHON_PREFIX}_EXECUTABLE) + # No specific version found. Retry with generic names + # try using HINTS + find_program (${_PYTHON_PREFIX}_EXECUTABLE + NAMES python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR} + python + ${_${_PYTHON_PREFIX}_IRON_PYTHON_NAMES} + NAMES_PER_DIR + HINTS ${_${_PYTHON_PREFIX}_HINTS} + PATH_SUFFIXES bin ${_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES} + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + # try using standard paths. + # NAMES_PER_DIR is not defined on purpose to have a chance to find + # expected version. + # For example, typical systems have 'python' for version 2.* and 'python3' + # for version 3.*. So looking for names per dir will find, potentially, + # systematically 'python' (i.e. version 2) even if version 3 is searched. + find_program (${_PYTHON_PREFIX}_EXECUTABLE + NAMES python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR} + python + ${_${_PYTHON_PREFIX}_IRON_PYTHON_NAMES}) + + _python_validate_interpreter () + endif() + + # retrieve exact version of executable found + if (${_PYTHON_PREFIX}_EXECUTABLE) + execute_process (COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c + "import sys; sys.stdout.write('.'.join([str(x) for x in sys.version_info[:3]]))" + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE ${_PYTHON_PREFIX}_VERSION + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (NOT _${_PYTHON_PREFIX}_RESULT) + string (REGEX MATCHALL "[0-9]+" _${_PYTHON_PREFIX}_VERSIONS "${${_PYTHON_PREFIX}_VERSION}") + list (GET _${_PYTHON_PREFIX}_VERSIONS 0 ${_PYTHON_PREFIX}_VERSION_MAJOR) + list (GET _${_PYTHON_PREFIX}_VERSIONS 1 ${_PYTHON_PREFIX}_VERSION_MINOR) + list (GET _${_PYTHON_PREFIX}_VERSIONS 2 ${_PYTHON_PREFIX}_VERSION_PATCH) + else() + # Interpreter is not usable + set (${_PYTHON_PREFIX}_EXECUTABLE ${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND CACHE INTERNAL "" FORCE) + unset (${_PYTHON_PREFIX}_VERSION) + endif() + endif() + + if (${_PYTHON_PREFIX}_EXECUTABLE + AND ${_PYTHON_PREFIX}_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR) + set (${_PYTHON_PREFIX}_Interpreter_FOUND TRUE) + # Use interpreter version for future searches to ensure consistency + set (_${_PYTHON_PREFIX}_FIND_VERSIONS ${${_PYTHON_PREFIX}_VERSION_MAJOR}.${${_PYTHON_PREFIX}_VERSION_MINOR}) + endif() + + if (${_PYTHON_PREFIX}_Interpreter_FOUND) + if (NOT CMAKE_SIZEOF_VOID_P) + # determine interpreter architecture + execute_process (COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c "import sys; print(sys.maxsize > 2**32)" + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE ${_PYTHON_PREFIX}_IS64BIT + ERROR_VARIABLE ${_PYTHON_PREFIX}_IS64BIT) + if (NOT _${_PYTHON_PREFIX}_RESULT) + if (${_PYTHON_PREFIX}_IS64BIT) + set (_${_PYTHON_PREFIX}_ARCH 64) + set (_${_PYTHON_PREFIX}_ARCH2 64) + else() + set (_${_PYTHON_PREFIX}_ARCH 32) + set (_${_PYTHON_PREFIX}_ARCH2 32) + endif() + endif() + endif() + + # retrieve interpreter identity + execute_process (COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -V + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE ${_PYTHON_PREFIX}_INTERPRETER_ID + ERROR_VARIABLE ${_PYTHON_PREFIX}_INTERPRETER_ID) + if (NOT _${_PYTHON_PREFIX}_RESULT) + if (${_PYTHON_PREFIX}_INTERPRETER_ID MATCHES "Anaconda") + set (${_PYTHON_PREFIX}_INTERPRETER_ID "Anaconda") + elseif (${_PYTHON_PREFIX}_INTERPRETER_ID MATCHES "Enthought") + set (${_PYTHON_PREFIX}_INTERPRETER_ID "Canopy") + else() + string (REGEX REPLACE "^([^ ]+).*" "\\1" ${_PYTHON_PREFIX}_INTERPRETER_ID "${${_PYTHON_PREFIX}_INTERPRETER_ID}") + if (${_PYTHON_PREFIX}_INTERPRETER_ID STREQUAL "Python") + # try to get a more precise ID + execute_process (COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c "import sys; print(sys.copyright)" + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE ${_PYTHON_PREFIX}_COPYRIGHT + ERROR_QUIET) + if (${_PYTHON_PREFIX}_COPYRIGHT MATCHES "ActiveState") + set (${_PYTHON_PREFIX}_INTERPRETER_ID "ActivePython") + endif() + endif() + endif() + else() + set (${_PYTHON_PREFIX}_INTERPRETER_ID Python) + endif() + else() + unset (${_PYTHON_PREFIX}_INTERPRETER_ID) + endif() + + # retrieve various package installation directories + execute_process (COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c "import sys; from distutils import sysconfig;sys.stdout.write(';'.join([sysconfig.get_python_lib(plat_specific=False,standard_lib=True),sysconfig.get_python_lib(plat_specific=True,standard_lib=True),sysconfig.get_python_lib(plat_specific=False,standard_lib=False),sysconfig.get_python_lib(plat_specific=True,standard_lib=False)]))" + + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_LIBPATHS + ERROR_QUIET) + if (NOT _${_PYTHON_PREFIX}_RESULT) + list (GET _${_PYTHON_PREFIX}_LIBPATHS 0 ${_PYTHON_PREFIX}_STDLIB) + list (GET _${_PYTHON_PREFIX}_LIBPATHS 1 ${_PYTHON_PREFIX}_STDARCH) + list (GET _${_PYTHON_PREFIX}_LIBPATHS 2 ${_PYTHON_PREFIX}_SITELIB) + list (GET _${_PYTHON_PREFIX}_LIBPATHS 3 ${_PYTHON_PREFIX}_SITEARCH) + else() + unset (${_PYTHON_PREFIX}_STDLIB) + unset (${_PYTHON_PREFIX}_STDARCH) + unset (${_PYTHON_PREFIX}_SITELIB) + unset (${_PYTHON_PREFIX}_SITEARCH) + endif() + + mark_as_advanced (${_PYTHON_PREFIX}_EXECUTABLE) +endif() + + +# second step, search for compiler (IronPython) +if ("Compiler" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS) + list (APPEND _${_PYTHON_PREFIX}_CACHED_VARS ${_PYTHON_PREFIX}_COMPILER) + if (${_PYTHON_PREFIX}_FIND_REQUIRED_Compiler) + list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_COMPILER) + endif() + + # IronPython specific artifacts + # If IronPython interpreter is found, use its path + unset (_${_PYTHON_PREFIX}_IRON_ROOT) + if (${_PYTHON_PREFIX}_Interpreter_FOUND AND ${_PYTHON_PREFIX}_INTERPRETER_ID STREQUAL "IronPython") + get_filename_component (_${_PYTHON_PREFIX}_IRON_ROOT "${${_PYTHON_PREFIX}_EXECUTABLE}" DIRECTORY) + endif() + + # try using root dir and registry + foreach (_${_PYTHON_PREFIX}_VERSION IN LISTS _${_PYTHON_PREFIX}_FIND_VERSIONS) + if (_${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST") + find_program (${_PYTHON_PREFIX}_COMPILER + NAMES ipyc + HINTS ${_${_PYTHON_PREFIX}_IRON_ROOT} ${_${_PYTHON_PREFIX}_HINTS} + PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\IronPython\\${_${_PYTHON_PREFIX}_VERSION}\\InstallPath] + PATH_SUFFIXES ${_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES} + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + + find_program (${_PYTHON_PREFIX}_COMPILER + NAMES ipyc + HINTS ${_${_PYTHON_PREFIX}_IRON_ROOT} ${_${_PYTHON_PREFIX}_HINTS} + PATH_SUFFIXES ${_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES} + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + + if (_${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "LAST") + find_program (${_PYTHON_PREFIX}_COMPILER + NAMES ipyc + PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\IronPython\\${_${_PYTHON_PREFIX}_VERSION}\\InstallPath] + PATH_SUFFIXES ${_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES} + NO_DEFAULT_PATH) + endif() + + _python_validate_compiler (${_${_PYTHON_PREFIX}_VERSION}) + if (${_PYTHON_PREFIX}_COMPILER) + break() + endif() + endforeach() + + # no specific version found, re-try in standard paths + find_program (${_PYTHON_PREFIX}_COMPILER + NAMES ipyc + HINTS ${_${_PYTHON_PREFIX}_IRON_ROOT} ${_${_PYTHON_PREFIX}_HINTS} + PATH_SUFFIXES ${_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES}) + + if (${_PYTHON_PREFIX}_COMPILER) + # retrieve python environment version from compiler + set (_${_PYTHON_PREFIX}_VERSION_DIR "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/PythonCompilerVersion.dir") + file (WRITE "${_${_PYTHON_PREFIX}_VERSION_DIR}/version.py" "import sys; sys.stdout.write('.'.join([str(x) for x in sys.version_info[:3]]))\n") + execute_process (COMMAND "${${_PYTHON_PREFIX}_COMPILER}" /target:exe /embed "${_${_PYTHON_PREFIX}_VERSION_DIR}/version.py" + WORKING_DIRECTORY "${_${_PYTHON_PREFIX}_VERSION_DIR}" + OUTPUT_QUIET + ERROR_QUIET) + execute_process (COMMAND "${_${_PYTHON_PREFIX}_VERSION_DIR}/version" + WORKING_DIRECTORY "${_${_PYTHON_PREFIX}_VERSION_DIR}" + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_VERSION + ERROR_QUIET) + if (NOT _${_PYTHON_PREFIX}_RESULT) + string (REGEX MATCHALL "[0-9]+" _${_PYTHON_PREFIX}_VERSIONS "${_${_PYTHON_PREFIX}_VERSION}") + list (GET _${_PYTHON_PREFIX}_VERSIONS 0 _${_PYTHON_PREFIX}_VERSION_MAJOR) + list (GET _${_PYTHON_PREFIX}_VERSIONS 1 _${_PYTHON_PREFIX}_VERSION_MINOR) + list (GET _${_PYTHON_PREFIX}_VERSIONS 2 _${_PYTHON_PREFIX}_VERSION_PATCH) + + if (NOT ${_PYTHON_PREFIX}_Interpreter_FOUND) + # set public version information + set (${_PYTHON_PREFIX}_VERSION ${_${_PYTHON_PREFIX}_VERSION}) + set (${_PYTHON_PREFIX}_VERSION_MAJOR ${_${_PYTHON_PREFIX}_VERSION_MAJOR}) + set (${_PYTHON_PREFIX}_VERSION_MINOR ${_${_PYTHON_PREFIX}_VERSION_MINOR}) + set (${_PYTHON_PREFIX}_VERSION_PATCH ${_${_PYTHON_PREFIX}_VERSION_PATCH}) + endif() + else() + # compiler not usable + set (${_PYTHON_PREFIX}_COMPILER ${_PYTHON_PREFIX}_COMPILER-NOTFOUND CACHE INTERNAL "" FORCE) + endif() + file (REMOVE_RECURSE "${_${_PYTHON_PREFIX}_VERSION_DIR}") + endif() + + if (${_PYTHON_PREFIX}_COMPILER) + if (${_PYTHON_PREFIX}_Interpreter_FOUND) + # Compiler must be compatible with interpreter + if (${_${_PYTHON_PREFIX}_VERSION_MAJOR}.${_${_PYTHON_PREFIX}_VERSION_MINOR} VERSION_EQUAL ${${_PYTHON_PREFIX}_VERSION_MAJOR}.${${_PYTHON_PREFIX}_VERSION_MINOR}) + set (${_PYTHON_PREFIX}_Compiler_FOUND TRUE) + endif() + elseif (${_PYTHON_PREFIX}_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR) + set (${_PYTHON_PREFIX}_Compiler_FOUND TRUE) + # Use compiler version for future searches to ensure consistency + set (_${_PYTHON_PREFIX}_FIND_VERSIONS ${${_PYTHON_PREFIX}_VERSION_MAJOR}.${${_PYTHON_PREFIX}_VERSION_MINOR}) + endif() + endif() + + if (${_PYTHON_PREFIX}_Compiler_FOUND) + set (${_PYTHON_PREFIX}_COMPILER_ID IronPython) + else() + unset (${_PYTHON_PREFIX}_COMPILER_ID) + endif() + + mark_as_advanced (${_PYTHON_PREFIX}_COMPILER) +endif() + + +# third step, search for the development artifacts +## Development environment is not compatible with IronPython interpreter +if ("Development" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS + AND NOT ${_PYTHON_PREFIX}_INTERPRETER_ID STREQUAL "IronPython") + list (APPEND _${_PYTHON_PREFIX}_CACHED_VARS ${_PYTHON_PREFIX}_LIBRARY + ${_PYTHON_PREFIX}_LIBRARY_RELEASE + ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE + ${_PYTHON_PREFIX}_LIBRARY_DEBUG + ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG + ${_PYTHON_PREFIX}_INCLUDE_DIR) + if (${_PYTHON_PREFIX}_FIND_REQUIRED_Development) + list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_LIBRARY + ${_PYTHON_PREFIX}_INCLUDE_DIR) + endif() + + # Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES + unset (_${_PYTHON_PREFIX}_CMAKE_FIND_LIBRARY_SUFFIXES) + if (DEFINED ${_PYTHON_PREFIX}_USE_STATIC_LIBS AND NOT WIN32) + set(_${_PYTHON_PREFIX}_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) + if(${_PYTHON_PREFIX}_USE_STATIC_LIBS) + set (CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX}) + else() + list (REMOVE_ITEM CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX}) + endif() + else() + endif() + + # if python interpreter is found, use its location and version to ensure consistency + # between interpreter and development environment + unset (_${_PYTHON_PREFIX}_PREFIX) + if (${_PYTHON_PREFIX}_Interpreter_FOUND) + execute_process (COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c + "import sys; from distutils import sysconfig; sys.stdout.write(sysconfig.PREFIX)" + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_PREFIX + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (_${_PYTHON_PREFIX}_RESULT) + unset (_${_PYTHON_PREFIX}_PREFIX) + endif() + endif() + set (_${_PYTHON_PREFIX}_HINTS "${_${_PYTHON_PREFIX}_PREFIX}" "${${_PYTHON_PREFIX}_ROOT_DIR}" ENV ${_PYTHON_PREFIX}_ROOT_DIR) + + foreach (_${_PYTHON_PREFIX}_VERSION IN LISTS _${_PYTHON_PREFIX}_FIND_VERSIONS) + string (REPLACE "." "" _${_PYTHON_PREFIX}_VERSION_NO_DOTS ${_${_PYTHON_PREFIX}_VERSION}) + + # try to use pythonX.Y-config tool + set (_${_PYTHON_PREFIX}_CONFIG_NAMES) + if (DEFINED CMAKE_LIBRARY_ARCHITECTURE) + set (_${_PYTHON_PREFIX}_CONFIG_NAMES "${CMAKE_LIBRARY_ARCHITECTURE}-python${_${_PYTHON_PREFIX}_VERSION}-config") + endif() + list (APPEND _${_PYTHON_PREFIX}_CONFIG_NAMES "python${_${_PYTHON_PREFIX}_VERSION}-config") + find_program (_${_PYTHON_PREFIX}_CONFIG + NAMES ${_${_PYTHON_PREFIX}_CONFIG_NAMES} + NAMES_PER_DIR + HINTS ${_${_PYTHON_PREFIX}_HINTS} + PATH_SUFFIXES bin) + unset (_${_PYTHON_PREFIX}_CONFIG_NAMES) + + if (NOT _${_PYTHON_PREFIX}_CONFIG) + continue() + endif() + if (DEFINED CMAKE_LIBRARY_ARCHITECTURE) + # check that config tool match library architecture + execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --configdir + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_CONFIGDIR + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (_${_PYTHON_PREFIX}_RESULT) + unset (_${_PYTHON_PREFIX}_CONFIG CACHE) + continue() + endif() + string(FIND "${_${_PYTHON_PREFIX}_CONFIGDIR}" "${CMAKE_LIBRARY_ARCHITECTURE}" _${_PYTHON_PREFIX}_RESULT) + if (_${_PYTHON_PREFIX}_RESULT EQUAL -1) + unset (_${_PYTHON_PREFIX}_CONFIG CACHE) + continue() + endif() + endif() + + # retrieve root install directory + execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --prefix + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_PREFIX + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (_${_PYTHON_PREFIX}_RESULT) + # python-config is not usable + unset (_${_PYTHON_PREFIX}_CONFIG CACHE) + continue() + endif() + set (_${_PYTHON_PREFIX}_HINTS "${_${_PYTHON_PREFIX}_PREFIX}" "${${_PYTHON_PREFIX}_ROOT_DIR}" ENV ${_PYTHON_PREFIX}_ROOT_DIR) + + # retrieve library + execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --ldflags + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_FLAGS + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (NOT _${_PYTHON_PREFIX}_RESULT) + # retrieve library directory + string (REGEX MATCHALL "-L[^ ]+" _${_PYTHON_PREFIX}_LIB_DIRS "${_${_PYTHON_PREFIX}_FLAGS}") + string (REPLACE "-L" "" _${_PYTHON_PREFIX}_LIB_DIRS "${_${_PYTHON_PREFIX}_LIB_DIRS}") + list (REMOVE_DUPLICATES _${_PYTHON_PREFIX}_LIB_DIRS) + # retrieve library name + string (REGEX MATCHALL "-lpython[^ ]+" _${_PYTHON_PREFIX}_LIB_NAMES "${_${_PYTHON_PREFIX}_FLAGS}") + string (REPLACE "-l" "" _${_PYTHON_PREFIX}_LIB_NAMES "${_${_PYTHON_PREFIX}_LIB_NAMES}") + list (REMOVE_DUPLICATES _${_PYTHON_PREFIX}_LIB_NAMES) + + find_library (${_PYTHON_PREFIX}_LIBRARY_RELEASE + NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES} + NAMES_PER_DIR + HINTS ${_${_PYTHON_PREFIX}_HINTS} ${_${_PYTHON_PREFIX}_LIB_DIRS} + PATH_SUFFIXES lib + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + # retrieve runtime library + if (${_PYTHON_PREFIX}_LIBRARY_RELEASE) + get_filename_component (_${_PYTHON_PREFIX}_PATH "${${_PYTHON_PREFIX}_LIBRARY_RELEASE}" DIRECTORY) + get_filename_component (_${_PYTHON_PREFIX}_PATH2 "${_${_PYTHON_PREFIX}_PATH}" DIRECTORY) + _python_find_runtime_library (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE + NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES} + NAMES_PER_DIR + HINTS "${_${_PYTHON_PREFIX}_PATH}" "${_${_PYTHON_PREFIX}_PATH2}" ${_${_PYTHON_PREFIX}_HINTS} + PATH_SUFFIXES bin + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + endif() + + # retrieve include directory + execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --includes + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_FLAGS + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (NOT _${_PYTHON_PREFIX}_RESULT) + # retrieve include directory + string (REGEX MATCHALL "-I[^ ]+" _${_PYTHON_PREFIX}_INCLUDE_DIRS "${_${_PYTHON_PREFIX}_FLAGS}") + string (REPLACE "-I" "" _${_PYTHON_PREFIX}_INCLUDE_DIRS "${_${_PYTHON_PREFIX}_INCLUDE_DIRS}") + list (REMOVE_DUPLICATES _${_PYTHON_PREFIX}_INCLUDE_DIRS) + + find_path (${_PYTHON_PREFIX}_INCLUDE_DIR + NAMES Python.h + HINTS ${_${_PYTHON_PREFIX}_INCLUDE_DIRS} + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + + if (${_PYTHON_PREFIX}_LIBRARY_RELEASE AND ${_PYTHON_PREFIX}_INCLUDE_DIR) + break() + endif() + endforeach() + + # Rely on HINTS and standard paths if config tool failed to locate artifacts + if (NOT (${_PYTHON_PREFIX}_LIBRARY_RELEASE OR ${_PYTHON_PREFIX}_LIBRARY_DEBUG) OR NOT ${_PYTHON_PREFIX}_INCLUDE_DIR) + foreach (_${_PYTHON_PREFIX}_VERSION IN LISTS _${_PYTHON_PREFIX}_FIND_VERSIONS) + string (REPLACE "." "" _${_PYTHON_PREFIX}_VERSION_NO_DOTS ${_${_PYTHON_PREFIX}_VERSION}) + + _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS ${_${_PYTHON_PREFIX}_VERSION}) + + set (_${_PYTHON_PREFIX}_REGISTRY_PATHS + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_CURRENT_USER\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_${_PYTHON_PREFIX}_VERSION}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath]) + + if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST") + find_library (${_PYTHON_PREFIX}_LIBRARY_RELEASE + NAMES python${_${_PYTHON_PREFIX}_VERSION_NO_DOTS} + python${_${_PYTHON_PREFIX}_VERSION}mu + python${_${_PYTHON_PREFIX}_VERSION}m + python${_${_PYTHON_PREFIX}_VERSION}u + python${_${_PYTHON_PREFIX}_VERSION} + NAMES_PER_DIR + PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS} + PATH_SUFFIXES lib/${CMAKE_LIBRARY_ARCHITECTURE} lib libs + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}mu + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}m + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}u + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION} + lib/python${_${_PYTHON_PREFIX}_VERSION}/config + NO_CMAKE_PATH + NO_CMAKE_ENVIRONMENT_PATH + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + + if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST") + find_library (${_PYTHON_PREFIX}_LIBRARY_RELEASE + NAMES python${_${_PYTHON_PREFIX}_VERSION_NO_DOTS} + python${_${_PYTHON_PREFIX}_VERSION}mu + python${_${_PYTHON_PREFIX}_VERSION}m + python${_${_PYTHON_PREFIX}_VERSION}u + python${_${_PYTHON_PREFIX}_VERSION} + NAMES_PER_DIR + HINTS ${_${_PYTHON_PREFIX}_HINTS} + PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS} + PATH_SUFFIXES lib/${CMAKE_LIBRARY_ARCHITECTURE} lib libs + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}mu + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}m + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}u + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION} + lib/python${_${_PYTHON_PREFIX}_VERSION}/config + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + + # search in HINTS locations + find_library (${_PYTHON_PREFIX}_LIBRARY_RELEASE + NAMES python${_${_PYTHON_PREFIX}_VERSION_NO_DOTS} + python${_${_PYTHON_PREFIX}_VERSION}mu + python${_${_PYTHON_PREFIX}_VERSION}m + python${_${_PYTHON_PREFIX}_VERSION}u + python${_${_PYTHON_PREFIX}_VERSION} + NAMES_PER_DIR + HINTS ${_${_PYTHON_PREFIX}_HINTS} + PATH_SUFFIXES lib/${CMAKE_LIBRARY_ARCHITECTURE} lib libs + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}mu + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}m + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}u + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION} + lib/python${_${_PYTHON_PREFIX}_VERSION}/config + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + + if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST") + set (__${_PYTHON_PREFIX}_FRAMEWORK_PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}) + else() + unset (__${_PYTHON_PREFIX}_FRAMEWORK_PATHS) + endif() + + if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "LAST") + set (__${_PYTHON_PREFIX}_REGISTRY_PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}) + else() + unset (__${_PYTHON_PREFIX}_REGISTRY_PATHS) + endif() + + # search in all default paths + find_library (${_PYTHON_PREFIX}_LIBRARY_RELEASE + NAMES python${_${_PYTHON_PREFIX}_VERSION_NO_DOTS} + python${_${_PYTHON_PREFIX}_VERSION}mu + python${_${_PYTHON_PREFIX}_VERSION}m + python${_${_PYTHON_PREFIX}_VERSION}u + python${_${_PYTHON_PREFIX}_VERSION} + NAMES_PER_DIR + PATHS ${__${_PYTHON_PREFIX}_FRAMEWORK_PATHS} + ${__${_PYTHON_PREFIX}_REGISTRY_PATHS} + PATH_SUFFIXES lib/${CMAKE_LIBRARY_ARCHITECTURE} lib libs + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}mu + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}m + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION}u + lib/python${_${_PYTHON_PREFIX}_VERSION}/config-${_${_PYTHON_PREFIX}_VERSION} + lib/python${_${_PYTHON_PREFIX}_VERSION}/config) + # retrieve runtime library + if (${_PYTHON_PREFIX}_LIBRARY_RELEASE) + get_filename_component (_${_PYTHON_PREFIX}_PATH "${${_PYTHON_PREFIX}_LIBRARY_RELEASE}" DIRECTORY) + get_filename_component (_${_PYTHON_PREFIX}_PATH2 "${_${_PYTHON_PREFIX}_PATH}" DIRECTORY) + _python_find_runtime_library (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE + NAMES python${_${_PYTHON_PREFIX}_VERSION_NO_DOTS} + python${_${_PYTHON_PREFIX}_VERSION}mu + python${_${_PYTHON_PREFIX}_VERSION}m + python${_${_PYTHON_PREFIX}_VERSION}u + python${_${_PYTHON_PREFIX}_VERSION} + NAMES_PER_DIR + HINTS "${_${_PYTHON_PREFIX}_PATH}" "${_${_PYTHON_PREFIX}_PATH2}" ${_${_PYTHON_PREFIX}_HINTS} + PATH_SUFFIXES bin) + endif() + + if (WIN32) + # search for debug library + if (${_PYTHON_PREFIX}_LIBRARY_RELEASE) + # use library location as a hint + get_filename_component (_${_PYTHON_PREFIX}_PATH "${${_PYTHON_PREFIX}_LIBRARY_RELEASE}" DIRECTORY) + find_library (${_PYTHON_PREFIX}_LIBRARY_DEBUG + NAMES python${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}_d + NAMES_PER_DIR + HINTS "${_${_PYTHON_PREFIX}_PATH}" ${_${_PYTHON_PREFIX}_HINTS} + NO_DEFAULT_PATH) + else() + # search first in known locations + if (_${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST") + find_library (${_PYTHON_PREFIX}_LIBRARY_DEBUG + NAMES python${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}_d + NAMES_PER_DIR + HINTS ${_${_PYTHON_PREFIX}_HINTS} + PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS} + PATH_SUFFIXES lib libs + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + # search in all default paths + find_library (${_PYTHON_PREFIX}_LIBRARY_DEBUG + NAMES python${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}_d + NAMES_PER_DIR + HINTS ${_${_PYTHON_PREFIX}_HINTS} + PATHS ${__${_PYTHON_PREFIX}_REGISTRY_PATHS} + PATH_SUFFIXES lib libs) + endif() + if (${_PYTHON_PREFIX}_LIBRARY_DEBUG) + get_filename_component (_${_PYTHON_PREFIX}_PATH "${${_PYTHON_PREFIX}_LIBRARY_DEBUG}" DIRECTORY) + get_filename_component (_${_PYTHON_PREFIX}_PATH2 "${_${_PYTHON_PREFIX}_PATH}" DIRECTORY) + _python_find_runtime_library (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG + NAMES python${_${_PYTHON_PREFIX}_VERSION_NO_DOTS}_d + NAMES_PER_DIR + HINTS "${_${_PYTHON_PREFIX}_PATH}" "${_${_PYTHON_PREFIX}_PATH2}" ${_${_PYTHON_PREFIX}_HINTS} + PATH_SUFFIXES bin) + endif() + endif() + + # Don't search for include dir until library location is known + if (${_PYTHON_PREFIX}_LIBRARY_RELEASE OR ${_PYTHON_PREFIX}_LIBRARY_DEBUG) + unset (_${_PYTHON_PREFIX}_INCLUDE_HINTS) + + if (${_PYTHON_PREFIX}_EXECUTABLE) + # pick up include directory from configuration + execute_process (COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c + "import sys; import sysconfig; sys.stdout.write(sysconfig.get_path('include'))" + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_PATH + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (NOT _${_PYTHON_PREFIX}_RESULT) + file (TO_CMAKE_PATH "${_${_PYTHON_PREFIX}_PATH}" _${_PYTHON_PREFIX}_PATH) + list (APPEND _${_PYTHON_PREFIX}_INCLUDE_HINTS "${_${_PYTHON_PREFIX}_PATH}") + endif() + endif() + + foreach (_${_PYTHON_PREFIX}_LIB IN ITEMS ${_PYTHON_PREFIX}_LIBRARY_RELEASE ${_PYTHON_PREFIX}_LIBRARY_DEBUG) + if (${_${_PYTHON_PREFIX}_LIB}) + # Use the library's install prefix as a hint + if (${_${_PYTHON_PREFIX}_LIB} MATCHES "^(.+/Frameworks/Python.framework/Versions/[0-9.]+)") + list (APPEND _${_PYTHON_PREFIX}_INCLUDE_HINTS "${CMAKE_MATCH_1}") + elseif (${_${_PYTHON_PREFIX}_LIB} MATCHES "^(.+)/lib(64|32)?/python[0-9.]+/config") + list (APPEND _${_PYTHON_PREFIX}_INCLUDE_HINTS "${CMAKE_MATCH_1}") + elseif (DEFINED CMAKE_LIBRARY_ARCHITECTURE AND ${_${_PYTHON_PREFIX}_LIB} MATCHES "^(.+)/lib/${CMAKE_LIBRARY_ARCHITECTURE}") + list (APPEND _${_PYTHON_PREFIX}_INCLUDE_HINTS "${CMAKE_MATCH_1}") + else() + # assume library is in a directory under root + get_filename_component (_${_PYTHON_PREFIX}_PREFIX "${${_${_PYTHON_PREFIX}_LIB}}" DIRECTORY) + get_filename_component (_${_PYTHON_PREFIX}_PREFIX "${_${_PYTHON_PREFIX}_PREFIX}" DIRECTORY) + list (APPEND _${_PYTHON_PREFIX}_INCLUDE_HINTS "${_${_PYTHON_PREFIX}_PREFIX}") + endif() + endif() + endforeach() + list (REMOVE_DUPLICATES _${_PYTHON_PREFIX}_INCLUDE_HINTS) + + if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST") + find_path (${_PYTHON_PREFIX}_INCLUDE_DIR + NAMES Python.h + HINTS ${_${_PYTHON_PREFIX}_HINTS} + PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS} + PATH_SUFFIXES include/python${_${_PYTHON_PREFIX}_VERSION}mu + include/python${_${_PYTHON_PREFIX}_VERSION}m + include/python${_${_PYTHON_PREFIX}_VERSION}u + include/python${_${_PYTHON_PREFIX}_VERSION} + include + NO_CMAKE_PATH + NO_CMAKE_ENVIRONMENT_PATH + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + + if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST") + find_path (${_PYTHON_PREFIX}_INCLUDE_DIR + NAMES Python.h + HINTS ${_${_PYTHON_PREFIX}_INCLUDE_HINTS} ${_${_PYTHON_PREFIX}_HINTS} + PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS} + PATH_SUFFIXES include/python${_${_PYTHON_PREFIX}_VERSION}mu + include/python${_${_PYTHON_PREFIX}_VERSION}m + include/python${_${_PYTHON_PREFIX}_VERSION}u + include/python${_${_PYTHON_PREFIX}_VERSION} + include + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + + find_path (${_PYTHON_PREFIX}_INCLUDE_DIR + NAMES Python.h + HINTS ${_${_PYTHON_PREFIX}_INCLUDE_HINTS} ${_${_PYTHON_PREFIX}_HINTS} + PATHS ${__${_PYTHON_PREFIX}_FRAMEWORK_PATHS} + ${__${_PYTHON_PREFIX}_REGISTRY_PATHS} + PATH_SUFFIXES include/python${_${_PYTHON_PREFIX}_VERSION}mu + include/python${_${_PYTHON_PREFIX}_VERSION}m + include/python${_${_PYTHON_PREFIX}_VERSION}u + include/python${_${_PYTHON_PREFIX}_VERSION} + include + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH) + endif() + + if ((${_PYTHON_PREFIX}_LIBRARY_RELEASE OR ${_PYTHON_PREFIX}_LIBRARY_DEBUG) AND ${_PYTHON_PREFIX}_INCLUDE_DIR) + break() + endif() + endforeach() + + # search header file in standard locations + find_path (${_PYTHON_PREFIX}_INCLUDE_DIR + NAMES Python.h) + endif() + + if (${_PYTHON_PREFIX}_INCLUDE_DIR) + # retrieve version from header file + file (STRINGS "${${_PYTHON_PREFIX}_INCLUDE_DIR}/patchlevel.h" _${_PYTHON_PREFIX}_VERSION + REGEX "^#define[ \t]+PY_VERSION[ \t]+\"[^\"]+\"") + string (REGEX REPLACE "^#define[ \t]+PY_VERSION[ \t]+\"([^\"]+)\".*" "\\1" + _${_PYTHON_PREFIX}_VERSION "${_${_PYTHON_PREFIX}_VERSION}") + string (REGEX MATCHALL "[0-9]+" _${_PYTHON_PREFIX}_VERSIONS "${_${_PYTHON_PREFIX}_VERSION}") + list (GET _${_PYTHON_PREFIX}_VERSIONS 0 _${_PYTHON_PREFIX}_VERSION_MAJOR) + list (GET _${_PYTHON_PREFIX}_VERSIONS 1 _${_PYTHON_PREFIX}_VERSION_MINOR) + list (GET _${_PYTHON_PREFIX}_VERSIONS 2 _${_PYTHON_PREFIX}_VERSION_PATCH) + + if (NOT ${_PYTHON_PREFIX}_Interpreter_FOUND AND NOT ${_PYTHON_PREFIX}_Compiler_FOUND) + # set public version information + set (${_PYTHON_PREFIX}_VERSION ${_${_PYTHON_PREFIX}_VERSION}) + set (${_PYTHON_PREFIX}_VERSION_MAJOR ${_${_PYTHON_PREFIX}_VERSION_MAJOR}) + set (${_PYTHON_PREFIX}_VERSION_MINOR ${_${_PYTHON_PREFIX}_VERSION_MINOR}) + set (${_PYTHON_PREFIX}_VERSION_PATCH ${_${_PYTHON_PREFIX}_VERSION_PATCH}) + endif() + endif() + + # define public variables + include (SelectLibraryConfigurations) + select_library_configurations (${_PYTHON_PREFIX}) + if (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE) + set (${_PYTHON_PREFIX}_RUNTIME_LIBRARY "${${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE}") + elseif (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG) + set (${_PYTHON_PREFIX}_RUNTIME_LIBRARY "${${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG}") + else() + set (${_PYTHON_PREFIX}_RUNTIME_LIBRARY "$${_PYTHON_PREFIX}_RUNTIME_LIBRARY-NOTFOUND") + endif() + + _python_set_library_dirs (${_PYTHON_PREFIX}_LIBRARY_DIRS + ${_PYTHON_PREFIX}_LIBRARY_RELEASE ${_PYTHON_PREFIX}_LIBRARY_DEBUG) + if (UNIX) + if (${_PYTHON_PREFIX}_LIBRARY_RELEASE MATCHES "${CMAKE_SHARED_LIBRARY_SUFFIX}$" + OR ${_PYTHON_PREFIX}_LIBRARY_RELEASE MATCHES "${CMAKE_SHARED_LIBRARY_SUFFIX}$") + set (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DIRS ${${_PYTHON_PREFIX}_LIBRARY_DIRS}) + endif() + else() + _python_set_library_dirs (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DIRS + ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG) + endif() + + set (${_PYTHON_PREFIX}_INCLUDE_DIRS "${${_PYTHON_PREFIX}_INCLUDE_DIR}") + + mark_as_advanced (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE + ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG + ${_PYTHON_PREFIX}_INCLUDE_DIR) + + if ((${_PYTHON_PREFIX}_LIBRARY_RELEASE OR ${_PYTHON_PREFIX}_LIBRARY_DEBUG) + AND ${_PYTHON_PREFIX}_INCLUDE_DIR) + if (${_PYTHON_PREFIX}_Interpreter_FOUND OR ${_PYTHON_PREFIX}_Compiler_FOUND) + # development environment must be compatible with interpreter/compiler + if (${_${_PYTHON_PREFIX}_VERSION_MAJOR}.${_${_PYTHON_PREFIX}_VERSION_MINOR} VERSION_EQUAL ${${_PYTHON_PREFIX}_VERSION_MAJOR}.${${_PYTHON_PREFIX}_VERSION_MINOR}) + set (${_PYTHON_PREFIX}_Development_FOUND TRUE) + endif() + elseif (${_PYTHON_PREFIX}_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR) + set (${_PYTHON_PREFIX}_Development_FOUND TRUE) + endif() + endif() + + # Restore the original find library ordering + if (DEFINED _${_PYTHON_PREFIX}_CMAKE_FIND_LIBRARY_SUFFIXES) + set (CMAKE_FIND_LIBRARY_SUFFIXES ${_${_PYTHON_PREFIX}_CMAKE_FIND_LIBRARY_SUFFIXES}) + endif() +endif() + +if ("NumPy" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS AND ${_PYTHON_PREFIX}_Interpreter_FOUND) + list (APPEND _${_PYTHON_PREFIX}_CACHED_VARS ${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR) + if (${_PYTHON_PREFIX}_FIND_REQUIRED_NumPy) + list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR) + endif() + execute_process( + COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c + "from __future__ import print_function\ntry: import numpy; print(numpy.get_include(), end='')\nexcept:pass\n" + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_NumPy_PATH + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (NOT _${_PYTHON_PREFIX}_RESULT) + find_path(${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR + NAMES "numpy/arrayobject.h" "numpy/numpyconfig.h" + HINTS "${_${_PYTHON_PREFIX}_NumPy_PATH}" + NO_DEFAULT_PATH) + endif() + if(${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR) + set(${_PYTHON_PREFIX}_NumPy_INCLUDE_DIRS "${${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR}") + set(${_PYTHON_PREFIX}_NumPy_FOUND TRUE) + endif() + if(${_PYTHON_PREFIX}_NumPy_FOUND) + execute_process( + COMMAND "${${_PYTHON_PREFIX}_EXECUTABLE}" -c + "from __future__ import print_function\ntry: import numpy; print(numpy.__version__, end='')\nexcept:pass\n" + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_NumPy_VERSION) + if (NOT _${_PYTHON_PREFIX}_RESULT) + set(${_PYTHON_PREFIX}_NumPy_VERSION "${_${_PYTHON_PREFIX}_NumPy_VERSION}") + endif() + endif() + # final step: set NumPy founded only if Development component is founded as well + if (NOT ${_PYTHON_PREFIX}_Development_FOUND) + set(${_PYTHON_PREFIX}_NumPy_FOUND FALSE) + endif() +endif() + +# final validation +if (${_PYTHON_PREFIX}_VERSION_MAJOR AND + NOT ${_PYTHON_PREFIX}_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR) + _python_display_failure ("Could NOT find ${_PYTHON_PREFIX}: Found unsuitable major version \"${${_PYTHON_PREFIX}_VERSION_MAJOR}\", but required major version is exact version \"${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}\"") +endif() + +include (FindPackageHandleStandardArgs) +find_package_handle_standard_args (${_PYTHON_PREFIX} + REQUIRED_VARS ${_${_PYTHON_PREFIX}_REQUIRED_VARS} + VERSION_VAR ${_PYTHON_PREFIX}_VERSION + HANDLE_COMPONENTS) + +# Create imported targets and helper functions +if(_${_PYTHON_PREFIX}_CMAKE_ROLE STREQUAL "PROJECT") + if ("Interpreter" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS + AND ${_PYTHON_PREFIX}_Interpreter_FOUND + AND NOT TARGET ${_PYTHON_PREFIX}::Interpreter) + add_executable (${_PYTHON_PREFIX}::Interpreter IMPORTED) + set_property (TARGET ${_PYTHON_PREFIX}::Interpreter + PROPERTY IMPORTED_LOCATION "${${_PYTHON_PREFIX}_EXECUTABLE}") + endif() + + if ("Compiler" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS + AND ${_PYTHON_PREFIX}_Compiler_FOUND + AND NOT TARGET ${_PYTHON_PREFIX}::Compiler) + add_executable (${_PYTHON_PREFIX}::Compiler IMPORTED) + set_property (TARGET ${_PYTHON_PREFIX}::Compiler + PROPERTY IMPORTED_LOCATION "${${_PYTHON_PREFIX}_COMPILER}") + endif() + + if ("Development" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS + AND ${_PYTHON_PREFIX}_Development_FOUND AND NOT TARGET ${_PYTHON_PREFIX}::Python) + + if (${_PYTHON_PREFIX}_LIBRARY_RELEASE MATCHES "${CMAKE_SHARED_LIBRARY_SUFFIX}$" + OR ${_PYTHON_PREFIX}_LIBRARY_DEBUG MATCHES "${CMAKE_SHARED_LIBRARY_SUFFIX}$" + OR ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE OR ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG) + set (_${_PYTHON_PREFIX}_LIBRARY_TYPE SHARED) + else() + set (_${_PYTHON_PREFIX}_LIBRARY_TYPE STATIC) + endif() + + add_library (${_PYTHON_PREFIX}::Python ${_${_PYTHON_PREFIX}_LIBRARY_TYPE} IMPORTED) + + set_property (TARGET ${_PYTHON_PREFIX}::Python + PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${${_PYTHON_PREFIX}_INCLUDE_DIR}") + + if ((${_PYTHON_PREFIX}_LIBRARY_RELEASE AND ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE) + OR (${_PYTHON_PREFIX}_LIBRARY_DEBUG AND ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG)) + # System manage shared libraries in two parts: import and runtime + if (${_PYTHON_PREFIX}_LIBRARY_RELEASE AND ${_PYTHON_PREFIX}_LIBRARY_DEBUG) + set_property (TARGET ${_PYTHON_PREFIX}::Python PROPERTY IMPORTED_CONFIGURATIONS RELEASE DEBUG) + set_target_properties (${_PYTHON_PREFIX}::Python + PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C" + IMPORTED_IMPLIB_RELEASE "${${_PYTHON_PREFIX}_LIBRARY_RELEASE}" + IMPORTED_LOCATION_RELEASE "${${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE}") + set_target_properties (${_PYTHON_PREFIX}::Python + PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C" + IMPORTED_IMPLIB_DEBUG "${${_PYTHON_PREFIX}_LIBRARY_DEBUG}" + IMPORTED_LOCATION_DEBUG "${${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG}") + else() + set_target_properties (${_PYTHON_PREFIX}::Python + PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_IMPLIB "${${_PYTHON_PREFIX}_LIBRARY}" + IMPORTED_LOCATION "${${_PYTHON_PREFIX}_RUNTIME_LIBRARY}") + endif() + else() + if (${_PYTHON_PREFIX}_LIBRARY_RELEASE AND ${_PYTHON_PREFIX}_LIBRARY_DEBUG) + set_property (TARGET ${_PYTHON_PREFIX}::Python PROPERTY IMPORTED_CONFIGURATIONS RELEASE DEBUG) + set_target_properties (${_PYTHON_PREFIX}::Python + PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C" + IMPORTED_LOCATION_RELEASE "${${_PYTHON_PREFIX}_LIBRARY_RELEASE}") + set_target_properties (${_PYTHON_PREFIX}::Python + PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C" + IMPORTED_LOCATION_DEBUG "${${_PYTHON_PREFIX}_LIBRARY_DEBUG}") + else() + set_target_properties (${_PYTHON_PREFIX}::Python + PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${${_PYTHON_PREFIX}_LIBRARY}") + endif() + endif() + + if (_${_PYTHON_PREFIX}_CONFIG AND _${_PYTHON_PREFIX}_LIBRARY_TYPE STREQUAL "STATIC") + # extend link information with dependent libraries + execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --ldflags + RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT + OUTPUT_VARIABLE _${_PYTHON_PREFIX}_FLAGS + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if (NOT _${_PYTHON_PREFIX}_RESULT) + string (REGEX MATCHALL "-[Ll][^ ]+" _${_PYTHON_PREFIX}_LINK_LIBRARIES "${_${_PYTHON_PREFIX}_FLAGS}") + # remove elements relative to python library itself + list (FILTER _${_PYTHON_PREFIX}_LINK_LIBRARIES EXCLUDE REGEX "-lpython") + foreach (_${_PYTHON_PREFIX}_DIR IN LISTS ${_PYTHON_PREFIX}_LIBRARY_DIRS) + list (FILTER _${_PYTHON_PREFIX}_LINK_LIBRARIES EXCLUDE REGEX "-L${${_PYTHON_PREFIX}_DIR}") + endforeach() + set_property (TARGET ${_PYTHON_PREFIX}::Python + PROPERTY INTERFACE_LINK_LIBRARIES ${_${_PYTHON_PREFIX}_LINK_LIBRARIES}) + endif() + endif() + + # + # PYTHON_ADD_LIBRARY (<name> [STATIC|SHARED|MODULE] src1 src2 ... srcN) + # It is used to build modules for python. + # + function (__${_PYTHON_PREFIX}_ADD_LIBRARY prefix name) + cmake_parse_arguments (PARSE_ARGV 2 PYTHON_ADD_LIBRARY + "STATIC;SHARED;MODULE" "" "") + + unset (type) + if (NOT (PYTHON_ADD_LIBRARY_STATIC + OR PYTHON_ADD_LIBRARY_SHARED + OR PYTHON_ADD_LIBRARY_MODULE)) + set (type MODULE) + endif() + add_library (${name} ${type} ${ARGN}) + target_link_libraries (${name} PRIVATE ${prefix}::Python) + + # customize library name to follow module name rules + get_property (type TARGET ${name} PROPERTY TYPE) + if (type STREQUAL "MODULE_LIBRARY") + set_property (TARGET ${name} PROPERTY PREFIX "") + if(CMAKE_SYSTEM_NAME STREQUAL "Windows") + set_property (TARGET ${name} PROPERTY SUFFIX ".pyd") + endif() + endif() + endfunction() + endif() + + if ("NumPy" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS AND ${_PYTHON_PREFIX}_NumPy_FOUND + AND NOT TARGET ${_PYTHON_PREFIX}::NumPy AND TARGET ${_PYTHON_PREFIX}::Python) + add_library (${_PYTHON_PREFIX}::NumPy INTERFACE IMPORTED) + set_property (TARGET ${_PYTHON_PREFIX}::NumPy + PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR}") + target_link_libraries (${_PYTHON_PREFIX}::NumPy INTERFACE ${_PYTHON_PREFIX}::Python) + endif() +endif() + +# final clean-up + +# Restore CMAKE_FIND_APPBUNDLE +if (DEFINED _${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE) + set (CMAKE_FIND_APPBUNDLE ${_${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE}) + unset (_${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE) +else() + unset (CMAKE_FIND_APPBUNDLE) +endif() +# Restore CMAKE_FIND_FRAMEWORK +if (DEFINED _${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK) + set (CMAKE_FIND_FRAMEWORK ${_${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK}) + unset (_${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK) +else() + unset (CMAKE_FIND_FRAMEWORK) +endif() + +unset (_${_PYTHON_PREFIX}_CONFIG CACHE) diff --git a/cmake/modules/FindPython3.cmake b/cmake/modules/FindPython3.cmake new file mode 100644 index 000000000..c2f338469 --- /dev/null +++ b/cmake/modules/FindPython3.cmake @@ -0,0 +1,189 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindPython3 +----------- + +Find Python 3 interpreter, compiler and development environment (include +directories and libraries). + +Three components are supported: + +* ``Interpreter``: search for Python 3 interpreter +* ``Compiler``: search for Python 3 compiler. Only offered by IronPython. +* ``Development``: search for development artifacts (include directories and + libraries) +* ``NumPy``: search for NumPy include directories. + +If no ``COMPONENTS`` is specified, ``Interpreter`` is assumed. + +To ensure consistent versions between components ``Interpreter``, ``Compiler``, +``Development`` and ``NumPy``, specify all components at the same time:: + + find_package (Python3 COMPONENTS Interpreter Development) + +This module looks only for version 3 of Python. This module can be used +concurrently with :module:`FindPython2` module to use both Python versions. + +The :module:`FindPython` module can be used if Python version does not matter +for you. + +.. note:: + + If components ``Interpreter`` and ``Development`` are both specified, this + module search only for interpreter with same platform architecture as the one + defined by ``CMake`` configuration. This contraint does not apply if only + ``Interpreter`` component is specified. + +Imported Targets +^^^^^^^^^^^^^^^^ + +This module defines the following :ref:`Imported Targets <Imported Targets>` +(when :prop_gbl:`CMAKE_ROLE` is ``PROJECT``): + +``Python3::Interpreter`` + Python 3 interpreter. Target defined if component ``Interpreter`` is found. +``Python3::Compiler`` + Python 3 compiler. Target defined if component ``Compiler`` is found. +``Python3::Python`` + Python 3 library. Target defined if component ``Development`` is found. +``Python3::NumPy`` + NumPy library for Python 3. Target defined if component ``NumPy`` is found. + +Result Variables +^^^^^^^^^^^^^^^^ + +This module will set the following variables in your project +(see :ref:`Standard Variable Names <CMake Developer Standard Variable Names>`): + +``Python3_FOUND`` + System has the Python 3 requested components. +``Python3_Interpreter_FOUND`` + System has the Python 3 interpreter. +``Python3_EXECUTABLE`` + Path to the Python 3 interpreter. +``Python3_INTERPRETER_ID`` + A short string unique to the interpreter. Possible values include: + * Python + * ActivePython + * Anaconda + * Canopy + * IronPython +``Python3_STDLIB`` + Standard platform independent installation directory. + + Information returned by + ``distutils.sysconfig.get_python_lib(plat_specific=False,standard_lib=True)``. +``Python3_STDARCH`` + Standard platform dependent installation directory. + + Information returned by + ``distutils.sysconfig.get_python_lib(plat_specific=True,standard_lib=True)``. +``Python3_SITELIB`` + Third-party platform independent installation directory. + + Information returned by + ``distutils.sysconfig.get_python_lib(plat_specific=False,standard_lib=False)``. +``Python3_SITEARCH`` + Third-party platform dependent installation directory. + + Information returned by + ``distutils.sysconfig.get_python_lib(plat_specific=True,standard_lib=False)``. +``Python3_Compiler_FOUND`` + System has the Python 3 compiler. +``Python3_COMPILER`` + Path to the Python 3 compiler. Only offered by IronPython. +``Python3_COMPILER_ID`` + A short string unique to the compiler. Possible values include: + * IronPython +``Python3_Development_FOUND`` + System has the Python 3 development artifacts. +``Python3_INCLUDE_DIRS`` + The Python 3 include directories. +``Python3_LIBRARIES`` + The Python 3 libraries. +``Python3_LIBRARY_DIRS`` + The Python 3 library directories. +``Python3_RUNTIME_LIBRARY_DIRS`` + The Python 3 runtime library directories. +``Python3_VERSION`` + Python 3 version. +``Python3_VERSION_MAJOR`` + Python 3 major version. +``Python3_VERSION_MINOR`` + Python 3 minor version. +``Python3_VERSION_PATCH`` + Python 3 patch version. +``Python3_NumPy_FOUND`` + System has the NumPy. +``Python3_NumPy_INCLUDE_DIRS`` + The NumPy include directries. +``Python3_NumPy_VERSION`` + The NumPy version. + +Hints +^^^^^ + +``Python3_ROOT_DIR`` + Define the root directory of a Python 3 installation. + +``Python3_USE_STATIC_LIBS`` + * If not defined, search for shared libraries and static libraries in that + order. + * If set to TRUE, search **only** for static libraries. + * If set to FALSE, search **only** for shared libraries. + +``Python3_FIND_REGISTRY`` + On Windows the ``Python3_FIND_REGISTRY`` variable determine the order + of preference between registry and environment variables. + the ``Python3_FIND_REGISTRY`` variable can be set to empty or one of the + following: + + * ``FIRST``: Try to use registry before environment variables. + This is the default. + * ``LAST``: Try to use registry after environment variables. + * ``NEVER``: Never try to use registry. + +``CMAKE_FIND_FRAMEWORK`` + On OS X the :variable:`CMAKE_FIND_FRAMEWORK` variable determine the order of + preference between Apple-style and unix-style package components. + + .. note:: + + Value ``ONLY`` is not supported so ``FIRST`` will be used instead. + +.. note:: + + If a Python virtual environment is configured, set variable + ``Python_FIND_REGISTRY`` (Windows) or ``CMAKE_FIND_FRAMEWORK`` (macOS) with + value ``LAST`` or ``NEVER`` to select it preferably. + +Commands +^^^^^^^^ + +This module defines the command ``Python3_add_library`` (when +:prop_gbl:`CMAKE_ROLE` is ``PROJECT``), which has the same semantics as +:command:`add_library`, but takes care of Python module naming rules +(only applied if library is of type ``MODULE``), and adds a dependency to target +``Python3::Python``:: + + Python3_add_library (my_module MODULE src1.cpp) + +If library type is not specified, ``MODULE`` is assumed. +#]=======================================================================] + + +set (_PYTHON_PREFIX Python3) + +set (_Python3_REQUIRED_VERSION_MAJOR 3) + +include (${CMAKE_CURRENT_LIST_DIR}/FindPython/Support.cmake) + +if (COMMAND __Python3_add_library) + macro (Python3_add_library) + __Python3_add_library (Python3 ${ARGV}) + endmacro() +endif() + +unset (_PYTHON_PREFIX) diff --git a/cmake/modules/FindRDKafka.cmake b/cmake/modules/FindRDKafka.cmake new file mode 100644 index 000000000..78f7d825c --- /dev/null +++ b/cmake/modules/FindRDKafka.cmake @@ -0,0 +1,33 @@ +find_package(PkgConfig QUIET) + +pkg_search_module(PC_rdkafka + rdkafka) + +find_path(rdkafka_INCLUDE_DIR + NAMES librdkafka/rdkafka.h + PATHS ${PC_rdkafka_INCLUDE_DIRS}) + +find_library(rdkafka_LIBRARY + NAMES rdkafka + PATHS ${PC_rdkafka_LIBRARY_DIRS}) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(RDKafka + REQUIRED_VARS rdkafka_INCLUDE_DIR rdkafka_LIBRARY + VERSION_VAR PC_rdkafka_VERSION) + +if(RDKafka_FOUND) + set(RDKafka_VERSION ${PC_rdkafka_VERSION}) + string(REPLACE "." ";" version_list ${PC_rdkafka_VERSION}) + list(GET version_list 0 RDKafka_VERSION_MAJOR) + list(GET version_list 1 RDKafka_VERSION_MINOR) + list(GET version_list 2 RDKafka_VERSION_PATCH) + + if(NOT TARGET RDKafka::RDKafka) + add_library(RDKafka::RDKafka UNKNOWN IMPORTED) + set_target_properties(RDKafka::RDKafka PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${rdkafka_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${rdkafka_LIBRARY}") + endif() +endif() diff --git a/cmake/modules/FindRabbitMQ.cmake b/cmake/modules/FindRabbitMQ.cmake new file mode 100644 index 000000000..93aa8204b --- /dev/null +++ b/cmake/modules/FindRabbitMQ.cmake @@ -0,0 +1,19 @@ +find_path(rabbitmq_INCLUDE_DIR + NAMES amqp.h) + +find_library(rabbitmq_LIBRARY + NAMES rabbitmq) + +include(FindPackageHandleStandardArgs) + +find_package_handle_standard_args(RabbitMQ DEFAULT_MSG + rabbitmq_INCLUDE_DIR + rabbitmq_LIBRARY) + +if(RabbitMQ_FOUND AND NOT (TARGET RabbitMQ::RabbitMQ)) + add_library(RabbitMQ::RabbitMQ UNKNOWN IMPORTED) + set_target_properties(RabbitMQ::RabbitMQ PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${rabbitmq_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${rabbitmq_LIBRARY}") +endif() diff --git a/cmake/modules/FindRocksDB.cmake b/cmake/modules/FindRocksDB.cmake new file mode 100644 index 000000000..c5dd3dfaf --- /dev/null +++ b/cmake/modules/FindRocksDB.cmake @@ -0,0 +1,47 @@ +# Find the native Rocksdb includes and library +# This module defines +# ROCKSDB_INCLUDE_DIR, where to find rocksdb/db.h, Set when +# ROCKSDB_INCLUDE_DIR is found. +# ROCKSDB_LIBRARIES, libraries to link against to use Rocksdb. +# ROCKSDB_FOUND, If false, do not try to use Rocksdb. +# ROCKSDB_VERSION_STRING +# ROCKSDB_VERSION_MAJOR +# ROCKSDB_VERSION_MINOR +# ROCKSDB_VERSION_PATCH + +find_path(ROCKSDB_INCLUDE_DIR rocksdb/db.h) + +find_library(ROCKSDB_LIBRARIES rocksdb) + +if(ROCKSDB_INCLUDE_DIR AND EXISTS "${ROCKSDB_INCLUDE_DIR}/rocksdb/version.h") + foreach(ver "MAJOR" "MINOR" "PATCH") + file(STRINGS "${ROCKSDB_INCLUDE_DIR}/rocksdb/version.h" ROCKSDB_VER_${ver}_LINE + REGEX "^#define[ \t]+ROCKSDB_${ver}[ \t]+[0-9]+$") + string(REGEX REPLACE "^#define[ \t]+ROCKSDB_${ver}[ \t]+([0-9]+)$" + "\\1" ROCKSDB_VERSION_${ver} "${ROCKSDB_VER_${ver}_LINE}") + unset(${ROCKSDB_VER_${ver}_LINE}) + endforeach() + set(ROCKSDB_VERSION_STRING + "${ROCKSDB_VERSION_MAJOR}.${ROCKSDB_VERSION_MINOR}.${ROCKSDB_VERSION_PATCH}") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(RocksDB + REQUIRED_VARS ROCKSDB_LIBRARIES ROCKSDB_INCLUDE_DIR + VERSION_VAR ROCKSDB_VERSION_STRING) + +mark_as_advanced( + ROCKSDB_INCLUDE_DIR + ROCKSDB_LIBRARIES) + +if(RocksDB_FOUND) + if(NOT TARGET RocksDB::RocksDB) + add_library(RocksDB::RocksDB UNKNOWN IMPORTED) + set_target_properties(RocksDB::RocksDB PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${ROCKSDB_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LOCATION "${ROCKSDB_LIBRARIES}" + VERSION "${ROCKSDB_VERSION_STRING}") + endif() +endif() + diff --git a/cmake/modules/FindSQLite3.cmake b/cmake/modules/FindSQLite3.cmake new file mode 100644 index 000000000..33e54d9e0 --- /dev/null +++ b/cmake/modules/FindSQLite3.cmake @@ -0,0 +1,12 @@ +find_path(SQLite3_INCLUDE_DIR NAMES sqlite3.h) +find_library(SQLite3_LIBRARY NAMES sqlite3 sqlite) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(SQLite3 DEFAULT_MSG SQLite3_LIBRARY SQLite3_INCLUDE_DIR) + +if(NOT TARGET SQLite3::SQLite3) + add_library(SQLite3::SQLite3 UNKNOWN IMPORTED) + set_target_properties(SQLite3::SQLite3 PROPERTIES + IMPORTED_LOCATION "${SQLite3_LIBRARY}" + INTERFACE_INCLUDE_DIRECTORIES "${SQLite3_INCLUDE_DIR}") +endif() diff --git a/cmake/modules/FindSanitizers.cmake b/cmake/modules/FindSanitizers.cmake new file mode 100644 index 000000000..fafd48124 --- /dev/null +++ b/cmake/modules/FindSanitizers.cmake @@ -0,0 +1,80 @@ +if(NOT Sanitizers_FIND_COMPONENTS) + set(Sanitizers_FIND_COMPONENTS + address undefined_behavior) +endif() +if(HAVE_JEMALLOC) + message(WARNING "JeMalloc does not work well with sanitizers") +endif() + +set(Sanitizers_COMPILE_OPTIONS) + +foreach(component ${Sanitizers_FIND_COMPONENTS}) + if(component STREQUAL "address") + set(Sanitizers_address_COMPILE_OPTIONS "-fsanitize=address") + elseif(component STREQUAL "leak") + set(Sanitizers_leak_COMPILE_OPTIONS "-fsanitize=leak") + elseif(component STREQUAL "thread") + if ("address" IN_LIST ${Sanitizers_FIND_COMPONENTS} OR + "leak" IN_LIST ${Sanitizers_FIND_COMPONENTS}) + message(SEND_ERROR "Cannot combine -fsanitize-leak w/ -fsanitize-thread") + elseif(NOT CMAKE_POSITION_INDEPENDENT_CODE) + message(SEND_ERROR "TSan requires all code to be position independent") + endif() + set(Sanitizers_thread_COMPILE_OPTIONS "-fsanitize=thread") + elseif(component STREQUAL "undefined_behavior") + # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=88684 + set(Sanitizers_undefined_behavior_COMPILE_OPTIONS "-fsanitize=undefined;-fno-sanitize=vptr") + else() + message(SEND_ERROR "Unsupported sanitizer: ${component}") + endif() + list(APPEND Sanitizers_COMPILE_OPTIONS "${Sanitizers_${component}_COMPILE_OPTIONS}") +endforeach() + +if(Sanitizers_address_COMPILE_OPTIONS OR Sanitizers_leak_COMPILE_OPTIONS) + # ASAN_LIBRARY will be read by ceph.in to preload the asan library + find_library(ASAN_LIBRARY + NAMES + libasan.so.5 + libasan.so.4 + libasan.so.3) +endif() + +if(Sanitizers_COMPILE_OPTIONS) + list(APPEND Sanitizers_COMPILE_OPTIONS + "-fno-omit-frame-pointer") +endif() + +include(CheckCXXSourceCompiles) +include(CMakePushCheckState) + +cmake_push_check_state() +string (REPLACE ";" " " CMAKE_REQUIRED_FLAGS "${Sanitizers_COMPILE_OPTIONS}") +set(CMAKE_REQUIRED_LIBRARIES ${Sanitizers_COMPILE_OPTIONS}) +check_cxx_source_compiles("int main() {}" + Sanitizers_ARE_SUPPORTED) +cmake_pop_check_state() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Sanitizers + REQUIRED_VARS + Sanitizers_COMPILE_OPTIONS + Sanitizers_ARE_SUPPORTED) + +if(Sanitizers_FOUND) + if(NOT TARGET Sanitizers::Sanitizers) + add_library(Sanitizers::Sanitizers INTERFACE IMPORTED) + set_target_properties(Sanitizers::Sanitizers PROPERTIES + INTERFACE_COMPILE_OPTIONS "${Sanitizers_COMPILE_OPTIONS}" + INTERFACE_LINK_LIBRARIES "${Sanitizers_COMPILE_OPTIONS}") + endif() + foreach(component ${Sanitizers_FIND_COMPONENTS}) + if(NOT TARGET Sanitizers::${component}) + set(target Sanitizers::${component}) + set(compile_option "${Sanitizers_${component}_COMPILE_OPTIONS}") + add_library(${target} INTERFACE IMPORTED) + set_target_properties(${target} PROPERTIES + INTERFACE_COMPILE_OPTIONS "${compile_option}" + INTERFACE_LINK_LIBRARIES "${compile_option}") + endif() + endforeach() +endif() diff --git a/cmake/modules/FindStdFilesystem.cmake b/cmake/modules/FindStdFilesystem.cmake new file mode 100644 index 000000000..5d3336571 --- /dev/null +++ b/cmake/modules/FindStdFilesystem.cmake @@ -0,0 +1,57 @@ +set(_std_filesystem_test_src + ${CMAKE_CURRENT_LIST_DIR}/FindStdFilesystem_test.cc) + +macro(try_std_filesystem_library _library _result _already_included) + set(_std_filesystem_try_compile_arg + CXX_STANDARD 17) + if(NOT _library STREQUAL "") + list(APPEND _std_filesystem_try_compile_arg + LINK_LIBRARIES ${_library}) + endif() + try_compile(_std_filesystem_compiles + ${CMAKE_CURRENT_BINARY_DIR} + SOURCES ${_std_filesystem_test_src} + ${_std_filesystem_try_compile_arg}) + unset(_std_filesystem_try_compile_arg) + if(_std_filesystem_compiles) + if(NOT _library STREQUAL "") + set(${_result} ${_library}) + else() + set(${_already_included} "included by standard library") + endif() + endif() + unset(_std_filesystem_compiles) +endmacro() + +set(_std_filesystem_required_var "StdFilesystem_LIBRARY") +set(_std_filesystem_already_included FALSE) +foreach(library + "" + "stdc++fs" + "c++experimental" + "c++fs") + try_std_filesystem_library("${library}" StdFilesystem_LIBRARY _std_filesystem_already_included) + if(_std_filesystem_already_included) + set(_std_filesystem_required_var "_std_filesystem_already_included") + break() + elseif(StdFilesystem_LIBRARY) + break() + endif() +endforeach() + +unset(_std_filesystem_test_src) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(StdFilesystem + FOUND_VAR StdFilesystem_FOUND + REQUIRED_VARS ${_std_filesystem_required_var}) + +mark_as_advanced(StdFilesystem_LIBRARY) + +if(StdFilesystem_FOUND AND NOT (TARGET StdFilesystem::filesystem)) + add_library(StdFilesystem::filesystem INTERFACE IMPORTED) + if(StdFilesystem_LIBRARY) + set_target_properties(StdFilesystem::filesystem PROPERTIES + INTERFACE_LINK_LIBRARIES ${StdFilesystem_LIBRARY}) + endif() +endif() diff --git a/cmake/modules/FindStdFilesystem_test.cc b/cmake/modules/FindStdFilesystem_test.cc new file mode 100644 index 000000000..8b308fff4 --- /dev/null +++ b/cmake/modules/FindStdFilesystem_test.cc @@ -0,0 +1,14 @@ +#if __has_include(<filesystem>) +#include <filesystem> +namespace fs = std::filesystem; +#elif __has_include(<experimental/filesystem>) +#include <experimental/filesystem> +namespace fs = std::experimental::filesystem; +#else +#error std::filesystem not available! +#endif + +int main() { + fs::create_directory("sandbox"); + fs::remove_all("sandbox"); +} diff --git a/cmake/modules/Findaio.cmake b/cmake/modules/Findaio.cmake new file mode 100644 index 000000000..04b064297 --- /dev/null +++ b/cmake/modules/Findaio.cmake @@ -0,0 +1,18 @@ +# - Find AIO +# +# AIO_INCLUDE - Where to find libaio.h +# AIO_LIBS - List of libraries when using AIO. +# AIO_FOUND - True if AIO found. + +find_path(AIO_INCLUDE_DIR + libaio.h + HINTS $ENV{AIO_ROOT}/include) + +find_library(AIO_LIBRARIES + aio + HINTS $ENV{AIO_ROOT}/lib) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(aio DEFAULT_MSG AIO_LIBRARIES AIO_INCLUDE_DIR) + +mark_as_advanced(AIO_INCLUDE_DIR AIO_LIBRARIES) diff --git a/cmake/modules/Findbabeltrace.cmake b/cmake/modules/Findbabeltrace.cmake new file mode 100644 index 000000000..6b29a246b --- /dev/null +++ b/cmake/modules/Findbabeltrace.cmake @@ -0,0 +1,22 @@ +# - Find Babeltrace +# This module defines the following variables: +# BABELTRACE_FOUND = Was Babeltrace found or not? +# BABELTRACE_EXECUTABLE = The path to lttng command +# BABELTRACE_LIBRARIES = The list of libraries to link to when using Babeltrace +# BABELTRACE_INCLUDE_DIR = The path to Babeltrace include directory +# + +find_path(BABELTRACE_INCLUDE_DIR + NAMES babeltrace/babeltrace.h babeltrace/ctf/events.h babeltrace/ctf/iterator.h) + +find_library(BABELTRACE_LIBRARY + NAMES babeltrace babeltrace-ctf) + +find_program(BABELTRACE_EXECUTABLE + NAMES babeltrace babeltrace-ctf) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(babeltrace DEFAULT_MSG + BABELTRACE_INCLUDE_DIR BABELTRACE_LIBRARY) +set(BABELTRACE_LIBRARIES ${BABELTRACE_LIBRARY}) +mark_as_advanced(BABELTRACE_INCLUDE_DIR BABELTRACE_LIBRARY) diff --git a/cmake/modules/Findblkid.cmake b/cmake/modules/Findblkid.cmake new file mode 100644 index 000000000..66de92f63 --- /dev/null +++ b/cmake/modules/Findblkid.cmake @@ -0,0 +1,33 @@ +# Copyright (C) 2007-2012 Hypertable, Inc. +# +# This file is part of Hypertable. +# +# Hypertable is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 3 +# of the License, or any later version. +# +# Hypertable is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Hypertable. If not, see <http://www.gnu.org/licenses/> +# + +# - Find libblkid +# Find the blkid library and includes +# +# BLKID_INCLUDE_DIR - where to find blkid.h, etc. +# BLKID_LIBRARIES - List of libraries when using blkid. +# BLKID_FOUND - True if blkid found. + +find_path(BLKID_INCLUDE_DIR blkid/blkid.h) + +find_library(BLKID_LIBRARIES blkid) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(blkid DEFAULT_MSG BLKID_LIBRARIES BLKID_INCLUDE_DIR) + +mark_as_advanced(BLKID_LIBRARIES BLKID_INCLUDE_DIR) diff --git a/cmake/modules/Findc-ares.cmake b/cmake/modules/Findc-ares.cmake new file mode 100644 index 000000000..6386f9ace --- /dev/null +++ b/cmake/modules/Findc-ares.cmake @@ -0,0 +1,30 @@ +find_package(PkgConfig QUIET) + +pkg_search_module(PC_cares + libcares) + +find_path(c-ares_INCLUDE_DIR + NAMES ares_dns.h + PATHS ${PC_cares_INCLUDE_DIRS}) + +find_library(c-ares_LIBRARY + NAMES cares + PATHS ${PC_cares_LIBRARY_DIRS}) + +set(c-ares_VERSION ${PC_cares_VERSION}) + +include(FindPackageHandleStandardArgs) + +find_package_handle_standard_args(c-ares + REQUIRED_VARS + c-ares_INCLUDE_DIR + c-ares_LIBRARY + VERSION_VAR c-ares_VERSION) + +if(c-ares_FOUND AND NOT (TARGET c-ares::c-ares)) + add_library(c-ares::c-ares UNKNOWN IMPORTED) + set_target_properties(c-ares::c-ares PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${c-ares_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${c-ares_LIBRARY}") +endif() diff --git a/cmake/modules/Finddpdk.cmake b/cmake/modules/Finddpdk.cmake new file mode 100644 index 000000000..f7b7a2d4b --- /dev/null +++ b/cmake/modules/Finddpdk.cmake @@ -0,0 +1,142 @@ +# Try to find dpdk +# +# Once done, this will define +# +# dpdk::dpdk +# dpdk_FOUND +# dpdk_INCLUDE_DIR +# dpdk_LIBRARIES + +find_package(PkgConfig QUIET) +if(PKG_CONFIG_FOUND) + pkg_check_modules(dpdk QUIET libdpdk) +endif() + +if(dpdk_INCLUDE_DIRS) + # good +elseif(TARGET dpdk::dpdk) + get_target_property(dpdk_INCLUDE_DIRS + dpdk::dpdk INTERFACE_INCLUDE_DIRECTORIES) +else() + find_path(dpdk_config_INCLUDE_DIR rte_config.h + HINTS + ENV DPDK_DIR + PATH_SUFFIXES + dpdk + include) + find_path(dpdk_common_INCLUDE_DIR rte_common.h + HINTS + ENC DPDK_DIR + PATH_SUFFIXES + dpdk + include) + set(dpdk_INCLUDE_DIRS "${dpdk_config_INCLUDE_DIR}") + if(NOT dpdk_config_INCLUDE_DIR EQUAL dpdk_common_INCLUDE_DIR) + list(APPEND dpdk_INCLUDE_DIRS "${dpdk_common_INCLUDE_DIR}") + endif() +endif() + +set(components + bus_pci + bus_vdev + cfgfile + cmdline + eal + ethdev + hash + kvargs + mbuf + mempool + mempool_ring + mempool_stack + net + pci + pmd_af_packet + pmd_bnxt + pmd_bond + pmd_cxgbe + pmd_e1000 + pmd_ena + pmd_enic + pmd_i40e + pmd_ixgbe + pmd_mlx5 + pmd_nfp + pmd_qede + pmd_ring + pmd_sfc_efx + pmd_vmxnet3_uio + ring + timer) + +# for collecting dpdk library targets, it will be used when defining dpdk::dpdk +set(_dpdk_libs) +# for list of dpdk library archive paths +set(dpdk_LIBRARIES) + +foreach(c ${components}) + set(dpdk_lib dpdk::${c}) + if(TARGET ${dpdk_lib}) + get_target_property(DPDK_rte_${c}_LIBRARY + ${dpdk_lib} IMPORTED_LOCATION) + else() + find_library(DPDK_rte_${c}_LIBRARY rte_${c} + HINTS + ENV DPDK_DIR + ${dpdk_LIBRARY_DIRS} + PATH_SUFFIXES lib) + endif() + if(DPDK_rte_${c}_LIBRARY) + if (NOT TARGET ${dpdk_lib}) + add_library(${dpdk_lib} UNKNOWN IMPORTED) + set_target_properties(${dpdk_lib} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${dpdk_INCLUDE_DIRS}" + IMPORTED_LOCATION "${DPDK_rte_${c}_LIBRARY}") + if(c STREQUAL pmd_mlx5) + find_package(verbs QUIET) + if(verbs_FOUND) + target_link_libraries(${dpdk_lib} INTERFACE IBVerbs::verbs) + endif() + endif() + endif() + list(APPEND _dpdk_libs ${dpdk_lib}) + list(APPEND dpdk_LIBRARIES ${DPDK_rte_${c}_LIBRARY}) + endif() +endforeach() + +mark_as_advanced(dpdk_INCLUDE_DIRS ${dpdk_LIBRARIES}) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(dpdk DEFAULT_MSG + dpdk_INCLUDE_DIRS + dpdk_LIBRARIES) + +if(dpdk_FOUND) + if(NOT TARGET dpdk::cflags) + if(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|AMD64") + set(rte_cflags "-march=core2") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM") + set(rte_cflags "-march=armv7-a") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|AARCH64") + set(rte_cflags "-march=armv8-a+crc") + endif() + add_library(dpdk::cflags INTERFACE IMPORTED) + if (rte_cflags) + set_target_properties(dpdk::cflags PROPERTIES + INTERFACE_COMPILE_OPTIONS "${rte_cflags}") + endif() + endif() + + if(NOT TARGET dpdk::dpdk) + add_library(dpdk::dpdk INTERFACE IMPORTED) + find_package(Threads QUIET) + list(APPEND _dpdk_libs + Threads::Threads + dpdk::cflags) + set_target_properties(dpdk::dpdk PROPERTIES + INTERFACE_LINK_LIBRARIES "${_dpdk_libs}" + INTERFACE_INCLUDE_DIRECTORIES "${dpdk_INCLUDE_DIRS}") + endif() +endif() + +unset(_dpdk_libs) diff --git a/cmake/modules/Findfcgi.cmake b/cmake/modules/Findfcgi.cmake new file mode 100644 index 000000000..d4e3c199c --- /dev/null +++ b/cmake/modules/Findfcgi.cmake @@ -0,0 +1,20 @@ +# CMake module to search for FastCGI headers +# +# If it's found it sets FCGI_FOUND to TRUE +# and following variables are set: +# FCGI_INCLUDE_DIR +# FCGI_LIBRARY +find_path(FCGI_INCLUDE_DIR + fcgio.h + PATHS + /usr/include + /usr/local/include + /usr/include/fastcgi) +find_library(FCGI_LIBRARY NAMES fcgi libfcgi PATHS + /usr/local/lib + /usr/lib) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(fcgi DEFAULT_MSG FCGI_LIBRARY FCGI_INCLUDE_DIR) + +mark_as_advanced(FCGI_LIBRARY FCGI_INCLUDE_DIR) diff --git a/cmake/modules/Findfmt.cmake b/cmake/modules/Findfmt.cmake new file mode 100644 index 000000000..734c2b057 --- /dev/null +++ b/cmake/modules/Findfmt.cmake @@ -0,0 +1,61 @@ +find_path(fmt_INCLUDE_DIR NAMES fmt/format.h) + +if(fmt_INCLUDE_DIR) + set(_fmt_version_file "${fmt_INCLUDE_DIR}/fmt/core.h") + if(NOT EXISTS "${_fmt_version_file}") + set(_fmt_version_file "${fmt_INCLUDE_DIR}/fmt/format.h") + endif() + if(EXISTS "${_fmt_version_file}") + # parse "#define FMT_VERSION 40100" to 4.1.0 + file(STRINGS "${_fmt_version_file}" fmt_VERSION_LINE + REGEX "^#define[ \t]+FMT_VERSION[ \t]+[0-9]+$") + string(REGEX REPLACE "^#define[ \t]+FMT_VERSION[ \t]+([0-9]+)$" + "\\1" fmt_VERSION "${fmt_VERSION_LINE}") + foreach(ver "fmt_VERSION_PATCH" "fmt_VERSION_MINOR" "fmt_VERSION_MAJOR") + math(EXPR ${ver} "${fmt_VERSION} % 100") + math(EXPR fmt_VERSION "(${fmt_VERSION} - ${${ver}}) / 100") + endforeach() + set(fmt_VERSION + "${fmt_VERSION_MAJOR}.${fmt_VERSION_MINOR}.${fmt_VERSION_PATCH}") + endif() +endif() + +find_library(fmt_LIBRARY NAMES fmt) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(fmt + REQUIRED_VARS fmt_INCLUDE_DIR fmt_LIBRARY + VERSION_VAR fmt_VERSION) +mark_as_advanced( + fmt_INCLUDE_DIR + fmt_LIBRARY + fmt_VERSION_MAJOR + fmt_VERSION_MINOR + fmt_VERSION_PATCH + fmt_VERSION_STRING) + +if(fmt_FOUND AND NOT (TARGET fmt::fmt)) + add_library(fmt-header-only INTERFACE) + set_target_properties(fmt-header-only PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${fmt_INCLUDE_DIR}" + INTERFACE_COMPILE_DEFINITIONS FMT_HEADER_ONLY=1 + INTERFACE_COMPILE_FEATURES cxx_std_11) + + add_library(fmt UNKNOWN IMPORTED GLOBAL) + set_target_properties(fmt PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${fmt_INCLUDE_DIR}" + INTERFACE_COMPILE_FEATURES cxx_std_11 + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LOCATION "${fmt_LIBRARY}") + + if(WITH_FMT_HEADER_ONLY) + # please note, this is different from how upstream defines fmt::fmt. + # in order to force 3rd party libraries to link against fmt-header-only if + # WITH_FMT_HEADER_ONLY is ON, we have to point fmt::fmt to fmt-header-only + # in this case. + add_library(fmt::fmt ALIAS fmt-header-only) + else() + add_library(fmt::fmt ALIAS fmt) + endif() + +endif() diff --git a/cmake/modules/Findgperftools.cmake b/cmake/modules/Findgperftools.cmake new file mode 100644 index 000000000..52e2df0de --- /dev/null +++ b/cmake/modules/Findgperftools.cmake @@ -0,0 +1,76 @@ +# Try to find gperftools +# Once done, this will define +# +# gperftools_FOUND - system has Profiler +# GPERFTOOLS_INCLUDE_DIR - the Profiler include directories +# Tcmalloc_INCLUDE_DIR - where to find Tcmalloc.h +# GPERFTOOLS_TCMALLOC_LIBRARY - link it to use tcmalloc +# GPERFTOOLS_TCMALLOC_MINIMAL_LIBRARY - link it to use tcmalloc_minimal +# GPERFTOOLS_PROFILER_LIBRARY - link it to use Profiler +# TCMALLOC_VERSION_STRING +# TCMALLOC_VERSION_MAJOR +# TCMALLOC_VERSION_MINOR +# TCMALLOC_VERSION_PATCH + +find_path(GPERFTOOLS_INCLUDE_DIR gperftools/profiler.h + HINTS $ENV{GPERF_ROOT}/include) +find_path(Tcmalloc_INCLUDE_DIR gperftools/tcmalloc.h + HINTS $ENV{GPERF_ROOT}/include) + +if(Tcmalloc_INCLUDE_DIR AND EXISTS "${Tcmalloc_INCLUDE_DIR}/gperftools/tcmalloc.h") + foreach(ver "MAJOR" "MINOR" "PATCH") + file(STRINGS "${Tcmalloc_INCLUDE_DIR}/gperftools/tcmalloc.h" TC_VER_${ver}_LINE + REGEX "^#define[ \t]+TC_VERSION_${ver}[ \t]+[^ \t]+$") + string(REGEX REPLACE "^#define[ \t]+TC_VERSION_${ver}[ \t]+(\".)?([0-9]*)\"?$" + "\\2" TCMALLOC_VERSION_${ver} "${TC_VER_${ver}_LINE}") + unset(TC_VER_${ver}_LINE) + endforeach() + set(TCMALLOC_VERSION_STRING "${TCMALLOC_VERSION_MAJOR}.${TCMALLOC_VERSION_MINOR}") + if(NOT TCMALLOC_VERSION_PATCH STREQUAL "") + set(TCMALLOC_VERSION_STRING "${TCMALLOC_VERSION_STRING}.${TCMALLOC_VERSION_PATCH}") + endif() +endif() + +foreach(component tcmalloc tcmalloc_minimal profiler) + string(TOUPPER ${component} COMPONENT) + find_library(GPERFTOOLS_${COMPONENT}_LIBRARY ${component} + HINTS $ENV{GPERF_ROOT}/lib) + list(APPEND GPERFTOOLS_LIBRARIES GPERFTOOLS_${COMPONENT}_LIBRARY) +endforeach() + +set(_gperftools_FIND_REQUIRED_VARS "GPERFTOOLS_INCLUDE_DIR") +if(gperftools_FIND_COMPONENTS) + foreach(component ${gperftools_FIND_COMPONENTS}) + string(TOUPPER ${component} COMPONENT) + list(APPEND _gperftools_FIND_REQUIRED_VARS "GPERFTOOLS_${COMPONENT}_LIBRARY") + endforeach() +else() + list(APPEND _gperftools_FIND_REQUIRED_VARS "GPERFTOOLS_LIBRARIES") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(gperftools + FOUND_VAR gperftools_FOUND + REQUIRED_VARS ${_gperftools_FIND_REQUIRED_VARS} + VERSION_VAR TCMALLOC_VERSION_STRING) + +mark_as_advanced(${GPERFTOOLS_LIBRARIES} GPERFTOOLS_INCLUDE_DIR) + +if(gperftools_FOUND) + foreach(component tcmalloc tcmalloc_minimal profiler) + if(NOT (TARGET gperftools::${component})) + string(TOUPPER ${component} COMPONENT) + add_library(gperftools::${component} UNKNOWN IMPORTED) + set_target_properties(gperftools::${component} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${GPERFTOOLS_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LOCATION "${GPERFTOOLS_${COMPONENT}_LIBRARY}") + endif() + endforeach() + foreach(component tcmalloc tcmalloc_minimal) + if(NOT (TARGET gperftools::${component})) + set_target_properties(gperftools::${component} PROPERTIES + INTERFACE_COMPILE_OPTIONS "-fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free") + endif() + endforeach() +endif() diff --git a/cmake/modules/Findkeyutils.cmake b/cmake/modules/Findkeyutils.cmake new file mode 100644 index 000000000..d88bc0782 --- /dev/null +++ b/cmake/modules/Findkeyutils.cmake @@ -0,0 +1,27 @@ +# Try to find Keyutils +# Once done, this will define +# +# KEYUTILS_FOUND - system has keyutils +# KEYUTILS_INCLUDE_DIR - the keyutils include directories +# KEYUTILS_LIBRARIES - link these to use keyutils + +find_path(KEYUTILS_INCLUDE_DIR keyutils.h PATHS + /opt/local/include + /usr/local/include +) + +find_library(KEYUTILS_LIBRARIES NAMES keyutils) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(keyutils + DEFAULT_MSG KEYUTILS_LIBRARIES KEYUTILS_INCLUDE_DIR) + +mark_as_advanced(KEYUTILS_LIBRARIES KEYUTILS_INCLUDE_DIR) + +if(KEYUTILS_FOUND AND NOT (TARGET keyutils::keyutils)) + add_library(keyutils::keyutils UNKNOWN IMPORTED) + set_target_properties(keyutils::keyutils PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${KEYUTILS_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${KEYUTILS_LIBRARIES}") +endif() diff --git a/cmake/modules/Findleveldb.cmake b/cmake/modules/Findleveldb.cmake new file mode 100644 index 000000000..32786e979 --- /dev/null +++ b/cmake/modules/Findleveldb.cmake @@ -0,0 +1,18 @@ +# - Find LevelDB +# +# LEVELDB_INCLUDE_DIR - Where to find leveldb/db.h +# LEVELDB_LIBRARIES - List of libraries when using LevelDB. +# LEVELDB_FOUND - True if LevelDB found. + +find_path(LEVELDB_INCLUDE_DIR leveldb/db.h + HINTS $ENV{LEVELDB_ROOT}/include + DOC "Path in which the file leveldb/db.h is located." ) + +find_library(LEVELDB_LIBRARIES leveldb + HINTS $ENV{LEVELDB_ROOT}/lib + DOC "Path to leveldb library." ) + +mark_as_advanced(LEVELDB_INCLUDE_DIR LEVELDB_LIBRARIES) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(leveldb DEFAULT_MSG LEVELDB_LIBRARIES LEVELDB_INCLUDE_DIR) diff --git a/cmake/modules/Findlibcryptsetup.cmake b/cmake/modules/Findlibcryptsetup.cmake new file mode 100644 index 000000000..f0bdd864e --- /dev/null +++ b/cmake/modules/Findlibcryptsetup.cmake @@ -0,0 +1,33 @@ +# - Find libcryptsetup +# Sets the following: +# +# LIBCRYPTSETUP_INCLUDE_DIR +# LIBCRYPTSETUP_LIBRARIES +# LIBCRYPTSETUP_VERSION +# LIBCRYPTSETUP_FOUND + +find_package(PkgConfig QUIET REQUIRED) +pkg_search_module(PC_libcryptsetup libcryptsetup) + +find_path(LIBCRYPTSETUP_INCLUDE_DIR + NAMES libcryptsetup.h + PATHS ${PC_libcryptsetup_INCLUDE_DIRS}) + +find_library(LIBCRYPTSETUP_LIBRARIES + NAMES libcryptsetup.so + PATHS ${PC_libcryptsetup_LIBRARY_DIRS}) + +set(LIBCRYPTSETUP_VERSION ${PC_libcryptsetup_VERSION}) + +include(FindPackageHandleStandardArgs) + +find_package_handle_standard_args(libcryptsetup + REQUIRED_VARS + LIBCRYPTSETUP_INCLUDE_DIR + LIBCRYPTSETUP_LIBRARIES + VERSION_VAR LIBCRYPTSETUP_VERSION) + +mark_as_advanced( + LIBCRYPTSETUP_LIBRARIES + LIBCRYPTSETUP_INCLUDE_DIR + LIBCRYPTSETUP_VERSION) diff --git a/cmake/modules/Findnl.cmake b/cmake/modules/Findnl.cmake new file mode 100644 index 000000000..1fd2fcda6 --- /dev/null +++ b/cmake/modules/Findnl.cmake @@ -0,0 +1,50 @@ +# - Find libnl +# Find the libnl-3 library and includes +# +# nl_INCLUDE_DIR - where to find netlink.h, etc. +# nl_<COMPONENT>_LIBRARY - library when using nl::<COMPONENT>. +# nl_FOUND - True if nl found. + +find_path(nl_INCLUDE_DIR + NAMES + netlink/netlink.h + PATH_SUFFIXES + libnl3) + +foreach(component "core" ${nl_FIND_COMPONENTS}) + set(nl_COMPONENTS core cli genl idiag nf route xfrm) + list(FIND nl_COMPONENTS "${component}" found) + if(found EQUAL -1) + message(FATAL_ERROR "unknown libnl-3 component: ${component}") + endif() + if(component STREQUAL "core") + find_library(nl_${component}_LIBRARY nl-3) + else() + find_library(nl_${component}_LIBRARY nl-${component}-3) + endif() + list(APPEND nl_LIBRARIES "nl_${component}_LIBRARY") +endforeach() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(nl + DEFAULT_MSG ${nl_LIBRARIES} nl_INCLUDE_DIR) + +mark_as_advanced( + ${nl_LIBRARIES} + nl_INCLUDE_DIR) + +if(nl_FOUND) + foreach(component "core" ${nl_FIND_COMPONENTS}) + if(NOT TARGET nl::${component}) + add_library(nl::${component} UNKNOWN IMPORTED) + set_target_properties(nl::${component} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${nl_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${nl_${component}_LIBRARY}") + if(NOT component STREQUAL "core") + set_target_properties(nl::${component} PROPERTIES + INTERFACE_LINK_LIBRARIES "${nl_core_LIBRARY}") + endif() + endif() + endforeach() +endif() diff --git a/cmake/modules/Findpmem.cmake b/cmake/modules/Findpmem.cmake new file mode 100644 index 000000000..9c8e21b91 --- /dev/null +++ b/cmake/modules/Findpmem.cmake @@ -0,0 +1,57 @@ +# - Find pmem +# +# pmem_INCLUDE_DIRS - Where to find libpmem headers +# pmem_LIBRARIES - List of libraries when using libpmem. +# pmem_FOUND - True if pmem found. + +foreach(component pmem ${pmem_FIND_COMPONENTS}) + if(component STREQUAL pmem) + find_path(pmem_${component}_INCLUDE_DIR libpmem.h) + find_library(pmem_${component}_LIBRARY pmem) + elseif(component STREQUAL pmemobj) + find_path(pmem_${component}_INCLUDE_DIR libpmemobj.h) + find_library(pmem_${component}_LIBRARY pmemobj) + else() + message(FATAL_ERROR "unknown libpmem component: ${component}") + endif() + pkg_check_modules(PKG_${component} QUIET "lib${component}") + if(NOT pmem_VERSION_STRING OR PKG_${component}_VERSION VERSION_LESS pmem_VERSION_STRING) + set(pmem_VERSION_STRING ${PKG_${component}_VERSION}) + endif() + find_path(pmem_${component}_INCLUDE_DIR + NAMES lib${component}.h + HINTS ${PKG_${component}_INCLUDE_DIRS}) + find_library(pmem_${component}_LIBRARY + NAMES ${component} + HINTS ${PKG_${component}_LIBRARY_DIRS}) + mark_as_advanced( + pmem_${component}_INCLUDE_DIR + pmem_${component}_LIBRARY) + list(APPEND pmem_INCLUDE_DIRS "pmem_${component}_INCLUDE_DIR") + list(APPEND pmem_LIBRARIES "pmem_${component}_LIBRARY") +endforeach() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(pmem + DEFAULT_MSG pmem_INCLUDE_DIRS pmem_LIBRARIES) + +mark_as_advanced( + pmem_INCLUDE_DIRS + pmem_LIBRARIES) + +if(pmem_FOUND) + foreach(component pmem ${pmem_FIND_COMPONENTS}) + if(NOT TARGET pmem::${component}) + add_library(pmem::${component} UNKNOWN IMPORTED) + set_target_properties(pmem::${component} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${pmem_${component}_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${pmem_${component}_LIBRARY}") + # all pmem libraries calls into pmem::pmem + if(NOT component STREQUAL pmem) + set_target_properties(pmem::${component} PROPERTIES + INTERFACE_LINK_LIBRARIES pmem::pmem) + endif() + endif() + endforeach() +endif() diff --git a/cmake/modules/Findqatzip.cmake b/cmake/modules/Findqatzip.cmake new file mode 100644 index 000000000..3a593228d --- /dev/null +++ b/cmake/modules/Findqatzip.cmake @@ -0,0 +1,17 @@ +# - Find Qatzip +# Find the qatzip compression library and includes +# +# QATZIP_INCLUDE_DIR - where to find qatzip.h, etc. +# QATZIP_LIBRARIES - List of libraries when using qatzip. +# QATZIP_FOUND - True if qatzip found. + +find_path(QATZIP_INCLUDE_DIR NAMES qatzip.h) + +find_library(QATZIP_LIBRARIES NAMES qatzip) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(qatzip DEFAULT_MSG QATZIP_LIBRARIES QATZIP_INCLUDE_DIR) + +mark_as_advanced( + QATZIP_LIBRARIES + QATZIP_INCLUDE_DIR) diff --git a/cmake/modules/Findrdmacm.cmake b/cmake/modules/Findrdmacm.cmake new file mode 100644 index 000000000..0016180f4 --- /dev/null +++ b/cmake/modules/Findrdmacm.cmake @@ -0,0 +1,26 @@ +# - Find rdma cm +# Find the rdma cm library and includes +# +# RDMACM_INCLUDE_DIR - where to find cma.h, etc. +# RDMACM_LIBRARIES - List of libraries when using rdmacm. +# RDMACM_FOUND - True if rdmacm found. + +find_path(RDMACM_INCLUDE_DIR rdma/rdma_cma.h) +find_library(RDMACM_LIBRARIES rdmacm) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(rdmacm DEFAULT_MSG RDMACM_LIBRARIES RDMACM_INCLUDE_DIR) + +if(RDMACM_FOUND) + if(NOT TARGET RDMA::RDMAcm) + add_library(RDMA::RDMAcm UNKNOWN IMPORTED) + endif() + set_target_properties(RDMA::RDMAcm PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${RDMACM_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${RDMACM_LIBRARIES}") +endif() + +mark_as_advanced( + RDMACM_LIBRARIES +) diff --git a/cmake/modules/Findsnappy.cmake b/cmake/modules/Findsnappy.cmake new file mode 100644 index 000000000..716ed1c81 --- /dev/null +++ b/cmake/modules/Findsnappy.cmake @@ -0,0 +1,38 @@ +# - Find Snappy +# Find the snappy compression library and includes +# +# SNAPPY_INCLUDE_DIR - where to find snappy.h, etc. +# SNAPPY_LIBRARIES - List of libraries when using snappy. +# SNAPPY_FOUND - True if snappy found. + +find_package(PkgConfig QUIET REQUIRED) +pkg_search_module(PC_snappy + snappy QUIET) + +find_path(SNAPPY_INCLUDE_DIR + NAMES snappy.h + HINTS + ${PC_snappy_INCLUDE_DIRS} + ${SNAPPY_ROOT_DIR}/include) + +find_library(SNAPPY_LIBRARIES + NAMES snappy + HINTS + ${PC_snappy_LIBRARY_DIRS} + ${SNAPPY_ROOT_DIR}/lib) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(snappy + DEFAULT_MSG SNAPPY_LIBRARIES SNAPPY_INCLUDE_DIR) + +mark_as_advanced( + SNAPPY_LIBRARIES + SNAPPY_INCLUDE_DIR) + +if(snappy_FOUND AND NOT (TARGET snappy::snappy)) + add_library(snappy::snappy UNKNOWN IMPORTED) + set_target_properties(snappy::snappy PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${SNAPPY_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" + IMPORTED_LOCATION "${SNAPPY_LIBRARIES}") +endif() diff --git a/cmake/modules/Findudev.cmake b/cmake/modules/Findudev.cmake new file mode 100644 index 000000000..fd936fc88 --- /dev/null +++ b/cmake/modules/Findudev.cmake @@ -0,0 +1,34 @@ +# Copyright (C) 2007-2012 Hypertable, Inc. +# +# This file is part of Hypertable. +# +# Hypertable is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 3 +# of the License, or any later version. +# +# Hypertable is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Hypertable. If not, see <http://www.gnu.org/licenses/> +# + +# - Find libudev +# Find the udev library and includes +# +# UDEV_INCLUDE_DIR - where to find libudev.h, etc. +# UDEV_LIBRARIES - List of libraries when using udev. +# UDEV_FOUND - True if udev found. + +find_path(UDEV_INCLUDE_DIR libudev.h) +find_library(UDEV_LIBRARIES udev) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(udev DEFAULT_MSG UDEV_LIBRARIES UDEV_INCLUDE_DIR) + +mark_as_advanced( + UDEV_LIBRARIES + UDEV_INCLUDE_DIR) diff --git a/cmake/modules/Finduring.cmake b/cmake/modules/Finduring.cmake new file mode 100644 index 000000000..10c8de425 --- /dev/null +++ b/cmake/modules/Finduring.cmake @@ -0,0 +1,21 @@ +# - Find uring +# +# URING_INCLUDE_DIR - Where to find liburing.h +# URING_LIBRARIES - List of libraries when using uring. +# uring_FOUND - True if uring found. + +find_path(URING_INCLUDE_DIR liburing.h) +find_library(URING_LIBRARIES liburing.a liburing) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(uring DEFAULT_MSG URING_LIBRARIES URING_INCLUDE_DIR) + +if(uring_FOUND AND NOT TARGET uring::uring) + add_library(uring::uring UNKNOWN IMPORTED) + set_target_properties(uring::uring PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${URING_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${URING_LIBRARIES}") +endif() + +mark_as_advanced(URING_INCLUDE_DIR URING_LIBRARIES) diff --git a/cmake/modules/Finduuid.cmake b/cmake/modules/Finduuid.cmake new file mode 100644 index 000000000..2bce82b37 --- /dev/null +++ b/cmake/modules/Finduuid.cmake @@ -0,0 +1,20 @@ +# Try to find libuuid +# Once done, this will define +# +# UUID_FOUND - system has Profiler +# UUID_INCLUDE_DIR - the Profiler include directories +# UUID_LIBRARIES - link these to use Profiler + +if(UUID_INCLUDE_DIR AND UUID_LIBRARIES) + set(UUID_FIND_QUIETLY TRUE) +endif() + +find_path(UUID_INCLUDE_DIR NAMES uuid/uuid.h) +find_library(UUID_LIBRARIES NAMES uuid) +set(UUID_LIBRARIES ${LIBUUID}) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(uuid + DEFAULT_MSG UUID_LIBRARIES UUID_INCLUDE_DIR) + +mark_as_advanced(UUID_LIBRARIES UUID_INCLUDE_DIR) diff --git a/cmake/modules/Findverbs.cmake b/cmake/modules/Findverbs.cmake new file mode 100644 index 000000000..e266a4ebc --- /dev/null +++ b/cmake/modules/Findverbs.cmake @@ -0,0 +1,36 @@ +# - Find rdma verbs +# Find the rdma verbs library and includes +# +# VERBS_INCLUDE_DIR - where to find ibverbs.h, etc. +# VERBS_LIBRARIES - List of libraries when using ibverbs. +# VERBS_FOUND - True if ibverbs found. +# HAVE_IBV_EXP - True if experimental verbs is enabled. + +find_path(VERBS_INCLUDE_DIR infiniband/verbs.h) +find_library(VERBS_LIBRARIES ibverbs) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(verbs DEFAULT_MSG VERBS_LIBRARIES VERBS_INCLUDE_DIR) + +if(VERBS_FOUND) + include(CheckCXXSourceCompiles) + CHECK_CXX_SOURCE_COMPILES(" + #include <infiniband/verbs.h> + int main() { + struct ibv_context* ctxt; + struct ibv_exp_gid_attr gid_attr; + ibv_exp_query_gid_attr(ctxt, 1, 0, &gid_attr); + return 0; + } " HAVE_IBV_EXP) + if(NOT TARGET IBVerbs::verbs) + add_library(IBVerbs::verbs UNKNOWN IMPORTED) + endif() + set_target_properties(IBVerbs::verbs PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${VERBS_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${VERBS_LIBRARIES}") +endif() + +mark_as_advanced( + VERBS_LIBRARIES +) diff --git a/cmake/modules/Findxfs.cmake b/cmake/modules/Findxfs.cmake new file mode 100644 index 000000000..6171e3289 --- /dev/null +++ b/cmake/modules/Findxfs.cmake @@ -0,0 +1,33 @@ +# Try to find xfs +# Once done, this will define +# +# XFS_FOUND - system has libxfs +# XFS_INCLUDE_DIR - the libxfs include directories +# XFS_LIBRARIES - link these to use libxfs + +if(XFS_INCLUDE_DIR AND XFS_LIBRARIES) + set(XFS_FIND_QUIETLY TRUE) +endif(XFS_INCLUDE_DIR AND XFS_LIBRARIES) + +INCLUDE(CheckCXXSymbolExists) + +# include dir + +find_path(XFS_INCLUDE_DIR xfs.h NO_DEFAULT_PATH PATHS + /usr/include + /usr/include/xfs + /opt/local/include + /usr/local/include +) + + +# finally the library itself +find_library(LIBXFS NAMES handle) +set(XFS_LIBRARIES ${LIBXFS}) + +# handle the QUIETLY and REQUIRED arguments and set XFS_FOUND to TRUE if +# all listed variables are TRUE +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(xfs DEFAULT_MSG XFS_LIBRARIES XFS_INCLUDE_DIR) + +mark_as_advanced(XFS_LIBRARIES XFS_INCLUDE_DIR) diff --git a/cmake/modules/Findyaml-cpp.cmake b/cmake/modules/Findyaml-cpp.cmake new file mode 100644 index 000000000..d1e135737 --- /dev/null +++ b/cmake/modules/Findyaml-cpp.cmake @@ -0,0 +1,62 @@ +# +# This file is open source software, licensed to you under the terms +# of the Apache License, Version 2.0 (the "License"). See the NOTICE file +# distributed with this work for additional information regarding copyright +# ownership. You may not use this file except in compliance with the License. +# +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +# +# Copyright (C) 2018 Scylladb, Ltd. +# + +find_package (PkgConfig REQUIRED) + +pkg_search_module (yaml-cpp_PC yaml-cpp) + +find_library (yaml-cpp_LIBRARY + NAMES yaml-cpp + HINTS + ${yaml-cpp_PC_LIBDIR} + ${yaml-cpp_PC_LIBRARY_DIRS}) + +find_path (yaml-cpp_INCLUDE_DIR + NAMES yaml-cpp/yaml.h + PATH_SUFFIXES yaml-cpp + HINTS + ${yaml-cpp_PC_INCLUDEDIR} + ${yaml-cpp_PC_INCLUDE_DIRS}) + +mark_as_advanced ( + yaml-cpp_LIBRARY + yaml-cpp_INCLUDE_DIR) + +include (FindPackageHandleStandardArgs) + +find_package_handle_standard_args (yaml-cpp + REQUIRED_VARS + yaml-cpp_LIBRARY + yaml-cpp_INCLUDE_DIR + VERSION_VAR yaml-cpp_PC_VERSION) + +set (yaml-cpp_LIBRARIES ${yaml-cpp_LIBRARY}) +set (yaml-cpp_INCLUDE_DIRS ${yaml-cpp_INCLUDE_DIR}) + +if (yaml-cpp_FOUND AND NOT (TARGET yaml-cpp::yaml-cpp)) + add_library (yaml-cpp::yaml-cpp UNKNOWN IMPORTED) + + set_target_properties (yaml-cpp::yaml-cpp + PROPERTIES + IMPORTED_LOCATION ${yaml-cpp_LIBRARY} + INTERFACE_INCLUDE_DIRECTORIES ${yaml-cpp_INCLUDE_DIRS}) +endif () diff --git a/cmake/modules/Findzbd.cmake b/cmake/modules/Findzbd.cmake new file mode 100644 index 000000000..f4b23ef2f --- /dev/null +++ b/cmake/modules/Findzbd.cmake @@ -0,0 +1,19 @@ +# - Find ZBD +# +# ZBD_INCLUDE - Where to find zbd.h +# ZBD_LIBRARIES - List of libraries when using zbd. +# ZBD_FOUND - True if zbd found. + +find_path(ZBD_INCLUDE_DIR + zbd.h + HINTS $ENV{ZBD_ROOT}/libzbd + PATH_SUFFIXES libzbd) + +find_library(ZBD_LIBRARIES + zbd + HINTS $ENV{ZBD_ROOT}/lib) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(zbd DEFAULT_MSG ZBD_LIBRARIES ZBD_INCLUDE_DIR) + +mark_as_advanced(ZBD_INCLUDE_DIR ZBD_LIBRARIES) diff --git a/cmake/modules/Findzfs.cmake b/cmake/modules/Findzfs.cmake new file mode 100644 index 000000000..d92dd1fb0 --- /dev/null +++ b/cmake/modules/Findzfs.cmake @@ -0,0 +1,28 @@ +# find libzfs or libzfslinux +# Once done, this will define +# +# ZFS_FOUND - system has libzfs +# ZFS_INCLUDE_DIR - the libzfs include directories +# ZFS_LIBRARIES - link these to use libzfs + +find_package(PkgConfig) +if(PKG_CONFIG_FOUND) + pkg_check_modules(ZFS QUIET libzfs) +else() + find_path(ZFS_INCLUDE_DIR libzfs.h + HINTS + ENV ZFS_DIR + PATH_SUFFIXES libzfs) + + find_library(ZFS_LIBRARIES + NAMES zfs + HINTS + ENV ZFS_DIR) + set(XFS_LIBRARIES ${LIBXFS}) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(zfs DEFAULT_MSG + ZFS_INCLUDE_DIRS ZFS_LIBRARIES) + +mark_as_advanced(ZFS_INCLUDE_DIRS XFS_LIBRARIES) diff --git a/cmake/modules/GetGitRevisionDescription.cmake b/cmake/modules/GetGitRevisionDescription.cmake new file mode 100644 index 000000000..fbe414856 --- /dev/null +++ b/cmake/modules/GetGitRevisionDescription.cmake @@ -0,0 +1,128 @@ +# - Returns a version string from Git +# +# These functions force a re-configure on each git commit so that you can +# trust the values of the variables in your build system. +# +# get_git_head_revision(<refspecvar> <hashvar> [<additional arguments to git describe> ...]) +# +# Returns the refspec and sha hash of the current head revision +# +# git_describe(<var> [<additional arguments to git describe> ...]) +# +# Returns the results of git describe on the source tree, and adjusting +# the output so that it tests false if an error occurs. +# +# git_get_exact_tag(<var> [<additional arguments to git describe> ...]) +# +# Returns the results of git describe --exact-match on the source tree, +# and adjusting the output so that it tests false if there was no exact +# matching tag. +# +# Requires CMake 2.6 or newer (uses the 'function' command) +# +# Original Author: +# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net> +# http://academic.cleardefinition.com +# Iowa State University HCI Graduate Program/VRAC +# +# Copyright Iowa State University 2009-2010. +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +if(__get_git_revision_description) + return() +endif() +set(__get_git_revision_description YES) + +# We must run the following at "include" time, not at function call time, +# to find the path to this module rather than the path to a calling list file +get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH) + +function(get_git_head_revision _refspecvar _hashvar) + set(GIT_DIR "${CMAKE_SOURCE_DIR}/.git") + if(NOT EXISTS "${GIT_DIR}") # .git dir not found + # We have reached the top of the source tree, we are not in git + set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE) + set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE) + return() + endif() + # check if this is a submodule or git-worktree + if(NOT IS_DIRECTORY ${GIT_DIR}) + file(READ ${GIT_DIR} gitdirfile) + string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" GIT_DIR_PATH ${gitdirfile}) + if(IS_ABSOLUTE ${GIT_DIR_PATH}) + get_filename_component(GIT_DIR ${GIT_DIR_PATH} ABSOLUTE) + else() + get_filename_component(LINKED_DIR ${GIT_DIR} PATH) + get_filename_component(GIT_DIR ${LINKED_DIR}/${GIT_DIR_PATH} ABSOLUTE) + endif() + endif() + set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data") + if(NOT EXISTS "${GIT_DATA}") + file(MAKE_DIRECTORY "${GIT_DATA}") + endif() + + if(NOT EXISTS "${GIT_DIR}/HEAD") + return() + endif() + set(HEAD_FILE "${GIT_DATA}/HEAD") + configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY) + + configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in" + "${GIT_DATA}/grabRef.cmake" + @ONLY) + include("${GIT_DATA}/grabRef.cmake") + + set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE) + set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE) +endfunction() + +function(git_describe _var) + if(NOT GIT_FOUND) + find_package(Git QUIET) + endif() + get_git_head_revision(refspec hash) + if(NOT GIT_FOUND) + set(${_var} "GIT-NOTFOUND" PARENT_SCOPE) + return() + endif() + if(NOT hash) + set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE) + return() + endif() + + # TODO sanitize + #if((${ARGN}" MATCHES "&&") OR + # (ARGN MATCHES "||") OR + # (ARGN MATCHES "\\;")) + # message("Please report the following error to the project!") + # message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}") + #endif() + + #message(STATUS "Arguments to execute_process: ${ARGN}") + + execute_process(COMMAND + "${GIT_EXECUTABLE}" + describe + ${hash} + ${ARGN} + WORKING_DIRECTORY + "${CMAKE_CURRENT_SOURCE_DIR}" + RESULT_VARIABLE + res + OUTPUT_VARIABLE + out + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT res EQUAL 0) + set(out "${out}-${res}-NOTFOUND") + endif() + + set(${_var} "${out}" PARENT_SCOPE) +endfunction() + +function(git_get_exact_tag _var) + git_describe(out --exact-match ${ARGN}) + set(${_var} "${out}" PARENT_SCOPE) +endfunction() diff --git a/cmake/modules/GetGitRevisionDescription.cmake.in b/cmake/modules/GetGitRevisionDescription.cmake.in new file mode 100644 index 000000000..41cf7ed5f --- /dev/null +++ b/cmake/modules/GetGitRevisionDescription.cmake.in @@ -0,0 +1,50 @@ +# +# Internal file for GetGitRevisionDescription.cmake +# +# Requires CMake 2.6 or newer (uses the 'function' command) +# +# Original Author: +# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net> +# http://academic.cleardefinition.com +# Iowa State University HCI Graduate Program/VRAC +# +# Copyright Iowa State University 2009-2010. +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +set(HEAD_HASH) + +file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024) + +string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS) +set(GIT_DIR "@GIT_DIR@") +# handle git-worktree +if(EXISTS "${GIT_DIR}/commondir") + file(READ "${GIT_DIR}/commondir" GIT_DIR_NEW LIMIT 1024) + string(STRIP "${GIT_DIR_NEW}" GIT_DIR_NEW) + if(NOT IS_ABSOLUTE "${GIT_DIR_NEW}") + get_filename_component(GIT_DIR_NEW ${GIT_DIR}/${GIT_DIR_NEW} ABSOLUTE) + endif() + if(EXISTS "${GIT_DIR_NEW}") + set(GIT_DIR "${GIT_DIR_NEW}") + endif() +endif() +if(HEAD_CONTENTS MATCHES "ref") + # named branch + string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}") + if(EXISTS "${GIT_DIR}/${HEAD_REF}") + configure_file("${GIT_DIR}/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY) + elseif(EXISTS "${GIT_DIR}/logs/${HEAD_REF}") + configure_file("${GIT_DIR}/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY) + set(HEAD_HASH "${HEAD_REF}") + endif() +else() + # detached HEAD + configure_file("${GIT_DIR}/HEAD" "@GIT_DATA@/head-ref" COPYONLY) +endif() + +if(NOT HEAD_HASH) + file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024) + string(STRIP "${HEAD_HASH}" HEAD_HASH) +endif() diff --git a/cmake/modules/IncludeJaeger.cmake b/cmake/modules/IncludeJaeger.cmake new file mode 100644 index 000000000..b62265c97 --- /dev/null +++ b/cmake/modules/IncludeJaeger.cmake @@ -0,0 +1,21 @@ +include(BuildJaeger) +include(BuildOpenTracing) + +include(ExternalProjectHelper) + +build_jaeger() + +add_library(opentracing::libopentracing SHARED IMPORTED) +add_dependencies(opentracing::libopentracing opentracing) +add_library(jaegertracing::libjaegertracing SHARED IMPORTED) +add_dependencies(jaegertracing::libjaegertracing Jaeger) +add_library(thrift::libthrift SHARED IMPORTED) +add_dependencies(thrift::libthrift thrift) + +#(set_library_properties_for_external_project _target _lib) +set_library_properties_for_external_project(opentracing::libopentracing + opentracing) +set_library_properties_for_external_project(jaegertracing::libjaegertracing + jaegertracing) +set_library_properties_for_external_project(thrift::libthrift + thrift) diff --git a/cmake/modules/SIMDExt.cmake b/cmake/modules/SIMDExt.cmake new file mode 100644 index 000000000..72f86e33b --- /dev/null +++ b/cmake/modules/SIMDExt.cmake @@ -0,0 +1,99 @@ +# detect SIMD extensions +# +# HAVE_ARMV8_CRC +# HAVE_ARMV8_SIMD +# HAVE_ARM_NEON +# HAVE_INTEL_SSE +# HAVE_INTEL_SSE2 +# HAVE_INTEL_SSE3 +# HAVE_INTEL_SSSE3 +# HAVE_INTEL_PCLMUL +# HAVE_INTEL_SSE4_1 +# HAVE_INTEL_SSE4_2 +# +# SIMD_COMPILE_FLAGS +# + +if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|AARCH64") + set(HAVE_ARM 1) + include(CheckCCompilerFlag) + + check_c_compiler_flag(-march=armv8-a+crc+crypto HAVE_ARMV8_CRC_CRYPTO_INTRINSICS) + if(HAVE_ARMV8_CRC_CRYPTO_INTRINSICS) + set(ARMV8_CRC_COMPILE_FLAGS "-march=armv8-a+crc+crypto") + set(HAVE_ARMV8_CRC TRUE) + set(HAVE_ARMV8_CRYPTO TRUE) + else() + check_c_compiler_flag(-march=armv8-a+crc HAVE_ARMV8_CRC) + check_c_compiler_flag(-march=armv8-a+crypto HAVE_ARMV8_CRYPTO) + if(HAVE_ARMV8_CRC) + set(ARMV8_CRC_COMPILE_FLAGS "-march=armv8-a+crc") + elseif(HAVE_ARMV8_CRYPTO) + set(ARMV8_CRC_COMPILE_FLAGS "-march=armv8-a+crypto") + endif() + endif() + + CHECK_C_COMPILER_FLAG(-march=armv8-a+simd HAVE_ARMV8_SIMD) + if(HAVE_ARMV8_SIMD) + set(SIMD_COMPILE_FLAGS "${SIMD_COMPILE_FLAGS} -march=armv8-a+simd") + endif() + +elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM") + set(HAVE_ARM 1) + CHECK_C_COMPILER_FLAG(-mfpu=neon HAVE_ARM_NEON) + if(HAVE_ARM_NEON) + set(SIMD_COMPILE_FLAGS "${SIMD_COMPILE_FLAGS} -mfpu=neon") + endif() + +elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i386|i686|amd64|x86_64|AMD64") + set(HAVE_INTEL 1) + if(CMAKE_SYSTEM_PROCESSOR MATCHES "i686|amd64|x86_64|AMD64") + CHECK_C_COMPILER_FLAG(-msse HAVE_INTEL_SSE) + if(HAVE_INTEL_SSE) + set(SIMD_COMPILE_FLAGS "${SIMD_COMPILE_FLAGS} -msse") + endif() + if(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|AMD64") + CHECK_C_COMPILER_FLAG(-msse2 HAVE_INTEL_SSE2) + if(HAVE_INTEL_SSE2) + set(SIMD_COMPILE_FLAGS "${SIMD_COMPILE_FLAGS} -msse2") + endif() + CHECK_C_COMPILER_FLAG(-msse3 HAVE_INTEL_SSE3) + if(HAVE_INTEL_SSE3) + set(SIMD_COMPILE_FLAGS "${SIMD_COMPILE_FLAGS} -msse3") + endif() + CHECK_C_COMPILER_FLAG(-mssse3 HAVE_INTEL_SSSE3) + if(HAVE_INTEL_SSSE3) + set(SIMD_COMPILE_FLAGS "${SIMD_COMPILE_FLAGS} -mssse3") + endif() + CHECK_C_COMPILER_FLAG(-mpclmul HAVE_INTEL_PCLMUL) + if(HAVE_INTEL_PCLMUL) + set(SIMD_COMPILE_FLAGS "${SIMD_COMPILE_FLAGS} -mpclmul") + endif() + CHECK_C_COMPILER_FLAG(-msse4.1 HAVE_INTEL_SSE4_1) + if(HAVE_INTEL_SSE4_1) + set(SIMD_COMPILE_FLAGS "${SIMD_COMPILE_FLAGS} -msse4.1") + endif() + CHECK_C_COMPILER_FLAG(-msse4.2 HAVE_INTEL_SSE4_2) + if(HAVE_INTEL_SSE4_2) + set(SIMD_COMPILE_FLAGS "${SIMD_COMPILE_FLAGS} -msse4.2") + endif() + endif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|AMD64") + endif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686|amd64|x86_64|AMD64") +elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(powerpc|ppc)64|(powerpc|ppc)64le") + if(CMAKE_SYSTEM_PROCESSOR MATCHES "(powerpc|ppc)64le") + set(HAVE_PPC64LE 1) + message(STATUS " we are ppc64le") + else() + set(HAVE_PPC64 1) + message(STATUS " we are ppc64") + endif(CMAKE_SYSTEM_PROCESSOR MATCHES "(powerpc|ppc)64le") + CHECK_C_COMPILER_FLAG("-maltivec" HAS_ALTIVEC) + if(HAS_ALTIVEC) + message(STATUS " HAS_ALTIVEC yes") + add_compile_options(-maltivec) + endif() + CHECK_C_COMPILER_FLAG("-mcpu=power8" HAVE_POWER8) + if(HAVE_POWER8) + message(STATUS " HAVE_POWER8 yes") + endif() +endif() diff --git a/cmake/modules/boost-python-use-public-api-for-filename.patch b/cmake/modules/boost-python-use-public-api-for-filename.patch new file mode 100644 index 000000000..899a02384 --- /dev/null +++ b/cmake/modules/boost-python-use-public-api-for-filename.patch @@ -0,0 +1,38 @@ +From d9f06052e28873037db7f98629bce72182a42410 Mon Sep 17 00:00:00 2001 +From: Pat Riehecky <riehecky@fnal.gov> +Date: Mon, 29 Jun 2020 10:51:58 -0500 +Subject: [PATCH] Convert Python 3.1+ to use public C API for filenames +--- + src/exec.cpp | 16 ++++++++++++---- + 1 file changed, 12 insertions(+), 4 deletions(-) +diff --git a/src/exec.cpp b/src/exec.cpp +index 171c6f4189..b2eabe59f6 100644 +--- a/src/boost/libs/python/src/exec.cpp ++++ b/src/boost/libs/python/src/exec.cpp +@@ -104,14 +104,22 @@ object BOOST_PYTHON_DECL exec_file(char const *filename, object global, object l + if (local.is_none()) local = global; + // should be 'char const *' but older python versions don't use 'const' yet. + char *f = const_cast<char *>(filename); +- // Let python open the file to avoid potential binary incompatibilities. +-#if PY_VERSION_HEX >= 0x03040000 +- FILE *fs = _Py_fopen(f, "r"); ++#if PY_VERSION_HEX >= 0x03010000 ++ // Let python manage any UTF bits to avoid potential incompatibilities. ++ PyObject *fo = Py_BuildValue("s", f); ++ PyObject *fb = Py_None; ++ PyUnicode_FSConverter(fo, &fb); ++ f = PyBytes_AsString(fb); ++ FILE *fs = fopen(f, "r"); ++ Py_DECREF(fo); ++ Py_DECREF(fb); + #elif PY_VERSION_HEX >= 0x03000000 ++ // Let python open the file to avoid potential binary incompatibilities. + PyObject *fo = Py_BuildValue("s", f); +- FILE *fs = _Py_fopen(fo, "r"); ++ FILE *fs = _Py_fopen(fo, "r"); // Private CPython API + Py_DECREF(fo); + #else ++ // Let python open the file to avoid potential binary incompatibilities. + PyObject *pyfile = PyFile_FromString(f, const_cast<char*>("r")); + if (!pyfile) throw std::invalid_argument(std::string(f) + " : no such file"); + python::handle<> file(pyfile); diff --git a/cmake/modules/patch-dpdk-conf.sh b/cmake/modules/patch-dpdk-conf.sh new file mode 100755 index 000000000..ad5bbf6a4 --- /dev/null +++ b/cmake/modules/patch-dpdk-conf.sh @@ -0,0 +1,57 @@ +#!/bin/sh +# -*- mode:sh; tab-width:4; indent-tabs-mode:nil -* + +setconf() { + local key=$1 + local val=$2 + if grep -q ^$key= ${conf}; then + sed -i -e "s:^$key=.*$:$key=$val:g" ${conf} + else + echo $key=$val >> ${conf} + fi +} + +conf=$1/.config +shift +machine=$1 +shift +arch=$1 +shift +numa=$1 +shift + +setconf CONFIG_RTE_MACHINE "${machine}" +setconf CONFIG_RTE_ARCH "${arch}" + +# Disable experimental features +setconf CONFIG_RTE_NEXT_ABI n +setconf CONFIG_RTE_LIBRTE_MBUF_OFFLOAD n +# Disable unmaintained features +setconf CONFIG_RTE_LIBRTE_POWER n + +setconf CONFIG_RTE_EAL_IGB_UIO n +setconf CONFIG_RTE_LIBRTE_KNI n +setconf CONFIG_RTE_KNI_KMOD n +setconf CONFIG_RTE_KNI_PREEMPT_DEFAULT n + +# no pdump +setconf CONFIG_RTE_LIBRTE_PDUMP n + +# no vm support +setconf CONFIG_RTE_LIBRTE_EAL_VMWARE_TSC_MAP_SUPPORT n +setconf CONFIG_RTE_LIBRTE_VHOST n +setconf CONFIG_RTE_LIBRTE_VHOST_NUMA n +setconf CONFIG_RTE_LIBRTE_VMXNET3_PMD n +setconf CONFIG_RTE_LIBRTE_PMD_VHOST n +setconf CONFIG_RTE_APP_EVENTDEV n +setconf CONFIG_RTE_MAX_VFIO_GROUPS 64 + +# no test +setconf CONFIG_RTE_APP_TEST n +setconf CONFIG_RTE_TEST_PMD n + +# async/dpdk does not like it +setconf CONFIG_RTE_MBUF_REFCNT_ATOMIC n + +# balanced allocation of hugepages +setconf CONFIG_RTE_EAL_NUMA_AWARE_HUGEPAGES "${numa}" |