lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 11.1.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2022-07-01 10:44:02 +02:00
parent b3bf75a2a1
commit c07cea1fe0
2172 changed files with 183300 additions and 123938 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/externals/ptl/cmake/Modules/BuildSettings.cmake
Vendored
-86
View File
@@ -1,86 +0,0 @@
################################################################################
#
# Handles the build settings
#
################################################################################
#
set(LIBNAME ptl)
include(GNUInstallDirs)
include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
include(Compilers)
include(MacroUtilities)
ptl_add_interface_library(ptl-compile-options)
ptl_add_interface_library(ptl-public-options)
ptl_add_interface_library(ptl-external-libraries)
ptl_add_interface_library(ptl-sanitizer-options)
# ---------------------------------------------------------------------------- #
#
#set(SANITIZE_TYPE leak CACHE STRING "-fsantitize=<TYPE>")
# ---------------------------------------------------------------------------- #
# if master project, set the output directory (critical on Windows and Xcode)
#
if("${CMAKE_PROJECT_NAME}" STREQUAL "${PROJECT_NAME}")
set(_BIN_DIR ${PROJECT_BINARY_DIR})
if(WIN32)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${_BIN_DIR}/outputs/runtime)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${_BIN_DIR}/outputs/library)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${_BIN_DIR}/outputs/archive)
else()
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${_BIN_DIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${_BIN_DIR})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${_BIN_DIR})
endif()
endif()
# ---------------------------------------------------------------------------- #
# debug macro
#
string(TOUPPER "${CMAKE_BUILD_TYPE}" UC_BUILD_TYPE)
if("${UC_BUILD_TYPE}" STREQUAL "DEBUG")
target_compile_definitions(ptl-compile-options INTERFACE DEBUG)
else()
target_compile_definitions(ptl-compile-options INTERFACE NDEBUG)
endif()
if(PTL_USE_LOCKS)
target_compile_definitions(ptl-public-options INTERFACE PTL_USE_LOCKS)
endif()
if(PTL_USE_COVERAGE)
target_compile_options(ptl-public-options INTERFACE
$<BUILD_INTERFACE:-fprofile-arcs>
$<BUILD_INTERFACE:-ftest-coverage>)
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
target_compile_options(ptl-public-options INTERFACE
$<BUILD_INTERFACE:-fprofile-abs-path>
$<BUILD_INTERFACE:--coverage>)
set_target_properties(ptl-public-options PROPERTIES
INTERFACE_LINK_OPTIONS
$<BUILD_INTERFACE:--coverage>)
else()
set_target_properties(ptl-public-options PROPERTIES
INTERFACE_LINK_OPTIONS
$<BUILD_INTERFACE:-fprofile-arcs>)
endif()
endif()
if(PTL_USE_SANITIZER AND PTL_SANITIZER_TYPE)
if("${PTL_SANITIZER_TYPE}" STREQUAL "thread")
target_compile_options(ptl-sanitizer-options INTERFACE
-fsanitize=${PTL_SANITIZER_TYPE})
else()
target_compile_options(ptl-sanitizer-options INTERFACE
-fsanitize=${PTL_SANITIZER_TYPE}
-fno-optimize-sibling-calls
-fno-omit-frame-pointer
-fno-inline-functions)
endif()
target_link_options(ptl-sanitizer-options INTERFACE
-fsanitize=${PTL_SANITIZER_TYPE})
endif()
source/externals/ptl/cmake/Modules/ClangFormat.cmake
Vendored
-36
View File
@@ -1,36 +0,0 @@
################################################################################
#
# Creates a 'format' target that runs clang-format
#
################################################################################
find_program(CLANG_FORMATTER
NAMES
clang-format-6
clang-format-6.0
clang-format-mp-6.0 # macports
clang-format)
if(CLANG_FORMATTER)
set(_Source_DIR ${PROJECT_SOURCE_DIR}/src)
set(_Header_DIR ${PROJECT_SOURCE_DIR}/include)
file(GLOB headers
${_Header_DIR}/*.hh ${_Header_DIR}/*.icc)
file(GLOB sources
${_Source_DIR}/*.cc)
# avoid conflicting format targets
set(FORMAT_NAME format)
if(TARGET format)
set(FORMAT_NAME format-ptl)
endif()
add_custom_target(${FORMAT_NAME}
COMMAND ${CLANG_FORMATTER} -i ${headers} ${sources}
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
COMMENT "Running '${CLANG_FORMATTER}' on '${_Source_DIR}'..."
SOURCES ${headers} ${sources})
endif()
source/externals/ptl/cmake/Modules/Compilers.cmake
Vendored
-399
View File
@@ -1,399 +0,0 @@
################################################################################
#
# Compilers
#
################################################################################
#
# sets (cached):
#
# CMAKE_C_COMPILER_IS_<TYPE>
# CMAKE_CXX_COMPILER_IS_<TYPE>
#
# where TYPE is:
# - GNU
# - CLANG
# - INTEL
# - INTEL_ICC
# - INTEL_ICPC
# - PGI
# - XLC
# - HP_ACC
# - MIPS
# - MSVC
#
# include guard
include_guard(DIRECTORY)
include(CheckLanguage)
include(CheckCCompilerFlag)
include(CheckCSourceCompiles)
include(CheckCSourceRuns)
include(CheckCXXCompilerFlag)
include(CheckCXXSourceCompiles)
include(CheckCXXSourceRuns)
include(MacroUtilities)
if("${LIBNAME}" STREQUAL "")
string(TOLOWER "${PROJECT_NAME}" LIBNAME)
endif()
ptl_add_interface_library(${LIBNAME}-compile-options)
#----------------------------------------------------------------------------------------#
# macro converting string to list
#----------------------------------------------------------------------------------------#
macro(to_list _VAR _STR)
STRING(REPLACE " " " " ${_VAR} "${_STR}")
STRING(REPLACE " " ";" ${_VAR} "${_STR}")
endmacro(to_list _VAR _STR)
#----------------------------------------------------------------------------------------#
# macro converting string to list
#----------------------------------------------------------------------------------------#
macro(to_string _VAR _STR)
STRING(REPLACE ";" " " ${_VAR} "${_STR}")
endmacro(to_string _VAR _STR)
#----------------------------------------------------------------------------------------#
# Macro to add to string
#----------------------------------------------------------------------------------------#
macro(add _VAR _FLAG)
if(NOT "${_FLAG}" STREQUAL "")
if("${${_VAR}}" STREQUAL "")
set(${_VAR} "${_FLAG}")
else()
set(${_VAR} "${${_VAR}} ${_FLAG}")
endif()
endif()
endmacro()
#----------------------------------------------------------------------------------------#
# macro to remove duplicates from string
#----------------------------------------------------------------------------------------#
macro(set_no_duplicates _VAR)
if(NOT "${ARGN}" STREQUAL "")
set(${_VAR} "${ARGN}")
endif()
# remove the duplicates
if(NOT "${${_VAR}}" STREQUAL "")
# create list of flags
to_list(_VAR_LIST "${${_VAR}}")
list(REMOVE_DUPLICATES _VAR_LIST)
to_string(${_VAR} "${_VAR_LIST}")
endif(NOT "${${_VAR}}" STREQUAL "")
endmacro(set_no_duplicates _VAR)
##########################################################################################
#
# C compiler flags
#
##########################################################################################
#----------------------------------------------------------------------------------------#
# add C flag to target
#----------------------------------------------------------------------------------------#
macro(ADD_TARGET_C_FLAG _TARG)
target_compile_options(${_TARG} INTERFACE $<$<COMPILE_LANGUAGE:C>:${ARGN}>)
endmacro()
#----------------------------------------------------------------------------------------#
# add C flag w/o check
#----------------------------------------------------------------------------------------#
macro(ADD_C_FLAG FLAG)
set(_TARG )
set(_LTARG )
if(NOT "${ARGN}" STREQUAL "")
set(_TARG ${ARGN})
string(TOLOWER "_${ARGN}" _LTARG)
endif()
if(NOT "${FLAG}" STREQUAL "")
if("${_LTARG}" STREQUAL "")
list(APPEND ${PROJECT_NAME}_C_FLAGS "${FLAG}")
list(APPEND ${PROJECT_NAME}_C_COMPILE_OPTIONS "${FLAG}")
add_target_c_flag(${LIBNAME}-compile-options ${FLAG})
else()
add_target_c_flag(${_TARG} ${FLAG})
endif()
endif()
endmacro()
#----------------------------------------------------------------------------------------#
# check C flag
#----------------------------------------------------------------------------------------#
macro(ADD_C_FLAG_IF_AVAIL FLAG)
set(_TARG )
set(_LTARG )
if(NOT "${ARGN}" STREQUAL "")
set(_TARG ${ARGN})
string(TOLOWER "_${ARGN}" _LTARG)
endif()
if(NOT "${FLAG}" STREQUAL "")
string(REGEX REPLACE "^/" "c${_LTARG}_" FLAG_NAME "${FLAG}")
string(REGEX REPLACE "^-" "c${_LTARG}_" FLAG_NAME "${FLAG}")
string(REPLACE "-" "_" FLAG_NAME "${FLAG_NAME}")
string(REPLACE " " "_" FLAG_NAME "${FLAG_NAME}")
string(REPLACE "=" "_" FLAG_NAME "${FLAG_NAME}")
check_c_compiler_flag("${FLAG}" ${FLAG_NAME})
if(${FLAG_NAME})
if("${_LTARG}" STREQUAL "")
list(APPEND ${PROJECT_NAME}_C_FLAGS "${FLAG}")
list(APPEND ${PROJECT_NAME}_C_COMPILE_OPTIONS "${FLAG}")
add_target_c_flag(${LIBNAME}-compile-options ${FLAG})
else()
add_target_c_flag(${_TARG} ${FLAG})
endif()
endif()
endif()
endmacro()
#----------------------------------------------------------------------------------------#
# add C flag to target
#----------------------------------------------------------------------------------------#
macro(ADD_TARGET_C_FLAG_IF_AVAIL _TARG)
foreach(_FLAG ${ARGN})
add_c_flag_if_avail(${_FLAG} ${_TARG})
endforeach()
endmacro()
##########################################################################################
#
# CXX compiler flags
#
##########################################################################################
#----------------------------------------------------------------------------------------#
# add CXX flag to target
#----------------------------------------------------------------------------------------#
macro(ADD_TARGET_CXX_FLAG _TARG)
target_compile_options(${_TARG} INTERFACE $<$<COMPILE_LANGUAGE:CXX>:${ARGN}>)
get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
if(CMAKE_CUDA_COMPILER AND "CUDA" IN_LIST LANGUAGES)
target_compile_options(${_TARG} INTERFACE $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=${ARGN}>)
endif()
endmacro()
#----------------------------------------------------------------------------------------#
# add CXX flag w/o check
#----------------------------------------------------------------------------------------#
macro(ADD_CXX_FLAG FLAG)
set(_TARG )
set(_LTARG )
if(NOT "${ARGN}" STREQUAL "")
set(_TARG ${ARGN})
string(TOLOWER "_${ARGN}" _LTARG)
endif()
if(NOT "${FLAG}" STREQUAL "")
if("${_LTARG}" STREQUAL "")
list(APPEND ${PROJECT_NAME}_CXX_FLAGS "${FLAG}")
list(APPEND ${PROJECT_NAME}_CXX_COMPILE_OPTIONS "${FLAG}")
add_target_cxx_flag(${LIBNAME}-compile-options ${FLAG})
else()
add_target_cxx_flag(${_TARG} ${FLAG})
endif()
endif()
endmacro()
#----------------------------------------------------------------------------------------#
# check CXX flag
#----------------------------------------------------------------------------------------#
macro(ADD_CXX_FLAG_IF_AVAIL FLAG)
set(_TARG )
set(_LTARG )
if(NOT "${ARGN}" STREQUAL "")
set(_TARG ${ARGN})
string(TOLOWER "_${ARGN}" _LTARG)
endif()
if(NOT "${FLAG}" STREQUAL "")
string(REGEX REPLACE "^/" "cxx${_LTARG}_" FLAG_NAME "${FLAG}")
string(REGEX REPLACE "^-" "cxx${_LTARG}_" FLAG_NAME "${FLAG}")
string(REPLACE "-" "_" FLAG_NAME "${FLAG_NAME}")
string(REPLACE " " "_" FLAG_NAME "${FLAG_NAME}")
string(REPLACE "=" "_" FLAG_NAME "${FLAG_NAME}")
check_cxx_compiler_flag("${FLAG}" ${FLAG_NAME})
if(${FLAG_NAME})
if("${_LTARG}" STREQUAL "")
list(APPEND ${PROJECT_NAME}_CXX_FLAGS "${FLAG}")
list(APPEND ${PROJECT_NAME}_CXX_COMPILE_OPTIONS "${FLAG}")
add_target_cxx_flag(${LIBNAME}-compile-options ${FLAG})
else()
add_target_cxx_flag(${_TARG} ${FLAG})
endif()
endif()
endif()
endmacro()
#----------------------------------------------------------------------------------------#
# add CXX flag to target
#----------------------------------------------------------------------------------------#
macro(ADD_TARGET_CXX_FLAG_IF_AVAIL _TARG)
foreach(_FLAG ${ARGN})
add_cxx_flag_if_avail(${_FLAG} ${_TARG})
endforeach()
endmacro()
##########################################################################################
#
# Common
#
##########################################################################################
#----------------------------------------------------------------------------------------#
# add C and CXX flag w/o checking
#----------------------------------------------------------------------------------------#
macro(ADD_TARGET_FLAG _TARG)
foreach(_ARG ${ARGN})
ADD_TARGET_C_FLAG(${_TARG} ${_ARG})
ADD_TARGET_CXX_FLAG(${_TARG} ${_ARG})
endforeach()
endmacro()
#----------------------------------------------------------------------------------------#
# check C and CXX flag
#----------------------------------------------------------------------------------------#
macro(ADD_FLAG_IF_AVAIL)
foreach(_ARG ${ARGN})
ADD_C_FLAG_IF_AVAIL("${_ARG}")
ADD_CXX_FLAG_IF_AVAIL("${_ARG}")
endforeach()
endmacro()
#----------------------------------------------------------------------------------------#
# check C and CXX flag
#----------------------------------------------------------------------------------------#
macro(ADD_TARGET_FLAG_IF_AVAIL _TARG)
foreach(_ARG ${ARGN})
ADD_TARGET_C_FLAG_IF_AVAIL(${_TARG} ${_ARG})
ADD_TARGET_CXX_FLAG_IF_AVAIL(${_TARG} ${_ARG})
endforeach()
endmacro()
#----------------------------------------------------------------------------------------#
# add to any language
#----------------------------------------------------------------------------------------#
function(ADD_USER_FLAGS _TARGET _LANGUAGE)
set(_FLAGS ${${_LANGUAGE}FLAGS} $ENV{${_LANGUAGE}FLAGS}
${${_LANGUAGE}_FLAGS} $ENV{${_LANGUAGE}_FLAGS})
string(REPLACE " " ";" _FLAGS "${_FLAGS}")
set(${PROJECT_NAME}_${_LANGUAGE}_FLAGS
${${PROJECT_NAME}_${_LANGUAGE}_FLAGS} ${_FLAGS} PARENT_SCOPE)
set(${PROJECT_NAME}_${_LANGUAGE}_COMPILE_OPTIONS
${${PROJECT_NAME}_${_LANGUAGE}_COMPILE_OPTIONS} ${_FLAGS} PARENT_SCOPE)
target_compile_options(${_TARGET} INTERFACE
$<$<COMPILE_LANGUAGE:${_LANGUAGE}>:${_FLAGS}>)
endfunction()
#----------------------------------------------------------------------------------------#
# determine compiler types for each language
#----------------------------------------------------------------------------------------#
foreach(LANG C CXX)
macro(SET_COMPILER_VAR VAR _BOOL)
set(CMAKE_${LANG}_COMPILER_IS_${VAR} ${_BOOL})
endmacro()
if(("${LANG}" STREQUAL "C" AND CMAKE_COMPILER_IS_GNUCC)
OR
("${LANG}" STREQUAL "CXX" AND CMAKE_COMPILER_IS_GNUCXX))
# GNU compiler
SET_COMPILER_VAR( GNU ON)
elseif(CMAKE_${LANG}_COMPILER MATCHES "icc.*")
# Intel icc compiler
SET_COMPILER_VAR( INTEL ON)
SET_COMPILER_VAR( INTEL_ICC ON)
elseif(CMAKE_${LANG}_COMPILER MATCHES "icpc.*")
# Intel icpc compiler
SET_COMPILER_VAR( INTEL ON)
SET_COMPILER_VAR( INTEL_ICPC ON)
elseif(CMAKE_${LANG}_COMPILER_ID MATCHES "Clang" OR
CMAKE_${LANG}_COMPILER_ID MATCHES "AppleClang")
# Clang/LLVM compiler
SET_COMPILER_VAR( CLANG ON)
elseif(CMAKE_${LANG}_COMPILER_ID MATCHES "PGI")
# PGI compiler
SET_COMPILER_VAR( PGI ON)
elseif(CMAKE_${LANG}_COMPILER MATCHES "xlC" AND UNIX)
# IBM xlC compiler
SET_COMPILER_VAR( XLC ON)
elseif(CMAKE_${LANG}_COMPILER MATCHES "aCC" AND UNIX)
# HP aC++ compiler
SET_COMPILER_VAR( HP_ACC ON)
elseif(CMAKE_${LANG}_COMPILER MATCHES "CC" AND
CMAKE_SYSTEM_NAME MATCHES "IRIX" AND UNIX)
# IRIX MIPSpro CC Compiler
SET_COMPILER_VAR( MIPS ON)
elseif(CMAKE_${LANG}_COMPILER_ID MATCHES "Intel")
SET_COMPILER_VAR( INTEL ON)
set(CTYPE ICC)
if("${LANG}" STREQUAL "CXX")
set(CTYPE ICPC)
endif()
SET_COMPILER_VAR( INTEL_${CTYPE} ON)
elseif(CMAKE_${LANG}_COMPILER MATCHES "MSVC")
# Windows Visual Studio compiler
SET_COMPILER_VAR( MSVC ON)
endif()
# set other to no
foreach(TYPE GNU INTEL INTEL_ICC INTEL_ICPC CLANG PGI XLC HP_ACC MIPS MSVC)
if(NOT ${CMAKE_${LANG}_COMPILER_IS_${TYPE}})
SET_COMPILER_VAR(${TYPE} OFF)
endif()
endforeach()
if(APPLE OR ("${CMAKE_INCLUDE_SYSTEM_FLAG_${LANG}}" STREQUAL "-I" AND NOT WIN32))
# set(CMAKE_INCLUDE_SYSTEM_FLAG_${LANG} "-isystem ")
endif()
endforeach()
source/externals/ptl/cmake/Modules/ConfigurePackage.cmake
Vendored
-43
View File
@@ -1,43 +0,0 @@
################################################################################
#
# PTL Package installation
#
################################################################################
include(CMakePackageConfigHelpers)
set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR})
set(LIB_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR})
configure_package_config_file(
${PROJECT_SOURCE_DIR}/cmake/Templates/${PROJECT_NAME}Config.cmake.in
${PROJECT_BINARY_DIR}/installation/${PROJECT_NAME}Config.cmake
INSTALL_DESTINATION ${CMAKE_INSTALL_CONFIGDIR}
INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}
PATH_VARS
INCLUDE_INSTALL_DIR
LIB_INSTALL_DIR)
write_basic_package_version_file(
${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
VERSION ${PROJECT_VERSION}
COMPATIBILITY SameMajorVersion)
install(FILES ${PROJECT_BINARY_DIR}/installation/${PROJECT_NAME}Config.cmake
${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
DESTINATION ${CMAKE_INSTALL_CONFIGDIR})
install(FILES ${PROJECT_SOURCE_DIR}/cmake/Modules/FindTBB.cmake
DESTINATION ${CMAKE_INSTALL_CONFIGDIR}/Modules)
set(BUILD_TREE ON)
configure_package_config_file(
${PROJECT_SOURCE_DIR}/cmake/Templates/${PROJECT_NAME}Config.cmake.in
${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
INSTALL_DESTINATION ${PROJECT_BINARY_DIR}
INSTALL_PREFIX ${PROJECT_BINARY_DIR}
PATH_VARS
INCLUDE_INSTALL_DIR
LIB_INSTALL_DIR)
source/externals/ptl/cmake/Modules/CudaConfig.cmake
Vendored
-44
View File
@@ -1,44 +0,0 @@
#------------------------------------------------------------------------------#
# CUDA function
#
function(NVCUDA_COMPILE_PTX)
set(options "")
set(oneValueArgs TARGET_PATH GENERATED_FILES OUTPUT_DIR)
set(multiValueArgs NVCC_OPTIONS SOURCES)
cmake_parse_arguments(NVCUDA_COMPILE_PTX "${options}" "${oneValueArgs}"
"${multiValueArgs}" ${ARGN})
# Match the bitness of the ptx to the bitness of the application
set( MACHINE "--machine=32" )
if( CMAKE_SIZEOF_VOID_P EQUAL 8)
set( MACHINE "--machine=64" )
endif()
set(_OUTPUT_DIR ${NVCUDA_COMPILE_PTX_OUTPUT_DIR})
if("${_OUTPUT_DIR}" STREQUAL "")
set(_OUTPUT_DIR ${CUDA_GENERATED_OUTPUT_DIR})
endif()
# Custom build rule to generate ptx files from cuda files
foreach(input ${NVCUDA_COMPILE_PTX_SOURCES})
get_filename_component(input_we ${input} NAME_WE)
# generate the *.ptx files inside "ptx" folder inside
# the executable's output directory.
set( output "${_OUTPUT_DIR}/${input_we}.ptx" )
list(APPEND PTX_FILES ${output})
add_custom_command(
OUTPUT ${output}
DEPENDS ${input}
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMAND ${CUDA_NVCC_EXECUTABLE} ${MACHINE}
--ptx ${NVCUDA_COMPILE_PTX_NVCC_OPTIONS} ${input}
-o ${output}
)
endforeach()
set(${NVCUDA_COMPILE_PTX_GENERATED_FILES} ${PTX_FILES} PARENT_SCOPE)
endfunction()
source/externals/ptl/cmake/Modules/Documentation.cmake
Vendored
+101 -86
View File
@@ -1,18 +1,20 @@
#
# Create a "make doc" target using Doxygen
# Create a "make doc" target using Doxygen.
#
# Prototype:
# GENERATE_DOCUMENTATION(doxygen_config_file)
#
# GENERATE_DOCUMENTATION(doxygen_config_file)
#
# Parameters:
# doxygen_config_file Doxygen configuration file (must in the
# root of the source directory)
#
# * doxygen_config_file: Doxygen configuration file (must in the root of the source
# directory)
include(MacroUtilities)
include(CMakeDependentOption)
#------------------------------------------------------------------------------#
# -------------------------------------------------------------------------------------- #
# if BUILD_DOXYGEN_DOCS = ON, we want to build docs quietly
# else, don't build quietly
# if BUILD_DOXYGEN_DOCS = ON, we want to build docs quietly else, don't build quietly
add_option(${PROJECT_NAME}_DOCS_QUIET "Suppress standard output when making the docs" ON)
mark_as_advanced(${PROJECT_NAME}_DOCS_QUIET)
@@ -40,7 +42,7 @@ set(AVAILABLE_DOXYGEN_DOC_FORMATS HTML LATEX MAN XML RTF)
set(_default_on "MAN")
foreach(_doc_format ${AVAILABLE_DOXYGEN_DOC_FORMATS})
# find if we want it on
STRING(REGEX MATCH "${_doc_format}" SET_TO_ON "${_default_on}")
string(REGEX MATCH "${_doc_format}" SET_TO_ON "${_default_on}")
# if doc format is MAN and it is not a UNIX machine --> turn off
if("${_doc_format}" STREQUAL "MAN" AND NOT UNIX)
set(SET_TO_ON "")
@@ -53,12 +55,12 @@ foreach(_doc_format ${AVAILABLE_DOXYGEN_DOC_FORMATS})
endif()
# add option
add_option(${PROJECT_NAME}_${_doc_format}_DOCS
"Build documentation with ${_doc_format} format" ${_default})
"Build documentation with ${_doc_format} format" ${_default})
mark_as_advanced(${PROJECT_NAME}_${_doc_format}_DOCS)
endforeach()
# loop over doc formats and set GENERATE_DOXYGEN_${_doc_format}_DOC to
# YES/NO GENERATE_DOXYGEN_${_doc_format}_DOC is used in configure_file @ONLY
# loop over doc formats and set GENERATE_DOXYGEN_${_doc_format}_DOC to YES/NO
# GENERATE_DOXYGEN_${_doc_format}_DOC is used in configure_file @ONLY
foreach(_doc_format ${AVAILABLE_DOXYGEN_DOC_FORMATS})
if(${PROJECT_NAME}_${_doc_format}_DOCS)
set(GENERATE_DOXYGEN_${_doc_format}_DOC YES)
@@ -67,7 +69,6 @@ foreach(_doc_format ${AVAILABLE_DOXYGEN_DOC_FORMATS})
endif()
endforeach()
if(DOXYGEN_DOT_FOUND)
set(DOXYGEN_DOT_GRAPH_TYPES CLASS CALL CALLER)
# options to turn generation of class, call, and caller graphs
@@ -78,8 +79,7 @@ if(DOXYGEN_DOT_FOUND)
option(${PROJECT_NAME}_${_graph_type}_GRAPH "${_message}" ON)
mark_as_advanced(${PROJECT_NAME}_${_graph_type}_GRAPH)
# set GENERATE_DOXYGEN_${_graph_type}_GRAPH to YES/NO
# GENERATE_DOXYGEN_${_graph_type}_GRAPH is used in configure_file
# @ONLY
# GENERATE_DOXYGEN_${_graph_type}_GRAPH is used in configure_file @ONLY
if(${PROJECT_NAME}_${_graph_type}_GRAPH)
set(GENERATE_DOXYGEN_${_graph_type}_GRAPH YES)
else()
@@ -95,10 +95,19 @@ if("${BUILDTREE_DIRS}" STREQUAL "")
message(FATAL_ERROR "Property PTL_DOCUMENTATION_DIRS is empty")
endif()
LIST(REMOVE_DUPLICATES BUILDTREE_DIRS)
list(REMOVE_DUPLICATES BUILDTREE_DIRS)
set(SOURCE_FILES)
set(EXTENSIONS h hh hpp c cc cpp icc tcc py)
set(EXTENSIONS
h
hh
hpp
c
cc
cpp
icc
tcc
py)
foreach(_DIR ${BUILDTREE_DIRS})
foreach(_EXT ${EXTENSIONS})
file(GLOB _FILES "${_DIR}/*.${_EXT}")
@@ -108,13 +117,12 @@ foreach(_DIR ${BUILDTREE_DIRS})
unset(_FILES CACHE)
endforeach()
endforeach()
#message(STATUS "source files: ${SOURCE_FILES}")
# Doxyfiles was spaces not semi-colon separated lists
STRING(REPLACE ";" " " BUILDTREE_DIRS "${BUILDTREE_DIRS}")
STRING(REPLACE ";" " " SOURCE_FILES "${SOURCE_FILES}")
string(REPLACE ";" " " BUILDTREE_DIRS "${BUILDTREE_DIRS}")
string(REPLACE ";" " " SOURCE_FILES "${SOURCE_FILES}")
#-----------------------------------------------------------------------
# -----------------------------------------------------------------------
if(XCODE)
set(GENERATE_DOCSET_IF_XCODE YES)
@@ -122,79 +130,86 @@ else()
set(GENERATE_DOCSET_IF_XCODE NO)
endif()
#-----------------------------------------------------------------------
# -----------------------------------------------------------------------
configure_file(${PROJECT_SOURCE_DIR}/cmake/Templates/Doxyfile.in
${PROJECT_BINARY_DIR}/doc/Doxyfile.${PROJECT_NAME}
@ONLY)
${PROJECT_BINARY_DIR}/doc/Doxyfile.${PROJECT_NAME} @ONLY)
if(${PROJECT_NAME}_HTML_DOCS)
FILE(WRITE ${PROJECT_BINARY_DIR}/doc/${PROJECT_NAME}_Documentation.html
"<meta http-equiv=\"refresh\" content=\"1;url=html/index.html\">")
file(WRITE ${PROJECT_BINARY_DIR}/doc/${PROJECT_NAME}_Documentation.html
"<meta http-equiv=\"refresh\" content=\"1;url=html/index.html\">")
endif()
#------------------------------------------------------------------------------#
# Macro to generate documentation
# from:
# http://www.cmake.org/pipermail/cmake/2007-May/014174.html
MACRO(GENERATE_DOCUMENTATION DOXYGEN_CONFIG_FILE)
# -------------------------------------------------------------------------------------- #
# Macro to generate documentation from:
# http://www.cmake.org/pipermail/cmake/2007-May/014174.html
macro(GENERATE_DOCUMENTATION DOXYGEN_CONFIG_FILE)
FIND_PACKAGE(Doxygen)
find_package(Doxygen)
if(NOT Doxygen_FOUND)
message(STATUS "Doxygen executable cannot be found. Disable ${PROJECT_NAME}_DOXYGEN_DOCS")
return()
message(
STATUS
"Doxygen executable cannot be found. Disable ${PROJECT_NAME}_DOXYGEN_DOCS"
)
return()
endif()
SET(DOXYFILE_FOUND false)
set(DOXYFILE_FOUND false)
IF(EXISTS ${PROJECT_BINARY_DIR}/doc/${DOXYGEN_CONFIG_FILE})
SET(DOXYFILE_FOUND true)
ELSE(EXISTS ${PROJECT_BINARY_DIR}/doc/${DOXYGEN_CONFIG_FILE})
MESSAGE(STATUS "Doxygen config file was not found at ${PROJECT_BINARY_DIR}/doc/${DOXYGEN_CONFIG_FILE}")
ENDIF(EXISTS ${PROJECT_BINARY_DIR}/doc/${DOXYGEN_CONFIG_FILE})
if(EXISTS ${PROJECT_BINARY_DIR}/doc/${DOXYGEN_CONFIG_FILE})
set(DOXYFILE_FOUND true)
else()
message(
STATUS
"Doxygen config file was not found at ${PROJECT_BINARY_DIR}/doc/${DOXYGEN_CONFIG_FILE}"
)
endif()
IF( DOXYGEN_FOUND )
IF( DOXYFILE_FOUND )
if(DOXYGEN_FOUND)
if(DOXYFILE_FOUND)
# Add target
ADD_CUSTOM_TARGET(docs ${DOXYGEN_EXECUTABLE}
"${PROJECT_BINARY_DIR}/doc/${DOXYGEN_CONFIG_FILE}" )
add_custom_target(docs ${DOXYGEN_EXECUTABLE}
"${PROJECT_BINARY_DIR}/doc/${DOXYGEN_CONFIG_FILE}")
install(DIRECTORY ${PROJECT_BINARY_DIR}/doc/man/
DESTINATION ${CMAKE_INSTALL_MANDIR}
OPTIONAL
COMPONENT documentation
)
install(
DIRECTORY ${PROJECT_BINARY_DIR}/doc/man/
DESTINATION ${CMAKE_INSTALL_MANDIR}
OPTIONAL
COMPONENT documentation)
install(DIRECTORY ${PROJECT_BINARY_DIR}/doc/html
DESTINATION ${CMAKE_INSTALL_DOCDIR}
OPTIONAL
COMPONENT documentation
)
install(
DIRECTORY ${PROJECT_BINARY_DIR}/doc/html
DESTINATION ${CMAKE_INSTALL_DOCDIR}
OPTIONAL
COMPONENT documentation)
install(DIRECTORY ${PROJECT_BINARY_DIR}/doc/latex
DESTINATION ${CMAKE_INSTALL_DOCDIR}
OPTIONAL
COMPONENT documentation
)
install(
DIRECTORY ${PROJECT_BINARY_DIR}/doc/latex
DESTINATION ${CMAKE_INSTALL_DOCDIR}
OPTIONAL
COMPONENT documentation)
install(FILES ${PROJECT_BINARY_DIR}/doc/${PROJECT_NAME}_Documentation.html
DESTINATION ${CMAKE_INSTALL_DOCDIR}
OPTIONAL
COMPONENT documentation
)
install(
FILES ${PROJECT_BINARY_DIR}/doc/${PROJECT_NAME}_Documentation.html
DESTINATION ${CMAKE_INSTALL_DOCDIR}
OPTIONAL
COMPONENT documentation)
ELSE( DOXYFILE_FOUND )
MESSAGE( STATUS "Doxygen configuration file not found - Documentation will not be generated" )
ENDIF( DOXYFILE_FOUND )
ELSE(DOXYGEN_FOUND)
MESSAGE(STATUS "Doxygen not found - Documentation will not be generated")
ENDIF(DOXYGEN_FOUND)
else()
message(
STATUS
"Doxygen configuration file not found - Documentation will not be generated"
)
endif()
else()
message(STATUS "Doxygen not found - Documentation will not be generated")
endif()
ENDMACRO(GENERATE_DOCUMENTATION)
endmacro()
#------------------------------------------------------------------------------#
# Macro to generate PDF manual from LaTeX using pdflatex
# assumes manual is in ${CMAKE_SOURCE_DIR}/doc
MACRO(GENERATE_MANUAL MANUAL_TEX MANUAL_BUILD_PATH EXTRA_FILES_TO_COPY)
# -------------------------------------------------------------------------------------- #
# Macro to generate PDF manual from LaTeX using pdflatex assumes manual is in
# ${CMAKE_SOURCE_DIR}/doc
macro(GENERATE_MANUAL MANUAL_TEX MANUAL_BUILD_PATH EXTRA_FILES_TO_COPY)
find_program(PDFLATEX pdflatex)
@@ -205,23 +220,23 @@ MACRO(GENERATE_MANUAL MANUAL_TEX MANUAL_BUILD_PATH EXTRA_FILES_TO_COPY)
set(MANUAL_BUILD_PATH ${CMAKE_BINARY_DIR}/${MANUAL_BUILD_PATH})
if(NOT EXISTS ${CMAKE_SOURCE_DIR}/doc/${MANUAL_TEX})
message(FATAL_ERROR "LaTeX of manual for ${PROJECT_NAME} is not in ${CMAKE_SOURCE_DIR}/doc")
message(
FATAL_ERROR
"LaTeX of manual for ${PROJECT_NAME} is not in ${CMAKE_SOURCE_DIR}/doc"
)
endif()
configure_file(${CMAKE_SOURCE_DIR}/doc/${MANUAL_TEX}
${MANUAL_BUILD_PATH}/${MANUAL_NAME}
COPYONLY)
${MANUAL_BUILD_PATH}/${MANUAL_NAME} COPYONLY)
foreach(_file ${EXTRA_FILES_TO_COPY})
configure_file(${CMAKE_SOURCE_DIR}/doc/${_file}
${MANUAL_BUILD_PATH}/${_file}
configure_file(${CMAKE_SOURCE_DIR}/doc/${_file} ${MANUAL_BUILD_PATH}/${_file}
COPYONLY)
endforeach()
add_custom_target(man
${PDFLATEX} "${MANUAL_NAME}"
WORKING_DIRECTORY
${MANUAL_BUILD_PATH}
)
add_custom_target(
man
${PDFLATEX} "${MANUAL_NAME}"
WORKING_DIRECTORY ${MANUAL_BUILD_PATH})
endif()
ENDMACRO()
endmacro()
source/externals/ptl/cmake/Modules/FindTBB.cmake
Vendored
+408 -285
View File
@@ -1,340 +1,463 @@
# Module for locating Intel's Threading Building Blocks (TBB).
# - Find ThreadingBuildingBlocks include dirs and libraries
# Use this module by invoking find_package with the form:
# find_package(TBB
# [REQUIRED] # Fail with error if TBB is not found
# ) #
# Once done, this will define
#
# Customizable variables:
# TBB_ROOT_DIR
# Specifies TBB's root directory.
# TBB_FOUND - system has TBB
# TBB_INCLUDE_DIRS - the TBB include directories
# TBB_LIBRARIES - TBB libraries to be lined, doesn't include malloc or
# malloc proxy
# TBB::tbb - imported target for the TBB library
#
# Read-only variables:
# TBB_FOUND
# Indicates whether the library has been found.
# TBB_VERSION_MAJOR - Major Product Version Number
# TBB_VERSION_MINOR - Minor Product Version Number
# TBB_INTERFACE_VERSION - Engineering Focused Version Number
# TBB_COMPATIBLE_INTERFACE_VERSION - The oldest major interface version
# still supported. This uses the engineering
# focused interface version numbers.
#
# TBB_INCLUDE_DIRS
# Specifies TBB's include directory.
# TBB_MALLOC_FOUND - system has TBB malloc library
# TBB_MALLOC_INCLUDE_DIRS - the TBB malloc include directories
# TBB_MALLOC_LIBRARIES - The TBB malloc libraries to be lined
# TBB::malloc - imported target for the TBB malloc library
#
# TBB_LIBRARIES
# Specifies TBB libraries that should be passed to target_link_libararies.
#
# TBB_<COMPONENT>_LIBRARIES
# Specifies the libraries of a specific <COMPONENT>.
#
# TBB_<COMPONENT>_FOUND
# Indicates whether the specified <COMPONENT> was found.
# TBB_MALLOC_PROXY_FOUND - system has TBB malloc proxy library
# TBB_MALLOC_PROXY_INCLUDE_DIRS = the TBB malloc proxy include directories
# TBB_MALLOC_PROXY_LIBRARIES - The TBB malloc proxy libraries to be lined
# TBB::malloc_proxy - imported target for the TBB malloc proxy library
#
#
# Copyright (c) 2012 Sergiu Dotenco
# This module reads hints about search locations from variables:
# ENV TBB_ARCH_PLATFORM - for eg. set it to "mic" for Xeon Phi builds
# ENV TBB_ROOT or just TBB_ROOT - root directory of tbb installation
# ENV TBB_BUILD_PREFIX - specifies the build prefix for user built tbb
# libraries. Should be specified with ENV TBB_ROOT
# and optionally...
# ENV TBB_BUILD_DIR - if build directory is different than ${TBB_ROOT}/build
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# Modified by Robert Maynard from the original OGRE source
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTTBBLAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
INCLUDE (FindPackageHandleStandardArgs)
#------------------------------------------------------------------------------#
#-------------------------------------------------------------------
# This file is part of the CMake build system for OGRE
# (Object-oriented Graphics Rendering Engine)
# For the latest info, see http://www.ogre3d.org/
#
# Paths
# The contents of this file are placed in the public domain. Feel
# free to make use of it in any way you like.
#-------------------------------------------------------------------
#
#------------------------------------------------------------------------------#
IF(CMAKE_VERSION VERSION_GREATER 2.8.7)
SET(_TBB_CHECK_COMPONENTS ON)
ELSE()
SET(_TBB_CHECK_COMPONENTS OFF)
ENDIF()
FIND_PATH(TBB_ROOT_DIR
NAMES include/tbb/tbb.h
PATHS ENV TBBROOT
ENV TBB40_INSTALL_DIR
ENV TBB30_INSTALL_DIR
ENV TBB22_INSTALL_DIR
ENV TBB21_INSTALL_DIR
ENV TBB_ROOT_DIR
DOC "TBB root directory")
FIND_PATH(TBB_INCLUDE_DIR
NAMES tbb/tbb.h
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES include
DOC "TBB include directory")
#------------------------------------------------------------------------------#
#=============================================================================
# Copyright 2010-2012 Kitware, Inc.
# Copyright 2012 Rolf Eike Beer <eike@sf-mail.de>
#
# Library suffixes
# 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.)
IF(MSVC11)
SET(_TBB_COMPILER vc11)
ELSEIF(MSVC10)
SET(_TBB_COMPILER vc10)
ELSEIF(MSVC90)
SET(_TBB_COMPILER vc9)
ELSEIF(MSVC80)
SET(_TBB_COMPILER vc8)
ELSEIF(WIN32)
SET(_TBB_COMPILER vc_mt)
ENDIF(MSVC11)
IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
SET(_TBB_POSSIBLE_LIB_SUFFIXES lib/intel64/${_TBB_COMPILER})
SET(_TBB_POSSIBLE_BIN_SUFFIXES bin/intel64/${_TBB_COMPILER})
ELSE(CMAKE_SIZEOF_VOID_P EQUAL 8)
SET(_TBB_POSSIBLE_LIB_SUFFIXES lib/ia32/${_TBB_COMPILER})
SET(_TBB_POSSIBLE_BIN_SUFFIXES bin/ia32/${_TBB_COMPILER})
ENDIF(CMAKE_SIZEOF_VOID_P EQUAL 8)
LIST(APPEND _TBB_POSSIBLE_LIB_SUFFIXES lib/$ENV{TBB_ARCH_PLATFORM})
IF(UNIX)
FOREACH(_VERSION 4.7 4.4 4.1)
IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
LIST(APPEND _TBB_POSSIBLE_LIB_SUFFIXES lib/intel64/gcc${_VERSION})
ELSE()
LIST(APPEND _TBB_POSSIBLE_LIB_SUFFIXES lib/ia32/gcc${_VERSION})
ENDIF()
ENDFOREACH()
ENDIF()
#------------------------------------------------------------------------------#
#=============================================================================
# FindTBB helper functions and macros
#
# TBB library
# Use TBBConfig.cmake if possible.
set(_tbb_find_quiet)
if (TBB_FIND_QUIETLY)
set(_tbb_find_quiet QUIET)
endif ()
set(_tbb_find_components)
set(_tbb_find_optional_components)
foreach (_tbb_find_component IN LISTS TBB_FIND_COMPONENTS)
if (TBB_FIND_REQUIRED_${_tbb_find_component})
list(APPEND _tbb_find_components "${_tbb_find_component}")
else ()
list(APPEND _tbb_find_optional_components "${_tbb_find_component}")
endif ()
endforeach ()
unset(_tbb_find_component)
find_package(TBB CONFIG ${_tbb_find_quiet}
COMPONENTS ${_tbb_find_components}
OPTIONAL_COMPONENTS ${_tbb_find_optional_components})
unset(_tbb_find_quiet)
unset(_tbb_find_components)
unset(_tbb_find_optional_components)
if (TBB_FOUND)
return ()
endif ()
#====================================================
# Fix the library path in case it is a linker script
#====================================================
function(tbb_extract_real_library library real_library)
if(NOT UNIX OR NOT EXISTS ${library})
set(${real_library} "${library}" PARENT_SCOPE)
return()
endif()
#Read in the first 4 bytes and see if they are the ELF magic number
set(_elf_magic "7f454c46")
file(READ ${library} _hex_data OFFSET 0 LIMIT 4 HEX)
if(_hex_data STREQUAL _elf_magic)
#we have opened a elf binary so this is what
#we should link to
set(${real_library} "${library}" PARENT_SCOPE)
return()
endif()
file(READ ${library} _data OFFSET 0 LIMIT 1024)
if("${_data}" MATCHES "INPUT \\(([^(]+)\\)")
#extract out the .so name from REGEX MATCH command
set(_proper_so_name "${CMAKE_MATCH_1}")
#construct path to the real .so which is presumed to be in the same directory
#as the input file
get_filename_component(_so_dir "${library}" DIRECTORY)
set(${real_library} "${_so_dir}/${_proper_so_name}" PARENT_SCOPE)
else()
#unable to determine what this library is so just hope everything works
#and pass it unmodified.
set(${real_library} "${library}" PARENT_SCOPE)
endif()
endfunction()
#===============================================
# Do the final processing for the package find.
#===============================================
macro(findpkg_finish PREFIX TARGET_NAME)
if (${PREFIX}_INCLUDE_DIR AND ${PREFIX}_LIBRARY)
set(${PREFIX}_FOUND TRUE)
set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIR})
set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARY})
else ()
if (${PREFIX}_FIND_REQUIRED AND NOT ${PREFIX}_FIND_QUIETLY)
message(FATAL_ERROR "Required library ${PREFIX} not found.")
endif ()
endif ()
if (NOT TARGET "TBB::${TARGET_NAME}")
if (${PREFIX}_LIBRARY_RELEASE)
tbb_extract_real_library(${${PREFIX}_LIBRARY_RELEASE} real_release)
endif ()
if (${PREFIX}_LIBRARY_DEBUG)
tbb_extract_real_library(${${PREFIX}_LIBRARY_DEBUG} real_debug)
endif ()
add_library(TBB::${TARGET_NAME} UNKNOWN IMPORTED)
set_target_properties(TBB::${TARGET_NAME} PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${${PREFIX}_INCLUDE_DIR}")
if (${PREFIX}_LIBRARY_DEBUG AND ${PREFIX}_LIBRARY_RELEASE)
set_target_properties(TBB::${TARGET_NAME} PROPERTIES
IMPORTED_LOCATION "${real_release}"
IMPORTED_LOCATION_DEBUG "${real_debug}"
IMPORTED_LOCATION_RELEASE "${real_release}")
elseif (${PREFIX}_LIBRARY_RELEASE)
set_target_properties(TBB::${TARGET_NAME} PROPERTIES
IMPORTED_LOCATION "${real_release}")
elseif (${PREFIX}_LIBRARY_DEBUG)
set_target_properties(TBB::${TARGET_NAME} PROPERTIES
IMPORTED_LOCATION "${real_debug}")
endif ()
endif ()
#mark the following variables as internal variables
mark_as_advanced(${PREFIX}_INCLUDE_DIR
${PREFIX}_LIBRARY
${PREFIX}_LIBRARY_DEBUG
${PREFIX}_LIBRARY_RELEASE)
endmacro()
#===============================================
# Generate debug names from given release names
#===============================================
macro(get_debug_names PREFIX)
foreach(i ${${PREFIX}})
set(${PREFIX}_DEBUG ${${PREFIX}_DEBUG} ${i}d ${i}D ${i}_d ${i}_D ${i}_debug ${i})
endforeach()
endmacro()
#===============================================
# See if we have env vars to help us find tbb
#===============================================
macro(getenv_path VAR)
set(ENV_${VAR} $ENV{${VAR}})
# replace won't work if var is blank
if (ENV_${VAR})
string( REGEX REPLACE "\\\\" "/" ENV_${VAR} ${ENV_${VAR}} )
endif ()
endmacro()
#===============================================
# Couple a set of release AND debug libraries
#===============================================
macro(make_library_set PREFIX)
if (${PREFIX}_RELEASE AND ${PREFIX}_DEBUG)
set(${PREFIX} optimized ${${PREFIX}_RELEASE} debug ${${PREFIX}_DEBUG})
elseif (${PREFIX}_RELEASE)
set(${PREFIX} ${${PREFIX}_RELEASE})
elseif (${PREFIX}_DEBUG)
set(${PREFIX} ${${PREFIX}_DEBUG})
endif ()
endmacro()
#=============================================================================
# Now to actually find TBB
#
#------------------------------------------------------------------------------#
FIND_LIBRARY(TBB_LIBRARY_RELEASE
NAMES tbb
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_POSSIBLE_LIB_SUFFIXES}
DOC "TBB release library")
# Get path, convert backslashes as ${ENV_${var}}
getenv_path(TBB_ROOT)
FIND_LIBRARY(TBB_LIBRARY_DEBUG
NAMES tbb_debug
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_POSSIBLE_LIB_SUFFIXES}
DOC "TBB debug library")
IF(TBB_LIBRARY_DEBUG AND "${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
IF(NOT TBB_LIBRARY)
SET(TBB_LIBRARY ${TBB_LIBRARY_DEBUG} CACHE FILEPATH "TBB library" FORCE)
ENDIF(NOT TBB_LIBRARY)
LIST(APPEND _TBB_ALL_LIBS ${TBB_LIBRARY_DEBUG})
ELSEIF(TBB_LIBRARY_RELEASE)
IF(NOT TBB_LIBRARY)
SET(TBB_LIBRARY ${TBB_LIBRARY_RELEASE} CACHE FILEPATH "TBB library" FORCE)
ENDIF(NOT TBB_LIBRARY)
LIST(APPEND _TBB_ALL_LIBS ${TBB_LIBRARY_RELEASE})
ENDIF()
# initialize search paths
set(TBB_PREFIX_PATH ${TBB_ROOT} ${ENV_TBB_ROOT})
set(TBB_INC_SEARCH_PATH "")
set(TBB_LIB_SEARCH_PATH "")
#------------------------------------------------------------------------------#
#
# Components
#
#------------------------------------------------------------------------------#
# If user built from sources
set(TBB_BUILD_PREFIX $ENV{TBB_BUILD_PREFIX})
if (TBB_BUILD_PREFIX AND ENV_TBB_ROOT)
getenv_path(TBB_BUILD_DIR)
if (NOT ENV_TBB_BUILD_DIR)
set(ENV_TBB_BUILD_DIR ${ENV_TBB_ROOT}/build)
endif ()
SET(_TBB_POSSIBLE_COMPONENTS preview malloc malloc_proxy)
# include directory under ${ENV_TBB_ROOT}/include
list(APPEND TBB_LIB_SEARCH_PATH
${ENV_TBB_BUILD_DIR}/${TBB_BUILD_PREFIX}_release
${ENV_TBB_BUILD_DIR}/${TBB_BUILD_PREFIX}_debug)
endif ()
FOREACH(_TBB_COMPONENT ${TBB_FIND_COMPONENTS})
STRING(REPLACE "_debug" "" _TBB_COMPONENT ${_TBB_COMPONENT})
STRING(TOUPPER ${_TBB_COMPONENT} _TBB_COMPONENT_UPPER)
SET(_TBB_LIBRARY_BASE TBB_${_TBB_COMPONENT_UPPER}_LIBRARY)
# For Windows, let's assume that the user might be using the precompiled
# TBB packages from the main website. These use a rather awkward directory
# structure (at least for automatically finding the right files) depending
# on platform and compiler, but we'll do our best to accommodate it.
# Not adding the same effort for the precompiled linux builds, though. Those
# have different versions for CC compiler versions and linux kernels which
# will never adequately match the user's setup, so there is no feasible way
# to detect the "best" version to use. The user will have to manually
# select the right files. (Chances are the distributions are shipping their
# custom version of tbb, anyway, so the problem is probably nonexistent.)
if (WIN32 AND MSVC)
set(COMPILER_PREFIX "vc7.1")
if (MSVC_VERSION EQUAL 1400)
set(COMPILER_PREFIX "vc8")
elseif(MSVC_VERSION EQUAL 1500)
set(COMPILER_PREFIX "vc9")
elseif(MSVC_VERSION EQUAL 1600)
set(COMPILER_PREFIX "vc10")
elseif(MSVC_VERSION EQUAL 1700)
set(COMPILER_PREFIX "vc11")
elseif(MSVC_VERSION EQUAL 1800)
set(COMPILER_PREFIX "vc12")
elseif(MSVC_VERSION GREATER_EQUAL 1900)
set(COMPILER_PREFIX "vc14")
endif ()
IF(${_TBB_COMPONENT} MATCHES "malloc*")
SET(_TBB_LIBRARY_NAME tbb${_TBB_COMPONENT})
ELSE()
SET(_TBB_LIBRARY_NAME tbb_${_TBB_COMPONENT})
ENDIF()
# for each prefix path, add ia32/64\${COMPILER_PREFIX}\lib to the lib search path
foreach (dir IN LISTS TBB_PREFIX_PATH)
if (CMAKE_CL_64)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia64/${COMPILER_PREFIX}/lib)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia64/${COMPILER_PREFIX})
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/${COMPILER_PREFIX}/lib)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64/${COMPILER_PREFIX})
else ()
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/${COMPILER_PREFIX}/lib)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32/${COMPILER_PREFIX})
endif ()
endforeach ()
endif ()
FIND_LIBRARY(${_TBB_LIBRARY_BASE}_RELEASE
NAMES ${_TBB_LIBRARY_NAME}
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_POSSIBLE_LIB_SUFFIXES}
DOC "TBB ${_TBB_COMPONENT} release library")
# For OS X binary distribution, choose libc++ based libraries for Mavericks (10.9)
# and above and AppleClang
if (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND
NOT CMAKE_SYSTEM_VERSION VERSION_LESS 13.0)
set (USE_LIBCXX OFF)
cmake_policy(GET CMP0025 POLICY_VAR)
FIND_LIBRARY(${_TBB_LIBRARY_BASE}_DEBUG
NAMES ${_TBB_LIBRARY_NAME}_debug
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_POSSIBLE_LIB_SUFFIXES}
DOC "TBB ${_TBB_COMPONENT} debug library")
if (POLICY_VAR STREQUAL "NEW")
if (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
set (USE_LIBCXX ON)
endif ()
else ()
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
set (USE_LIBCXX ON)
endif ()
endif ()
MARK_AS_ADVANCED (${_TBB_LIBRARY_BASE} ${_TBB_LIBRARY_BASE}_DEBUG)
if (USE_LIBCXX)
foreach (dir IN LISTS TBB_PREFIX_PATH)
list (APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/libc++ ${dir}/libc++/lib)
endforeach ()
endif ()
endif ()
# default assumption
SET(TBB_${_TBB_COMPONENT_UPPER}_FOUND ON)
SET(TBB_${_TBB_COMPONENT}_FOUND ON)
# check compiler ABI
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
set(COMPILER_PREFIX)
if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
list(APPEND COMPILER_PREFIX "gcc4.8")
endif()
if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7)
list(APPEND COMPILER_PREFIX "gcc4.7")
endif()
if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.4)
list(APPEND COMPILER_PREFIX "gcc4.4")
endif()
list(APPEND COMPILER_PREFIX "gcc4.1")
elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
set(COMPILER_PREFIX)
if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.0) # Complete guess
list(APPEND COMPILER_PREFIX "gcc4.8")
endif()
if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.6)
list(APPEND COMPILER_PREFIX "gcc4.7")
endif()
list(APPEND COMPILER_PREFIX "gcc4.4")
else() # Assume compatibility with 4.4 for other compilers
list(APPEND COMPILER_PREFIX "gcc4.4")
endif ()
IF(${_TBB_LIBRARY_BASE}_DEBUG AND ${_TBB_LIBRARY_BASE}_RELEASE)
SET(${_TBB_LIBRARY_BASE}
debug ${${_TBB_LIBRARY_BASE}_DEBUG}
optimized ${${_TBB_LIBRARY_BASE}_RELEASE} CACHE STRING
"TBB ${_TBB_COMPONENT} library")
LIST(APPEND _TBB_ALL_LIBS
optimized ${${_TBB_LIBRARY_BASE}_RELEASE}
debug ${${_TBB_LIBRARY_BASE}_DEBUG})
LIST(APPEND TBB_FOUND_COMPONENTS ${_TBB_LIBRARY_BASE} ${_TBB_LIBRARY_BASE}_debug)
SET(TBB_${_TBB_COMPONENT_UPPER}_LIBRARY ${${_TBB_LIBRARY_BASE}_RELEASE})
ELSEIF(${_TBB_LIBRARY_BASE}_DEBUG)
SET(${_TBB_LIBRARY_BASE} ${${_TBB_LIBRARY_BASE}_DEBUG})
LIST(APPEND _TBB_ALL_LIBS ${${_TBB_LIBRARY_BASE}_DEBUG})
LIST(APPEND TBB_FOUND_COMPONENTS ${_TBB_LIBRARY_BASE})
SET(TBB_${_TBB_COMPONENT_UPPER}_LIBRARY ${${_TBB_LIBRARY_BASE}_DEBUG})
ELSEIF(${_TBB_LIBRARY_BASE}_RELEASE)
SET(${_TBB_LIBRARY_BASE} ${${_TBB_LIBRARY_BASE}_RELEASE}
CACHE FILEPATH "TBB ${_TBB_COMPONENT} library")
LIST(APPEND _TBB_ALL_LIBS ${${_TBB_LIBRARY_BASE}_RELEASE})
LIST(APPEND TBB_FOUND_COMPONENTS ${_TBB_LIBRARY_BASE}_debug)
SET(TBB_${_TBB_COMPONENT_UPPER}_LIBRARY ${${_TBB_LIBRARY_BASE}_RELEASE})
ELSE()
# Component missing: record it for a later report
LIST(APPEND _TBB_MISSING_COMPONENTS ${_TBB_COMPONENT})
SET(TBB_${_TBB_COMPONENT}_FOUND OFF)
SET(TBB_${_TBB_COMPONENT_UPPER}_FOUND OFF)
ENDIF()
# if platform architecture is explicitly specified
set(TBB_ARCH_PLATFORM $ENV{TBB_ARCH_PLATFORM})
if (TBB_ARCH_PLATFORM)
foreach (dir IN LISTS TBB_PREFIX_PATH)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/${TBB_ARCH_PLATFORM}/lib)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/${TBB_ARCH_PLATFORM})
endforeach ()
endif ()
IF(${_TBB_LIBRARY_BASE})
# setup the TBB_<COMPONENT>_LIBRARIES variable
SET(TBB_${_TBB_COMPONENT_UPPER}_LIBRARIES ${${_TBB_LIBRARY_BASE}})
ELSE()
LIST(APPEND _TBB_MISSING_LIBRARIES ${_TBB_LIBRARY_BASE})
ENDIF()
foreach (dir IN LISTS TBB_PREFIX_PATH)
foreach (prefix IN LISTS COMPILER_PREFIX)
if (CMAKE_SIZEOF_VOID_P EQUAL 8)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64/${prefix})
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/lib)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/${prefix}/lib)
else ()
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32/${prefix})
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/lib)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/${prefix}/lib)
endif ()
endforeach()
endforeach ()
ENDFOREACH(_TBB_COMPONENT ${TBB_FIND_COMPONENTS})
# add general search paths
foreach (dir IN LISTS TBB_PREFIX_PATH)
list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib ${dir}/Lib ${dir}/lib/tbb
${dir}/Libs)
list(APPEND TBB_INC_SEARCH_PATH ${dir}/include ${dir}/Include
${dir}/include/tbb)
endforeach ()
#------------------------------------------------------------------------------#
#
# Standard variables
#
#------------------------------------------------------------------------------#
IF(_TBB_ALL_LIBS)
SET(TBB_LIBRARIES ${_TBB_ALL_LIBS})
ENDIF()
set(TBB_LIBRARY_NAMES tbb)
get_debug_names(TBB_LIBRARY_NAMES)
IF(TBB_INCLUDE_DIR)
SET(TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR})
ENDIF()
IF(DEFINED _TBB_MISSING_COMPONENTS AND _TBB_CHECK_COMPONENTS)
IF(NOT TBB_FIND_QUIETLY)
MESSAGE(STATUS "One or more TBB components were not found:")
# Display missing components indented, each on a separate line
FOREACH(_TBB_MISSING_COMPONENT ${_TBB_MISSING_COMPONENTS})
MESSAGE(STATUS " " ${_TBB_MISSING_COMPONENT})
ENDFOREACH(_TBB_MISSING_COMPONENT ${_TBB_MISSING_COMPONENTS})
ENDIF(NOT TBB_FIND_QUIETLY)
ENDIF(DEFINED _TBB_MISSING_COMPONENTS AND _TBB_CHECK_COMPONENTS)
find_path(TBB_INCLUDE_DIR
NAMES tbb/tbb.h
PATHS ${TBB_INC_SEARCH_PATH})
#------------------------------------------------------------------------------#
#
# Library's version
#
#------------------------------------------------------------------------------#
find_library(TBB_LIBRARY_RELEASE
NAMES ${TBB_LIBRARY_NAMES}
PATHS ${TBB_LIB_SEARCH_PATH})
find_library(TBB_LIBRARY_DEBUG
NAMES ${TBB_LIBRARY_NAMES_DEBUG}
PATHS ${TBB_LIB_SEARCH_PATH})
make_library_set(TBB_LIBRARY)
SET(_TBB_VERSION_HEADER ${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h)
findpkg_finish(TBB tbb)
IF(EXISTS ${_TBB_VERSION_HEADER})
FILE(READ ${_TBB_VERSION_HEADER} _TBB_VERSION_CONTENTS)
#if we haven't found TBB no point on going any further
if (NOT TBB_FOUND)
return()
endif ()
STRING(REGEX REPLACE ".*#define TBB_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1"
TBB_VERSION_MAJOR "${_TBB_VERSION_CONTENTS}")
STRING(REGEX REPLACE ".*#define TBB_VERSION_MINOR[ \t]+([0-9]+).*" "\\1"
TBB_VERSION_MINOR "${_TBB_VERSION_CONTENTS}")
#=============================================================================
# Look for TBB's malloc package
set(TBB_MALLOC_LIBRARY_NAMES tbbmalloc)
get_debug_names(TBB_MALLOC_LIBRARY_NAMES)
SET(TBB_VERSION ${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR})
SET(TBB_VERSION_COMPONENTS 2)
ENDIF()
find_path(TBB_MALLOC_INCLUDE_DIR
NAMES tbb/tbb.h
PATHS ${TBB_INC_SEARCH_PATH})
IF(WIN32)
FIND_PROGRAM(LIB_EXECUTABLE NAMES lib
HINTS
"$ENV{VS110COMNTOOLS}/../../VC/bin"
"$ENV{VS100COMNTOOLS}/../../VC/bin"
"$ENV{VS90COMNTOOLS}/../../VC/bin"
"$ENV{VS71COMNTOOLS}/../../VC/bin"
"$ENV{VS80COMNTOOLS}/../../VC/bin"
DOC "Library manager")
find_library(TBB_MALLOC_LIBRARY_RELEASE
NAMES ${TBB_MALLOC_LIBRARY_NAMES}
PATHS ${TBB_LIB_SEARCH_PATH})
find_library(TBB_MALLOC_LIBRARY_DEBUG
NAMES ${TBB_MALLOC_LIBRARY_NAMES_DEBUG}
PATHS ${TBB_LIB_SEARCH_PATH})
make_library_set(TBB_MALLOC_LIBRARY)
MARK_AS_ADVANCED (LIB_EXECUTABLE)
ENDIF()
findpkg_finish(TBB_MALLOC tbbmalloc)
MACRO(GET_LIB_REQUISITES LIB REQUISITES)
IF(LIB_EXECUTABLE)
GET_FILENAME_COMPONENT(_LIB_PATH ${LIB_EXECUTABLE} PATH)
#=============================================================================
# Look for TBB's malloc proxy package
set(TBB_MALLOC_PROXY_LIBRARY_NAMES tbbmalloc_proxy)
get_debug_names(TBB_MALLOC_PROXY_LIBRARY_NAMES)
IF(MSVC)
# Do not redirect the output
UNSET(ENV{VS_UNICODE_OUTPUT})
ENDIF()
find_path(TBB_MALLOC_PROXY_INCLUDE_DIR
NAMES tbb/tbbmalloc_proxy.h
PATHS ${TBB_INC_SEARCH_PATH})
EXECUTE_PROCESS(COMMAND ${LIB_EXECUTABLE} /nologo /list ${LIB}
WORKING_DIRECTORY ${_LIB_PATH}/../../Common7/IDE
OUTPUT_VARIABLE _LIB_OUTPUT ERROR_QUIET)
find_library(TBB_MALLOC_PROXY_LIBRARY_RELEASE
NAMES ${TBB_MALLOC_PROXY_LIBRARY_NAMES}
PATHS ${TBB_LIB_SEARCH_PATH})
find_library(TBB_MALLOC_PROXY_LIBRARY_DEBUG
NAMES ${TBB_MALLOC_PROXY_LIBRARY_NAMES_DEBUG}
PATHS ${TBB_LIB_SEARCH_PATH})
make_library_set(TBB_MALLOC_PROXY_LIBRARY)
STRING(REPLACE "\n" ";" "${REQUISITES}" "${_LIB_OUTPUT}")
LIST(REMOVE_DUPLICATES ${REQUISITES})
ENDIF()
ENDMACRO()
findpkg_finish(TBB_MALLOC_PROXY tbbmalloc_proxy)
IF(_TBB_ALL_LIBS)
# collect lib requisites using the lib tool
FOREACH(_TBB_COMPONENT ${_TBB_ALL_LIBS})
GET_LIB_REQUISITES(${_TBB_COMPONENT} _TBB_REQUISITES)
ENDFOREACH(_TBB_COMPONENT)
ENDIF()
IF(NOT TBB_BINARY_DIR)
SET(_TBB_UPDATE_BINARY_DIR ON)
ELSE()
SET(_TBB_UPDATE_BINARY_DIR OFF)
ENDIF()
#=============================================================================
#parse all the version numbers from tbb
if(NOT TBB_VERSION)
if (EXISTS "${TBB_INCLUDE_DIR}/oneapi/tbb/version.h")
file(STRINGS
"${TBB_INCLUDE_DIR}/oneapi/tbb/version.h"
TBB_VERSION_CONTENTS
REGEX "VERSION")
else()
#only read the start of the file
file(STRINGS
"${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h"
TBB_VERSION_CONTENTS
REGEX "VERSION")
endif()
SET(_TBB_BINARY_DIR_HINTS ${_TBB_POSSIBLE_BIN_SUFFIXES})
string(REGEX REPLACE
".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1"
TBB_VERSION_MAJOR "${TBB_VERSION_CONTENTS}")
IF(_TBB_REQUISITES)
FIND_FILE(TBB_BINARY_DIR NAMES ${_TBB_REQUISITES}
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_BINARY_DIR_HINTS} NO_DEFAULT_PATH)
ENDIF()
string(REGEX REPLACE
".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1"
TBB_VERSION_MINOR "${TBB_VERSION_CONTENTS}")
IF(TBB_BINARY_DIR AND _TBB_UPDATE_BINARY_DIR)
SET(_TBB_BINARY_DIR ${TBB_BINARY_DIR})
UNSET(TBB_BINARY_DIR CACHE)
string(REGEX REPLACE
".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1"
TBB_INTERFACE_VERSION "${TBB_VERSION_CONTENTS}")
IF(_TBB_BINARY_DIR)
GET_FILENAME_COMPONENT(TBB_BINARY_DIR ${_TBB_BINARY_DIR} PATH)
ENDIF()
ENDIF()
string(REGEX REPLACE
".*#define TBB_COMPATIBLE_INTERFACE_VERSION ([0-9]+).*" "\\1"
TBB_COMPATIBLE_INTERFACE_VERSION "${TBB_VERSION_CONTENTS}")
SET(TBB_BINARY_DIR ${TBB_BINARY_DIR} CACHE PATH "TBB binary directory")
set(TBB_VERSION "${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR}")
MARK_AS_ADVANCED(TBB_INCLUDE_DIR TBB_LIBRARY TBB_LIBRARY_RELEASE
TBB_LIBRARY_DEBUG TBB_BINARY_DIR)
endif()
IF(NOT _TBB_CHECK_COMPONENTS)
SET(_TBB_FPHSA_ADDITIONAL_ARGS HANDLE_COMPONENTS)
ENDIF()
LIST(APPEND _TBB_FPHSA_ADDITIONAL_ARGS VERSION_VAR TBB_VERSION)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(TBB
REQUIRED_VARS
TBB_ROOT_DIR
TBB_INCLUDE_DIR
TBB_LIBRARY
${_TBB_MISSING_LIBRARIES}
HANDLE_COMPONENTS
${_TBB_FPHSA_ADDITIONAL_ARGS})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(TBB
REQUIRED_VARS TBB_INCLUDE_DIR TBB_LIBRARY
VERSION_VAR TBB_VERSION)
source/externals/ptl/cmake/Modules/MacroUtilities.cmake
Vendored
-994
View File
@@ -1,994 +0,0 @@
# MacroUtilities - useful macros and functions for generic tasks
#
# CMake Extensions
# ----------------
# macro set_ifnot(<var> <value>)
# If variable var is not set, set its value to that provided
#
# function enum_option(<option>
# VALUES <value1> ... <valueN>
# TYPE <valuetype>
# DOC <docstring>
# [DEFAULT <elem>]
# [CASE_INSENSITIVE])
# Declare a cache variable <option> that can only take values
# listed in VALUES. TYPE may be FILEPATH, PATH or STRING.
# <docstring> should describe that option, and will appear in
# the interactive CMake interfaces. If DEFAULT is provided,
# <elem> will be taken as the zero-indexed element in VALUES
# to which the value of <option> should default to if not
# provided. Otherwise, the default is taken as the first
# entry in VALUES. If CASE_INSENSITIVE is present, then
# checks of the value of <option> against the allowed values
# will ignore the case when performing string comparison.
#
#
# General
# --------------
# function add_feature(<NAME> <DOCSTRING>)
# Add a feature, whose activation is specified by the
# existence of the variable <NAME>, to the list of enabled/disabled
# features, plus a docstring describing the feature
#
# function print_enabled_features()
# Print enabled features plus their docstrings.
#
#
# - Include guard
include_guard(DIRECTORY)
cmake_policy(PUSH)
if(NOT CMAKE_VERSION VERSION_LESS 3.1)
cmake_policy(SET CMP0054 NEW)
endif()
include(CMakeDependentOption)
include(CMakeParseArguments)
#-----------------------------------------------------------------------
# CMAKE EXTENSIONS
#-----------------------------------------------------------------------
# macro set_ifnot(<var> <value>)
# If variable var is not set, set its value to that provided
#
macro(ptl_set_ifnot _var _value)
if(NOT DEFINED ${_var})
set(${_var} ${_value} ${ARGN})
endif()
endmacro()
#-----------------------------------------------------------------------
# macro safe_remove_duplicates(<list>)
# ensures remove_duplicates is only called if list has values
#
macro(ptl_safe_remove_duplicates _list)
if(NOT "${${_list}}" STREQUAL "")
list(REMOVE_DUPLICATES ${_list})
endif(NOT "${${_list}}" STREQUAL "")
endmacro()
#-----------------------------------------------------------------------
# function - capitalize - make a string capitalized (first letter is capital)
# usage:
# capitalize("SHARED" CShared)
# message(STATUS "-- CShared is \"${CShared}\"")
# $ -- CShared is "Shared"
function(ptl_capitalize str var)
# make string lower
string(TOLOWER "${str}" str)
string(SUBSTRING "${str}" 0 1 _first)
string(TOUPPER "${_first}" _first)
string(SUBSTRING "${str}" 1 -1 _remainder)
if(GOOD_CMAKE)
string(CONCAT str "${_first}" "${_remainder}")
else(GOOD_CMAKE)
set(str "${_first}${_remainder}")
endif(GOOD_CMAKE)
set(${var} "${str}" PARENT_SCOPE)
endfunction()
#-----------------------------------------------------------------------
# macro set_ifnot_match(<var> <value>)
# If variable var is not set, set its value to that provided
#
macro(PTL_SET_IFNOT_MATCH VAR APPEND)
if(NOT "${APPEND}" STREQUAL "")
STRING(REGEX MATCH "${APPEND}" _MATCH "${${VAR}}")
if(NOT "${_MATCH}" STREQUAL "")
SET(${VAR} "${${VAR}} ${APPEND}")
endif()
endif()
endmacro()
#-----------------------------------------------------------------------
# macro cache_ifnot(<var> <value>)
# If variable var is not set, set its value to that provided and cache it
#
macro(ptl_cache_ifnot _var _value _type _doc)
if(NOT ${_var} OR NOT ${CACHE_VARIABLES} MATCHES ${_var})
set(${_var} ${_value} CACHE ${_type} "${_doc}")
endif()
endmacro()
#-----------------------------------------------------------------------
# function enum_option(<option>
# VALUES <value1> ... <valueN>
# TYPE <valuetype>
# DOC <docstring>
# [DEFAULT <elem>]
# [CASE_INSENSITIVE])
# Declare a cache variable <option> that can only take values
# listed in VALUES. TYPE may be FILEPATH, PATH or STRING.
# <docstring> should describe that option, and will appear in
# the interactive CMake interfaces. If DEFAULT is provided,
# <elem> will be taken as the zero-indexed element in VALUES
# to which the value of <option> should default to if not
# provided. Otherwise, the default is taken as the first
# entry in VALUES. If CASE_INSENSITIVE is present, then
# checks of the value of <option> against the allowed values
# will ignore the case when performing string comparison.
#
function(ptl_enum_option _var)
set(options CASE_INSENSITIVE)
set(oneValueArgs DOC TYPE DEFAULT)
set(multiValueArgs VALUES)
cmake_parse_arguments(_ENUMOP "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
# - Validation as needed arguments
if(NOT _ENUMOP_VALUES)
message(FATAL_ERROR "enum_option must be called with non-empty VALUES\n(Called for enum_option '${_var}')")
endif()
# - Set argument defaults as needed
if(_ENUMOP_CASE_INSENSITIVE)
set(_ci_values )
foreach(_elem ${_ENUMOP_VALUES})
string(TOLOWER "${_elem}" _ci_elem)
list(APPEND _ci_values "${_ci_elem}")
endforeach()
set(_ENUMOP_VALUES ${_ci_values})
endif()
set_ifnot(_ENUMOP_TYPE STRING)
set_ifnot(_ENUMOP_DEFAULT 0)
list(GET _ENUMOP_VALUES ${_ENUMOP_DEFAULT} _default)
if(NOT DEFINED ${_var})
set(${_var} ${_default} CACHE ${_ENUMOP_TYPE} "${_ENUMOP_DOC} (${_ENUMOP_VALUES})")
else()
set(_var_tmp ${${_var}})
if(_ENUMOP_CASE_INSENSITIVE)
string(TOLOWER ${_var_tmp} _var_tmp)
endif()
list(FIND _ENUMOP_VALUES ${_var_tmp} _elem)
if(_elem LESS 0)
message(FATAL_ERROR "Value '${${_var}}' for variable ${_var} is not allowed\nIt must be selected from the set: ${_ENUMOP_VALUES} (DEFAULT: ${_default})\n")
else()
# - convert to lowercase
if(_ENUMOP_CASE_INSENSITIVE)
set(${_var} ${_var_tmp} CACHE ${_ENUMOP_TYPE} "${_ENUMOP_DOC} (${_ENUMOP_VALUES})" FORCE)
endif()
endif()
endif()
endfunction()
#-----------------------------------------------------------------------
# from
# http://www.cmake.org/pipermail/cmake/2008-April/021345.html
#-----------------------------------------------------------------------
#
#
# Adds a file or directory to the FILES_TO_DELETE var so that it is removed
# when "make distclean" is run
#
# Prototype:
# PTL_ADD_TO_DISTCLEAN(file)
# Parameters:
# file A file or dir
#
MACRO(PTL_ADD_TO_DISTCLEAN TARGET_TO_DELETE)
SET( FILES_TO_DELETE ${FILES_TO_DELETE} ${TARGET_TO_DELETE} )
ENDMACRO(PTL_ADD_TO_DISTCLEAN)
#-----------------------------------------------------------------------
# from
# http://www.cmake.org/pipermail/cmake/2008-April/021345.html
#-----------------------------------------------------------------------
#
# Create a "make distclean" target
#
# Prototype:
# GENERATE_DISTCLEAN_TARGET()
# Parameters:
# (none)
#
MACRO(PTL_GENERATE_DISTCLEAN_TARGET)
IF( EXISTS ${PROJECT_BINARY_DIR}/distclean_manifest.txt )
FILE( REMOVE ${PROJECT_BINARY_DIR}/distclean_manifest.txt )
ENDIF( EXISTS ${PROJECT_BINARY_DIR}/distclean_manifest.txt )
IF(MSVC)
SET( FILES_TO_DELETE ${FILES_TO_DELETE} ${PROJECT_BINARY_DIR}/*.dir )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/*.vcproj )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/*.vcproj.cmake )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.sln )
ENDIF(MSVC)
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/distclean.dir )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/CMakeCache.txt )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/install_manifest.txt )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/CPackConfig.cmake )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/CPackSourceConfig.cmake )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/_CPack_Packages )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/PACKAGE.dir )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/cmake_install.cmake )
# This code does not work yet. I don't know why CPACK_GENERATOR is null.
IF(CPACK_GENERATOR)
FOREACH(gen ${CPACK_GENERATOR})
MESSAGE("Adding file ${PROJECT_BINARY_DIR}/${CPACK_SOURCE_PACKAGE_FILE_NAME}.${gen} to distclean")
PTL_ADD_TO_DISTCLEAN(${PROJECT_BINARY_DIR}/${CPACK_SOURCE_PACKAGE_FILE_NAME}.${gen} )
ENDFOREACH(gen)
ELSE(CPACK_GENERATOR)
MESSAGE("CPACK_GENERATOR was not defined (value: ${CPACK_GENERATOR})")
ENDIF(CPACK_GENERATOR)
IF(EXECUTABLE_OUTPUT_PATH)
PTL_ADD_TO_DISTCLEAN( ${EXECUTABLE_OUTPUT_PATH} )
ENDIF(EXECUTABLE_OUTPUT_PATH)
IF(LIBRARY_OUTPUT_PATH)
PTL_ADD_TO_DISTCLEAN( ${LIBRARY_OUTPUT_PATH} )
ENDIF(LIBRARY_OUTPUT_PATH)
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/${CMAKE_FILES_DIRECTORY} )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/Makefile )
PTL_ADD_TO_DISTCLEAN( ${PROJECT_BINARY_DIR}/distclean_manifest.txt )
FOREACH(f ${FILES_TO_DELETE})
FILE(TO_NATIVE_PATH ${f} ff)
FILE(APPEND ${PROJECT_BINARY_DIR}/distclean_manifest.txt ${ff})
FILE(APPEND ${PROJECT_BINARY_DIR}/distclean_manifest.txt "\n")
ENDFOREACH(f)
IF(WIN32)
FILE( TO_NATIVE_PATH ${PROJECT_BINARY_DIR} PROJECT_BINARY_DIR_WIN32 )
ADD_CUSTOM_TARGET(distclean
FOR /F \"tokens=1* delims= \" %%f IN
\(${PROJECT_BINARY_DIR_WIN32}\\distclean_manifest.txt\) DO \(
IF EXIST %%f\\nul \(
rd /q /s %%f
\) ELSE \(
IF EXIST %%f \(
del /q /f %%f
\) ELSE \(
echo Warning: Problem when removing %%f. - Probable causes: File already removed or not enough permissions
\)
\)
\)
)
ELSE(WIN32)
# Unix
ADD_CUSTOM_TARGET(distclean cat
"${PROJECT_BINARY_DIR}/distclean_manifest.txt" | while read f \; do if
\[ -e \"\$\${f}\" \]; then rm -rf \"\$\${f}\" \; else echo \"Warning:
Problem when removing \"\$\${f}\" - Probable causes: File already
removed or not enough permissions\" \; fi\; done COMMENT Cleaning all
generated files...
)
ENDIF(WIN32)
ENDMACRO()
#-----------------------------------------------------------------------
# Determine if two paths are the same
#
#-----------------------------------------------------------------------
function(ptl_equal_paths VAR PATH1 PATH2)
get_filename_component(PATH1 ${PATH1} ABSOLUTE)
get_filename_component(PATH2 ${PATH2} ABSOLUTE)
if ("${PATH1}" STREQUAL "${PATH2}")
set(${VAR} ON PARENT_SCOPE)
else()
set(${VAR} OFF PARENT_SCOPE)
endif()
endfunction()
#-----------------------------------------------------------------------
# Resolve symbolic links, remove duplicates, and remove system paths
# in CMAKE_PREFIX_PATH
#
#-----------------------------------------------------------------------
function(ptl_clean_prefix_path)
set(_prefix_path )
foreach(_path ${CMAKE_PREFIX_PATH})
get_filename_component(_path ${_path} REALPATH)
set(IS_SYS_PATH OFF)
# loop over system path types
foreach(_type PREFIX INCLUDE LIBRARY APPBUNDLE FRAMEWORK PROGRAM)
# loop over system paths
foreach(_syspath ${CMAKE_SYSTEM_${_type}_PATH})
# check if equal
equal_paths(IS_SYS_PATH ${_path} ${_syspath})
# exit loop if equal
if(IS_SYS_PATH)
break()
endif(IS_SYS_PATH)
endforeach(_syspath ${CMAKE_SYSTEM_${_type}_PATH})
# exit loop if equal
if(IS_SYS_PATH)
break()
endif(IS_SYS_PATH)
endforeach(_type PREFIX INCLUDE LIBRARY APPBUNDLE FRAMEWORK PROGRAM)
# if not a system path
if(NOT IS_SYS_PATH)
list(APPEND _prefix_path ${_path})
endif(NOT IS_SYS_PATH)
endforeach()
# remove any duplicates
if(NOT "${_prefix_path}" STREQUAL "")
list(REMOVE_DUPLICATES _prefix_path)
endif()
# force the new prefix path
set(CMAKE_PREFIX_PATH ${_prefix_path} CACHE PATH
"Prefix path for finding packages" FORCE)
endfunction()
#-----------------------------------------------------------------------
# Add a defined ${PACKAGE_NAME}_ROOT variable defined via CMake or in
# environment to the CMAKE_PREFIX_PATH
#
# This macro should NOT be called directly, instead call
# ConfigureRootSearchPath (i.e. with "_" prefix)
#-----------------------------------------------------------------------
function(subConfigureRootSearchPath _package_name _search_other)
mark_as_advanced(PREVIOUS_${_package_name}_ROOT)
# if ROOT not already defined and ENV variable defines it
if(NOT ${_package_name}_ROOT_DIR AND
NOT "$ENV{${_package_name}_ROOT}" STREQUAL "")
ptl_cache_ifnot(${_package_name}_ROOT_DIR $ENV{${_package_name}_ROOT}
FILEPATH "ROOT search path for ${_package_name}")
endif()
# if ROOT is still not defined, check upper case and capitalize version
# and return
if(NOT ${_package_name}_ROOT_DIR)
if(_search_other)
string(TOUPPER "${_package_name}" ALT_PACKAGE_NAME)
if("${ALT_PACKAGE_NAME}" STREQUAL "${_package_name}")
ptl_capitalize("${_package_name}" ALT_PACKAGE_NAME)
subConfigureRootSearchPath(${ALT_PACKAGE_NAME} OFF)
else()
subConfigureRootSearchPath(${ALT_PACKAGE_NAME} OFF)
endif()
endif()
return()
endif()
# if ROOT is defined and has changed
if(${_package_name}_ROOT_DIR AND PREVIOUS_${_package_name}_ROOT_DIR AND
NOT "${PREVIOUS_${_package_name}_ROOT_DIR}" STREQUAL "${${_package_name}_ROOT_DIR}")
if(NOT "${PREVIOUS_${_package_name}_ROOT_DIR}" STREQUAL "${${_package_name}_ROOT_DIR}")
set(UNCACHE_PACKAGE_VARS ON)
endif()
# make sure it exists and is a directory
if(EXISTS "${${_package_name}_ROOT_DIR}" AND
IS_DIRECTORY "${${_package_name}_ROOT_DIR}")
set(CMAKE_PREFIX_PATH ${${_package_name}_ROOT_DIR} ${CMAKE_PREFIX_PATH}
CACHE PATH "CMake prefix paths" FORCE)
# store previous root to see if it changed
set(PREVIOUS_${_package_name}_ROOT_DIR ${${_package_name}_ROOT_DIR}
CACHE FILEPATH "Previous root search path for ${_package_name}" FORCE)
ptl_clean_prefix_path()
else()
message(WARNING "${_package_name}_ROOT_DIR specified an invalid directory")
unset(${_package_name}_ROOT_DIR CACHE)
endif()
# root changed so we want to refind the package
if(UNCACHE_PACKAGE_VARS)
string(TOLOWER "${_package_name}" CAP_PACKAGE_NAME)
string(SUBSTRING "${CAP_PACKAGE_NAME}" 0 1 FIRST)
string(SUBSTRING "${CAP_PACKAGE_NAME}" 1 -1 REST)
string(TOUPPER "${FIRST}" FIRST)
string(CONCAT CAP_PACKAGE_NAME "${FIRST}" "${REST}")
string(TOUPPER "${_package_name}" UPP_PACKAGE_NAME)
string(TOLOWER "${_package_name}" LOW_PACKAGE_NAME)
get_cmake_property(CACHED_VARIABLES CACHE_VARIABLES)
foreach(_name ${_package_name} ${CAP_PACKAGE_NAME}
${UPP_PACKAGE_NAME} ${LOW_PACKAGE_NAME})
# skip maintain
if(NOT MAINTAIN_${_name}_CACHE)
# loop over cached variables
foreach(_var ${CACHED_VARIABLES})
if("${_var}_" MATCHES "${_name}")
if(NOT "${_var}" STREQUAL "${_name}_ROOT_DIR" AND
NOT "${_var}" STREQUAL "PREVIOUS_${_name}_ROOT_DIR" AND
NOT "${_var}" STREQUAL "MAINTAIN_${_name}_CACHE")
unset(${_var} CACHE)
list(REMOVE_ITEM CACHED_VARIABLES "${_var}")
endif()
endif()
endforeach(_var ${CACHE_VARIABLES})
endif()
endforeach()
endif()
else()
if(EXISTS "${${_package_name}_ROOT_DIR}" AND
IS_DIRECTORY "${${_package_name}_ROOT_DIR}")
set(_add ON)
foreach(_path ${CMAKE_PREFIX_PATH})
if("${_path}" STREQUAL "${${_package_name}_ROOT_DIR}")
set(_add OFF)
break()
endif()
endforeach()
if(_add)
set(CMAKE_PREFIX_PATH ${${_package_name}_ROOT_DIR} ${CMAKE_PREFIX_PATH}
CACHE PATH "CMake prefix paths" FORCE)
clean_prefix_path()
endif()
# store previous root to see if it changed
set(PREVIOUS_${_package_name}_ROOT_DIR ${${_package_name}_ROOT_DIR}
CACHE FILEPATH "Previous root search path for ${_package_name}" FORCE)
else()
message(WARNING "${_package_name}_ROOT_DIR specified an invalid directory")
unset(${_package_name}_ROOT_DIR CACHE)
endif()
endif()
endfunction()
#-----------------------------------------------------------------------
# Add a defined ${PACKAGE_NAME}_ROOT_DIR variable defined via CMake or in
# environment to the CMAKE_PREFIX_PATH
#
# Different from _ConfigureRootSearchPath
#-----------------------------------------------------------------------
macro(ConfigureRootSearchPath)
foreach(_package_name ${ARGN})
subConfigureRootSearchPath(${_package_name} ON)
if($ENV{${_package_name}_DIR})
set(${_package_name}_DIR "$ENV{${_package_name}_DIR}" CACHE PATH
"CMake config directory for ${_package_name}")
endif()
endforeach()
endmacro()
#-----------------------------------------------------------------------
# GENERAL
#-----------------------------------------------------------------------
# function add_feature(<NAME> <DOCSTRING>)
# Add a project feature, whose activation is specified by the
# existence of the variable <NAME>, to the list of enabled/disabled
# features, plus a docstring describing the feature
#
FUNCTION(PTL_ADD_FEATURE _var _description)
set(EXTRA_DESC "")
foreach(currentArg ${ARGN})
if(NOT "${currentArg}" STREQUAL "${_var}" AND
NOT "${currentArg}" STREQUAL "${_description}")
set(EXTRA_DESC "${EXTA_DESC}${currentArg}")
endif()
endforeach()
set_property(GLOBAL APPEND PROPERTY PROJECT_FEATURES ${_var})
#set(${_var} ${${_var}} CACHE INTERNAL "${_description}${EXTRA_DESC}")
set_property(GLOBAL PROPERTY ${_var}_DESCRIPTION "${_description}${EXTRA_DESC}")
ENDFUNCTION()
#------------------------------------------------------------------------------#
# function add_subfeature(<ROOT_OPTION> <NAME> <DOCSTRING>)
# Add a subfeature, whose activation is specified by the
# existence of the variable <NAME>, to the list of enabled/disabled
# features, plus a docstring describing the feature
#
FUNCTION(PTL_ADD_SUBFEATURE _root _var _description)
set(EXTRA_DESC "")
foreach(currentArg ${ARGN})
if(NOT "${currentArg}" STREQUAL "${_var}" AND
NOT "${currentArg}" STREQUAL "${_description}")
set(EXTRA_DESC "${EXTA_DESC}${currentArg}")
endif()
endforeach()
set_property(GLOBAL APPEND PROPERTY ${_root}_FEATURES ${_var})
set_property(GLOBAL PROPERTY ${_root}_${_var}_DESCRIPTION "${_description}${EXTRA_DESC}")
ENDFUNCTION()
#------------------------------------------------------------------------------#
# function add_option(<OPTION_NAME> <DOCSRING> <DEFAULT_SETTING> [NO_FEATURE])
# Add an option and add as a feature if NO_FEATURE is not provided
#
FUNCTION(PTL_ADD_OPTION _NAME _MESSAGE _DEFAULT)
SET(__FEATURE ${ARGN})
IF(PTL_MASTER_PROJECT)
OPTION(${_NAME} "${_MESSAGE}" ${_DEFAULT})
IF(NOT "${__FEATURE}" STREQUAL "NO_FEATURE")
PTL_ADD_FEATURE(${_NAME} "${_MESSAGE}")
ELSE()
MARK_AS_ADVANCED(${_NAME})
ENDIF()
ELSE()
IF(NOT DEFINED ${_NAME})
SET(${_NAME} ${_DEFAULT})
ENDIF()
ENDIF()
ENDFUNCTION(PTL_ADD_OPTION _NAME _MESSAGE _DEFAULT)
#------------------------------------------------------------------------------#
# function add_dependent_option(<OPTION_NAME> <DOCSRING>
# <CONDITION_TRUE_SETTING> <CONDITION>
# <DEFAULT_SETTING> [NO_FEATURE])
# Add an option and add as a feature if NO_FEATURE is not provided
#
FUNCTION(PTL_ADD_DEPENDENT_OPTION _NAME _MESSAGE _COND_SETTING _COND _DEFAULT)
SET(_FEATURE ${ARGN})
IF(DEFINED ${_NAME} AND NOT ${_COND})
OPTION(${_NAME} "${_MESSAGE}" ${_DEFAULT})
ELSE(DEFINED ${_NAME} AND NOT ${_COND})
CMAKE_DEPENDENT_OPTION(${_NAME} "${_MESSAGE}" ${_COND_SETTING}
"${_COND}" ${_DEFAULT})
ENDIF(DEFINED ${_NAME} AND NOT ${_COND})
IF(NOT "${_FEATURE}" STREQUAL "NO_FEATURE")
ADD_FEATURE(${_NAME} "${_MESSAGE}")
ELSE()
MARK_AS_ADVANCED(${_NAME})
ENDIF()
ENDFUNCTION(PTL_ADD_DEPENDENT_OPTION _NAME _MESSAGE _DEFAULT _COND _COND_SETTING)
#------------------------------------------------------------------------------#
# function print_enabled_features()
# Print enabled features plus their docstrings.
#
function(ptl_print_enabled_features)
set(_basemsg "The following features are defined/enabled (+):")
set(_currentFeatureText "${_basemsg}")
get_property(_features GLOBAL PROPERTY PROJECT_FEATURES)
if(NOT "${_features}" STREQUAL "")
list(REMOVE_DUPLICATES _features)
list(SORT _features)
endif()
foreach(_feature ${_features})
if(${_feature})
# add feature to text
set(_currentFeatureText "${_currentFeatureText}\n ${_feature}")
# get description
get_property(_desc GLOBAL PROPERTY ${_feature}_DESCRIPTION)
# print description, if not standard ON/OFF, print what is set to
if(_desc)
if(NOT "${${_feature}}" STREQUAL "ON" AND
NOT "${${_feature}}" STREQUAL "TRUE")
set(_currentFeatureText "${_currentFeatureText}: ${_desc} -- [\"${${_feature}}\"]")
else()
string(REGEX REPLACE "^USE_" "" _feature_tmp "${_feature}")
string(TOLOWER "${_feature_tmp}" _feature_tmp_l)
ptl_capitalize("${_feature_tmp}" _feature_tmp_c)
foreach(_var _feature_tmp _feature_tmp_l _feature_tmp_c)
set(_ver "${${${_var}}_VERSION}")
if(NOT "${_ver}" STREQUAL "")
set(_desc "${_desc} -- [found version ${_ver}]")
break()
endif()
unset(_ver)
endforeach(_var _feature_tmp _feature_tmp_l _feature_tmp_c)
set(_currentFeatureText "${_currentFeatureText}: ${_desc}")
endif()
set(_desc NOTFOUND)
endif(_desc)
# check for subfeatures
get_property(_subfeatures GLOBAL PROPERTY ${_feature}_FEATURES)
# remove duplicates and sort if subfeatures exist
if(NOT "${_subfeatures}" STREQUAL "")
list(REMOVE_DUPLICATES _subfeatures)
list(SORT _subfeatures)
endif()
# sort enabled and disabled features into lists
set(_enabled_subfeatures )
set(_disabled_subfeatures )
foreach(_subfeature ${_subfeatures})
if(${_subfeature})
list(APPEND _enabled_subfeatures ${_subfeature})
else()
list(APPEND _disabled_subfeatures ${_subfeature})
endif()
endforeach()
# loop over enabled subfeatures
foreach(_subfeature ${_enabled_subfeatures})
# add subfeature to text
set(_currentFeatureText "${_currentFeatureText}\n + ${_subfeature}")
# get subfeature description
get_property(_subdesc GLOBAL PROPERTY ${_feature}_${_subfeature}_DESCRIPTION)
# print subfeature description. If not standard ON/OFF, print
# what is set to
if(_subdesc)
if(NOT "${${_subfeature}}" STREQUAL "ON" AND
NOT "${${_subfeature}}" STREQUAL "TRUE")
set(_currentFeatureText "${_currentFeatureText}: ${_subdesc} -- [\"${${_subfeature}}\"]")
else()
set(_currentFeatureText "${_currentFeatureText}: ${_subdesc}")
endif()
set(_subdesc NOTFOUND)
endif(_subdesc)
endforeach(_subfeature)
# loop over disabled subfeatures
foreach(_subfeature ${_disabled_subfeatures})
# add subfeature to text
set(_currentFeatureText "${_currentFeatureText}\n - ${_subfeature}")
# get subfeature description
get_property(_subdesc GLOBAL PROPERTY ${_feature}_${_subfeature}_DESCRIPTION)
# print subfeature description.
if(_subdesc)
set(_currentFeatureText "${_currentFeatureText}: ${_subdesc}")
set(_subdesc NOTFOUND)
endif(_subdesc)
endforeach(_subfeature)
endif(${_feature})
endforeach(_feature)
if(NOT "${_currentFeatureText}" STREQUAL "${_basemsg}")
message(STATUS "${_currentFeatureText}\n")
endif()
endfunction()
#------------------------------------------------------------------------------#
# function print_disabled_features()
# Print disabled features plus their docstrings.
#
function(ptl_print_disabled_features)
set(_basemsg "The following features are NOT defined/enabled (-):")
set(_currentFeatureText "${_basemsg}")
get_property(_features GLOBAL PROPERTY PROJECT_FEATURES)
if(NOT "${_features}" STREQUAL "")
list(REMOVE_DUPLICATES _features)
list(SORT _features)
endif()
foreach(_feature ${_features})
if(NOT ${_feature})
set(_currentFeatureText "${_currentFeatureText}\n ${_feature}")
get_property(_desc GLOBAL PROPERTY ${_feature}_DESCRIPTION)
if(_desc)
set(_currentFeatureText "${_currentFeatureText}: ${_desc}")
set(_desc NOTFOUND)
endif(_desc)
endif()
endforeach(_feature)
if(NOT "${_currentFeatureText}" STREQUAL "${_basemsg}")
message(STATUS "${_currentFeatureText}\n")
endif()
endfunction()
#------------------------------------------------------------------------------#
# function print_features()
# Print all features plus their docstrings.
#
function(ptl_print_features)
message(STATUS "")
ptl_print_enabled_features()
ptl_print_disabled_features()
endfunction()
#------------------------------------------------------------------------------#
macro(PTL_DETERMINE_LIBDIR_DEFAULT VAR)
set(_LIBDIR_DEFAULT "lib")
# Override this default 'lib' with 'lib64' iff:
# - we are on Linux system but NOT cross-compiling
# - we are NOT on debian
# - we are on a 64 bits system
# reason is: amd64 ABI: https://github.com/hjl-tools/x86-psABI/wiki/X86-psABI
# For Debian with multiarch, use 'lib/${CMAKE_LIBRARY_ARCHITECTURE}' if
# CMAKE_LIBRARY_ARCHITECTURE is set (which contains e.g. "i386-linux-gnu"
# and CMAKE_INSTALL_PREFIX is "/usr"
# See http://wiki.debian.org/Multiarch
if(DEFINED _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX)
set(__LAST_LIBDIR_DEFAULT "lib")
# __LAST_LIBDIR_DEFAULT is the default value that we compute from
# _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX, not a cache entry for
# the value that was last used as the default.
# This value is used to figure out whether the user changed the
# LIBDIR_DEFAULT value manually, or if the value was the
# default one. When CMAKE_INSTALL_PREFIX changes, the value is
# updated to the new default, unless the user explicitly changed it.
endif()
if(CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU)$"
AND NOT CMAKE_CROSSCOMPILING)
if (EXISTS "/etc/debian_version") # is this a debian system ?
if(CMAKE_LIBRARY_ARCHITECTURE)
if("${CMAKE_INSTALL_PREFIX}" MATCHES "^/usr/?$")
set(_LIBDIR_DEFAULT "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
endif()
if(DEFINED _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX
AND "${_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX}" MATCHES "^/usr/?$")
set(__LAST_LIBDIR_DEFAULT "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
endif()
endif()
else() # not debian, rely on CMAKE_SIZEOF_VOID_P:
if(NOT DEFINED CMAKE_SIZEOF_VOID_P)
message(AUTHOR_WARNING
"Unable to determine default LIBDIR_DEFAULT directory "
"because no target architecture is known. "
"Please enable at least one language before including GNUInstallDirs.")
else()
if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
set(_LIBDIR_DEFAULT "lib64")
if(DEFINED _GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX)
set(__LAST_LIBDIR_DEFAULT "lib64")
endif()
endif()
endif()
endif()
endif()
# if assign to another variable
if(NOT "${VAR}" STREQUAL "LIBDIR_DEFAULT")
set(${VAR} "${_LIBDIR_DEFAULT}")
endif(NOT "${VAR}" STREQUAL "LIBDIR_DEFAULT")
# cache the value
if(NOT DEFINED LIBDIR_DEFAULT)
set(LIBDIR_DEFAULT "${_LIBDIR_DEFAULT}" CACHE PATH "Object code libraries (${_LIBDIR_DEFAULT})" FORCE)
elseif(DEFINED __LAST_LIBDIR_DEFAULT
AND "${__LAST_LIBDIR_DEFAULT}" STREQUAL "${LIBDIR_DEFAULT}")
set(LIBDIR_DEFAULT "${_LIBDIR_DEFAULT}" CACHE STRING "")
set_property(CACHE LIBDIR_DEFAULT PROPERTY VALUE "${_LIBDIR_DEFAULT}")
endif()
endmacro()
#------------------------------------------------------------------------------#
# macro CACHE_VARIABLES_FOR_REFERENCE(...)
# Provide a list of variables that will be stored in the cache
# as {variable_name}_REF for later reference
# This version does not force the cache to be updated
macro(PTL_CACHE_VARIABLES_FOR_REFERENCE)
foreach(_var ${ARGN})
set(${_var}_REF ${${_var}} CACHE STRING
"Cached reference of ${_var} under ${_var}_REF for later comparison")
endforeach()
endmacro()
#------------------------------------------------------------------------------#
# macro CACHE_VARIABLES_FOR_REFERENCE(...)
# Provide a list of variables that will be stored in the cache
# as {variable_name}_REF for later reference
# This version forces the cache to be updated
macro(PTL_UPDATE_REFERENCE_CACHE_VARIABLES)
foreach(_var ${ARGN})
set(${_var}_REF ${${_var}} CACHE STRING
"Cached reference of ${_var} under ${_var}_REF for later comparison"
FORCE)
endforeach()
endmacro()
#------------------------------------------------------------------------------#
# macro GET_HOSTNAME(<VAR>)
#
function(GET_HOSTNAME VAR)
find_program(HOSTNAME_CMD hostname)
execute_process(COMMAND ${HOSTNAME_CMD}
OUTPUT_VARIABLE _HOSTNAME
WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
OUTPUT_STRIP_TRAILING_WHITESPACE)
set(${VAR} "${_HOSTNAME}" PARENT_SCOPE)
endfunction(GET_HOSTNAME VAR)
#------------------------------------------------------------------------------#
# macro CHECKOUT_GIT_SUBMODULE()
#
# Run "git submodule update" if a file in a submodule does not exist
#
# ARGS:
# RECURSIVE (option) -- add "--recursive" flag
# RELATIVE_PATH (one value) -- typically the relative path to submodule
# from PROJECT_SOURCE_DIR
# WORKING_DIRECTORY (one value) -- (default: PROJECT_SOURCE_DIR)
# TEST_FILE (one value) -- file to check for (default: CMakeLists.txt)
# ADDITIONAL_CMDS (many value) -- any addition commands to pass
#
macro(PTL_CHECKOUT_GIT_SUBMODULE)
# parse args
cmake_parse_arguments(
CHECKOUT
"RECURSIVE"
"RELATIVE_PATH;WORKING_DIRECTORY;TEST_FILE"
"ADDITIONAL_CMDS"
${ARGN})
if(NOT CHECKOUT_WORKING_DIRECTORY)
set(CHECKOUT_WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
endif(NOT CHECKOUT_WORKING_DIRECTORY)
if(NOT CHECKOUT_TEST_FILE)
set(CHECKOUT_TEST_FILE "CMakeLists.txt")
endif(NOT CHECKOUT_TEST_FILE)
set(_DIR "${CHECKOUT_WORKING_DIRECTORY}/${CHECKOUT_RELATIVE_PATH}")
# ensure the (possibly empty) directory exists
if(NOT EXISTS "${_DIR}")
message(FATAL_ERROR "submodule directory does not exist")
endif(NOT EXISTS "${_DIR}")
# if this file exists --> project has been checked out
# if not exists --> not been checked out
set(_TEST_FILE "${_DIR}/${CHECKOUT_TEST_FILE}")
# if the module has not been checked out
if(NOT EXISTS "${_TEST_FILE}")
find_package(Git REQUIRED)
set(_RECURSE )
if(CHECKOUT_RECURSIVE)
set(_RECURSE --recursive)
endif(CHECKOUT_RECURSIVE)
# perform the checkout
execute_process(
COMMAND
${GIT_EXECUTABLE} submodule update --init ${_RECURSE}
${CHECKOUT_ADDITIONAL_CMDS} ${CHECKOUT_RELATIVE_PATH}
WORKING_DIRECTORY
${CHECKOUT_WORKING_DIRECTORY}
RESULT_VARIABLE RET)
# check the return code
if(RET GREATER 0)
set(_CMD "${GIT_EXECUTABLE} submodule update --init ${_RECURSE}
${CHECKOUT_ADDITIONAL_CMDS} ${CHECKOUT_RELATIVE_PATH}")
message(STATUS "macro(CHECKOUT_SUBMODULE) failed.")
message(FATAL_ERROR "Command: \"${_CMD}\"")
endif(RET GREATER 0)
endif(NOT EXISTS "${_TEST_FILE}")
endmacro()
#----------------------------------------------------------------------------
# Macro for building library
#
macro(PTL_BUILD_LIBRARY)
cmake_parse_arguments(LIB
"VERSION" "TYPE;TARGET_NAME;OUTPUT_NAME;EXTENSION" "LINK_LIBRARIES;SOURCES;EXTRA_ARGS"
${ARGN})
macro(setifnot VAR)
if(NOT ${VAR} OR "${${VAR}}" STREQUAL "")
set(${VAR} ${ARGN})
endif()
endmacro()
setifnot(LIB_EXTENSION ${PYTHON_MODULE_EXTENSION})
setifnot(LIB_OUTPUT_NAME ${LIB_TARGET_NAME})
add_library(${LIB_TARGET_NAME} ${LIB_TYPE} ${LIB_SOURCES})
add_library(${PROJECT_NAME}::${LIB_TARGET_NAME} ALIAS ${LIB_TARGET_NAME})
if(LIB_VERSION)
list(APPEND LIB_EXTRA_ARGS VERSION ${${PROJECT_NAME}_VERSION}
SOVERSION ${${PROJECT_NAME}_VERSION_MAJOR})
endif()
target_link_libraries(${LIB_TARGET_NAME} PUBLIC
ptl-external-packages ${LIB_LINK_LIBRARIES})
set_target_properties(${LIB_TARGET_NAME}
PROPERTIES
OUTPUT_NAME ${LIB_OUTPUT_NAME}
LANGUAGE CXX
LINKER_LANGUAGE CXX
POSITION_INDEPENDENT_CODE ON
${LIB_EXTRA_ARGS})
if(WIN32)
set_target_properties(${LIB_TARGET_NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
endif()
target_compile_definitions(${LIB_TARGET_NAME} PUBLIC
${${PROJECT_NAME}_DEFINITIONS})
target_compile_features(${LIB_TARGET_NAME}
PUBLIC cxx_std_${CMAKE_CXX_STANDARD})
get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
if("CUDA" IN_LIST languages)
target_compile_options(${LIB_TARGET_NAME} PUBLIC
$<$<COMPILE_LANGUAGE:C>:${${PROJECT_NAME}_C_FLAGS} ${LIB_CFLAGS}>
$<$<COMPILE_LANGUAGE:CXX>:${${PROJECT_NAME}_CXX_FLAGS} ${LIB_CXXFLAGS}>
$<$<COMPILE_LANGUAGE:CUDA>:${${PROJECT_NAME}_CUDA_FLAGS} ${LIB_CUDAFLAGS}>)
else()
target_compile_options(${LIB_TARGET_NAME} PUBLIC
$<$<COMPILE_LANGUAGE:C>:${${PROJECT_NAME}_C_FLAGS} ${LIB_CFLAGS}>
$<$<COMPILE_LANGUAGE:CXX>:${${PROJECT_NAME}_CXX_FLAGS} ${LIB_CXXFLAGS}>)
endif()
endmacro()
#-----------------------------------------------------------------------
# function add_enabled_interface(<NAME>)
# Mark an interface library as enabled
#
FUNCTION(PTL_ADD_ENABLED_INTERFACE _var)
set_property(GLOBAL APPEND PROPERTY ${PROJECT_NAME}_ENABLED_INTERFACES ${_var})
ENDFUNCTION()
#-----------------------------------------------------------------------
# function add_disabled_interface(<NAME>)
# Mark an interface as disabled
#
FUNCTION(PTL_ADD_DISABLED_INTERFACE _var)
get_property(_DISABLED GLOBAL PROPERTY ${PROJECT_NAME}_DISABLED_INTERFACES)
if(NOT ${_var} IN_LIST _DISABLED)
set_property(GLOBAL APPEND PROPERTY ${PROJECT_NAME}_DISABLED_INTERFACES ${_var})
endif()
ENDFUNCTION()
#----------------------------------------------------------------------------------------#
# macro to add an interface lib
#
FUNCTION(PTL_ADD_INTERFACE_LIBRARY _TARGET)
if(NOT TARGET ${_TARGET})
add_library(${_TARGET} INTERFACE ${ARGN})
add_library(${PROJECT_NAME}::${_TARGET} ALIAS ${_TARGET})
set_property(GLOBAL APPEND PROPERTY ${PROJECT_NAME}_INTERFACE_LIBRARIES ${_TARGET})
ptl_add_enabled_interface(${_TARGET})
install(TARGETS ${_TARGET}
DESTINATION ${CMAKE_INSTALL_LIBDIR}
EXPORT ${PROJECT_NAME}Targets
COMPONENT Development)
endif()
ENDFUNCTION()
#----------------------------------------------------------------------------------------#
# get the list of interface libraries
#
FUNCTION(PTL_GET_INTERFACE_LIBRARIES _VAR)
get_property(_LIBS GLOBAL PROPERTY ${PROJECT_NAME}_INTERFACE_LIBRARIES)
set(${_VAR} ${_LIBS} PARENT_SCOPE)
ENDFUNCTION()
#------------------------------------------------------------------------------#
# always determine the default lib directory
PTL_DETERMINE_LIBDIR_DEFAULT(LIBDIR_DEFAULT)
#------------------------------------------------------------------------------#
# get the hostname
get_hostname(HOSTNAME)
string(REPLACE ".local" "" HOSTNAME "${HOSTNAME}")
cmake_policy(POP)
source/externals/ptl/cmake/Modules/Options.cmake
Vendored
-113
View File
@@ -1,113 +0,0 @@
################################################################################
#
# PTL Options
#
################################################################################
include(MacroUtilities)
include(Compilers)
set(_FEATURE )
if(NOT PTL_MASTER_PROJECT)
set(_FEATURE NO_FEATURE)
endif()
#set(CMAKE_CXX_STANDARD_REQUIRED ON CACHE BOOL "Require the C++ standard" FORCE)
#set(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "Disable GNU extensions")
# features
ptl_add_feature(CMAKE_BUILD_TYPE "Build type (Debug, Release, RelWithDebInfo, MinSizeRel)")
ptl_add_feature(CMAKE_INSTALL_PREFIX "Installation prefix")
ptl_add_feature(CMAKE_CXX_STANDARD "C++11 STL standard")
ptl_add_feature(${PROJECT_NAME}_C_FLAGS "C flags for project")
ptl_add_feature(${PROJECT_NAME}_CXX_FLAGS "C++ flags for project")
# options (always available)
ptl_add_option(BUILD_STATIC_LIBS "Build static library" ON ${_FEATURE})
ptl_add_option(BUILD_SHARED_LIBS "Build shared library" ON ${_FEATURE})
ptl_add_option(PTL_BUILD_EXAMPLES "Build examples" OFF ${_FEATURE})
ptl_add_option(PTL_BUILD_DOCS "Build documentation with Doxygen" OFF ${_FEATURE})
ptl_add_option(PTL_DEVELOPER_INSTALL "Install headers, cmake export, and shared libs" ON ${_FEATURE})
ptl_add_option(PTL_USE_TBB "Enable TBB" ON ${_FEATURE})
ptl_add_option(PTL_USE_GPU "Enable GPU preprocessor" OFF ${_FEATURE})
ptl_add_option(PTL_USE_SANITIZER "Enable -fsanitize=<type>" OFF ${_FEATURE})
ptl_add_option(PTL_USE_CLANG_TIDY "Enable running clang-tidy on" OFF ${_FEATURE})
ptl_add_option(PTL_USE_COVERAGE "Enable code coverage" OFF ${_FEATURE})
ptl_add_option(PTL_USE_LOCKS "Enable mutex locking in task subqueues for extra safety" OFF ${_FEATURE})
# add_option(PTL_USE_PROFILE "Enable profiling" OFF ${_FEATURE})
if(PTL_USE_ARCH)
ptl_add_option(PTL_USE_AVX512 "Enable AVX-512 flags (if available)" OFF ${_FEATURE})
endif()
if(PTL_USE_COVERAGE)
set(CMAKE_BUILD_TYPE Debug)
endif()
if(PTL_USE_SANITIZER)
ptl_add_feature(PTL_SANITIZER_TYPE "Sanitizer type (i.e. -fsanitize=<type>)")
#set(PTL_SANITIZER_TYPE thread CACHE STRING "Sanitizer type (i.e. -fsanitize=<type>)")
endif()
if(PTL_USE_GPU)
# Check if CUDA can be enabled
find_package(CUDA QUIET)
if(CUDA_FOUND)
check_language(CUDA)
if(CMAKE_CUDA_COMPILER)
enable_language(CUDA)
else()
message(STATUS "No CUDA support")
set(_USE_CUDA OFF)
endif()
else()
set(_USE_CUDA OFF)
set(PTL_USE_GPU OFF)
endif()
if(_USE_CUDA)
list(APPEND ${PROJECT_NAME}_DEFINITIONS PTL_USE_GPU)
ptl_add_option(PTL_USE_CUDA "Enable CUDA option for GPU execution" ${_USE_CUDA} ${_FEATURE})
ptl_add_option(PTL_USE_NVTX "Enable NVTX for Nsight" ${_USE_CUDA} ${_FEATURE})
set(CUDA_ARCH "sm_35" CACHE STRING "CUDA architecture flag")
if(_FEATURE)
ptl_add_feature(CUDA_ARCH "CUDA architecture (e.g. sm_35)")
ptl_add_feature(CUDA_GENERATED_OUTPUT_DIR "CUDA output directory for generated files")
endif()
endif()
endif()
# RPATH settings
#set(_RPATH_LINK OFF)
#if(APPLE)
# set(_RPATH_LINK ON)
#endif()
#ptl_add_option(CMAKE_INSTALL_RPATH_USE_LINK_PATH "Hardcode installation rpath based on link path" ${_RPATH_LINK} ${_FEATURE})
#unset(_RPATH_LINK)
# clang-tidy
if(PTL_USE_CLANG_TIDY)
find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
ptl_add_feature(CLANG_TIDY_COMMAND "Path to clang-tidy command")
if(NOT CLANG_TIDY_COMMAND)
message(WARNING "PTL_USE_CLANG_TIDY is ON but clang-tidy is not found!")
set(PTL_USE_CLANG_TIDY OFF)
else()
set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND}")
# Create a preprocessor definition that depends on .clang-tidy content so
# the compile command will change when .clang-tidy changes. This ensures
# that a subsequent build re-runs clang-tidy on all sources even if they
# do not otherwise need to be recompiled. Nothing actually uses this
# definition. We add it to targets on which we run clang-tidy just to
# get the build dependency on the .clang-tidy file.
file(SHA1 ${PROJECT_SOURCE_DIR}/.clang-tidy clang_tidy_sha1)
set(CLANG_TIDY_DEFINITIONS "CLANG_TIDY_SHA1=${clang_tidy_sha1}")
unset(clang_tidy_sha1)
endif()
configure_file(${PROJECT_SOURCE_DIR}/.clang-tidy ${PROJECT_SOURCE_DIR}/.clang-tidy COPYONLY)
endif()
source/externals/ptl/cmake/Modules/PTLBuildSettings.cmake
Vendored
+144
View File
@@ -0,0 +1,144 @@
# PTL Build Settings and Options
include(PTLCMakeUtilities)
include(CheckCXXCompilerFlag)
# -------------------------------------------------------------------------------------- #
#
# Build Type(s)
#
# -------------------------------------------------------------------------------------- #
set(__ptl_default_build_type "Release")
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
message(
STATUS
"Forcing PTL CMAKE_BUILD_TYPE to '${__ptl_default_build_type}' as none was specified"
)
set(CMAKE_BUILD_TYPE
"${__ptl_default_build_type}"
CACHE STRING "Choose the type of build." FORCE)
# Set the possible values of build type for cmake-gui
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel"
"RelWithDebInfo")
endif()
# -------------------------------------------------------------------------------------- #
#
# Output Directories for build products
#
# -------------------------------------------------------------------------------------- #
# If master project, set the output directory (critical on Windows and Xcode) Otherwise we
# leave this at the discretion of the parent project
#
if(PTL_MASTER_PROJECT)
set(_BIN_DIR ${PROJECT_BINARY_DIR})
if(WIN32)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${_BIN_DIR}/outputs/runtime)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${_BIN_DIR}/outputs/library)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${_BIN_DIR}/outputs/archive)
else()
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${_BIN_DIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${_BIN_DIR})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${_BIN_DIR})
endif()
endif()
# -------------------------------------------------------------------------------------- #
#
# Library types
#
# -------------------------------------------------------------------------------------- #
ptl_add_option(BUILD_STATIC_LIBS "Build static library" ON)
ptl_add_option(BUILD_SHARED_LIBS "Build shared library" ON)
if(NOT "${CMAKE_PROJECT_NAME}" STREQUAL "${PROJECT_NAME}")
ptl_add_option(BUILD_OBJECT_LIBS "Build object library (only valid as subproject)"
OFF)
set(PTL_EXCLUDE_FROM_ALL EXCLUDE_FROM_ALL)
set(PTL_BUILD_LIBS_ERROR_DESC
"BUILD_STATIC_LIBS, BUILD_SHARED_LIBS, and BUILD_OBJECT_LIBS are all OFF")
else()
set(BUILD_OBJECT_LIBS OFF)
set(PTL_EXCLUDE_FROM_ALL)
set(PTL_BUILD_LIBS_ERROR_DESC
"Neither BUILD_STATIC_LIBS nor BUILD_SHARED_LIBS are set")
endif()
if((NOT BUILD_SHARED_LIBS)
AND (NOT BUILD_STATIC_LIBS)
AND (NOT BUILD_OBJECT_LIBS))
message(FATAL_ERROR "${PTL_BUILD_LIBS_ERROR_DESC}. One must be ON")
endif()
# -------------------------------------------------------------------------------------- #
#
# C/C++ Standard and Flags
#
# -------------------------------------------------------------------------------------- #
if(WIN32)
set(CMAKE_CXX_STANDARD
14
CACHE STRING "C++ STL standard")
else()
set(CMAKE_CXX_STANDARD
11
CACHE STRING "C++ STL standard")
endif()
ptl_message_on_change(CMAKE_CXX_STANDARD "Building PTL with CMAKE_CXX_STANDARD")
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
# Add allocation export symbol for the PTL module Should this be a
# target_compile_definition?
add_compile_definitions(PTL_ALLOC_EXPORT)
# -------------------------------------------------------------------------------------- #
#
# Testing/Profiling Options
#
# -------------------------------------------------------------------------------------- #
# Coverage compile/link settings See also:
# https://discourse.cmake.org/t/best-practice-for-multi-config-build-options/2049
ptl_add_option(PTL_USE_COVERAGE "Enable code coverage" OFF)
if(PTL_USE_COVERAGE)
if((NOT CMAKE_BUILD_TYPE STREQUAL "Debug") AND (NOT CMAKE_CONFIGURATION_TYPES))
message(
WARNING
"PTL_USE_COVERAGE is ON, but the build mode is not 'Debug': coverage testing will be disabled."
)
set(PTL_USE_COVERAGE
OFF
CACHE BOOL "Enable code coverage (disabled)" FORCE)
else()
include(PTLCoverage)
endif()
endif()
# Sanitizer compile/link flags See also:
# https://discourse.cmake.org/t/best-practice-for-multi-config-build-options/2049
ptl_add_option(PTL_USE_SANITIZER "Enable -fsanitize=<type>" OFF)
if(PTL_USE_SANITIZER)
set(__ptl_sanitizer_type_default "thread")
if(PTL_SANITIZER_TYPE)
set(__ptl_sanitizer_type_default "${PTL_SANITIZER_TYPE}")
endif()
set(PTL_SANITIZER_TYPE
"${__ptl_sanitizer_type_default}"
CACHE STRING "Sanitizer type (-fsanitize=<type>)")
set_property(CACHE PTL_SANITIZER_TYPE PROPERTY STRINGS "thread" "address" "undefined")
ptl_message_on_change(PTL_SANITIZER_TYPE "Building PTL with sanitizer type")
include(PTLSanitize)
endif()
# Clang Tooling
if(PTL_MASTER_PROJECT)
include(PTLFormatting)
endif()
ptl_add_option(PTL_USE_CLANG_TIDY "Enable running clang-tidy on sources" OFF)
if(PTL_USE_CLANG_TIDY)
include(PTLLinting)
endif()
source/externals/ptl/cmake/Modules/PTLCMakeUtilities.cmake
Vendored
+122
View File
@@ -0,0 +1,122 @@
# PTLCMakeUtilities - useful macros and functions for generic tasks
#
# CMake Extensions
# ----------------
# * Include guard
include_guard(DIRECTORY)
include(CMakeParseArguments)
# -------------------------------------------------------------------------------------- #
# function ptl_message_on_change(<VAR> <MESSAGE>) Watch <VAR> and print <MESSAGE> and
# <VAR>'s value when the value changes
#
function(ptl_message_on_change _var _prefix)
set(_ptl_watch_var_name PTL_WATCH_VALUE_${_var})
if(DEFINED ${_ptl_watch_var_name})
if("${${_var}}" STREQUAL "${${_ptl_watch_var_name}}")
return()
endif()
endif()
set(${_ptl_watch_var_name}
"${${_var}}"
CACHE INTERNAL "Last value of ${_var}" FORCE)
message(STATUS "${_prefix} - ${${_var}}")
endfunction()
# -------------------------------------------------------------------------------------- #
# function ptl_add_feature(<NAME> <DOCSTRING>) Store activation of a feature and a
# docstring describing it. <NAME> should be a variable whose value indicates activation of
# the feature
#
function(ptl_add_feature _var _description)
if(${_var})
set_property(GLOBAL APPEND PROPERTY PTL_ENABLED_FEATURES ${_var})
endif()
set_property(GLOBAL PROPERTY PTL_FEATURE_${_var}_DESCRIPTION "${_description}")
endfunction()
# -----------------------------------------------------------------------
# function ptl_print_features() Print enabled features plus their docstrings.
#
function(ptl_print_features)
set(_currentFeatureText "The following PTL features are enabled:")
get_property(_enabledFeatures GLOBAL PROPERTY PTL_ENABLED_FEATURES)
foreach(_feature ${_enabledFeatures})
set(_currentFeatureText "${_currentFeatureText}\n - ${_feature}")
get_property(_desc GLOBAL PROPERTY PTL_FEATURE_${_feature}_DESCRIPTION)
if(_desc)
set(_currentFeatureText "${_currentFeatureText}: ${_desc}")
set(_desc NOTFOUND)
endif()
endforeach()
message(STATUS "${_currentFeatureText}\n")
endfunction()
# -------------------------------------------------------------------------------------- #
# function ptl_add_option(<OPTION_NAME> <DOCSTRING> <DEFAULT_SETTING>) Add an option for
# master project only, always reporting its value
#
function(ptl_add_option _NAME _MESSAGE _DEFAULT)
if(PTL_MASTER_PROJECT)
option(${_NAME} "${_MESSAGE}" ${_DEFAULT})
ptl_add_feature(${_NAME} "${_MESSAGE}")
endif()
# Always on configure time reporting
ptl_message_on_change(${_NAME} "Building PTL with option ${_NAME}")
endfunction()
# ----------------------------------------------------------------------------
# function ptl_build_library Encapsulates common build/install for main PTL shared/static
# libs
#
function(ptl_build_library)
cmake_parse_arguments(LIB "" "TYPE;TARGET_NAME;OUTPUT_NAME" "SOURCES;EXTRA_ARGS"
${ARGN})
if(NOT LIB_OUTPUT_NAME)
set(LIB_OUTPUT_NAME ${LIB_TARGET_NAME})
endif()
add_library(${LIB_TARGET_NAME} ${LIB_TYPE} ${PTL_EXCLUDE_FROM_ALL})
add_library(${PROJECT_NAME}::${LIB_TARGET_NAME} ALIAS ${LIB_TARGET_NAME})
target_sources(${LIB_TARGET_NAME} PRIVATE ${LIB_SOURCES})
target_compile_definitions(${LIB_TARGET_NAME} PRIVATE $<$<CONFIG:Debug>:DEBUG>)
target_compile_features(${LIB_TARGET_NAME} PUBLIC cxx_std_${CMAKE_CXX_STANDARD})
# Subproject overrides only if not a master project
if(NOT PTL_MASTER_PROJECT)
target_compile_options(
${LIB_TARGET_NAME}
PRIVATE $<$<COMPILE_LANGUAGE:C>:${${PROJECT_NAME}_C_FLAGS}>
$<$<COMPILE_LANGUAGE:CXX>:${${PROJECT_NAME}_CXX_FLAGS}>)
endif()
set_target_properties(
${LIB_TARGET_NAME}
PROPERTIES OUTPUT_NAME ${LIB_OUTPUT_NAME}
VERSION ${${PROJECT_NAME}_VERSION}
SOVERSION ${${PROJECT_NAME}_VERSION_MAJOR}
WINDOWS_EXPORT_ALL_SYMBOLS ON)
# Install the targets and export libraries
if(NOT "${LIB_TYPE}" STREQUAL "OBJECT")
install(
TARGETS ${LIB_TARGET_NAME}
EXPORT ${PROJECT_NAME}Targets
COMPONENT Development
ARCHIVE DESTINATION ${PTL_INSTALL_LIBDIR}
LIBRARY DESTINATION ${PTL_INSTALL_LIBDIR}
RUNTIME DESTINATION ${PTL_INSTALL_BINDIR} OPTIONAL)
endif()
endfunction()
source/externals/ptl/cmake/Modules/PTLCoverage.cmake
Vendored
+23
View File
@@ -0,0 +1,23 @@
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|(Apple)?Clang")
set(ptl_coverage_args "--coverage")
check_cxx_compiler_flag("-fprofile-abs-path ${PTL_COVERAGE_FLAGS}"
PTL_HAS_PROFILE_ABS_PATH)
if(PTL_HAS_PROFILE_ABS_PATH)
string(APPEND ptl_coverage_args " -fprofile-abs-path")
endif()
else()
set(ptl_coverage_args)
message(
WARNING
"PTL_USE_COVERAGE is ON, but is not supported for compiler '${CMAKE_CXX_COMPILER_ID}"
)
endif()
# We're setting the DEBUG CXX flags and C flags because we only use coverage in Debug
# builds but want them to propagate down Once CMake 3.13 is the minimum, we can use
# add_{compile,link}_options + genexs instead
string(APPEND CMAKE_C_FLAGS_DEBUG " ${ptl_coverage_args}")
string(APPEND CMAKE_CXX_FLAGS_DEBUG " ${ptl_coverage_args}")
string(APPEND CMAKE_EXE_LINKER_FLAGS_DEBUG " ${ptl_coverage_args}")
string(APPEND CMAKE_SHARED_LINKER_FLAGS_DEBUG " ${ptl_coverage_args}")
string(APPEND CMAKE_MODULE_LINKER_FLAGS_DEBUG " ${ptl_coverage_args}")
source/externals/ptl/cmake/Modules/PTLFormatting.cmake
Vendored
+60
View File
@@ -0,0 +1,60 @@
# * Clang-format only for master project
if(PTL_CLANG_FORMATTER MATCHES ".*-6")
unset(PTL_CLANG_FORMATTER CACHE)
endif()
find_program(PTL_CLANG_FORMATTER NAMES clang-format-9 clang-format-mp-9.0 clang-format)
mark_as_advanced(PTL_CLANG_FORMATTER)
find_program(PTL_CMAKE_FORMATTER NAMES cmake-format)
mark_as_advanced(PTL_CMAKE_FORMATTER)
set(PTL_FORMAT_TARGET format)
if(TARGET format)
set(PTL_FORMAT_TARGET format-ptl)
endif()
if(PTL_CLANG_FORMATTER)
set(_Source_DIR ${PROJECT_SOURCE_DIR}/source)
set(_Example_DIR ${PROJECT_SOURCE_DIR}/examples)
file(GLOB_RECURSE headers ${_Source_DIR}/*.hh ${_Source_DIR}/*.icc
${_Example_DIR}/*.hh ${_Example_DIR}/*.h)
file(GLOB_RECURSE sources ${_Source_DIR}/*.cc ${_Source_DIR}/*.c ${_Example_DIR}/*.cc
${_Example_DIR}/*.cu)
add_custom_target(
${PTL_FORMAT_TARGET}-source
COMMAND ${PTL_CLANG_FORMATTER} -i ${headers} ${sources}
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
COMMENT
"Running '${PTL_CLANG_FORMATTER}' on '${_Source_DIR}' and '${_Example_DIR}..."
SOURCES ${headers} ${sources})
endif()
if(PTL_CMAKE_FORMATTER)
set(_Source_DIR ${PROJECT_SOURCE_DIR}/source)
set(_Example_DIR ${PROJECT_SOURCE_DIR}/examples)
file(GLOB_RECURSE cmake_files "${PROJECT_SOURCE_DIR}/**/CMakeLists.txt"
"${PROJECT_SOURCE_DIR}/*.cmake" "${PROJECT_SOURCE_DIR}/*.cmake.in")
list(REMOVE_ITEM cmake_files "${PROJECT_SOURCE_DIR}/cmake/Modules/FindTBB.cmake")
add_custom_target(
${PTL_FORMAT_TARGET}-cmake
COMMAND ${PTL_CMAKE_FORMATTER} -i ${cmake_files}
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
COMMENT "Running '${PTL_CMAKE_FORMATTER}'..."
SOURCES ${cmake_files})
endif()
foreach(_FORMAT_TARGET ${PTL_FORMAT_TARGET}-source)
# avoid conflicting format targets
if(NOT TARGET ${PTL_FORMAT_TARGET})
add_custom_target(${PTL_FORMAT_TARGET})
endif()
if(TARGET ${_FORMAT_TARGET})
add_dependencies(${PTL_FORMAT_TARGET} ${_FORMAT_TARGET})
endif()
endforeach()
source/externals/ptl/cmake/Modules/PTLInstallDirs.cmake
Vendored
+28
View File
@@ -0,0 +1,28 @@
# -------------------------------------------------------------------------------------- #
#
# installation directories
#
# -------------------------------------------------------------------------------------- #
include(GNUInstallDirs)
# cmake installation folder (not exposed to user)
set(CMAKE_INSTALL_CMAKEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
if(NOT IS_ABSOLUTE "${CMAKE_INSTALL_CMAKEDIR}")
set(CMAKE_INSTALL_FULL_CMAKEDIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_CMAKEDIR})
else()
set(CMAKE_INSTALL_FULL_CMAKEDIR ${CMAKE_INSTALL_CMAKEDIR})
endif()
# Create PTL_ versions that are used internally and may be overriden by master projects
# When we are the master project, these are *always* set to the value(s) of
# CMAKE_INSTALL_<TYPE> Otherwise, the value of CMAKE_INSTALL_<TYPE> is used as the
# default.
foreach(_TYPE DATAROOT CMAKE INCLUDE LIB BIN MAN DOC)
if(PTL_MASTER_PROJECT)
set(PTL_INSTALL_${_TYPE}DIR "${CMAKE_INSTALL_${_TYPE}DIR}")
else()
if(NOT DEFINED PTL_INSTALL_${_TYPE}DIR)
set(PTL_INSTALL_${_TYPE}DIR "${CMAKE_INSTALL_${_TYPE}DIR}")
endif()
endif()
endforeach()
source/externals/ptl/cmake/Modules/PTLLinting.cmake
Vendored
+22
View File
@@ -0,0 +1,22 @@
# Only search for clang-tidy if user has not supplied it through CMAKE_CXX_CLANG_TIDY
if(NOT DEFINED CMAKE_CXX_CLANG_TIDY)
find_program(
PTL_CLANG_TIDY_COMMAND NAMES clang-tidy clang-tidy-12 clang-tidy-11 clang-tidy-10
clang-tidy-9 clang-tidy-8 clang-tidy-7)
mark_as_advanced(PTL_CLANG_TIDY_COMMAND)
if(NOT PTL_CLANG_TIDY_COMMAND)
message(
FATAL_ERROR
"PTL_USE_CLANG_TIDY is ON, but no clang-tidy program could be found")
endif()
set(CMAKE_CXX_CLANG_TIDY "${PTL_CLANG_TIDY_COMMAND}")
endif()
# Create a preprocessor definition that depends on .clang-tidy content so the compile
# command will change when .clang-tidy changes. Nothing actually uses this definition, it
# is simply added to trigger a rebuild when *only* .clang-tidy changes.
file(SHA1 ${PROJECT_SOURCE_DIR}/.clang-tidy __ptl_clang_tidy_sha1)
add_compile_definitions("PTL_CLANG_TIDY_SHA1=${__ptl_clang_tidy_sha1}")
unset(__ptl_clang_tidy_sha1)
configure_file(${PROJECT_SOURCE_DIR}/.clang-tidy ${PROJECT_SOURCE_DIR}/.clang-tidy
COPYONLY)
source/externals/ptl/cmake/Modules/PTLPackageConfigHelpers.cmake
Vendored
+76
View File
@@ -0,0 +1,76 @@
# -------------------------------------------------------------------------------------- #
# PTL CMake Package Config installation
#
include(CMakePackageConfigHelpers)
# Generic
write_basic_package_version_file(
${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
VERSION ${PROJECT_VERSION}
COMPATIBILITY SameMajorVersion)
# Install Tree
set(INCLUDE_INSTALL_DIR "${PTL_INSTALL_INCLUDEDIR}")
set(LIB_INSTALL_DIR "${PTL_INSTALL_LIBDIR}")
set(CMAKE_MODULE_INSTALL_DIR "${PTL_INSTALL_CMAKEDIR}/Modules")
configure_package_config_file(
${PROJECT_SOURCE_DIR}/cmake/Templates/${PROJECT_NAME}Config.cmake.in
${PROJECT_BINARY_DIR}/installation/${PROJECT_NAME}Config.cmake
INSTALL_DESTINATION ${PTL_INSTALL_CMAKEDIR}
INSTALL_PREFIX ${PTL_INSTALL_PREFIX}
PATH_VARS INCLUDE_INSTALL_DIR LIB_INSTALL_DIR CMAKE_MODULE_INSTALL_DIR)
install(
FILES ${PROJECT_BINARY_DIR}/installation/${PROJECT_NAME}Config.cmake
${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
DESTINATION ${PTL_INSTALL_CMAKEDIR}
COMPONENT Development)
install(
FILES ${PROJECT_SOURCE_DIR}/cmake/Modules/FindTBB.cmake
DESTINATION ${PTL_INSTALL_CMAKEDIR}/Modules
COMPONENT Development)
# Build Tree
set(INCLUDE_INSTALL_DIR "${PROJECT_SOURCE_DIR}/include")
set(LIB_INSTALL_DIR "${PROJECT_BINARY_DIR}")
set(CMAKE_MODULE_INSTALL_DIR "${PROJECT_SOURCE_DIR}/cmake/Modules")
configure_package_config_file(
${PROJECT_SOURCE_DIR}/cmake/Templates/${PROJECT_NAME}Config.cmake.in
${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
INSTALL_DESTINATION ${PROJECT_BINARY_DIR}
INSTALL_PREFIX ${PROJECT_BINARY_DIR}
PATH_VARS INCLUDE_INSTALL_DIR LIB_INSTALL_DIR CMAKE_MODULE_INSTALL_DIR)
configure_file(${PROJECT_SOURCE_DIR}/cmake/Templates/${PROJECT_NAME}BuildTargets.cmake
${PROJECT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake COPYONLY)
# -------------------------------------------------------------------------------------- #
# PTL pkg-config file install NB: The `-std=c++<EPOCH>` flag is currently exported to
# Cflags. Not at all clear how this is supposed to be handled in pkg-config yet. This is
# therefore a "simplest and dumbest" solution
set(PTL_PC_INCLUDEDIR "\${prefix}/${PTL_INSTALL_INCLUDEDIR}")
if(IS_ABSOLUTE "${PTL_INSTALL_INCLUDEDIR}")
set(PTL_PC_INCLUDEDIR "${PTL_INSTALL_INCLUDEDIR}")
endif()
set(PTL_PC_LIBDIR "\${prefix}/${PTL_INSTALL_LIBDIR}")
if(IS_ABSOLUTE "${PTL_INSTALL_LIBDIR}")
set(PTL_PC_INCLUDEDIR "${PTL_INSTALL_LIBDIR}")
endif()
if(PTL_USE_TBB)
# Left as exact until we know version/soversions for TBB better
set(PTL_PC_TBB_REQUIREMENT "tbb = ${TBB_VERSION}")
endif()
configure_file(${PROJECT_SOURCE_DIR}/cmake/Templates/ptl.pc.in
${PROJECT_BINARY_DIR}/installation/ptl.pc @ONLY)
install(
FILES "${PROJECT_BINARY_DIR}/installation/ptl.pc"
RENAME "G4ptl.pc"
DESTINATION ${PTL_INSTALL_LIBDIR}/pkgconfig/
COMPONENT Development)
source/externals/ptl/cmake/Modules/PTLSanitize.cmake
Vendored
+24
View File
@@ -0,0 +1,24 @@
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|(Apple)?Clang")
set(ptl_sanitize_args "-fsanitize=${PTL_SANITIZER_TYPE}")
if(NOT ("${PTL_SANITIZER_TYPE}" STREQUAL "thread"))
string(
APPEND ptl_sanitize_args
" -fno-optimize-sibling-calls -fno-omit-frame-pointer -fno-inline-functions")
endif()
else()
set(ptl_sanitize_args)
message(
WARNING
"PTL_USE_SANITIZER is ON, but is not supported for compiler '${CMAKE_CXX_COMPILER_ID}"
)
endif()
# We're setting the CXX flags and C flags beacuse they're propagated down independent of
# build type. Once CMake 3.13 is the minimum, we can use add_{compile,link}_options +
# genexs instead
string(APPEND CMAKE_CXX_FLAGS " ${ptl_sanitize_args}")
string(APPEND CMAKE_C_FLAGS " ${ptl_sanitize_args}")
string(APPEND CMAKE_EXE_LINKER_FLAGS " ${ptl_sanitize_args}")
string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${ptl_sanitize_args}")
string(APPEND CMAKE_MODULE_LINKER_FLAGS " ${ptl_sanitize_args}")
source/externals/ptl/cmake/Modules/Packages.cmake
Vendored
-51
View File
@@ -1,51 +0,0 @@
#
# Find packages
#
include(FindPackageHandleStandardArgs)
include(MacroUtilities)
ptl_add_interface_library(ptl-external-packages)
ptl_add_interface_library(ptl-threads)
ptl_add_interface_library(ptl-tbb)
################################################################################
#
# Threads
#
################################################################################
if(NOT WIN32)
set(CMAKE_THREAD_PREFER_PTHREAD ON)
set(THREADS_PREFER_PTHREAD_FLAG ON)
endif()
find_package(Threads)
if(Threads_FOUND)
target_link_libraries(ptl-threads INTERFACE Threads::Threads)
target_link_libraries(ptl-external-packages INTERFACE ptl-threads)
endif()
################################################################################
#
# TBB
#
################################################################################
if(PTL_USE_TBB)
find_package(TBB 2017)
if(TBB_FOUND)
target_compile_definitions(ptl-tbb INTERFACE PTL_USE_TBB)
target_include_directories(ptl-tbb SYSTEM INTERFACE ${TBB_INCLUDE_DIRS})
target_link_libraries(ptl-tbb INTERFACE ${TBB_LIBRARIES})
target_link_libraries(ptl-external-packages INTERFACE ptl-tbb)
else()
set(PTL_USE_TBB OFF)
ptl_add_disabled_interface(ptl-tbb)
endif()
else()
set(PTL_USE_TBB OFF)
ptl_add_disabled_interface(ptl-tbb)
endif()
source/externals/ptl/cmake/Modules/ProjectSettings.cmake
Vendored
-45
View File
@@ -1,45 +0,0 @@
################################################################################
#
# Project settings
#
################################################################################
string(TOUPPER "${CMAKE_BUILD_TYPE}" _CONFIG)
ptl_add_feature(CMAKE_C_FLAGS_${_CONFIG} "C compiler build-specific flags")
ptl_add_feature(CMAKE_CXX_FLAGS_${_CONFIG} "C++ compiler build-specific flags")
################################################################################
#
# installation directories
#
################################################################################
# cmake installation folder
if(NOT CMAKE_INSTALL_CONFIGDIR)
set(CMAKE_INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME})
endif()
# create the full path version and generic path versions
foreach(_TYPE DATAROOT CONFIG INCLUDE LIB BIN MAN DOC)
# set the absolute versions
if(NOT IS_ABSOLUTE "${CMAKE_INSTALL_${_TYPE}DIR}")
set(CMAKE_INSTALL_FULL_${_TYPE}DIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_${_TYPE}DIR})
else(NOT IS_ABSOLUTE "${CMAKE_INSTALL_${_TYPE}DIR}")
set(CMAKE_INSTALL_FULL_${_TYPE}DIR ${CMAKE_INSTALL_${_TYPE}DIR})
endif(NOT IS_ABSOLUTE "${CMAKE_INSTALL_${_TYPE}DIR}")
# generic "PROJECT_INSTALL_" variables (used by documentation)"
set(PROJECT_INSTALL_${_TYPE}DIR ${CMAKE_INSTALL_${TYPE}DIR})
set(PROJECT_INSTALL_FULL_${_TYPE}DIR ${CMAKE_INSTALL_FULL_${TYPE}DIR})
if(NOT DEFINED PTL_INSTALL_${_TYPE}DIR)
set(PTL_INSTALL_${_TYPE}DIR "${CMAKE_INSTALL_${_TYPE}DIR}")
endif()
if(PTL_MASTER_PROJECT)
set(PTL_INSTALL_${_TYPE}DIR "${CMAKE_INSTALL_${_TYPE}DIR}" CACHE STRING
"${_TYPE} Installation Path")
endif()
endforeach()