lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
80e2389dd8fbe88e4127f9df638bfd4fe8d10040
geant4/cmake/Modules/G4DeveloperAPI.cmake
T
Gabriele Cosmo 80e2389dd8 Import Geant4 11.0.0 source tree
2021-12-10 16:15:15 +00:00

1025 lines
38 KiB
CMake
Raw Blame History

#.rst:
# G4DeveloperAPI
# --------------
#
# .. code-block::cmake
#
# include(G4DeveloperAPI)
#
# CMake functions and macros for declaring and working with build
# products of Geant4.
#
#-----------------------------------------------------------------
# License and Disclaimer
#
# The Geant4 software is copyright of the Copyright Holders of
# the Geant4 Collaboration. It is provided under the terms and
# conditions of the Geant4 Software License, included in the file
# LICENSE and available at http://cern.ch/geant4/license . These
# include a list of copyright holders.
#
# Neither the authors of this software system, nor their employing
# institutes,nor the agencies providing financial support for this
# work make any representation or warranty, express or implied,
# regarding this software system or assume any liability for its
# use. Please see the license in the file LICENSE and URL above
# for the full disclaimer and the limitation of liability.
#
# This code implementation is the result of the scientific and
# technical work of the GEANT4 collaboration.
# By using, copying, modifying or distributing the software (or
# any work based on the software) you agree to acknowledge its
# use in resulting scientific publications, and indicate your
# acceptance of all terms of the Geant4 Software license.
#
#-----------------------------------------------------------------
include_guard(DIRECTORY)
#-----------------------------------------------------------------------
#.rst:
# Module Commands
# ^^^^^^^^^^^^^^^
#
# .. cmake:command:: geant4_add_module
#
# .. code-block:: cmake
#
# geant4_add_module(<name>
# PUBLIC_HEADERS header1 [header2 ...]
# [SOURCES source1 [source2 ...]])
#
# Add a Geant4 module called ``<name>`` to the project, composed
# of the source files listed in the ``PUBLIC_HEADERS`` and ``SOURCES``
# arguments. The ``<name>`` must be unique within the project.
# The directory in which the module is added (i.e. ``CMAKE_CURRENT_LIST_DIR``
# for the CMake script in which ``geant4_add_module`` is called) must contain:
#
# * An ``include`` subdirectory for the public headers
# * A ``src`` subdirectory for source files if the module provides these
#
# The ``PUBLIC_HEADERS`` argument must list the headers comprising the
# public interface of the module. If a header is supplied as a relative path,
# this is interpreted as being relative to the ``include`` subdirectory of the module.
# Absolute paths may also be supplied, e.g. if headers are generated by the project.
#
# The ``SOURCES`` argument should list any source files for the module.
# If a source is is supplied as a relative path, this is interpreted as being
# relative to the ``src`` subdirectory of the module. Absolute paths may
# also be supplied, e.g. if sources are generated by the project.
#
function(geant4_add_module _name)
__geant4_module_assert_not_exists(${_name})
set_property(GLOBAL APPEND PROPERTY GEANT4_DEFINED_MODULES ${_name})
cmake_parse_arguments(G4ADDMOD
""
""
"PUBLIC_HEADERS;SOURCES"
${ARGN}
)
__geant4_assert_no_unparsed_arguments(G4ADDMOD geant4_add_module)
# - Check required directory structure at definition point
# Headers always
if(NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/include")
message(FATAL_ERROR "Missing required 'include' subdirectory for module '${_name}' at '${CMAKE_CURRENT_LIST_DIR}'")
endif()
# Sources if defined
if(G4ADDMOD_SOURCES AND (NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/src"))
message(FATAL_ERROR "Missing required 'src' subdirectory for module '${_name}' at '${CMAKE_CURRENT_LIST_DIR}'")
endif()
# Compose header/source lists
set(__tmp_HEADERS)
foreach(__elem ${G4ADDMOD_PUBLIC_HEADERS})
if(IS_ABSOLUTE "${__elem}")
list(APPEND __tmp_HEADERS "${__elem}")
else()
list(APPEND __tmp_HEADERS "${CMAKE_CURRENT_LIST_DIR}/include/${__elem}")
endif()
endforeach()
geant4_set_module_property(${_name} PROPERTY PUBLIC_HEADERS ${__tmp_HEADERS})
set(__tmp_SOURCES)
foreach(__elem ${G4ADDMOD_SOURCES})
if(IS_ABSOLUTE "${__elem}")
list(APPEND __tmp_SOURCES "${__elem}")
else()
list(APPEND __tmp_SOURCES "${CMAKE_CURRENT_LIST_DIR}/src/${__elem}")
endif()
endforeach()
geant4_set_module_property(${_name} PROPERTY SOURCES ${__tmp_SOURCES})
# Set the default include directory for this module
geant4_module_include_directories(${_name} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>)
# Backward compatibility shim for direct usage of build directory
# Not all clients (esp. those using ROOT) may not fully support usage requirements
# and expect GEANT4_INCLUDE_DIRS to be complete
set_property(GLOBAL APPEND PROPERTY GEANT4_BUILDTREE_INCLUDE_DIRS "${CMAKE_CURRENT_LIST_DIR}/include")
# Record where we're defined so we can pop the file into IDEs
geant4_set_module_property(${_name} PROPERTY CMAKE_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}")
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_module_include_directories
#
# .. code-block:: cmake
#
# geant4_module_include_directories(<module>
# [PUBLIC pub1 [pub2 ...]
# [PRIVATE pri1 [pri2 ...]
# [INTERFACE int1 [int2 ...])
#
# Add include directories to given module.
#
function(geant4_module_include_directories _module)
__geant4_module_assert_exists(${_module})
cmake_parse_arguments(G4MODINCDIR
""
""
"PUBLIC;PRIVATE;INTERFACE"
${ARGN}
)
__geant4_assert_no_unparsed_arguments(G4MODINCDIR geant4_module_include_directories)
foreach(_dir ${G4MODINCDIR_PUBLIC})
geant4_set_module_property(${_module} APPEND PROPERTY PUBLIC_INCLUDE_DIRECTORIES ${_dir})
endforeach()
foreach(_dir ${G4MODINCDIR_PRIVATE})
geant4_set_module_property(${_module} APPEND PROPERTY PRIVATE_INCLUDE_DIRECTORIES ${_dir})
endforeach()
foreach(_dir ${G4MODINCDIR_INTERFACE})
geant4_set_module_property(${_module} APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${_dir})
endforeach()
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_module_link_libraries
#
# .. code-block:: cmake
#
# geant4_module_link_libraries(<module>
# [PUBLIC pub1 [pub2 ...]
# [PRIVATE pri1 [pri2 ...]
# [INTERFACE int1 [int2 ...])
#
# Link ``<module>`` to given targets.
#
function(geant4_module_link_libraries _module)
__geant4_module_assert_exists(${_module})
cmake_parse_arguments(G4MODLINKLIB
""
""
"PUBLIC;PRIVATE;INTERFACE"
${ARGN}
)
__geant4_assert_no_unparsed_arguments(G4MODLINKLIB geant4_module_link_libraries)
foreach(_lib ${G4MODLINKLIB_PUBLIC})
geant4_set_module_property(${_module} APPEND PROPERTY PUBLIC_LINK_LIBRARIES ${_lib})
endforeach()
foreach(_lib ${G4MODLINKLIB_PRIVATE})
geant4_set_module_property(${_module} APPEND PROPERTY PRIVATE_LINK_LIBRARIES ${_lib})
endforeach()
foreach(_dir ${G4MODLINKLIB_INTERFACE})
geant4_set_module_property(${_module} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${_lib})
endforeach()
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_module_compile_definitions
#
# .. code-block:: cmake
#
# geant4_module_compile_definitions(<module>
# [PUBLIC pub1 [pub2 ...]
# [PRIVATE pri1 [pri2 ...]
# [INTERFACE int1 [int2 ...])
#
# Add compile definitions for this module
#
# Use cases:
# 1. workarounds when a config header isn't suitable
#
# Needs care with DLLs if used for import/export declspecs
# Application of specific defs to single files not considered
# Expected that uses cases here minimal, and developers should
# in that case use set_source_files_properties or similar
# directly.
#
function(geant4_module_compile_definitions _module)
__geant4_module_assert_exists(${_module})
cmake_parse_arguments(G4MODCOMPILEDEF
""
""
"PUBLIC;PRIVATE;INTERFACE"
${ARGN}
)
__geant4_assert_no_unparsed_arguments(G4MODCOMPILEDEF geant4_module_compile_definitions)
foreach(_lib ${G4MODCOMPILEDEF_PUBLIC})
geant4_set_module_property(${_module} APPEND PROPERTY PUBLIC_COMPILE_DEFINITIONS ${_lib})
endforeach()
foreach(_lib ${G4MODCOMPILEDEF_PRIVATE})
geant4_set_module_property(${_module} APPEND PROPERTY PRIVATE_COMPILE_DEFINITIONS ${_lib})
endforeach()
foreach(_dir ${G4MODCOMPILEDEF_INTERFACE})
geant4_set_module_property(${_module} APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS ${_lib})
endforeach()
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_get_modules
#
# .. code-block:: cmake
#
# geant4_get_modules(<result>)
#
# Store the list of currently defined modules in the variable ``<result>``.
#
function(geant4_get_modules _result)
get_property(__tmp GLOBAL PROPERTY GEANT4_DEFINED_MODULES)
set(${_result} ${__tmp} PARENT_SCOPE)
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_has_module
#
# .. code-block:: cmake
#
# geant4_has_module(<result> <name>)
#
# Set variable ``<result>`` to a boolean which will be true if the module
# ``<name>`` is defined.
#
function(geant4_has_module _result _name)
set(__exists FALSE)
geant4_get_modules(__tmp)
if(__tmp)
list(FIND __tmp ${_name} __index)
if(__index GREATER -1)
set(__exists TRUE)
endif()
endif()
set(${_result} ${__exists} PARENT_SCOPE)
endfunction()
#-----------------------------------------------------------------------
#.rst:
# Module Properties
# =================
#
# A Geant4 module stores its build and usage requirements in a series
# of properties:
#
# * ``PUBLIC_HEADERS``
# * ``PRIVATE_HEADERS``
# * ``SOURCES``
# * ``PRIVATE_COMPILE_DEFINITIONS``
# * ``PUBLIC_COMPILE_DEFINITIONS``
# * ``INTERFACE_COMPILE_DEFINITIONS``
# * ``PRIVATE_INCLUDE_DIRECTORIES``
# * ``PUBLIC_INCLUDE_DIRECTORIES``
# * ``INTERFACE_INCLUDE_DIRECTORIES``
# * ``PRIVATE_LINK_LIBRARIES``
# * ``PUBLIC_LINK_LIBRARIES``
# * ``INTERFACE_LINK_LIBRARIES``
# * ``PARENT_TARGET``
# * ``CMAKE_LIST_FILE``
# * ``GLOBAL_DEPENDENCIES``
#
# The properties of a module may be queried and set using the following
# commands.
# .. cmake:command:: geant4_get_module_property
#
# .. code-block:: cmake
#
# geant4_get_module_property(<result> <module> <property>)
#
# Store value of property ``<property>`` for ``<module>`` in variable
# ``<result>``.
#
# If ``<property>`` is not a valid module property, a FATAL_ERROR is
# emitted.
#
function(geant4_get_module_property _output _module _propertyname)
__geant4_module_assert_exists(${_module})
__geant4_module_validate_property(${_propertyname})
get_property(__result GLOBAL PROPERTY ${_module}_${_propertyname})
set(${_output} ${__result} PARENT_SCOPE)
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_set_module_property
#
# .. code-block:: cmake
#
# geant4_set_module_property(<module>
# [APPEND | APPEND_STRING]
# PROPERTY <property> <value>)
#
# Set property ``<property>`` of module ``<module>`` to ``<value>``.
#
# If ``APPEND`` is supplied, ``<value>`` will be appended to any existing
# value for the property as a list.
#
# If ``APPEND_STRING`` is supplied, ``<value>`` will be appended to any existing
# value for the property as a string. This option is mutually exclusive with
# ``APPEND``.
#
# If ``<property>`` is not a valid module property, a FATAL_ERROR is
# emitted.
#
function(geant4_set_module_property _module)
__geant4_module_assert_exists(${_module})
cmake_parse_arguments(G4SMP
"APPEND;APPEND_STRING"
""
"PROPERTY"
${ARGN}
)
__geant4_assert_no_unparsed_arguments(G4SMP geant4_set_module_property)
# Append/Append_string are mutually exclusive
if(G4SMP_APPEND AND G4SMP_APPEND_STRING)
message(FATAL_ERROR "geant4_set_module_property: cannot set both APPEND and APPEND_STRING")
elseif(G4SMP_APPEND)
set(G4SMP_APPEND_MODE "APPEND")
elseif(G4SMP_APPEND_MODE)
set(G4SMP_APPEND_MODE "APPEND_STRING")
endif()
# First element of PROPERTY list is prop name
list(GET G4SMP_PROPERTY 0 G4SMP_PROPERTY_NAME)
if(NOT G4SMP_PROPERTY_NAME)
message(FATAL_ERROR "geant4_set_module_property: Required PROPERTY argument is missing")
endif()
__geant4_module_validate_property(${G4SMP_PROPERTY_NAME})
# Remainder is arguments, so strip first element
list(REMOVE_AT G4SMP_PROPERTY 0)
set_property(GLOBAL ${G4SMP_APPEND_MODE} PROPERTY ${_module}_${G4SMP_PROPERTY_NAME} ${G4SMP_PROPERTY})
endfunction()
#-----------------------------------------------------------------------
#.rst:
# Category Commands
# ^^^^^^^^^^^^^^^^^
#
# .. cmake:command:: geant4_add_category
#
# .. code-block:: cmake
#
# geant4_add_category(<name> MODULES <module> [<module> ...])
#
# Add a Geant4 category ``<name>`` to the project, composed of the modules
# supplied in the ``MODULES`` list.
#
# Calling this function does not create an actual CMake library target.
# Because modules declare dependencies on modules rather than libraries, we
# defer creation of library targets to after creation of categories, which
# allows resolution of module <-> category use. Additionally, category specific
# actions such as install may be added.
#
function(geant4_add_category _name)
# Check existence? final add_library will warn, but may wish to double check
set_property(GLOBAL APPEND PROPERTY GEANT4_DEFINED_CATEGORIES ${_name})
cmake_parse_arguments(G4ADDCAT
""
""
"MODULES"
${ARGN}
)
# - Modules must not be empty (Could also just be ARGN)
if(NOT G4ADDCAT_MODULES)
message(FATAL_ERROR "geant4_add_category: Missing/empty 'MODULES' argument")
endif()
# Compose Category from Modules
foreach(__g4module ${G4ADDCAT_MODULES})
# Module must not have been composed already
geant4_get_module_property(_parent ${__g4module} PARENT_TARGET)
if(${_parent})
message(FATAL_ERROR "geant4_add_category: trying to compose category '${_name}' using module '${__g4module}' which is already composed into category '${_parent}'")
endif()
# Compose it
geant4_set_module_property(${__g4module} PROPERTY PARENT_TARGET ${_name})
set_property(GLOBAL APPEND PROPERTY GEANT4_CATEGORIES_${_name}_MODULES ${__g4module})
geant4_get_module_property(_headers ${__g4module} PUBLIC_HEADERS)
set_property(GLOBAL APPEND PROPERTY GEANT4_CATEGORIES_${_name}_PUBLIC_HEADERS ${_headers})
endforeach()
# As we do not create a physical target, store the script in which we're called
set_property(GLOBAL PROPERTY GEANT4_CATEGORIES_${_name}_CMAKE_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}")
endfunction()
#-----------------------------------------------------------------------
# Resolve a list of links
# These may include Geant4 modules as well as standard targets or other expressions
# Resolve Modules to PARENT_TARGET, removing duplicates
# Leave other links unchanged
function(geant4_resolve_link_libraries _list)
set(_resolved_list )
foreach(__lib ${${_list}})
# If "library" is a module, resolve it to PARENT_TARGET
geant4_has_module(__is_module ${__lib})
if(__is_module)
geant4_get_module_property(__parent_lib ${__lib} PARENT_TARGET)
list(APPEND _resolved_list ${__parent_lib})
else()
list(APPEND _resolved_list ${__lib})
endif()
endforeach()
if(_resolved_list)
list(REMOVE_DUPLICATES _resolved_list)
endif()
set(${_list} ${_resolved_list} PARENT_SCOPE)
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_compose_targets
#
# .. code-block:: cmake
#
# geant4_compose_targets()
#
# Create physical SHARED/STATIC library targets from the defined Geant4
# categories and modules.
#
# Can only be called once, and must be done so after all Geant4 libraries
# and modules are defined.
#
function(geant4_compose_targets)
get_property(__alreadyCalled GLOBAL PROPERTY GEANT4_COMPOSE_TARGETS_CALLED)
if(__alreadyCalled)
get_property(__callsite GLOBAL PROPERTY GEANT4_COMPOSE_TARGETS_LIST_FILE)
message(FATAL_ERROR "geant4_compose_targets already called from ${__callsite}")
endif()
# Check that every defined module is composed
geant4_get_modules(__g4definedmodules)
foreach(__module ${__g4definedmodules})
geant4_get_module_property(__iscomposed ${__module} PARENT_TARGET)
if(NOT __iscomposed)
message(FATAL_ERROR "Geant4 module '${__module}' is not composed into any category")
endif()
endforeach()
# - For each module, write out files for
# 1. module -> used modules adjacency list for detecting module-module cycles
file(WRITE "${PROJECT_BINARY_DIR}/G4ModuleAdjacencyList.txt" "# Geant4 Module - Module Adjacencies\n")
foreach(__module ${__g4definedmodules})
# Adjacency list - take all dependencies
geant4_get_module_property(__publicdeps ${__module} PUBLIC_LINK_LIBRARIES)
geant4_get_module_property(__privatedeps ${__module} PRIVATE_LINK_LIBRARIES)
geant4_get_module_property(__interfacedeps ${__module} INTERFACE_LINK_LIBRARIES)
set(__alldeps_l ${__publicdeps} ${__privatedeps} ${__interfacedeps})
list(JOIN __alldeps_l " " __alldeps)
file(APPEND "${PROJECT_BINARY_DIR}/G4ModuleAdjacencyList.txt" "${__module} ${__alldeps}\n")
endforeach()
# Process all defined libraries, except for G4{clhep,expat,ptl}{-static}
# These are corner cases because its call to add_library happens
# at a different (lower) directory level than all the other targets
# This means we cannot install it here. That's left to it
get_property(__g4definedlibraries GLOBAL PROPERTY GEANT4_DEFINED_CATEGORIES)
list(REMOVE_ITEM __g4definedlibraries G4clhep G4clhep-static G4expat G4expat-static G4ptl G4ptl-static)
set(__g4builtlibraries)
set(__g4public_headers)
foreach(__g4lib ${__g4definedlibraries})
if(BUILD_SHARED_LIBS)
__geant4_add_library(${__g4lib} SHARED)
list(APPEND __g4builtlibraries ${__g4lib})
endif()
if(BUILD_STATIC_LIBS)
__geant4_add_library(${__g4lib} STATIC)
list(APPEND __g4builtlibraries ${__g4lib}-static)
endif()
get_property(__headers GLOBAL PROPERTY GEANT4_CATEGORIES_${__g4lib}_PUBLIC_HEADERS)
list(APPEND __g4public_headers ${__headers})
endforeach()
#-----------------------------------------------------------------------
# TEMP INSTALL - do here purely to review exported links. Should be
# factored out into separate function later.
install(TARGETS ${__g4builtlibraries}
EXPORT Geant4LibraryDepends
ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT Development
LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT Runtime
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT Runtime
INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}")
install(FILES ${__g4public_headers} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}" COMPONENT Development)
set_property(GLOBAL PROPERTY GEANT4_COMPOSE_TARGETS_CALLED ON)
set_property(GLOBAL PROPERTY GEANT4_COMPOSE_TARGETS_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}")
endfunction()
#-----------------------------------------------------------------------
#.rst:
# Backward Compatibility Commands
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#
# These commands implement the old module/library definition macros in
# terms of the new command set. They provide a facade allowing migration
# to the new interfaces with a controlled transition.
#
# As migration progresses, these commands will gradually be deprecated,
# with warnings issued about what to do at each stage.
#
# .. cmake:command:: geant4_define_module
#
# .. code-block:: cmake
#
# geant4_define_module(NAME <name>
# HEADERS header1 [header2 ...]
# SOURCES source1 [source2 ...]
# GRANULAR_DEPENDENCIES lib1 [lib2 ...]
# GLOBAL_DEPENDENCIES lib1 [lib2 ...]
# LINK_LIBRARIES lib1 [lib2 ...])
#
# DEPRECATED: Use :cmake:command:`geant4_add_module` to add a module with headers/sources,
# and :cmake:command:`geant4_module_link_libraries` to declare internal and external
# libraries to link to.
#
function(geant4_define_module)
cmake_parse_arguments(G4DEFMOD
""
"NAME"
"HEADERS;SOURCES;GRANULAR_DEPENDENCIES;GLOBAL_DEPENDENCIES;LINK_LIBRARIES"
${ARGN}
)
__geant4_assert_no_unparsed_arguments(G4DEFMOD geant4_define_module)
# HEADERS -> PUBLIC_HEADERS
# SOURCES -> SOURCES
geant4_add_module(${G4DEFMOD_NAME}
PUBLIC_HEADERS ${G4DEFMOD_HEADERS}
SOURCES ${G4DEFMOD_SOURCES}
)
# GRANULAR_DEPENDENCIES -> geant4_module_link_libraries(mod PUBLIC ...)
# GLOBAL_DEPENDENCIES -> new property... Just record it for now, later
# we need to link these to the physical library the module is composed into
# checking that
# i) Granular -> Global link is complete, i.e. resolving granular deps results
# in same global link list.
# Has to be stored separately because we want/need to check for full resolution of
# the granular libs to the same set of global libs. That's needed to ensure we
# can correct any missing links in existing GRANULAR_DEPENDENCIES lists.
# (i.e. it's a transtional property)
# LINK_LIBRARIES -> geant4_module_link_libraries(mod PUBLIC ...)
geant4_module_link_libraries(${G4DEFMOD_NAME} PUBLIC ${G4DEFMOD_GRANULAR_DEPENDENCIES} ${G4DEFMOD_LINK_LIBRARIES})
geant4_set_module_property(${G4DEFMOD_NAME} PROPERTY GLOBAL_DEPENDENCIES ${G4DEFMOD_GLOBAL_DEPENDENCIES})
# When we are ready, start issuing a deprecation warning here, including instructions for
# migration...
#message(WARNING "Use of geant4_define_module is deprecated, please use... instead")
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_global_library_target
#
# .. code-block:: cmake
#
# geant4_global_library_target(NAME <name>
# COMPONENTS file1 [file2 ...])
#
# DEPRECATED: Use :cmake:command:`geant4_add_library` to add a library with a list
# of modules.
#
# This function provides a facade around :cmake:command:`geant4_add_library` to
# allow back compatibility with the older module/library functions
#
function(geant4_global_library_target)
cmake_parse_arguments(G4GLOBLIB
""
"NAME"
"COMPONENTS"
${ARGN}
)
__geant4_assert_no_unparsed_arguments(G4GLOBLIB geant4_global_library_target)
# Because components are sources.cmake files, must know currently defined modules
# so we can pick up the newly defined ones
geant4_get_modules(__oldmodules)
# Load components
foreach(__comp ${G4GLOBLIB_COMPONENTS})
include(${__comp})
endforeach()
# Reset directory scope include dirs so we enforce usage requirements
set_directory_properties(PROPERTIES INCLUDE_DIRECTORIES "")
# List modules now defined, and filter out old from new
geant4_get_modules(__newmodules)
if(__oldmodules)
list(REMOVE_ITEM __newmodules ${__oldmodules})
endif()
# Old function allowed optional NAME argument, in which case it should
# be the first element in the module list
if(NOT G4GLOBLIB_NAME)
list(GET __newmodules 0 G4GLOBLIB_NAME)
endif()
# Some compile definitions are still transported via directory level
# "add_definitions" calls at the site of the geant4_global_library call
# These, if they exist, are equivalent to PRIVATE level compile defs.
get_directory_property(__local_compile_defs COMPILE_DEFINITIONS)
foreach(__module ${__newmodules})
geant4_module_compile_definitions(${__module} PRIVATE ${__local_compile_defs})
endforeach()
# Compose the modules into the category
geant4_add_category(${G4GLOBLIB_NAME} MODULES ${__newmodules})
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_library_target
#
# .. code-block::
#
# geant4_library_target(NAME <name>
# SOURCES source1 [source2 ...]
# GEANT4_LINK_LIBRARIES lib1 [lib2 ...]
# LINK_LIBRARIES lib1 [lib2 ...])
#
# Maintained for building internal G4clhep,G4expat targets because we try and
# reuse their upstream code/build layout as far as possible
#
function(geant4_library_target)
cmake_parse_arguments(G4GLOBLIB
""
"NAME"
"SOURCES;GEANT4_LINK_LIBRARIES;LINK_LIBRARIES"
${ARGN}
)
__geant4_assert_no_unparsed_arguments(G4GLOBLIB geant4_library_target)
# Currently a hack to get G4clhep to build, so an error if used elsewhere
if(NOT (${G4GLOBLIB_NAME} MATCHES "G4clhep|G4expat"))
message(FATAL_ERROR "geant4_library_target called for '${G4GLOBLIB_NAME}' in '${CMAKE_CURRENT_LIST_DIR}'")
endif()
if(BUILD_SHARED_LIBS)
add_library(${G4GLOBLIB_NAME} SHARED ${G4GLOBLIB_SOURCES})
add_library(Geant4::${G4GLOBLIB_NAME} ALIAS ${G4GLOBLIB_NAME})
target_compile_features(${G4GLOBLIB_NAME} PUBLIC ${GEANT4_TARGET_COMPILE_FEATURES})
target_compile_definitions(${G4GLOBLIB_NAME} PUBLIC G4LIB_BUILD_DLL)
target_include_directories(${G4GLOBLIB_NAME}
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
)
set_target_properties(${G4GLOBLIB_NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
install(TARGETS ${G4GLOBLIB_NAME}
EXPORT Geant4LibraryDepends
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT Runtime
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Runtime
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Development
INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME})
endif()
if(BUILD_STATIC_LIBS)
add_library(${G4GLOBLIB_NAME}-static STATIC ${G4GLOBLIB_SOURCES})
add_library(Geant4::${G4GLOBLIB_NAME}-static ALIAS ${G4GLOBLIB_NAME}-static)
target_compile_features(${G4GLOBLIB_NAME}-static PUBLIC ${GEANT4_TARGET_COMPILE_FEATURES})
target_include_directories(${G4GLOBLIB_NAME}-static
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
)
if(NOT WIN32)
set_target_properties(${G4GLOBLIB_NAME}-static PROPERTIES OUTPUT_NAME ${G4GLOBLIB_NAME})
endif()
install(TARGETS ${G4GLOBLIB_NAME}-static
EXPORT Geant4LibraryDepends
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT Runtime
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Runtime
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Development
INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME})
endif()
# Needs to be in defined category list for static/shared to be linked correctly.
set_property(GLOBAL APPEND PROPERTY GEANT4_DEFINED_CATEGORIES ${G4GLOBLIB_NAME})
endfunction()
#-----------------------------------------------------------------------
# .rst:
# .. cmake:command:: geant4_add_compile_definitions
#
# .. code-block:: cmake
#
# geant4_add_compile_definitions(SOURCES <source1> ... <sourceN>
# COMPILE_DEFINITIONS <def1> ... <defN>)
#
# Add extra compile definitions to a specific list of sources
# in the current module. Macroized to handle the need to specify absolute paths.
# and *must* be called at the same level as geant4_define_module
#
macro(geant4_add_compile_definitions)
cmake_parse_arguments(G4ADDDEF
""
""
"SOURCES;COMPILE_DEFINITIONS"
${ARGN}
)
__geant4_assert_no_unparsed_arguments(G4ADDDEF geant4_add_compile_definitions)
# We assume that the sources have been added at the level of a
# a sources.cmake, so are inside the src subdir of the sources.cmake
get_filename_component(_ACD_BASE_PATH ${CMAKE_CURRENT_LIST_FILE} PATH)
# Now for each file, add the definitions
foreach(_acd_source ${G4ADDDEF_SOURCES})
# Extract any existing compile definitions
get_source_file_property(
_acd_existing_properties
${_ACD_BASE_PATH}/src/${_acd_source}
COMPILE_DEFINITIONS)
if(_acd_existing_properties)
set(_acd_new_defs ${_acd_existing_properties}
${G4ADDDEF_COMPILE_DEFINITIONS})
else()
set(_acd_new_defs ${G4ADDDEF_COMPILE_DEFINITIONS})
endif()
# quote compile defs because this must epand to space separated list
set_source_files_properties(${_ACD_BASE_PATH}/src/${_acd_source}
PROPERTIES COMPILE_DEFINITIONS "${_acd_new_defs}")
endforeach()
endmacro()
#-----------------------------------------------------------------------
#.rst:
# Internal Helper Commands
# ^^^^^^^^^^^^^^^^^^^^^^^^
#
# These macros and functions are for use in the implementation of the
# module and library functions. They should never be used directly
# in developer-level scripts.
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: __geant4_assert_no_unparsed_arguments
#
# .. code-block:: cmake
#
# __geant4_assert_no_unparsed_arguments(<prefix> <function>)
#
# Emit a ``FATAL_ERROR`` if ``<prefix>_UNPARSED_ARGUMENTS`` is non-empty
# in ``<function>``
#
# This is a macro intended for use in G4DeveloperAPI functions that cannot
# have unparsed arguments to validate their input.
#
# From CMake 3.17, the ``<function>`` argument is no longer required and
# ``CMAKE_CURRENT_FUNCTION`` can be used
#
macro(__geant4_assert_no_unparsed_arguments _prefix _function)
if(${_prefix}_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "${_function} called with unparsed arguments: '${${_prefix}_UNPARSED_ARGUMENTS}'")
endif()
endmacro()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: __geant4_module_assert_exists
#
# .. code-block:: cmake
#
# __geant4_module_assert_exists(<name>)
#
# Emit a ``FATAL_ERROR`` if the module ``<name>`` is not defined.
#
# This is a macro intended for use in G4DeveloperAPI functions when
# the existence of a module is required for further processing
#
macro(__geant4_module_assert_exists _module)
geant4_has_module(__geant4_module_assert_exists_tmp ${_module})
if(NOT __geant4_module_assert_exists_tmp)
message(FATAL_ERROR "Geant4 module '${_module}' has not been created")
endif()
endmacro()
#.rst:
# .. cmake:command:: __geant4_module_assert_not_exists
#
# .. code-block:: cmake
#
# __geant4_module_assert_not_exists(<name>)
#
# Emit a ``FATAL_ERROR`` if the module ``<name>`` is defined
#
# This is a macro intended for use in G4DeveloperAPI functions when
# the non-existence of a module is required for further processing
#
macro(__geant4_module_assert_not_exists _module)
geant4_has_module(__geant4_module_assert_not_exists_tmp ${_module})
if(__geant4_module_assert_not_exists_tmp)
geant4_get_module_property(__previous_cmake_list ${_module} CMAKE_LIST_FILE)
message(FATAL_ERROR "Geant4 module '${_module}' has already been created by call in '${__previous_cmake_list}'")
endif()
endmacro()
#.rst:
# .. cmake:command:: __geant4_module_validate_property
#
# .. code-block:: cmake
#
# __geant4_module_validate_property(<property>)
#
# Emit a ``FATAL_ERROR`` if the ``<property>`` is not one of the valid
# properties for a module:
#
# This is used internally by the property get/set functions.
#
function(__geant4_module_validate_property _property)
if(NOT (${_property} MATCHES "PUBLIC_HEADERS|PRIVATE_HEADERS|SOURCES|PRIVATE_COMPILE_DEFINITIONS|PUBLIC_COMPILE_DEFINITIONS|INTERFACE_COMPILE_DEFINITIONS|PRIVATE_INCLUDE_DIRECTORIES|PUBLIC_INCLUDE_DIRECTORIES|INTERFACE_INCLUDE_DIRECTORIES|PRIVATE_LINK_LIBRARIES|PUBLIC_LINK_LIBRARIES|INTERFACE_LINK_LIBRARIES|PARENT_TARGET|CMAKE_LIST_FILE|GLOBAL_DEPENDENCIES"))
message(FATAL_ERROR "Undefined property '${_property}'")
endif()
endfunction()
#.rst:
# .. cmake:command:: __geant4_add_library
#
# .. code-block:: cmake
#
# __geant4_add_library(<libraryname> <mode>)
#
# Compose an actual CMake library target
#
# This is used internally by the ``geant4_compose_targets`` command.
#
function(__geant4_add_library _name _type)
# TEMP HACK: G4clhep/G4expat/G4ptl are a special cases, and build is handled separately
if(_name MATCHES "G4clhep|G4expat|G4ptl")
return()
endif()
if(NOT (${_type} MATCHES "SHARED|STATIC"))
message(FATAL_ERROR "Invalid library type '${_type}'")
endif()
# Get targets
get_property(__g4definedlibraries GLOBAL PROPERTY GEANT4_DEFINED_CATEGORIES)
set(_target_name ${_name})
if(_type STREQUAL "STATIC")
set(_target_name ${_name}-static)
endif()
# - General target creation/properties
add_library(${_target_name} ${_type} "")
# Alias for transparent use with imported targets
add_library(Geant4::${_target_name} ALIAS ${_target_name})
target_compile_features(${_target_name} PUBLIC ${GEANT4_TARGET_COMPILE_FEATURES})
if(_type STREQUAL "SHARED")
# G4LIB_BUILD_DLL is public as despite the name it indicates the shared/archive mode
# and clients must apply it when linking to the shared libs. The global
# category handles the exact import/export statements
target_compile_definitions(${_target_name} PUBLIC G4LIB_BUILD_DLL)
set_target_properties(${_target_name} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
# MacOS
# Use '@rpath' in install names of libraries on macOS to provide relocatibility
# Add '@loader_path' to INSTALL_RPATH on macOS so that Geant4
# libraries self-locate each other whilst remaining relocatable
set_target_properties(${_target_name} PROPERTIES MACOSX_RPATH 1)
if(APPLE)
set_property(TARGET ${G4LIBTARGET_NAME} APPEND PROPERTY INSTALL_RPATH "@loader_path")
endif()
endif()
if((_type STREQUAL "STATIC") AND NOT WIN32)
set_target_properties(${_target_name} PROPERTIES OUTPUT_NAME ${_name})
endif()
get_property(__g4modules GLOBAL PROPERTY GEANT4_CATEGORIES_${_name}_MODULES)
foreach(__g4mod ${__g4modules})
# - Process sources...
geant4_get_module_property(_headers ${__g4mod} PUBLIC_HEADERS)
geant4_get_module_property(_srcs ${__g4mod} SOURCES)
geant4_get_module_property(_cmakescript ${__g4mod} CMAKE_LIST_FILE)
# - Group sources and scripts for IDEs
# NB: Seemingly has to be done at same level we define target.
# TODO: If lib name is same as mod name, don't group avoid extra
# folder layer.
source_group(${__g4mod}\\Headers FILES ${_headers})
source_group(${__g4mod}\\Sources FILES ${_srcs})
source_group(${__g4mod} FILES ${_cmakescript})
# - Add sources to target - PRIVATE, because consuming targets don't need them
target_sources(${_target_name} PRIVATE ${_headers} ${_srcs} ${_cmakescript})
# - Process usage properties
# Include dirs, compile definitions and libraries can be handled together
# Important to note that these promote PUBLIC/PRIVATE/INTERFACE
# from module level to library level. I.e. other modules in the
# library can see each other's PRIVATE include paths/compile defs.
# The only known way to fully wall things off is OBJECT libs,
# but then run into issues mentioned at start - linking and
# use in IDEs (though newer CMake versions should resolve these)
# This "promotion" is probably correct though - interfaces are
# at physical library level rather than module, and in Geant4
# all files must have globally unique names (no nested headers
# nor namespaces). Also, DLL export symbols may need this
# behaviour (esp. ALLOC_EXPORT).
# Only really an issue if header names/definitions aren't
# globally (in Geant4) unique. Or if a module is moved and hasn't
# declared its deps correctly (but then an error will occur
# anyway, and point is that libs are linked, not modules!)
# "Module" level really means "Source file" level, so same
# sets of rules should apply (i.e. can't specify inc dirs
# at source level).
foreach(_prop IN ITEMS PRIVATE PUBLIC INTERFACE)
geant4_get_module_property(_incdirs ${__g4mod} ${_prop}_INCLUDE_DIRECTORIES)
target_include_directories(${_target_name} ${_prop} ${_incdirs})
geant4_get_module_property(_defs ${__g4mod} ${_prop}_COMPILE_DEFINITIONS)
target_compile_definitions(${_target_name} ${_prop} ${_defs})
# Target linking requires additional processing to resolve
geant4_get_module_property(_linklibs ${__g4mod} ${_prop}_LINK_LIBRARIES)
geant4_resolve_link_libraries(_linklibs)
# Remove self-linking
if(_linklibs)
list(REMOVE_ITEM _linklibs ${_name})
endif()
# Filter list for internal static targets
if(_type STREQUAL "STATIC")
set(_g4linklibs )
foreach(_linklib ${_linklibs})
# If the linklib is a G4Library, change name to "name-static"
list(FIND __g4definedlibraries ${_linklib} _isg4lib)
if(_isg4lib GREATER -1)
list(APPEND _g4linklibs "${_linklib}-static")
else()
list(APPEND _g4linklibs "${_linklib}")
endif()
endforeach()
set(_linklibs ${_g4linklibs})
endif()
target_link_libraries(${_target_name} ${_prop} ${_linklibs})
endforeach()
# Temp workaround for modules needing Qt. We use AUTOMOC, but can't yet set
# it on a per module basis. However, only have four modules that require
# moc-ing, so hard code for now.
# TODO: likely need an additional "module target properties" to hold things
# that can be passed to set_target_properties
if(__g4mod MATCHES "G4UIbasic|G4OpenGL|G4OpenInventor|G4ToolsSG" AND GEANT4_USE_QT)
set_target_properties(${_target_name} PROPERTIES AUTOMOC ON)
endif()
endforeach()
# - Postprocess target properties to remove duplicates
# NB: This makes the assumption that there is no order dependence here (and any is considered a bug!)
# CMake will handle static link ordering internally
foreach(_link_prop IN ITEMS LINK_LIBRARIES INTERFACE_LINK_LIBRARIES INCLUDE_DIRECTORIES INTERFACE_INCLUDE_DIRECTORIES COMPILE_DEFINITIONS INTERFACE_COMPILE_DEFINITIONS)
get_target_property(__g4lib_link_libs ${_target_name} ${_link_prop})
if(__g4lib_link_libs)
list(SORT __g4lib_link_libs)
list(REMOVE_DUPLICATES __g4lib_link_libs)
set_property(TARGET ${_target_name} PROPERTY ${_link_prop} ${__g4lib_link_libs})
endif()
endforeach()
endfunction()
Reference in New Issue View Git Blame Copy Permalink