1get_filename_component(_VTKModuleMacros_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) 2 3set(_VTKModuleMacros_DEFAULT_LABEL "VTKModular") 4 5include(${_VTKModuleMacros_DIR}/vtkModuleAPI.cmake) 6include(GenerateExportHeader) 7include(vtkWrapping) 8if(VTK_MAKE_INSTANTIATORS) 9 include(vtkMakeInstantiator) 10endif() 11if(UNIX AND VTK_BUILD_FORWARDING_EXECUTABLES) 12 include(vtkForwardingExecutable) 13endif() 14 15# vtk_module(<name>) 16# 17# Main function for declaring a VTK module, usually in a module.cmake file in 18# the module search path. The module name is the only required argument, all 19# others are optional named arguments that will be outlined below. The following 20# named options take one (or more) arguments, such as the names of dependent 21# modules: 22# DEPENDS = Modules that will be publicly linked to this module 23# PRIVATE_DEPENDS = Modules that will be privately linked to this module 24# COMPILE_DEPENDS = Modules that are needed at compile time by this module 25# TEST_DEPENDS = Modules that are needed by this modules testing executables 26# DESCRIPTION = Free text description of the module 27# TCL_NAME = Alternative name for the TCL wrapping (cannot contain numbers) 28# IMPLEMENTS = Modules that this module implements, using the auto init feature 29# BACKEND = An implementation backend that this module belongs (valid with 30# IMPLEMENTS only) 31# GROUPS = Module groups this module should be included in 32# TEST_LABELS = Add labels to the tests for the module 33# 34# The following options take no arguments: 35# EXCLUDE_FROM_ALL = Exclude this module from the build all modules flag 36# EXCLUDE_FROM_WRAPPING = Do not attempt to wrap this module in any language 37# EXCLUDE_FROM_WRAP_HIERARCHY = Do not attempt to process with wrap hierarchy 38# 39# This macro will ensure the module name is compliant, and set the appropriate 40# module variables as declared in the module.cmake file. 41macro(vtk_module _name) 42 vtk_module_check_name(${_name}) 43 set(vtk-module ${_name}) 44 set(vtk-module-test ${_name}-Test) 45 set(_doing "") 46 set(${vtk-module}_DECLARED 1) 47 set(${vtk-module-test}_DECLARED 1) 48 set(${vtk-module}_DEPENDS "") 49 set(${vtk-module}_COMPILE_DEPENDS "") 50 set(${vtk-module}_PRIVATE_DEPENDS "") 51 set(${vtk-module-test}_DEPENDS "${vtk-module}") 52 set(${vtk-module}_IMPLEMENTS "") 53 set(${vtk-module}_BACKEND "") 54 set(${vtk-module}_DESCRIPTION "description") 55 set(${vtk-module}_TCL_NAME "${vtk-module}") 56 set(${vtk-module}_EXCLUDE_FROM_ALL 0) 57 set(${vtk-module}_EXCLUDE_FROM_WRAPPING 0) 58 set(${vtk-module}_EXCLUDE_FROM_WRAP_HIERARCHY 0) 59 set(${vtk-module}_TEST_LABELS "") 60 set(${vtk-module}_KIT "") 61 foreach(arg ${ARGN}) 62 # XXX: Adding a new keyword? Update Utilities/Maintenance/WhatModulesVTK.py 63 # and Utilities/Maintenance/VisualizeModuleDependencies.py as well. 64 if("${arg}" MATCHES "^((|COMPILE_|PRIVATE_|TEST_|)DEPENDS|DESCRIPTION|TCL_NAME|IMPLEMENTS|BACKEND|DEFAULT|GROUPS|TEST_LABELS|KIT)$") 65 set(_doing "${arg}") 66 elseif("${arg}" STREQUAL "EXCLUDE_FROM_ALL") 67 set(_doing "") 68 set(${vtk-module}_EXCLUDE_FROM_ALL 1) 69 elseif("${arg}" STREQUAL "EXCLUDE_FROM_WRAPPING") 70 set(_doing "") 71 set(${vtk-module}_EXCLUDE_FROM_WRAPPING 1) 72 elseif("${arg}" MATCHES "^EXCLUDE_FROM_\([A-Z]+\)_WRAPPING$") 73 set(_doing "") 74 set(${vtk-module}_EXCLUDE_FROM_${CMAKE_MATCH_1}_WRAPPING 1) 75 elseif("${arg}" STREQUAL "EXCLUDE_FROM_WRAP_HIERARCHY") 76 set(_doing "") 77 set(${vtk-module}_EXCLUDE_FROM_WRAP_HIERARCHY 1) 78 elseif("${arg}" MATCHES "^[A-Z][A-Z][A-Z]$" AND 79 NOT "${arg}" MATCHES "^(ON|OFF|MPI)$") 80 set(_doing "") 81 message(AUTHOR_WARNING "Unknown argument [${arg}]") 82 elseif("${_doing}" STREQUAL "DEPENDS") 83 list(APPEND ${vtk-module}_DEPENDS "${arg}") 84 elseif("${_doing}" STREQUAL "TEST_LABELS") 85 list(APPEND ${vtk-module}_TEST_LABELS "${arg}") 86 elseif("${_doing}" STREQUAL "TEST_DEPENDS") 87 list(APPEND ${vtk-module-test}_DEPENDS "${arg}") 88 elseif("${_doing}" STREQUAL "COMPILE_DEPENDS") 89 list(APPEND ${vtk-module}_COMPILE_DEPENDS "${arg}") 90 elseif("${_doing}" STREQUAL "PRIVATE_DEPENDS") 91 list(APPEND ${vtk-module}_PRIVATE_DEPENDS "${arg}") 92 elseif("${_doing}" STREQUAL "DESCRIPTION") 93 set(_doing "") 94 set(${vtk-module}_DESCRIPTION "${arg}") 95 elseif("${_doing}" STREQUAL "TCL_NAME") 96 set(_doing "") 97 set(${vtk-module}_TCL_NAME "${arg}") 98 elseif("${_doing}" STREQUAL "IMPLEMENTS") 99 list(APPEND ${vtk-module}_DEPENDS "${arg}") 100 list(APPEND ${vtk-module}_IMPLEMENTS "${arg}") 101 elseif("${_doing}" STREQUAL "BACKEND") 102 # Backends control groups of implementation modules, a module may be in 103 # multiple groups, and it should be an implementation of an interface 104 # module. The current BACKENDS are OpenGL and OpenGL2 (new rendering). 105 if(NOT DEFINED VTK_BACKEND_${arg}_MODULES) 106 list(APPEND VTK_BACKENDS ${arg}) 107 endif() 108 list(APPEND VTK_BACKEND_${arg}_MODULES ${vtk-module}) 109 list(APPEND ${vtk-module}_BACKEND "${arg}") 110 # Being a backend implicitly excludes from all (mutual exclusivity). 111 set(${vtk-module}_EXCLUDE_FROM_ALL 1) 112 elseif("${_doing}" MATCHES "^DEFAULT") 113 message(FATAL_ERROR "Invalid argument [DEFAULT]") 114 elseif("${_doing}" STREQUAL "GROUPS") 115 # Groups control larger groups of modules. 116 if(NOT DEFINED VTK_GROUP_${arg}_MODULES) 117 list(APPEND VTK_GROUPS ${arg}) 118 endif() 119 list(APPEND VTK_GROUP_${arg}_MODULES ${vtk-module}) 120 elseif("${_doing}" STREQUAL "KIT") 121 set(${vtk-module}_KIT "${arg}") 122 else() 123 set(_doing "") 124 message(AUTHOR_WARNING "Unknown argument [${arg}]") 125 endif() 126 endforeach() 127 list(SORT ${vtk-module}_DEPENDS) # Deterministic order. 128 set(${vtk-module}_LINK_DEPENDS "${${vtk-module}_DEPENDS}") 129 list(APPEND ${vtk-module}_DEPENDS 130 ${${vtk-module}_COMPILE_DEPENDS} 131 ${${vtk-module}_PRIVATE_DEPENDS}) 132 unset(${vtk-module}_COMPILE_DEPENDS) 133 list(SORT ${vtk-module}_DEPENDS) # Deterministic order. 134 list(SORT ${vtk-module-test}_DEPENDS) # Deterministic order. 135 list(SORT ${vtk-module}_IMPLEMENTS) # Deterministic order. 136 if(NOT (${vtk-module}_EXCLUDE_FROM_WRAPPING OR 137 ${vtk-module}_EXCLUDE_FROM_TCL_WRAPPING) AND 138 "${${vtk-module}_TCL_NAME}" MATCHES "[0-9]") 139 message(AUTHOR_WARNING "Specify a TCL_NAME with no digits.") 140 endif() 141endmacro() 142 143# vtk_module_check_name(<name>) 144# 145# Check if the proposed module name is compliant. 146function(vtk_module_check_name _name) 147 if(NOT "${_name}" MATCHES "^[a-zA-Z][a-zA-Z0-9]*$") 148 message(FATAL_ERROR "Invalid module name: ${_name}") 149 endif() 150endfunction() 151 152# vtk_module_impl() 153# 154# This macro provides module implementation, setting up important variables 155# necessary to build a module. It assumes we are in the directory of the module. 156macro(vtk_module_impl) 157 include(module.cmake OPTIONAL) # Load module meta-data 158 159 vtk_module_config(_dep ${${vtk-module}_DEPENDS}) 160 if(_dep_INCLUDE_DIRS) 161 include_directories(${_dep_INCLUDE_DIRS}) 162 # This variable is used in vtkWrapping.cmake 163 set(${vtk-module}_DEPENDS_INCLUDE_DIRS ${_dep_INCLUDE_DIRS}) 164 endif() 165 if(_dep_LIBRARY_DIRS) 166 link_directories(${_dep_LIBRARY_DIRS}) 167 endif() 168 169 if(NOT DEFINED ${vtk-module}_LIBRARIES) 170 foreach(dep IN LISTS ${vtk-module}_LINK_DEPENDS) 171 list(APPEND ${vtk-module}_LIBRARIES "${${dep}_LIBRARIES}") 172 endforeach() 173 if(${vtk-module}_LIBRARIES) 174 list(REMOVE_DUPLICATES ${vtk-module}_LIBRARIES) 175 endif() 176 endif() 177 178 list(APPEND ${vtk-module}_INCLUDE_DIRS 179 ${${vtk-module}_BINARY_DIR} 180 ${${vtk-module}_SOURCE_DIR}) 181 list(REMOVE_DUPLICATES ${vtk-module}_INCLUDE_DIRS) 182 183 if(${vtk-module}_INCLUDE_DIRS) 184 include_directories(${${vtk-module}_INCLUDE_DIRS}) 185 endif() 186 if(${vtk-module}_SYSTEM_INCLUDE_DIRS) 187 include_directories(${${vtk-module}_SYSTEM_INCLUDE_DIRS}) 188 endif() 189 190 if(${vtk-module}_SYSTEM_LIBRARY_DIRS) 191 link_directories(${${vtk-module}_SYSTEM_LIBRARY_DIRS}) 192 endif() 193 194 if(${vtk-module}_THIRD_PARTY) 195 vtk_module_warnings_disable(C CXX) 196 endif() 197endmacro() 198 199# vtk_module_export_code_find_package(<name>) 200# 201# Add code that runs when the module is loaded in an application 202# to find the given package in the same place VTK found it. 203# This is useful for finding external dependencies that provide 204# imported targets linked by VTK libraries. 205# 206# The <name>_DIR variable must be set to the package location. 207# The VTK_INSTALL_FIND_PACKAGE_<name>_DIR variable may be set 208# to an alternative location for the install tree to reference, 209# or to a false value to remove any default location. 210macro(vtk_module_export_code_find_package _name) 211 if(${_name}_DIR) 212 if(DEFINED VTK_INSTALL_FIND_PACKAGE_${_name}_DIR) 213 set(_dir "${VTK_INSTALL_FIND_PACKAGE_${_name}_DIR}") 214 else() 215 set(_dir "${${_name}_DIR}") 216 endif() 217 if(_dir) 218 set(${vtk-module}_EXPORT_CODE_INSTALL "${${vtk-module}_EXPORT_CODE_INSTALL} 219if(NOT ${_name}_DIR) 220 set(${_name}_DIR \"${_dir}\") 221endif()") 222 endif() 223 set(${vtk-module}_EXPORT_CODE_INSTALL "${${vtk-module}_EXPORT_CODE_INSTALL} 224find_package(${_name} REQUIRED QUIET) 225") 226 set(${vtk-module}_EXPORT_CODE_BUILD "${${vtk-module}_EXPORT_CODE_BUILD} 227if(NOT ${_name}_DIR) 228 set(${_name}_DIR \"${${_name}_DIR}\") 229endif() 230find_package(${_name} REQUIRED QUIET) 231") 232 endif() 233endmacro() 234 235# vtk_module_export_info() 236# 237# Export just the essential data from a module such as name, include directory, 238# libraries provided by the module, and any custom variables that are part of 239# the module configuration. 240macro(vtk_module_export_info) 241 vtk_module_impl() 242 # First gather and configure the high level module information. 243 set(_code "") 244 foreach(opt ${${vtk-module}_EXPORT_OPTIONS}) 245 set(_code "${_code}set(${opt} \"${${opt}}\")\n") 246 endforeach() 247 if(${vtk-module}_EXCLUDE_FROM_WRAPPING) 248 set(_code "${_code}set(${vtk-module}_EXCLUDE_FROM_WRAPPING 1)\n") 249 endif() 250 if(${vtk-module}_IMPLEMENTS) 251 set(_code "${_code}set(${vtk-module}_IMPLEMENTS \"${${vtk-module}_IMPLEMENTS}\")\n") 252 endif() 253 set(vtk-module-EXPORT_CODE-build "${_code}${${vtk-module}_EXPORT_CODE_BUILD}") 254 set(vtk-module-EXPORT_CODE-install "${_code}${${vtk-module}_EXPORT_CODE_INSTALL}") 255 if(${vtk-module}_WRAP_HINTS) 256 set(vtk-module-EXPORT_CODE-build 257 "${vtk-module-EXPORT_CODE-build}set(${vtk-module}_WRAP_HINTS \"${${vtk-module}_WRAP_HINTS}\")\n") 258 set(vtk-module-EXPORT_CODE-install 259 "${vtk-module-EXPORT_CODE-install}set(${vtk-module}_WRAP_HINTS \"\${CMAKE_CURRENT_LIST_DIR}/${vtk-module}_hints\")\n") 260 endif() 261 262 set(vtk-module-DEPENDS "${${vtk-module}_DEPENDS}") 263 set(vtk-module-LIBRARIES "${${vtk-module}_LIBRARIES}") 264 set(vtk-module-INCLUDE_DIRS-build "${${vtk-module}_INCLUDE_DIRS}") 265 set(vtk-module-INCLUDE_DIRS-install "\${VTK_INSTALL_PREFIX}/${VTK_INSTALL_INCLUDE_DIR}") 266 if(${vtk-module}_SYSTEM_INCLUDE_DIRS) 267 list(APPEND vtk-module-INCLUDE_DIRS-build "${${vtk-module}_SYSTEM_INCLUDE_DIRS}") 268 list(APPEND vtk-module-INCLUDE_DIRS-install "${${vtk-module}_SYSTEM_INCLUDE_DIRS}") 269 endif() 270 if(WIN32) 271 set(vtk-module-RUNTIME_LIBRARY_DIRS-build "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}") 272 set(vtk-module-RUNTIME_LIBRARY_DIRS-install "\${VTK_INSTALL_PREFIX}/${VTK_INSTALL_RUNTIME_DIR}") 273 else() 274 set(vtk-module-RUNTIME_LIBRARY_DIRS-build "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}") 275 set(vtk-module-RUNTIME_LIBRARY_DIRS-install "\${VTK_INSTALL_PREFIX}/${VTK_INSTALL_LIBRARY_DIR}") 276 endif() 277 set(vtk-module-LIBRARY_DIRS "${${vtk-module}_SYSTEM_LIBRARY_DIRS}") 278 set(vtk-module-RUNTIME_LIBRARY_DIRS "${vtk-module-RUNTIME_LIBRARY_DIRS-build}") 279 set(vtk-module-INCLUDE_DIRS "${vtk-module-INCLUDE_DIRS-build}") 280 set(vtk-module-EXPORT_CODE "${vtk-module-EXPORT_CODE-build}") 281 set(vtk-module-WRAP_HIERARCHY_FILE "${${vtk-module}_WRAP_HIERARCHY_FILE}") 282 configure_file(${_VTKModuleMacros_DIR}/vtkModuleInfo.cmake.in 283 ${VTK_MODULES_DIR}/${vtk-module}.cmake @ONLY) 284 set(vtk-module-INCLUDE_DIRS "${vtk-module-INCLUDE_DIRS-install}") 285 set(vtk-module-RUNTIME_LIBRARY_DIRS "${vtk-module-RUNTIME_LIBRARY_DIRS-install}") 286 set(vtk-module-EXPORT_CODE "${vtk-module-EXPORT_CODE-install}") 287 set(vtk-module-WRAP_HIERARCHY_FILE 288 "\${CMAKE_CURRENT_LIST_DIR}/${vtk-module}Hierarchy.txt") 289 configure_file(${_VTKModuleMacros_DIR}/vtkModuleInfo.cmake.in 290 CMakeFiles/${vtk-module}.cmake @ONLY) 291 if (NOT VTK_INSTALL_NO_DEVELOPMENT) 292 install(FILES ${${vtk-module}_BINARY_DIR}/CMakeFiles/${vtk-module}.cmake 293 DESTINATION ${VTK_INSTALL_PACKAGE_DIR}/Modules 294 COMPONENT Development) 295 if(NOT ${vtk-module}_EXCLUDE_FROM_WRAPPING) 296 if(VTK_WRAP_PYTHON OR VTK_WRAP_TCL OR VTK_WRAP_JAVA) 297 install(FILES ${${vtk-module}_WRAP_HIERARCHY_FILE} 298 DESTINATION ${VTK_INSTALL_PACKAGE_DIR}/Modules 299 COMPONENT Development) 300 endif() 301 if(${vtk-module}_WRAP_HINTS AND EXISTS "${${vtk-module}_WRAP_HINTS}") 302 install(FILES ${${vtk-module}_WRAP_HINTS} 303 RENAME ${vtk-module}_HINTS 304 DESTINATION ${VTK_INSTALL_PACKAGE_DIR}/Modules 305 COMPONENT Development) 306 endif() 307 endif() 308 endif() 309endmacro() 310 311# vtk_module_export(<sources>) 312# 313# Export data from a module such as name, include directory and header level 314# information useful for wrapping. This calls vtk_module_export_info() and then 315# exports additional information in a supplemental file useful for wrapping 316# generators. 317function(vtk_module_export sources) 318 vtk_module_export_info() 319 # Now iterate through the headers in the module to get header level information. 320 foreach(arg ${sources}) 321 get_filename_component(src "${arg}" ABSOLUTE) 322 323 string(REGEX REPLACE "\\.(cxx|txx|mm)$" ".h" hdr "${src}") 324 if("${hdr}" MATCHES "\\.h$") 325 if(EXISTS "${hdr}") 326 get_filename_component(_filename "${hdr}" NAME) 327 string(REGEX REPLACE "\\.h$" "" _cls "${_filename}") 328 329 get_source_file_property(_wrap_exclude ${src} WRAP_EXCLUDE) 330 get_source_file_property(_abstract ${src} ABSTRACT) 331 get_source_file_property(_wrap_special ${src} WRAP_SPECIAL) 332 333 if(_wrap_special OR NOT _wrap_exclude) 334 list(APPEND vtk-module-HEADERS ${_cls}) 335 336 if(_abstract) 337 set(vtk-module-ABSTRACT 338 "${vtk-module-ABSTRACT}set(${vtk-module}_HEADER_${_cls}_ABSTRACT 1)\n") 339 endif() 340 341 if(_wrap_exclude) 342 set(vtk-module-WRAP_EXCLUDE 343 "${vtk-module-WRAP_EXCLUDE}set(${vtk-module}_HEADER_${_cls}_WRAP_EXCLUDE 1)\n") 344 endif() 345 346 if(_wrap_special) 347 set(vtk-module-WRAP_SPECIAL 348 "${vtk-module-WRAP_SPECIAL}set(${vtk-module}_HEADER_${_cls}_WRAP_SPECIAL 1)\n") 349 endif() 350 endif() 351 endif() 352 endif() 353 endforeach() 354 # Configure wrapping information for external wrapping of headers. 355 configure_file(${_VTKModuleMacros_DIR}/vtkModuleHeaders.cmake.in 356 ${VTK_MODULES_DIR}/${vtk-module}-Headers.cmake @ONLY) 357endfunction() 358 359macro(vtk_module_test) 360 if(NOT vtk_module_test_called) 361 set(vtk_module_test_called 1) # Run once in a given scope. 362 include(../../module.cmake) # Load module meta-data 363 vtk_module_config(${vtk-module-test}-Cxx ${${vtk-module-test}-Cxx_DEPENDS}) 364 if(${vtk-module-test}-Cxx_INCLUDE_DIRS) 365 include_directories(${${vtk-module-test}-Cxx_INCLUDE_DIRS}) 366 endif() 367 if(${vtk-module-test}-Cxx_LIBRARY_DIRS) 368 link_directories(${${vtk-module-test}-Cxx_LIBRARY_DIRS}) 369 endif() 370 endif() 371endmacro() 372 373function(vtk_module_warnings_disable) 374 foreach(lang IN LISTS ARGN) 375 if(MSVC) 376 string(REGEX REPLACE "(^| )[/-]W[0-4]( |$)" " " 377 CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS} -w") 378 elseif(BORLAND) 379 set(CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS} -w-") 380 else() 381 set(CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS} -w") 382 endif() 383 set(CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS}" PARENT_SCOPE) 384 endforeach() 385endfunction() 386 387function(vtk_target_label _target_name) 388 if(vtk-module) 389 set(_label ${vtk-module}) 390 else() 391 set(_label ${_VTKModuleMacros_DEFAULT_LABEL}) 392 endif() 393 set_property(TARGET ${_target_name} PROPERTY LABELS ${_label}) 394endfunction() 395 396# vtk_target_name(<name>) 397# 398# This macro does some basic checking for library naming, and also adds a suffix 399# to the output name with the VTK version by default. Setting the variable 400# VTK_CUSTOM_LIBRARY_SUFFIX will override the suffix. 401function(vtk_target_name _name) 402 get_property(_type TARGET ${_name} PROPERTY TYPE) 403 if(NOT "${_type}" STREQUAL EXECUTABLE AND NOT VTK_JAVA_INSTALL) 404 set_property(TARGET ${_name} PROPERTY VERSION 1) 405 set_property(TARGET ${_name} PROPERTY SOVERSION 1) 406 endif() 407 if("${_name}" MATCHES "^[Vv][Tt][Kk]") 408 set(_vtk "") 409 else() 410 set(_vtk "vtk") 411 #message(AUTHOR_WARNING "Target [${_name}] does not start in 'vtk'.") 412 endif() 413 # Support custom library suffix names, for other projects wanting to inject 414 # their own version numbers etc. 415 if(DEFINED VTK_CUSTOM_LIBRARY_SUFFIX) 416 set(_lib_suffix "${VTK_CUSTOM_LIBRARY_SUFFIX}") 417 else() 418 set(_lib_suffix "-${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}") 419 endif() 420 set_property(TARGET ${_name} PROPERTY OUTPUT_NAME ${_vtk}${_name}${_lib_suffix}) 421endfunction() 422 423function(vtk_target_export _name) 424 set_property(GLOBAL APPEND PROPERTY VTK_TARGETS ${_name}) 425endfunction() 426 427function(vtk_target_install _name) 428 if(NOT VTK_INSTALL_NO_LIBRARIES) 429 if(APPLE AND VTK_JAVA_INSTALL) 430 set_target_properties(${_name} PROPERTIES SUFFIX ".jnilib") 431 endif() 432 if(VTK_INSTALL_NO_DEVELOPMENT) 433 # Installation for deployment does not need static libraries. 434 get_property(_type TARGET ${_name} PROPERTY TYPE) 435 if(_type STREQUAL "STATIC_LIBRARY") 436 return() 437 endif() 438 set(_archive_destination "") 439 else() 440 # Installation for development needs static libraries. 441 set(_archive_destination 442 ARCHIVE DESTINATION ${VTK_INSTALL_ARCHIVE_DIR} COMPONENT Development 443 ) 444 endif() 445 install(TARGETS ${_name} 446 EXPORT ${VTK_INSTALL_EXPORT_NAME} 447 RUNTIME DESTINATION ${VTK_INSTALL_RUNTIME_DIR} COMPONENT RuntimeLibraries 448 LIBRARY DESTINATION ${VTK_INSTALL_LIBRARY_DIR} COMPONENT RuntimeLibraries 449 ${_archive_destination} 450 ) 451 endif() 452endfunction() 453 454function(vtk_target _name) 455 set(_install 1) 456 foreach(arg IN LISTS ARGN) 457 if(arg STREQUAL "NO_INSTALL") 458 set(_install 0) 459 else() 460 message(FATAL_ERROR "Unknown argument [${arg}]") 461 endif() 462 endforeach() 463 vtk_target_name(${_name}) 464 vtk_target_label(${_name}) 465 vtk_target_export(${_name}) 466 if(_install) 467 vtk_target_install(${_name}) 468 endif() 469endfunction() 470 471#------------------------------------------------------------------------------ 472# Export a target for a tool that used during the compilation process. 473# This is called by vtk_compile_tools_target(). 474function(vtk_compile_tools_target_export _name) 475 set_property(GLOBAL APPEND PROPERTY VTK_COMPILETOOLS_TARGETS ${_name}) 476endfunction() 477 478#------------------------------------------------------------------------------ 479function(vtk_compile_tools_target_install _name) 480 if(NOT VTK_INSTALL_NO_DEVELOPMENT) 481 install(TARGETS ${_name} 482 EXPORT ${VTK_INSTALL_EXPORT_NAME} 483 RUNTIME DESTINATION ${VTK_INSTALL_RUNTIME_DIR} COMPONENT RuntimeLibraries 484 LIBRARY DESTINATION ${VTK_INSTALL_LIBRARY_DIR} COMPONENT RuntimeLibraries 485 ARCHIVE DESTINATION ${VTK_INSTALL_ARCHIVE_DIR} COMPONENT Development 486 ) 487 endif() 488endfunction() 489 490#------------------------------------------------------------------------------ 491# vtk_compile_tools_target() is used to declare a target that builds a tool that 492# is used during the building process. This macro ensures that the target is 493# added to VTK_COMPILETOOLS_TARGETS global property. This also adds install 494# rules for the target unless NO_INSTALL argument is specified or 495# VTK_INSTALL_NO_DEVELOPMENT variable is set. 496function(vtk_compile_tools_target _name) 497 if (CMAKE_CROSSCOMPILING) 498 message(AUTHOR_WARNING 499 "vtk_compile_tools_target is being called when CMAKE_CROSSCOMPILING is true. " 500 "This generally signifies a script issue. compile-tools are not expected " 501 "to built, but rather imported when CMAKE_CROSSCOMPILING is ON") 502 endif () 503 set(_install 1) 504 foreach(arg IN LISTS ARGN) 505 if(arg STREQUAL "NO_INSTALL") 506 set(_install 0) 507 else() 508 message(FATAL_ERROR "Unknown argument [${arg}]") 509 endif() 510 endforeach() 511 vtk_target_name(${_name}) 512 vtk_target_label(${_name}) 513 vtk_compile_tools_target_export(${_name}) 514 if(_install) 515 vtk_compile_tools_target_install(${_name}) 516 endif() 517endfunction() 518#------------------------------------------------------------------------------ 519 520function(vtk_add_library name) 521 add_library(${name} ${ARGN} ${headers}) 522 if(NOT ARGV1 STREQUAL OBJECT) 523 vtk_target(${name}) 524 endif() 525endfunction() 526 527function(vtk_add_executable name) 528 if(UNIX AND VTK_BUILD_FORWARDING_EXECUTABLES) 529 vtk_add_executable_with_forwarding(VTK_EXE_SUFFIX ${name} ${ARGN}) 530 set_property(GLOBAL APPEND PROPERTY VTK_TARGETS ${name}) 531 else() 532 add_executable(${name} ${ARGN}) 533 set_property(GLOBAL APPEND PROPERTY VTK_TARGETS ${name}) 534 endif() 535endfunction() 536 537macro(vtk_module_test_executable test_exe_name) 538 vtk_module_test() 539 # No forwarding or export for test executables. 540 add_executable(${test_exe_name} MACOSX_BUNDLE ${ARGN}) 541 target_link_libraries(${test_exe_name} LINK_PRIVATE ${${vtk-module-test}-Cxx_LIBRARIES}) 542 543 if(${vtk-module-test}-Cxx_DEFINITIONS) 544 set_property(TARGET ${test_exe_name} APPEND PROPERTY COMPILE_DEFINITIONS 545 ${${vtk-module-test}-Cxx_DEFINITIONS}) 546 endif() 547endmacro() 548 549function(vtk_module_library name) 550 if(NOT "${name}" STREQUAL "${vtk-module}") 551 message(FATAL_ERROR "vtk_module_library must be invoked with module name") 552 endif() 553 554 set(${vtk-module}_LIBRARIES ${vtk-module}) 555 vtk_module_impl() 556 557 set(vtk-module-HEADERS) 558 set(vtk-module-ABSTRACT) 559 set(vtk-module-WRAP_SPECIAL) 560 561 # Collect header files matching sources. 562 set(_hdrs ${${vtk-module}_HDRS}) 563 foreach(arg ${ARGN}) 564 get_filename_component(src "${arg}" ABSOLUTE) 565 566 string(REGEX REPLACE "\\.(cxx|mm)$" ".h" hdr "${src}") 567 if("${hdr}" MATCHES "\\.h$" AND EXISTS "${hdr}") 568 list(APPEND _hdrs "${hdr}") 569 elseif("${src}" MATCHES "\\.txx$" AND EXISTS "${src}") 570 list(APPEND _hdrs "${src}") 571 string(REGEX REPLACE "\\.txx$" ".h" hdr "${src}") 572 if("${hdr}" MATCHES "\\.h$" AND EXISTS "${hdr}") 573 list(APPEND _hdrs "${hdr}") 574 endif() 575 endif() 576 endforeach() 577 list(APPEND _hdrs "${CMAKE_CURRENT_BINARY_DIR}/${vtk-module}Module.h") 578 list(REMOVE_DUPLICATES _hdrs) 579 580 # The instantiators are off by default, and only work on wrapped modules. 581 if(VTK_MAKE_INSTANTIATORS AND NOT ${vtk-module}_EXCLUDE_FROM_WRAPPING) 582 string(TOUPPER "${vtk-module}_EXPORT" _export_macro) 583 vtk_make_instantiator3(${vtk-module}Instantiator _instantiator_SRCS 584 "${ARGN}" ${_export_macro} ${CMAKE_CURRENT_BINARY_DIR} 585 ${vtk-module}Module.h) 586 list(APPEND _hdrs "${CMAKE_CURRENT_BINARY_DIR}/${vtk-module}Instantiator.h") 587 endif() 588 589 # Add the vtkWrapHierarchy custom command output to the target, if any. 590 # TODO: Re-order things so we do not need to duplicate this condition. 591 if(NOT ${vtk-module}_EXCLUDE_FROM_WRAPPING AND 592 NOT ${vtk-module}_EXCLUDE_FROM_WRAP_HIERARCHY AND 593 ( VTK_WRAP_PYTHON OR VTK_WRAP_TCL OR VTK_WRAP_JAVA )) 594 set(_hierarchy ${CMAKE_CURRENT_BINARY_DIR}/${vtk-module}Hierarchy.stamp.txt) 595 else() 596 set(_hierarchy "") 597 endif() 598 if(CMAKE_GENERATOR MATCHES "Visual Studio 7([^0-9]|$)" AND 599 NOT VTK_BUILD_SHARED_LIBS AND _hierarchy) 600 # For VS <= 7.1 use explicit dependencies between static libraries 601 # to tell CMake to use an ugly workaround for a VS limitation. 602 set(_help_vs7 1) 603 else() 604 set(_help_vs7 0) 605 endif() 606 607 set(target_suffix) 608 set(force_object) 609 set(export_symbol_object) 610 if(_vtk_build_as_kit) 611 # Hack up the target name to end with 'Objects' and make it an OBJECT 612 # library. 613 set(target_suffix Objects) 614 set(force_object ${target_suffix} OBJECT) 615 set(export_symbol_object ${target_suffix} BASE_NAME ${vtk-module}) 616 # OBJECT libraries don't like this variable being set; clear it. 617 unset(${vtk-module}_LIB_DEPENDS CACHE) 618 endif() 619 vtk_add_library(${vtk-module}${force_object} ${ARGN} ${_hdrs} ${_instantiator_SRCS} ${_hierarchy}) 620 if(_vtk_build_as_kit) 621 # Make an interface library to link with for libraries. 622 add_library(${vtk-module} INTERFACE) 623 vtk_target_export(${vtk-module}) 624 vtk_target_install(${vtk-module}) 625 set_target_properties(${vtk-module} 626 PROPERTIES 627 INTERFACE_LINK_LIBRARIES "${_vtk_build_as_kit}") 628 if(BUILD_SHARED_LIBS) 629 # Define a kit-wide export symbol for the objects in this module. 630 set_property(TARGET ${vtk-module}Objects APPEND 631 PROPERTY 632 COMPILE_DEFINITIONS ${${vtk-module}_KIT}_EXPORTS) 633 set_target_properties(${vtk-module}Objects 634 PROPERTIES 635 # Tell generate_export_header what kit-wide export symbol we use. 636 DEFINE_SYMBOL ${${vtk-module}_KIT}_EXPORTS 637 POSITION_INDEPENDENT_CODE TRUE) 638 endif() 639 endif() 640 foreach(dep IN LISTS ${vtk-module}_LINK_DEPENDS) 641 vtk_module_link_libraries(${vtk-module} LINK_PUBLIC ${${dep}_LIBRARIES}) 642 if(_help_vs7 AND ${dep}_LIBRARIES) 643 add_dependencies(${vtk-module} ${${dep}_LIBRARIES}) 644 endif() 645 endforeach() 646 647 # Handle the private dependencies, setting up link/include directories. 648 foreach(dep IN LISTS ${vtk-module}_PRIVATE_DEPENDS) 649 if(${dep}_INCLUDE_DIRS) 650 include_directories(${${dep}_INCLUDE_DIRS}) 651 endif() 652 if(${dep}_LIBRARY_DIRS) 653 link_directories(${${dep}_LIBRARY_DIRS}) 654 endif() 655 vtk_module_link_libraries(${vtk-module} LINK_PRIVATE ${${dep}_LIBRARIES}) 656 if(_help_vs7 AND ${dep}_LIBRARIES) 657 add_dependencies(${vtk-module} ${${dep}_LIBRARIES}) 658 endif() 659 endforeach() 660 661 unset(_help_vs7) 662 663 set(sep "") 664 if(${vtk-module}_EXPORT_CODE) 665 set(sep "\n\n") 666 endif() 667 668 # Include module headers from dependencies that need auto-init. 669 set(mod_autoinit_deps "") 670 foreach(dep IN LISTS ${vtk-module}_LINK_DEPENDS) 671 get_property(dep_autoinit GLOBAL PROPERTY ${dep}_NEEDS_AUTOINIT) 672 if(dep_autoinit) 673 set(mod_autoinit_deps "${mod_autoinit_deps}\n#include \"${dep}Module.h\"") 674 endif() 675 endforeach() 676 if(mod_autoinit_deps) 677 set(${vtk-module}_EXPORT_CODE "${${vtk-module}_EXPORT_CODE}${sep}/* AutoInit dependencies. */${mod_autoinit_deps}") 678 set(sep "\n\n") 679 set_property(GLOBAL PROPERTY ${vtk-module}_NEEDS_AUTOINIT 1) 680 endif() 681 682 # Perform auto-init if this module has or implements an interface. 683 if(${vtk-module}_IMPLEMENTED OR ${vtk-module}_IMPLEMENTS) 684 set_property(GLOBAL PROPERTY ${vtk-module}_NEEDS_AUTOINIT 1) 685 set(${vtk-module}_EXPORT_CODE 686 "${${vtk-module}_EXPORT_CODE}${sep}/* AutoInit implementations. */ 687#if defined(${vtk-module}_INCLUDE) 688# include ${vtk-module}_INCLUDE 689#endif 690#if defined(${vtk-module}_AUTOINIT) 691# include \"vtkAutoInit.h\" 692VTK_AUTOINIT(${vtk-module}) 693#endif") 694 endif() 695 696 # Generate the export macro header for symbol visibility/Windows DLL declspec 697 if(target_suffix) 698 set(${vtk-module}${target_suffix}_EXPORT_CODE 699 ${${vtk-module}_EXPORT_CODE}) 700 endif() 701 generate_export_header(${vtk-module}${export_symbol_object} EXPORT_FILE_NAME ${vtk-module}Module.h) 702 if (BUILD_SHARED_LIBS) 703 # export flags are only added when building shared libs, they cause 704 # mismatched visibility warnings when building statically since not all 705 # libraries that VTK builds don't set visibility flags. Until we get a 706 # time to do that, we skip visibility flags for static libraries. 707 add_compiler_export_flags(my_abi_flags) 708 set_property(TARGET ${vtk-module}${target_suffix} APPEND 709 PROPERTY COMPILE_FLAGS "${my_abi_flags}") 710 endif() 711 712 if(BUILD_TESTING AND PYTHON_EXECUTABLE AND NOT ${vtk-module}_NO_HeaderTest AND VTK_SOURCE_DIR) 713 string(TOUPPER "${vtk-module}" MOD) 714 add_test(NAME ${vtk-module}-HeaderTest 715 COMMAND ${PYTHON_EXECUTABLE} ${VTK_SOURCE_DIR}/Testing/Core/HeaderTesting.py 716 ${CMAKE_CURRENT_SOURCE_DIR} ${MOD}_EXPORT 717 ) 718 set_tests_properties(${vtk-module}-HeaderTest 719 PROPERTIES LABELS "${${vtk-module}_TEST_LABELS}" 720 ) 721 endif() 722 723 if(BUILD_TESTING AND TCL_TCLSH) 724 add_test(NAME ${vtk-module}-TestSetObjectMacro 725 COMMAND ${TCL_TCLSH} 726 ${VTK_SOURCE_DIR}/Testing/Core/FindString.tcl 727 "${${vtk-module}_SOURCE_DIR}/vtk\\\\*.h" 728 # "${CMAKE_CURRENT_SOURCE_DIR}/vtk\\\\*.h" 729 "vtkSetObjectMacro" 730 ${VTK_SOURCE_DIR}/Common/Core/vtkSetGet.h 731 ) 732 add_test(NAME ${vtk-module}-TestPrintSelf 733 COMMAND ${TCL_TCLSH} 734 ${VTK_SOURCE_DIR}/Testing/Core/PrintSelfCheck.tcl 735 ${${vtk-module}_SOURCE_DIR}) 736 set_tests_properties(${vtk-module}-TestSetObjectMacro 737 PROPERTIES LABELS "${${vtk-module}_TEST_LABELS}" 738 ) 739 set_tests_properties(${vtk-module}-TestPrintSelf 740 PROPERTIES LABELS "${${vtk-module}_TEST_LABELS}" 741 ) 742 endif() 743 744 # Add the module to the list of wrapped modules if necessary 745 vtk_add_wrapping(${vtk-module} "${ARGN}" "${${vtk-module}_HDRS}") 746 747 # Export the module information. 748 vtk_module_export("${ARGN}") 749 750 # Figure out which headers to install. 751 if(NOT VTK_INSTALL_NO_DEVELOPMENT AND _hdrs) 752 install(FILES ${_hdrs} 753 DESTINATION ${VTK_INSTALL_INCLUDE_DIR} 754 COMPONENT Development 755 ) 756 endif() 757endfunction() 758 759function(vtk_module_link_libraries module) 760 if(VTK_ENABLE_KITS AND ${module}_KIT) 761 set_property(GLOBAL APPEND 762 PROPERTY 763 ${${module}_KIT}_LIBS ${ARGN}) 764 foreach(dep IN LISTS ARGN) 765 if(TARGET ${dep}Objects) 766 add_dependencies(${module}Objects ${dep}Objects) 767 elseif(TARGET ${dep}) 768 add_dependencies(${module}Objects ${dep}) 769 endif() 770 endforeach() 771 else() 772 target_link_libraries(${module} ${ARGN}) 773 endif() 774endfunction() 775 776macro(vtk_module_third_party _pkg) 777 string(TOLOWER "${_pkg}" _lower) 778 string(TOUPPER "${_pkg}" _upper) 779 780 set(_includes "") 781 set(_libs "") 782 set(_nolibs 0) 783 set(_subdir 1) 784 set(_components "") 785 set(_optional_components "") 786 set(_doing "") 787 foreach(arg ${ARGN}) 788 if("${arg}" MATCHES "^(LIBRARIES|INCLUDE_DIRS|COMPONENTS|OPTIONAL_COMPONENTS)$") 789 set(_doing "${arg}") 790 elseif("${arg}" STREQUAL "NO_ADD_SUBDIRECTORY") 791 set(_doing "") 792 set(_subdir 0) 793 elseif("${arg}" STREQUAL "NO_LIBRARIES") 794 set(_doing "") 795 set(_nolibs 1) 796 elseif("${_doing}" STREQUAL "LIBRARIES") 797 list(APPEND _libs "${arg}") 798 elseif("${_doing}" STREQUAL "INCLUDE_DIRS") 799 list(APPEND _includes "${arg}") 800 elseif("${_doing}" STREQUAL "COMPONENTS") 801 list(APPEND _components "${arg}") 802 elseif("${_doing}" STREQUAL "OPTIONAL_COMPONENTS") 803 list(APPEND _optional_components "${arg}") 804 else() 805 set(_doing "") 806 message(AUTHOR_WARNING "Unknown argument [${arg}]") 807 endif() 808 endforeach() 809 if(_libs AND _nolibs) 810 message(FATAL_ERROR "Cannot specify both LIBRARIES and NO_LIBRARIES") 811 endif() 812 813 option(VTK_USE_SYSTEM_${_upper} "Use system-installed ${_pkg}" ${VTK_USE_SYSTEM_LIBRARIES}) 814 mark_as_advanced(VTK_USE_SYSTEM_${_upper}) 815 816 if(VTK_USE_SYSTEM_${_upper}) 817 set(__extra_args) 818 if(_components) 819 list(APPEND __extra_args ${_components}) 820 endif() 821 if (_optional_components) 822 if ("${CMAKE_VERSION}" VERSION_GREATER "2.8.7") 823 list(APPEND __extra_args "OPTIONAL_COMPONENTS" ${_optional_components}) 824 else () 825 # for cmake version <= 2.8.7, since OPTIONAL_COMPONENTS is not 826 # available, we just treat them as required components. 827 list(APPEND __extra_args ${_optional_components}) 828 endif() 829 endif() 830 find_package(${_pkg} REQUIRED ${__extra_args}) 831 if(NOT ${_upper}_FOUND AND NOT ${_pkg}_FOUND) 832 message(FATAL_ERROR "VTK_USE_SYSTEM_${_upper} is ON but ${_pkg} is not found!") 833 endif() 834 if(${_pkg}_INCLUDE_DIRS) 835 set(vtk${_lower}_SYSTEM_INCLUDE_DIRS ${${_pkg}_INCLUDE_DIRS}) 836 elseif(${_upper}_INCLUDE_DIRS) 837 set(vtk${_lower}_SYSTEM_INCLUDE_DIRS ${${_upper}_INCLUDE_DIRS}) 838 else() 839 set(vtk${_lower}_SYSTEM_INCLUDE_DIRS ${${_upper}_INCLUDE_DIR}) 840 endif() 841 if(${_pkg}_LIBRARIES) 842 set(vtk${_lower}_LIBRARIES "${${_pkg}_LIBRARIES}") 843 else() 844 set(vtk${_lower}_LIBRARIES "${${_upper}_LIBRARIES}") 845 endif() 846 847 #a workaround for bad FindHDF5 behavior in which deb or opt can 848 #end up empty. cmake >= 2.8.12.2 makes this uneccessary 849 string(REGEX MATCH "debug;.*optimized;.*" 850 _remove_deb_opt "${vtk${_lower}_LIBRARIES}") 851 if (_remove_deb_opt) 852 set(_tmp ${vtk${_lower}_LIBRARIES}) 853 list(REMOVE_ITEM _tmp "debug") 854 list(REMOVE_ITEM _tmp "optimized") 855 list(REMOVE_DUPLICATES _tmp) 856 set(vtk${_lower}_LIBRARIES ${_tmp}) 857 endif() 858 859 set(vtk${_lower}_INCLUDE_DIRS "") 860 else() 861 if(_nolibs) 862 set(vtk${_lower}_LIBRARIES "") 863 elseif(_libs) 864 set(vtk${_lower}_LIBRARIES "${_libs}") 865 else() 866 set(vtk${_lower}_LIBRARIES vtk${_lower}) 867 endif() 868 set(vtk${_lower}_INCLUDE_DIRS "${_includes}") 869 endif() 870 871 set(vtk${_lower}_THIRD_PARTY 1) 872 vtk_module_impl() 873 874 # Export the core module information. 875 vtk_module_export_info() 876 877 configure_file(vtk_${_lower}.h.in vtk_${_lower}.h) 878 if (NOT VTK_INSTALL_NO_DEVELOPMENT) 879 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/vtk_${_lower}.h 880 DESTINATION ${VTK_INSTALL_INCLUDE_DIR} 881 COMPONENT Development) 882 endif() 883 884 if(_subdir AND NOT VTK_USE_SYSTEM_${_upper}) 885 add_subdirectory(vtk${_lower}) 886 endif() 887endmacro() 888 889# called internally to add one module to the list of available modules 890macro(vtk_add_module src f bld ) # [test-langs] 891 unset(vtk-module) 892 include(${src}/${f} OPTIONAL) 893 if(DEFINED vtk-module) 894 list(APPEND VTK_MODULES_ALL ${vtk-module}) 895 get_filename_component(${vtk-module}_BASE ${f} PATH) 896 set(${vtk-module}_SOURCE_DIR ${src}/${${vtk-module}_BASE}) 897 set(${vtk-module}_BINARY_DIR ${bld}/${${vtk-module}_BASE}) 898 foreach(_lang ${ARGN}) 899 if(EXISTS ${${vtk-module}_SOURCE_DIR}/Testing/${_lang}/CMakeLists.txt) 900 vtk_add_test_module(${_lang}) 901 endif() 902 endforeach() 903 if(${vtk-module}_IMPLEMENTS) 904 foreach(dep IN LISTS ${vtk-module}_IMPLEMENTS) 905 set(${dep}_IMPLEMENTED 1) 906 endforeach() 907 endif() 908 endif() 909 unset(vtk-module) 910 unset(vtk-module-test) 911endmacro() 912 913# called internally to add all the modules undeneath a particular directory to the list of modules 914macro(vtk_module_glob src bld) # [test-langs] 915 file(GLOB meta RELATIVE "${src}" "${src}/*/*/module.cmake") 916 foreach(f ${meta}) 917 vtk_add_module(${src} ${f} ${bld} ${ARGN}) 918 endforeach() 919endmacro() 920 921# called to search for all modules under the 922# vtk_module_src_glob_path and vtk_module_src_path paths to the list 923macro(vtk_module_search) # [test-langs] 924 set(VTK_MODULES_ALL) 925 926 vtk_module_glob("${VTK_SOURCE_DIR}" "${VTK_BINARY_DIR}" ${ARGN}) 927 928 #go through any additional dirs, and make modules of any ./module.cmakes found under them 929 foreach(pair ${vtk_module_search_path}) 930 string(REGEX MATCH "^([^,]*),([^,]*)$" m "${pair}") 931 set(src "${CMAKE_MATCH_1}") 932 set(bld "${CMAKE_MATCH_2}") 933 vtk_add_module("${src}" module.cmake "${bld}" ${ARGN}) 934 endforeach() 935 936endmacro() 937 938macro(vtk_add_test_module _lang) 939 set(_test_module_name ${vtk-module-test}-${_lang}) 940 941 list(APPEND VTK_MODULES_ALL ${_test_module_name}) 942 set(${_test_module_name}_DEPENDS ${${vtk-module-test}_DEPENDS}) 943 set(${_test_module_name}_SOURCE_DIR ${${vtk-module}_SOURCE_DIR}/Testing/${_lang}) 944 set(${_test_module_name}_BINARY_DIR ${${vtk-module}_BINARY_DIR}/Testing/${_lang}) 945 set(${_test_module_name}_IS_TEST 1) 946 list(APPEND ${vtk-module}_TESTED_BY ${_test_module_name}) 947 set(${_test_module_name}_TESTS_FOR ${vtk-module}) 948 set(${_test_module_name}_DECLARED 1) 949 # Exclude test modules from wrapping 950 set(${_test_module_name}_EXCLUDE_FROM_WRAPPING 1) 951endmacro() 952