713 lines
26 KiB
CMake
Executable File
713 lines
26 KiB
CMake
Executable File
if( NOT CGAL_MACROS_FILE_INCLUDED )
|
|
set(CGAL_MACROS_FILE_INCLUDED 1 )
|
|
|
|
include("${CGAL_MODULES_DIR}/CGAL_VersionUtils.cmake")
|
|
|
|
# Probably unused. -- Laurent Rineau, 2011/07/21
|
|
macro(assert _arg )
|
|
if ( NOT ${_arg} )
|
|
message( FATAL_ERROR "Variable ${_arg} must be defined" )
|
|
endif()
|
|
endmacro()
|
|
|
|
macro( hide_variable var )
|
|
set ( ${var} ${${var}} CACHE INTERNAL "Variable hidden from user" FORCE )
|
|
endmacro()
|
|
|
|
macro( cache_set var )
|
|
set ( ${var} ${ARGN} CACHE INTERNAL "" )
|
|
set ( ${var} ${ARGN} CACHE INTERNAL "" )
|
|
endmacro()
|
|
|
|
macro( typed_cache_set type doc var )
|
|
set ( ${var} ${ARGN} CACHE ${type} ${doc} FORCE )
|
|
set ( ${var} ${ARGN} CACHE ${type} ${doc} FORCE )
|
|
endmacro()
|
|
|
|
macro( cache_get var )
|
|
set ( ${var} )
|
|
endmacro()
|
|
|
|
# Splits inlist in the first element (head) and the rest (tail)
|
|
macro( list_split head tail )
|
|
set( ${head} )
|
|
set( ${tail} )
|
|
set( _LS_is_head TRUE )
|
|
foreach( _LS_item ${ARGN} )
|
|
if ( _LS_is_head )
|
|
set( ${head} ${_LS_item} )
|
|
set( _LS_is_head FALSE )
|
|
else()
|
|
list( APPEND ${tail} ${_LS_item} )
|
|
endif()
|
|
endforeach()
|
|
endmacro()
|
|
|
|
# adds elements to an internal cached list
|
|
macro( add_to_cached_list listname )
|
|
cache_get ( ${listname} )
|
|
set( _ATC_${listname}_tmp ${${listname}} )
|
|
if ( NOT "${ARGN}" STREQUAL "" )
|
|
list( APPEND _ATC_${listname}_tmp ${ARGN} )
|
|
endif()
|
|
cache_set ( ${listname} ${_ATC_${listname}_tmp} )
|
|
endmacro()
|
|
|
|
# adds elements to an in-memory variable named 'listname'
|
|
macro( add_to_memory_list listname )
|
|
if ( NOT "${ARGN}" STREQUAL "" )
|
|
list( APPEND ${listname} ${ARGN} )
|
|
endif()
|
|
endmacro()
|
|
|
|
# adds elements to a list.
|
|
# If the first argument after 'listname' is PERSISTENT then 'listname'
|
|
# is a persistent internal cached variable, otherwise is a memory variable.
|
|
macro( add_to_list listname )
|
|
list_split( _ATL_ARGN_HEAD _ATL_ARGN_TAIL ${ARGN} )
|
|
if ( "${_ATL_ARGN_HEAD}" STREQUAL "PERSISTENT" )
|
|
add_to_cached_list( ${listname} ${_ATL_ARGN_TAIL} )
|
|
else()
|
|
add_to_memory_list( ${listname} ${ARGN} )
|
|
endif()
|
|
endmacro()
|
|
|
|
# Probably unused. -- Laurent Rineau, 2011/07/21
|
|
macro( at list idx var )
|
|
list( LENGTH ${list} ${list}_length )
|
|
if ( ${idx} LESS ${${list}_length} )
|
|
list( GET ${list} ${idx} ${var} )
|
|
else()
|
|
set( ${var} "NOTFOUND" )
|
|
endif()
|
|
endmacro()
|
|
|
|
macro( found_in_list item_list item result )
|
|
set( ${result} "FALSE" )
|
|
foreach( element ${${item_list}} )
|
|
if ( "${element}" STREQUAL "${item}" )
|
|
set( ${result} "TRUE" )
|
|
endif()
|
|
endforeach()
|
|
endmacro()
|
|
|
|
macro( uniquely_add_flags target_var )
|
|
if ( "${ARGC}" GREATER "1" )
|
|
set( target_list "${${target_var}}" )
|
|
set( source_list "${ARGN}" )
|
|
separate_arguments( target_list )
|
|
separate_arguments( source_list )
|
|
foreach( flag ${source_list} )
|
|
found_in_list( target_list ${flag} ${flag}_FOUND )
|
|
if ( NOT ${flag}_FOUND )
|
|
typed_cache_set( STRING "User-defined flags" ${target_var} "${${target_var}} ${flag}" )
|
|
endif()
|
|
endforeach()
|
|
endif()
|
|
endmacro()
|
|
|
|
function( CGAL_display_compiler_version )
|
|
set(search_dirs "")
|
|
message("Compiler version:")
|
|
set(version "Unknown compiler. Cannot display its version")
|
|
if(MSVC)
|
|
execute_process(COMMAND "${CMAKE_CXX_COMPILER}"
|
|
RESULT_VARIABLE ok
|
|
ERROR_VARIABLE out_version
|
|
TIMEOUT 5)
|
|
if(ok EQUAL 0)
|
|
set(version "${out_version}")
|
|
endif()
|
|
else()
|
|
foreach(flag "-V" "--version" "-v")
|
|
execute_process(COMMAND "${CMAKE_CXX_COMPILER}" ${flag}
|
|
RESULT_VARIABLE ok
|
|
OUTPUT_VARIABLE out_version
|
|
ERROR_VARIABLE out_version
|
|
TIMEOUT 5)
|
|
if(ok EQUAL 0)
|
|
if("${out_version}" MATCHES "^clang")
|
|
execute_process(COMMAND "${CMAKE_CXX_COMPILER}" -print-search-dirs
|
|
RESULT_VARIABLE ok
|
|
OUTPUT_VARIABLE out_search_dirs
|
|
TIMEOUT 5)
|
|
if(ok EQUAL 0)
|
|
set(search_dirs "${out_search_dirs}")
|
|
endif()
|
|
endif()
|
|
set(version "${out_version}")
|
|
break()
|
|
endif()
|
|
endforeach()
|
|
endif()
|
|
message("${version}")
|
|
if(search_dirs)
|
|
message("Search dirs:")
|
|
message("${search_dirs}")
|
|
endif()
|
|
endfunction()
|
|
|
|
macro( get_dependency_version LIB )
|
|
|
|
if ( "${ARGC}" GREATER "1" )
|
|
set( PKG ${ARGV1} )
|
|
else()
|
|
set( PKG ${LIB} )
|
|
endif()
|
|
|
|
if ( ${PKG}_FOUND )
|
|
|
|
set ( ${LIB}_VERSION "unknown" )
|
|
|
|
if(NOT CMAKE_CROSSCOMPILING)
|
|
if(EXISTS "${CGAL_MODULES_DIR}/config/support/print_${LIB}_version.cpp")
|
|
try_run( ${LIB}_RUN_RES
|
|
${LIB}_COMPILE_RES
|
|
"${CMAKE_BINARY_DIR}"
|
|
"${CGAL_MODULES_DIR}/config/support/print_${LIB}_version.cpp"
|
|
CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${${PKG}_INCLUDE_DIR};${${PKG}_DEPENDENCY_INCLUDE_DIR}"
|
|
"-DLINK_LIBRARIES:STRING=${${PKG}_LIBRARIES};${${PKG}_DEPENDENCY_LIBRARIES}"
|
|
"-DLINK_DIRECTORIES:STRING=${${PKG}_LIBRARIES_DIR};${${PKG}_DEPENDENCY_LIBRARIES_DIR}"
|
|
OUTPUT_VARIABLE ${LIB}_OUTPUT
|
|
)
|
|
endif()
|
|
else()
|
|
set(${LIB}_COMPILE_RES FALSE)
|
|
message(STATUS "CROSS-COMPILING!")
|
|
endif()
|
|
if ( ${LIB}_COMPILE_RES )
|
|
|
|
if ( ${LIB}_RUN_RES EQUAL "0" )
|
|
|
|
string( REGEX MATCH "version=.*\$" ${LIB}_VERSION_LINE ${${LIB}_OUTPUT} )
|
|
string( REPLACE "\n" "" ${LIB}_VERSION_LINE2 ${${LIB}_VERSION_LINE} )
|
|
string( REPLACE "\r" "" ${LIB}_VERSION_LINE3 ${${LIB}_VERSION_LINE2} )
|
|
string( REPLACE "version=" "" ${LIB}_VERSION ${${LIB}_VERSION_LINE3} )
|
|
|
|
else()
|
|
|
|
message( STATUS "WARNING: ${LIB} found but print_${LIB}_version.cpp exited with error condition: ${${LIB}_RUN_RES}" )
|
|
message( STATUS "${PKG}_INCLUDE_DIR=${${PKG}_INCLUDE_DIR}" )
|
|
message( STATUS "${PKG}_LIBRARIES=${${PKG}_LIBRARIES}" )
|
|
message( STATUS "${PKG}_LIBRARIES_DIR=${${PKG}_LIBRARIES_DIR}" )
|
|
message( STATUS "${${LIB}_OUTPUT}" )
|
|
|
|
endif()
|
|
|
|
else()
|
|
|
|
message( STATUS "WARNING: ${LIB} found but could not compile print_${LIB}_version.cpp:")
|
|
message( STATUS "${PKG}_INCLUDE_DIR=${${PKG}_INCLUDE_DIR}" )
|
|
message( STATUS "${PKG}_LIBRARIES=${${PKG}_LIBRARIES}" )
|
|
message( STATUS "${PKG}_LIBRARIES_DIR=${${PKG}_LIBRARIES_DIR}" )
|
|
message( STATUS "${${LIB}_OUTPUT}" )
|
|
|
|
endif()
|
|
|
|
message( STATUS "USING ${LIB}_VERSION = '${${LIB}_VERSION}'" )
|
|
|
|
endif()
|
|
|
|
endmacro()
|
|
|
|
macro( use_lib )
|
|
|
|
set (lib "${ARGV0}")
|
|
|
|
set (vlib ${CGAL_EXT_LIB_${lib}_PREFIX} )
|
|
|
|
if ( ${vlib}_FOUND AND (NOT TARGET CGAL OR WITH_${lib}))
|
|
|
|
if ( NOT ${vlib}_SETUP ) # avoid double usage
|
|
|
|
if ( "${ARGC}" EQUAL "2" )
|
|
|
|
set (usefile "${ARGV1}")
|
|
|
|
include( ${usefile} )
|
|
message (STATUS "Configured ${lib} from UseLIB-file: ${usefile}")
|
|
|
|
# UseLIB-file has to set ${vlib}_SETUP to TRUE
|
|
# TODO EBEB what about Qt5, zlib?
|
|
|
|
else()
|
|
|
|
####message( STATUS "${lib} include: ${${vlib}_INCLUDE_DIR}" )
|
|
include_directories ( SYSTEM ${${vlib}_INCLUDE_DIR} )
|
|
|
|
# TODO EBEB remove definitions?
|
|
####message( STATUS "${lib} definitions: ${${vlib}_DEFINITIONS}" )
|
|
add_definitions( ${${vlib}_DEFINITIONS} "-DCGAL_USE_${vlib}" )
|
|
|
|
if ( ${vlib}_LIBRARIES )
|
|
####message( STATUS "${lib} libraries: ${${vlib}_LIBRARIES}" )
|
|
link_libraries( ${${vlib}_LIBRARIES} )
|
|
endif()
|
|
|
|
####message (STATUS "Configured ${lib} in standard way")
|
|
|
|
set( ${vlib}_SETUP TRUE )
|
|
|
|
endif()
|
|
|
|
endif()
|
|
|
|
if (NOT ${vlib}_SETUP )
|
|
|
|
message( WARNING "${vlib} has not been set up" )
|
|
|
|
endif()
|
|
|
|
else()
|
|
|
|
if ( WITH_${lib} )
|
|
message( SEND_ERROR "Try to use ${lib} that is not found")
|
|
endif()
|
|
|
|
endif()
|
|
|
|
endmacro()
|
|
|
|
|
|
macro( use_component component)
|
|
|
|
message (STATUS "Requested component: ${component}")
|
|
|
|
if(WITH_CGAL_${component})
|
|
if(TARGET CGAL::CGAL_${component})
|
|
add_to_list( CGAL_LIBRARIES CGAL::CGAL_${component} )
|
|
elseif(TARGET CGAL_${component})
|
|
add_to_list( CGAL_LIBRARIES CGAL_${component} )
|
|
else()
|
|
add_to_list( CGAL_LIBRARIES ${CGAL_${component}_LIBRARY} )
|
|
endif()
|
|
add_to_list( CGAL_3RD_PARTY_LIBRARIES ${CGAL_${component}_3RD_PARTY_LIBRARIES} )
|
|
|
|
add_to_list( CGAL_3RD_PARTY_INCLUDE_DIRS ${CGAL_${component}_3RD_PARTY_INCLUDE_DIRS} )
|
|
add_to_list( CGAL_3RD_PARTY_DEFINITIONS ${CGAL_${component}_3RD_PARTY_DEFINITIONS} )
|
|
add_to_list( CGAL_3RD_PARTY_LIBRARIES_DIRS ${CGAL_${component}_3RD_PARTY_LIBRARIES_DIRS} )
|
|
|
|
# To deal with imported targets of Qt5 and Boost, when CGAL
|
|
# targets are themselves imported by another project.
|
|
if(NOT CGAL_BUILDING_LIBS)
|
|
if (NOT MSVC AND "${component}" STREQUAL "Core")
|
|
# See the release notes of CGAL-4.10: CGAL_Core now requires
|
|
# Boost.Thread, with all compilers but MSVC.
|
|
find_package( Boost 1.48 REQUIRED thread system )
|
|
add_to_list( CGAL_3RD_PARTY_LIBRARIES ${Boost_LIBRARIES} )
|
|
endif()
|
|
|
|
if (${component} STREQUAL "Qt5")
|
|
find_package(Qt5 COMPONENTS OpenGL Gui Core Script ScriptTools QUIET)
|
|
endif()
|
|
endif()
|
|
|
|
else(WITH_CGAL_${component})
|
|
|
|
# now we are talking about 3rd party libs
|
|
list( FIND CGAL_CONFIGURED_LIBRARIES "CGAL_${component}" POSITION )
|
|
if ( "${POSITION}" EQUAL "-1" ) # if component is not a CGAL_<lib>
|
|
|
|
if (NOT DEFINED CGAL_EXT_LIB_${component}_PREFIX)
|
|
set(CGAL_EXT_LIB_${component}_PREFIX ${component})
|
|
endif()
|
|
|
|
set( vlib "${CGAL_EXT_LIB_${component}_PREFIX}" )
|
|
|
|
if ( NOT CGAL_IGNORE_PRECONFIGURED_${component} AND ${vlib}_FOUND)
|
|
|
|
####message( STATUS "External library ${component} has been preconfigured")
|
|
use_lib( ${component} ${${vlib}_USE_FILE})
|
|
|
|
else()
|
|
|
|
####message( STATUS "External library ${vlib} after find")
|
|
if (${vlib}_FOUND)
|
|
####message( STATUS "External library ${vlib} about to be used")
|
|
use_lib( ${component} ${${vlib}_USE_FILE})
|
|
endif()
|
|
|
|
endif()
|
|
else()
|
|
|
|
if (NOT WITH_CGAL_${component})
|
|
message(STATUS "NOTICE: The CGAL_${component} library seems to be required but is not build. Thus, it is expected that some executables will not be compiled.")
|
|
endif()
|
|
|
|
endif()
|
|
|
|
endif(WITH_CGAL_${component})
|
|
|
|
endmacro()
|
|
|
|
macro( use_essential_libs )
|
|
|
|
# Comment: This is subject to be changed in the future
|
|
# - either more specific (giving precise include_dir- and link-order)
|
|
# - or even less specific if order becomes less relevant
|
|
# Eric Berberich 2012/06/29
|
|
|
|
if(NOT CGAL_DISABLE_GMP)
|
|
if(RS_FOUND)
|
|
use_component( RS )
|
|
endif()
|
|
|
|
if(MPFI_FOUND)
|
|
use_component( MPFI )
|
|
endif()
|
|
|
|
if(MPFR_FOUND)
|
|
use_component( MPFR )
|
|
endif()
|
|
|
|
if (GMPXX_FOUND)
|
|
use_component( GMPXX )
|
|
endif()
|
|
|
|
if(GMP_FOUND)
|
|
use_component( GMP )
|
|
endif()
|
|
endif(NOT CGAL_DISABLE_GMP)
|
|
|
|
if(LEDA_FOUND)
|
|
use_component( LEDA )
|
|
endif()
|
|
|
|
if(NTL_FOUND)
|
|
use_component( NTL )
|
|
endif()
|
|
endmacro()
|
|
|
|
|
|
function( cgal_setup_module_path )
|
|
# Avoid to modify the modules path twice
|
|
if(NOT CGAL_MODULE_PATH_IS_SET)
|
|
# Where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked
|
|
set(CGAL_CMAKE_MODULE_PATH ${CGAL_MODULES_DIR})
|
|
|
|
set(ORIGINAL_CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} PARENT_SCOPE)
|
|
|
|
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CGAL_CMAKE_MODULE_PATH})
|
|
|
|
# Export those variables to the parent scope (the scope that calls the function)
|
|
set(CGAL_MODULE_PATH_IS_SET TRUE PARENT_SCOPE)
|
|
set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" PARENT_SCOPE)
|
|
set(CGAL_CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" PARENT_SCOPE)
|
|
set(ORIGINAL_CMAKE_MODULE_PATH "${ORIGINAL_CMAKE_MODULE_PATH}" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
macro( create_CGALconfig_files )
|
|
|
|
include(CMakePackageConfigHelpers)
|
|
|
|
# CGALConfig.cmake is platform specific so it is generated and stored in the binary folder.
|
|
configure_file("${CGAL_MODULES_DIR}/CGALConfig_binary.cmake.in" "${CMAKE_BINARY_DIR}/CGALConfig.cmake" @ONLY)
|
|
write_basic_package_version_file("${CMAKE_BINARY_DIR}/CGALConfigVersion.cmake"
|
|
VERSION "${CGAL_MAJOR_VERSION}.${CGAL_MINOR_VERSION}.${CGAL_BUILD_VERSION}"
|
|
COMPATIBILITY SameMajorVersion)
|
|
|
|
# There is also a version of CGALConfig.cmake that is prepared in case CGAL in installed in CMAKE_INSTALL_PREFIX.
|
|
configure_file("${CGAL_MODULES_DIR}/CGALConfig_install.cmake.in" "${CMAKE_BINARY_DIR}/config/CGALConfig.cmake" @ONLY)
|
|
|
|
#write prefix exceptions
|
|
file( APPEND ${CMAKE_BINARY_DIR}/CGALConfig.cmake "${SPECIAL_PREFIXES}\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/config/CGALConfig.cmake "${SPECIAL_PREFIXES}")
|
|
|
|
foreach( lib ${CGAL_SUPPORTING_3RD_PARTY_LIBRARIES} )
|
|
|
|
list( FIND CGAL_ESSENTIAL_3RD_PARTY_LIBRARIES "${lib}" POSITION )
|
|
# if lib is essential or preconfiguration for an activated library ...
|
|
if ( ("${POSITION}" STRGREATER "-1") OR ( CGAL_ENABLE_PRECONFIG AND WITH_${lib} ))
|
|
|
|
set (vlib ${CGAL_EXT_LIB_${lib}_PREFIX} )
|
|
#the next 'if' is needed to avoid ${vlib} config variables to be overidden in case of a local configuration change
|
|
file( APPEND ${CMAKE_BINARY_DIR}/CGALConfig.cmake "if (NOT CGAL_IGNORE_PRECONFIGURED_${lib})\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/CGALConfig.cmake " set( ${vlib}_FOUND \"${${vlib}_FOUND}\" )\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/CGALConfig.cmake " set( ${vlib}_USE_FILE \"${${vlib}_USE_FILE}\" )\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/CGALConfig.cmake " set( ${vlib}_INCLUDE_DIR \"${${vlib}_INCLUDE_DIR}\" )\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/CGALConfig.cmake " set( ${vlib}_LIBRARIES \"${${vlib}_LIBRARIES}\" )\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/CGALConfig.cmake " set( ${vlib}_DEFINITIONS \"${${vlib}_DEFINITIONS}\" )\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/CGALConfig.cmake "endif()\n\n")
|
|
|
|
|
|
#the next 'if' is needed to avoid ${vlib} config variables to be overidden in case of a local configuration change
|
|
file( APPEND ${CMAKE_BINARY_DIR}/config/CGALConfig.cmake "if (NOT CGAL_IGNORE_PRECONFIGURED_${lib})\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/config/CGALConfig.cmake " set( ${vlib}_FOUND \"${${vlib}_FOUND}\")\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/config/CGALConfig.cmake " set( ${vlib}_USE_FILE \"${${vlib}_USE_FILE}\" )\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/config/CGALConfig.cmake " set( ${vlib}_INCLUDE_DIR \"${${vlib}_INCLUDE_DIR}\" )\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/config/CGALConfig.cmake " set( ${vlib}_LIBRARIES \"${${vlib}_LIBRARIES}\" )\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/config/CGALConfig.cmake " set( ${vlib}_DEFINITIONS \"${${vlib}_DEFINITIONS}\" )\n")
|
|
file( APPEND ${CMAKE_BINARY_DIR}/config/CGALConfig.cmake "endif()\n\n")
|
|
endif()
|
|
|
|
endforeach()
|
|
|
|
endmacro()
|
|
|
|
macro ( fetch_env_var VAR )
|
|
if ( "${${VAR}}" STREQUAL "" )
|
|
set( ${VAR}_env_value "$ENV{${VAR}}" )
|
|
if ( NOT "${${VAR}_env_value}" STREQUAL "" )
|
|
# Convert Windows path to Unix-style
|
|
FILE(TO_CMAKE_PATH ${${VAR}_env_value} ${VAR})
|
|
endif()
|
|
endif()
|
|
endmacro()
|
|
|
|
## All the following macros are probably unused. -- Laurent Rineau, 2011/07/21
|
|
|
|
# Composes a tagged list of libraries: a list with interpersed keywords or tags
|
|
# indicating that all following libraries, up to the next tag, are to be linked only for the
|
|
# corresponding build type. The 'general' tag indicates libraries that corresponds to all build types.
|
|
# 'optimized' corresponds to release builds and 'debug' to debug builds. Tags are case sensitve and
|
|
# the inital range of libraries listed before any tag is implicitely 'general'
|
|
#
|
|
# This macro takes 3 lists of general, optimized and debug libraries, resp, and populates the list
|
|
# given in the fourth argument.
|
|
#
|
|
# The first three parameters must be strings containing a semi-colon separated list of elements.
|
|
# All three lists must be passed, but any of them can be an empty string "".
|
|
# The fourth parameter, corresponding to the result, must be a variable name and it will be APPENDED
|
|
# (retaining any previous contents)
|
|
#
|
|
# If there is a last parameter whose value is "PERSISTENT" then the result is an internal cached variable,
|
|
# otherwise it is an in-memory variable
|
|
#
|
|
macro( compose_tagged_libraries libs_general libs_optimized libs_debug libs )
|
|
|
|
if ( "${ARGN}" STREQUAL "PERSISTENT" )
|
|
set( _CTL_IN_CACHE "PERSISTENT" )
|
|
else()
|
|
set( _CTL_IN_CACHE )
|
|
endif()
|
|
|
|
if ( NOT "${libs_general}" STREQUAL "" )
|
|
add_to_list( ${libs} ${_CTL_IN_CACHE} ${libs_general} )
|
|
endif()
|
|
|
|
if ( NOT "${libs_optimized}" STREQUAL "" )
|
|
add_to_list( ${libs} ${_CTL_IN_CACHE} optimized ${libs_optimized} )
|
|
endif()
|
|
|
|
if ( NOT "${libs_debug}" STREQUAL "" )
|
|
add_to_list( ${libs} ${_CTL_IN_CACHE} debug ${libs_debug} )
|
|
endif()
|
|
|
|
endmacro()
|
|
|
|
# Decomposes a tagged list of libraries (see macro compose_tagged_libraries).
|
|
# The first argument is the tagged list and the next 3 arguments are the lists
|
|
# where the general, optimized and debug libraries are collected.
|
|
#
|
|
# The first parameter must be a string containing a semi-colon separated list of elements.
|
|
# It cannot be ommitted, but it can be an empty string ""
|
|
#
|
|
# TThe next three arguments must be the names of the variables containing the result, and they
|
|
# will be APPENDED (retaining any previous contents)
|
|
#
|
|
# If there is a last parameter whose value is "PERSISTENT" then the result variables are internal in the cache,
|
|
# otherwise they are in-memory.
|
|
#
|
|
macro( decompose_tagged_libraries libs libs_general libs_optimized libs_debug )
|
|
|
|
if ( "${ARGN}" STREQUAL "PERSISTENT" )
|
|
set( _DTL_IN_CACHE "PERSISTENT" )
|
|
else()
|
|
set( _DTL_IN_CACHE )
|
|
endif()
|
|
|
|
set( _DTL_tag general )
|
|
|
|
foreach( _DTL_lib ${libs} )
|
|
|
|
if ( "${_DTL_lib}" STREQUAL "general" OR "${_DTL_lib}" STREQUAL "optimized" OR "${_DTL_lib}" STREQUAL "debug" )
|
|
|
|
set( _DTL_tag "${_DTL_lib}" )
|
|
|
|
else()
|
|
|
|
if ( "${_DTL_tag}" STREQUAL "general" )
|
|
set( _DTL_target ${libs_general} )
|
|
elseif ( "${_DTL_tag}" STREQUAL "optimized" )
|
|
set( _DTL_target ${libs_optimized} )
|
|
else()
|
|
set( _DTL_target ${libs_debug} )
|
|
endif()
|
|
|
|
add_to_list( ${_DTL_target} ${_DTL_IN_CACHE} ${_DTL_lib} )
|
|
|
|
endif()
|
|
|
|
endforeach()
|
|
|
|
endmacro()
|
|
|
|
# Given lists of optimized and debug libraries, creates a tagged list which will
|
|
# contain the libraries listed in the 'general' section if any of the two lists is empty,
|
|
#
|
|
# All arguments are variable names (not values), thus the input list can be undefined or empty.
|
|
# The return variable ('libs') will be APPENDED the result (retaining any previous contents)
|
|
#
|
|
# If there is a last parameter whose value is "PERSISTENT" then the result is an internal cached variable,
|
|
# otherwise it is an in-memory variable
|
|
#
|
|
# Example:
|
|
#
|
|
# set( LIBS_1 libA.so libB.so )
|
|
# set( LIBS_2 libC.so )
|
|
#
|
|
# tag_libraries( LIBS_1 LIBS_2 LIBS_R )
|
|
#
|
|
# LIBS_R -> optimized;libA.so;libB.so;debug;libC.so
|
|
#
|
|
# tag_libraries( LIBS_1 SOME_UNDEFINED_VARIABLE_OR_EMPTY_LIST LIBS_R )
|
|
#
|
|
# LIBS_R -> libA.so;libB.so (implicitely 'general' since there is no tag)
|
|
#
|
|
# tag_libraries( SOME_UNDEFINED_VARIABLE_OR_EMPTY_LIST LIBS_2 LIBS_R )
|
|
#
|
|
# LIBS_R -> libC.so (implicitely 'general' since there is no tag)
|
|
#
|
|
macro( tag_libraries libs_general_or_optimized libs_general_or_debug libs )
|
|
|
|
list( LENGTH ${libs_general_or_optimized} _TL_libs_general_or_optimized_len )
|
|
list( LENGTH ${libs_general_or_debug} _TL_libs_general_or_debug_len )
|
|
|
|
if ( _TL_libs_general_or_optimized_len EQUAL 0 )
|
|
compose_tagged_libraries( "${${libs_general_or_debug}}" "" "" ${libs} ${ARGN} )
|
|
elseif ( _TL_libs_general_or_debug_len EQUAL 0 )
|
|
compose_tagged_libraries( "${${libs_general_or_optimized}}" "" "" ${libs} ${ARGN} )
|
|
else()
|
|
compose_tagged_libraries( "" "${${libs_general_or_optimized}}" "${${libs_general_or_debug}}" ${libs} ${ARGN} )
|
|
endif()
|
|
|
|
endmacro()
|
|
|
|
# add_to_tagged_libraries( libsR ${libsA} <PERSISTENT> )
|
|
#
|
|
# Appends the list of tagged libraries contained in the variable 'libA' to the list
|
|
# of tagged libraries contained in the variable 'libR', properly redistributing each tagged subsequence.
|
|
#
|
|
# The first argument is the name of the variable recieving the list. It will be APPENDED
|
|
# (retaining any previous contents).
|
|
# The second parameter is a single string value containing the tagged
|
|
# lists of libraries to append (as a semi-colon separated list). It can be empty, in which case noting is added.
|
|
#
|
|
# If there is a third parameter whose value is PERSISTENT, then 'libR' is an internal cached variable, otherwise
|
|
# it is an in-memory variable.
|
|
#
|
|
# It is not possible to append more than one list in the same call.
|
|
#
|
|
# Example:
|
|
#
|
|
# set( LIBS_1 libG0.so libG1.so optimized libO0.so)
|
|
# set( LIBS_2 libG2.so debug libD0.so)
|
|
# set( LIBS_3 debug libD1.so optimized libO1.so libO2.so )
|
|
#
|
|
# concat_tagged_libraries( LIBS_R ${LIBS_1} PERSISTENT )
|
|
# concat_tagged_libraries( LIBS_R ${LIBS_2} PERSISTENT )
|
|
# concat_tagged_libraries( LIBS_R ${LIBS_3} PERSISTENT )
|
|
#
|
|
# LIBS_R -> libG0.so;libG1.so;libG2.so;optimized;libO0.so;libO1.so;libO2.so;debug;libD0.so;libD1.so, in the cache
|
|
#
|
|
macro( add_to_tagged_libraries libsR in_cache libsA )
|
|
|
|
if ( "${in_cache}" STREQUAL "PERSISTENT" )
|
|
set( _CTL_IN_CACHE "PERSISTENT" )
|
|
else()
|
|
set( _CTL_IN_CACHE )
|
|
endif()
|
|
|
|
set( _CTL_general_0 )
|
|
set( _CTL_optimized_0 )
|
|
set( _CTL_debug_0 )
|
|
set( _CTL_general_1 )
|
|
set( _CTL_optimized_1 )
|
|
set( _CTL_debug_0 )
|
|
|
|
decompose_tagged_libraries( "${${libsR}}" _CTL_general_0 _CTL_optimized_0 _CTL_debug_0 )
|
|
decompose_tagged_libraries( "${libsA}" _CTL_general_1 _CTL_optimized_1 _CTL_debug_1 )
|
|
|
|
add_to_list( _CTL_general_0 ${_CTL_general_1} )
|
|
add_to_list( _CTL_optimized_0 ${_CTL_optimized_1} )
|
|
add_to_list( _CTL_debug_0 ${_CTL_debug_1} )
|
|
|
|
if ( "${_CTL_IN_CACHE}" STREQUAL "PERSISTENT" )
|
|
cache_set( ${libsR} )
|
|
else()
|
|
set( ${libsR} )
|
|
endif()
|
|
|
|
compose_tagged_libraries( "${_CTL_general_0}" "${_CTL_optimized_0}" "${_CTL_debug_0}" ${libsR} ${_CTL_IN_CACHE} )
|
|
|
|
endmacro()
|
|
|
|
|
|
macro( add_to_persistent_tagged_libraries libsR )
|
|
add_to_tagged_libraries( ${libsR} PERSISTENT "${ARGN}" )
|
|
endmacro()
|
|
|
|
macro( add_to_in_memory_tagged_libraries libsR )
|
|
add_to_tagged_libraries( ${libsR} NOT_PERSISTENT "${ARGN}" )
|
|
endmacro()
|
|
|
|
|
|
endif()
|
|
|
|
|
|
function(process_CGAL_subdirectory entry subdir type_name)
|
|
# For example, subdir can be "examples", type_name "example", and entry "Mesh_2"
|
|
|
|
if ( CGAL_BRANCH_BUILD )
|
|
string( REGEX REPLACE "${CMAKE_SOURCE_DIR}/.*/${subdir}/" "" ENTRY_DIR_NAME "${entry}" )
|
|
else()
|
|
string( REGEX REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" ENTRY_DIR_NAME "${entry}" )
|
|
endif()
|
|
|
|
if( NOT "${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}") # out-of-source
|
|
make_directory("${CMAKE_BINARY_DIR}/${subdir}/${ENTRY_DIR_NAME}")
|
|
endif()
|
|
|
|
set(ADD_SUBDIR TRUE)
|
|
|
|
if(EXISTS ${entry}/../../dont_submit)
|
|
file(STRINGS ${entry}/../../dont_submit dont_submit_grep REGEX "^${ENTRY_DIR_NAME}/?\$")
|
|
if(dont_submit_grep)
|
|
set(ADD_SUBDIR FALSE)
|
|
endif()
|
|
file(STRINGS ${entry}/../../dont_submit dont_submit_grep REGEX "^${subdir}/${ENTRY_DIR_NAME}/?\$")
|
|
if(dont_submit_grep)
|
|
set(ADD_SUBDIR FALSE)
|
|
endif()
|
|
file(STRINGS ${entry}/../../dont_submit dont_submit_grep REGEX "^${subdir}/?\$")
|
|
if(dont_submit_grep)
|
|
set(ADD_SUBDIR FALSE)
|
|
endif()
|
|
endif()
|
|
|
|
if(ADD_SUBDIR)
|
|
message("\n-- Configuring ${subdir} in ${subdir}/${ENTRY_DIR_NAME}")
|
|
if(EXISTS ${entry}/CMakeLists.txt)
|
|
set(source_dir ${entry})
|
|
add_subdirectory( ${entry} ${CMAKE_BINARY_DIR}/${subdir}/${ENTRY_DIR_NAME} )
|
|
else()
|
|
if(CGAL_CREATE_CMAKE_SCRIPT)
|
|
# message("bah ${CGAL_CREATE_CMAKE_SCRIPT} ${type_name} --source_dir ${entry}")
|
|
execute_process(
|
|
COMMAND bash ${CGAL_CREATE_CMAKE_SCRIPT} ${type_name} --source_dir "${entry}"
|
|
WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/${subdir}/${ENTRY_DIR_NAME}"
|
|
RESULT_VARIABLE RESULT_VAR OUTPUT_QUIET)
|
|
if(NOT RESULT_VAR)
|
|
# message("Subdir ${CMAKE_BINARY_DIR}/${subdir}/${ENTRY_DIR_NAME}")
|
|
set(source_dir "${CMAKE_BINARY_DIR}/${subdir}/${ENTRY_DIR_NAME}")
|
|
add_subdirectory( "${source_dir}" "${CMAKE_BINARY_DIR}/${subdir}/${ENTRY_DIR_NAME}")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
else()
|
|
message(STATUS "${subdir}/${ENTRY_DIR_NAME} is in dont_submit")
|
|
endif()
|
|
endfunction()
|
|
|