phynexis-deps/cgal
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
93c19eeccf2aa196b080f327e7342d9727a4e8da
cgal/Installation/cmake/modules/CGAL_Macros.cmake
T
Marius Kintel 3f369718be Bugfix: ORIGINAL_CMAKE_MODULE_PATH was set to PARENT_SCOPE and later referenced in the current scope 
In the `cgal_setup_module_path` function, the intent is to set a few variables then later export them.
The ORIGINAL_CMAKE_MODULE_PATH variable, however, was set directly in the parent scope. When later trying to export it, it reads from the current scope, where the variable is empty as it hasn't yet been set.
This fix makes correctly sets the variable in the local scope the first time, making the export work as expected.
2021-10-04 16:13:30 -04:00

636 lines
22 KiB
CMake
Raw Blame History

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()
message( STATUS "USING COMPILER_VERSION = '${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}'" )
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 (${component} STREQUAL "Qt5")
find_package(Qt5 COMPONENTS OpenGL Gui Core Script ScriptTools QUIET)
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 (${vlib}_FOUND)
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()
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})
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_BUGFIX_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}")
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()
Reference in New Issue View Git Blame Copy Permalink