Debian Codegraph @

cmake/tribits/core/package_arch/TribitsGlobalMacros.cmake

raw
1 # @HEADER
2 # *****************************************************************************
3 # TriBITS: Tribal Build, Integrate, and Test System
4 #
5 # Copyright 2013-2016 NTESS and the TriBITS contributors.
6 # SPDX-License-Identifier: BSD-3-Clause
7 # *****************************************************************************
8 # @HEADER
9
10 # Standard TriBITS system includes
11
12 include("${CMAKE_CURRENT_LIST_DIR}/../utils/TribitsGitRepoVersionInfo.cmake")
13
14 include("${CMAKE_CURRENT_LIST_DIR}/../common/TribitsConstants.cmake")
15
16 include("${CMAKE_CURRENT_LIST_DIR}/../test_support/TribitsTestCategories.cmake")
17 include("${CMAKE_CURRENT_LIST_DIR}/../test_support/TribitsAddTestHelpers.cmake")
18
19 include(TribitsSetupMPI)
20 include(TribitsGeneralMacros)
21 include(TribitsVerbosePrintVar)
22 include(TribitsProcessEnabledTpls)
23 include(TribitsInstallHeaders)
24 include(TribitsGetVersionDate)
25 include(TribitsReportInvalidTribitsUsage)
26 include(TribitsReadAllProjectDepsFilesCreateDepsGraph)
27 include(TribitsAdjustPackageEnables)
28 include(TribitsSetUpEnabledOnlyDependencies)
29 include(TribitsConfigureTiming)
30
31 # Standard TriBITS utilities includes
32 include(TribitsAddOptionAndDefine)
33 include(TribitsAddEnumCacheVar)
34 include(AdvancedOption)
35 include(AdvancedSet)
36 include(AppendStringVar)
37 include(AppendStringVarWithSep)
38 include(AssertAndTouchDefined)
39 include(CMakeBuildTypesList)
40 include(FindListElement)
41 include(GlobalNullSet)
42 include(PrintNonemptyVar)
43 include(PrintVar)
44 include(RemoveGlobalDuplicates)
45 include(Split)
46 include(TimingUtils)
47 include(SetDefaultAndFromEnv) # Used by some call-back files
48 include(TribitsFilepathHelpers)
49 include(TribitsDeprecatedHelpers)
50
51 # Standard CMake includes
52 include(CheckIncludeFileCXX)
53
54 # Include here so it does not need to be included in each individual
55 # FindTPL<TPLNAME>.cmake file over and over.
56 include(TribitsTplFindIncludeDirsAndLibraries)
57 include(TribitsTplDeclareLibraries) # Deprecated
58 # ABOVE: We need to include TribitsTplDeclareLibraries.cmake until all client
59 # projects stop using it.
60
61
62 # Assert and setup project binary directory and other project variables
63 #
64 macro(tribits_assert_and_setup_project_and_static_system_vars)
65
66 string(APPEND IN_SOURCE_ERROR_COMMON_MSG
67 "\nYou must now run something like:\n"
68 " $ cd ${CMAKE_CURRENT_SOURCE_DIR}/\n"
69 " $ rm -r CMakeCache.txt CMakeFiles/"
70 "\n"
71 "Please create a different directory and configure ${PROJECT_NAME}"
72 " under that such as:\n"
73 " $ cd ${CMAKE_CURRENT_SOURCE_DIR}/\n"
74 " $ mkdir MY_BUILD\n"
75 " $ cd MY_BUILD\n"
76 " $ cmake [OPTIONS] .."
77 )
78
79 if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CMakeCache.txt")
80 message(FATAL_ERROR "ERROR! "
81 "The file ${CMAKE_CURRENT_SOURCE_DIR}/CMakeCache.txt exists from a"
82 " likely prior attempt to do an in-source build."
83 "${IN_SOURCE_ERROR_COMMON_MSG}"
84 )
85 endif()
86
87 if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
88 message(FATAL_ERROR "ERROR! "
89 "CMAKE_CURRENT_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}"
90 " == CMAKE_CURRENT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}"
91 "\n${PROJECT_NAME} does not support in source builds!\n"
92 "NOTE: You must now delete the CMakeCache.txt file and the CMakeFiles/ directory under"
93 " the source directory for ${PROJECT_NAME} or you will not be able to configure ${PROJECT_NAME} correctly!"
94 "${IN_SOURCE_ERROR_COMMON_MSG}"
95 )
96 endif()
97
98 string(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UC)
99 set(PROJECT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE INTERNAL "")
100 set(PROJECT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE INTERNAL "")
101 print_var(PROJECT_SOURCE_DIR)
102 print_var(PROJECT_BINARY_DIR)
103 print_var(${PROJECT_NAME}_TRIBITS_DIR)
104 print_var(TriBITS_VERSION_STRING)
105 # Above, we put these in the cache so we can grep them out of the cache file
106
107 #
108 # Print some basic static info provided by CMake automatically
109 #
110
111 print_var(CMAKE_VERSION)
112 print_var(CMAKE_GENERATOR)
113
114 endmacro()
115
116
117 # Set up some really basic system variables
118 #
119 # This macro needs to be called *before* the user *.cmake option files are
120 # read in so that there is an opportunity to override these.
121 #
122 macro(tribits_setup_basic_system_vars)
123
124 # CMAKE_HOST_SYSTEM_NAME is provided by CMake automatically but can actually
125 # be overridden in the cache.
126 print_var(CMAKE_HOST_SYSTEM_NAME)
127
128 site_name(${PROJECT_NAME}_HOSTNAME)
129 mark_as_advanced(${PROJECT_NAME}_HOSTNAME)
130 print_var(${PROJECT_NAME}_HOSTNAME)
131
132 # NOTE: CMAKE_HOST_SYSTEM_NAME and ${PROJECT_NAME}_HOSTNAME are used by
133 # TRIBITS_ADD[_ADVANCED]_test() to include/exclude tests based in the
134 # arguments HOSTS, XHOSTS, HOSTTYPES, AND XHOSTTYPES.
135
136 endmacro()
137
138
139 # Define an option to include a file that reads in a bunch of options and read
140 # those files
141 #
142 macro(tribits_read_in_options_from_file)
143
144 set( ${PROJECT_NAME}_CONFIGURE_OPTIONS_FILE "" CACHE FILEPATH
145 "Name of an optional file that is included first to define any cmake options with set( ... CACHE ...) calls. NOTE: paths can be separated by commas instead of semicolons but paths cannot contain commas."
146 )
147
148 split("${${PROJECT_NAME}_CONFIGURE_OPTIONS_FILE}" ","
149 ${PROJECT_NAME}_CONFIGURE_OPTIONS_FILE)
150
151 set( ${PROJECT_NAME}_CONFIGURE_OPTIONS_FILE_ALL
152 ${${PROJECT_NAME}_CONFIGURE_OPTIONS_FILE}
153 ${${PROJECT_NAME}_CONFIGURE_OPTIONS_FILE_APPEND})
154
155 foreach (CONFIG_OPTS_FILE ${${PROJECT_NAME}_CONFIGURE_OPTIONS_FILE_ALL})
156 message("-- " "Reading in configuration options from ${CONFIG_OPTS_FILE} ...")
157 tribits_trace_file_processing(PROJECT INCLUDE "${CONFIG_OPTS_FILE}")
158 include(${CONFIG_OPTS_FILE})
159 endforeach()
160
161
162 endmacro()
163
164
165 # Assert ${PROJECT_NAME}_SET_GROUP_AND_PERMISSIONS_ON_INSTALL_BASE_DIR set
166 # correctly
167 #
168 function(assert_project_set_group_and_permissions_on_install_base_dir)
169
170 if (
171 (NOT "${CMAKE_INSTALL_PREFIX}" STREQUAL "")
172 AND
173 (NOT "${${PROJECT_NAME}_SET_GROUP_AND_PERMISSIONS_ON_INSTALL_BASE_DIR}" STREQUAL "")
174 )
175 tribits_dir_is_basedir(
176 "${${PROJECT_NAME}_SET_GROUP_AND_PERMISSIONS_ON_INSTALL_BASE_DIR}"
177 "${CMAKE_INSTALL_PREFIX}"
178 isBaseDir)
179 if (NOT isBaseDir)
180 message(FATAL_ERROR
181 "\n"
182 "***\n"
183 "*** ERROR in ${PROJECT_NAME}_SET_GROUP_AND_PERMISSIONS_ON_INSTALL_BASE_DIR!\n"
184 "***\n"
185 "\n"
186 "${PROJECT_NAME}_SET_GROUP_AND_PERMISSIONS_ON_INSTALL_BASE_DIR=${${PROJECT_NAME}_SET_GROUP_AND_PERMISSIONS_ON_INSTALL_BASE_DIR}\n"
187 "\n"
188 "is not a strict base dir of:\n"
189 "\n"
190 "CMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}\n"
191 "\n"
192 "Either remove ${PROJECT_NAME}_SET_GROUP_AND_PERMISSIONS_ON_INSTALL_BASE_DIR from the cache or set it to be a base dir of CMAKE_INSTALL_PREFIX!\n"
193 "\n"
194 )
195 endif()
196 endif()
197
198 endfunction()
199
200
201 # Define all of the standard global package architecture options.
202 #
203 macro(tribits_define_global_options_and_define_extra_repos)
204
205 set( ${PROJECT_NAME}_ENABLE_ALL_PACKAGES OFF CACHE BOOL
206 "Enable all packages PT packages (ST packages as well if ${PROJECT_NAME}_ENABLE_SECONDARY_TESTED_CODE is true)." )
207
208 set(${PROJECT_NAME}_ENABLE_ALL_OPTIONAL_PACKAGES ON CACHE BOOL
209 "Recursively enable all optional packages for set of enabled packages." )
210
211 set( ${PROJECT_NAME}_INSTALL_EXECUTABLES ON CACHE BOOL
212 "Enable the installation of executables provided by the ${PROJECT_NAME} packages." )
213
214 advanced_set(${PROJECT_NAME}_ENABLE_ALL_FORWARD_DEP_PACKAGES OFF CACHE BOOL
215 "Recursively enable all packages that have required or optional dependencies for set of enabled packages." )
216
217 if (${PROJECT_NAME}_DISABLE_ENABLED_FORWARD_DEP_PACKAGES_DEFAULT STREQUAL "")
218 set(${PROJECT_NAME}_DISABLE_ENABLED_FORWARD_DEP_PACKAGES_DEFAULT OFF)
219 endif()
220 set(${PROJECT_NAME}_DISABLE_ENABLED_FORWARD_DEP_PACKAGES
221 ${${PROJECT_NAME}_DISABLE_ENABLED_FORWARD_DEP_PACKAGES_DEFAULT}
222 CACHE BOOL
223 "Disable (and printing warning) for enabled packages that have hard-disabled upstream dependencies. Otherwise, is to raises a fatal configure failure." )
224
225 set_cache_on_off_empty( ${PROJECT_NAME}_ENABLE_TESTS ""
226 "Enable tests (execs and ctest add_test()) in all packages (set to ON, OFF, or leave empty)." )
227
228 set_cache_on_off_empty(${PROJECT_NAME}_ENABLE_EXAMPLES ""
229 "Enable examples (exec and ctest add_test()) in all packages (set to ON, OFF, or leave empty). If left empty, then this will be set to ON if ${PROJECT_NAME}_ENABLE_TESTS=ON" )
230
231 set(${PROJECT_NAME}_SKIP_CTEST_ADD_TEST OFF CACHE BOOL
232 "Skip ctest add_test() for all defined tests (but still build any enabled test or example executable targets)." )
233
234 if (${PROJECT_NAME}_ENABLE_TESTS AND ${PROJECT_NAME}_ENABLE_EXAMPLES STREQUAL "")
235 message(STATUS "Setting ${PROJECT_NAME}_ENABLE_EXAMPLES=ON because ${PROJECT_NAME}_ENABLE_TESTS=ON")
236 set(${PROJECT_NAME}_ENABLE_EXAMPLES ON)
237 endif()
238
239 advanced_set( ${PROJECT_NAME}_UNENABLE_ENABLED_PACKAGES OFF CACHE BOOL
240 "Set to empty all package enables (set to OFF at end)." )
241
242 advanced_option(${PROJECT_NAME}_REMOVE_DEFAULT_PACKAGE_DISABLES
243 "Removes all default disables from the packages list. Used for testing etc."
244 OFF )
245
246 if ("${${PROJECT_NAME}_ENABLE_C_DEFAULT}" STREQUAL "")
247 set(${PROJECT_NAME}_ENABLE_C_DEFAULT ON)
248 endif()
249 advanced_option(${PROJECT_NAME}_ENABLE_C
250 "Enable the C compiler and related code"
251 ${${PROJECT_NAME}_ENABLE_C_DEFAULT} )
252
253 if ("${${PROJECT_NAME}_C_Standard_DEFAULT}" STREQUAL "")
254 set(${PROJECT_NAME}_C_Standard_DEFAULT c99)
255 endif()
256 advanced_set(${PROJECT_NAME}_C_Standard
257 ${${PROJECT_NAME}_C_Standard_DEFAULT}
258 CACHE STRING
259 "The standard <cstd> to use in --std=<cstd> for GCC compilers." )
260
261 if ("${${PROJECT_NAME}_ENABLE_CXX_DEFAULT}" STREQUAL "")
262 set(${PROJECT_NAME}_ENABLE_CXX_DEFAULT ON)
263 endif()
264 advanced_option(${PROJECT_NAME}_ENABLE_CXX
265 "Enable the C++ compiler and related code"
266 ${${PROJECT_NAME}_ENABLE_CXX_DEFAULT} )
267
268 # Hard-code a variable with the same name as a now-removed option that is always enabled.
269 # This can be removed after clients have been updated.
270 set(${PROJECT_NAME}_ENABLE_CXX11 ON)
271
272 if ("${${PROJECT_NAME}_ENABLE_Fortran_DEFAULT}" STREQUAL "")
273 if (WIN32)
274 set(${PROJECT_NAME}_ENABLE_Fortran_DEFAULT OFF)
275 else()
276 set(${PROJECT_NAME}_ENABLE_Fortran_DEFAULT ON)
277 endif()
278 endif()
279
280 option(${PROJECT_NAME}_ENABLE_Fortran
281 "Enable the Fortran compiler and related code"
282 ${${PROJECT_NAME}_ENABLE_Fortran_DEFAULT} )
283
284 advanced_option(${PROJECT_NAME}_SKIP_FORTRANCINTERFACE_VERIFY_TEST
285 "Skip the Fortran/C++ compatibility test"
286 OFF )
287
288 advanced_set(
289 ${PROJECT_NAME}_MAKE_INSTALL_WORLD_READABLE
290 "${${PROJECT_NAME}_MAKE_INSTALL_WORLD_READABLE_DEFAULT}"
291 CACHE BOOL
292 "If TRUE, the directory and file permissions on the installed directories and files will be set to world readable. NOTE: Empty '' (the default) leaves default CMake permissions in place."
293 )
294
295 advanced_set(
296 ${PROJECT_NAME}_MAKE_INSTALL_GROUP_WRITABLE ""
297 CACHE BOOL
298 "If TRUE, the directory and file permissions on the installed directories and files will be set to group-writable. Setting to TRUE also implies ${PROJECT_NAME}_MAKE_INSTALL_GROUP_READABLE=TRUE. NOTE: Empty '' (the default) avoid adding the group write permission."
299 )
300
301 if ("${${PROJECT_NAME}_MAKE_INSTALL_GROUP_READABLE_DEFAULT}" STREQUAL "")
302 if (${PROJECT_NAME}_MAKE_INSTALL_GROUP_WRITABLE)
303 set(${PROJECT_NAME}_MAKE_INSTALL_GROUP_READABLE_DEFAULT TRUE)
304 else()
305 set(${PROJECT_NAME}_MAKE_INSTALL_GROUP_READABLE_DEFAULT
306 "${${PROJECT_NAME}_MAKE_INSTALL_WORLD_READABLE}")
307 endif()
308 endif()
309 advanced_set(
310 ${PROJECT_NAME}_MAKE_INSTALL_GROUP_READABLE
311 "${${PROJECT_NAME}_MAKE_INSTALL_GROUP_READABLE_DEFAULT}"
312 CACHE BOOL
313 "If TRUE, the directory and file permissions on the installed directories and files will be set to group readable. Setting ${PROJECT_NAME}_MAKE_INSTALL_WORLD_READABLE=ON implies this is 'ON' as well. NOTE: Empty '' (the default) leaves default CMake permissions in place."
314 )
315
316 advanced_set(
317 ${PROJECT_NAME}_MAKE_INSTALL_GROUP ""
318 CACHE STRING
319 "If set, then the installed files and directories from ${PROJECT_NAME}_SET_GROUP_AND_PERMISSIONS_ON_INSTALL_BASE_DIR on down will be given over to this owning group. The default is empty '' which means the default group will not be changed."
320 )
321
322 advanced_set(
323 ${PROJECT_NAME}_SET_GROUP_AND_PERMISSIONS_ON_INSTALL_BASE_DIR
324 "${CMAKE_INSTALL_PREFIX}"
325 CACHE FILEPATH
326 "Set the base path for which a recursive chmod and chgrp will be called to set the group and permissions after the install is complete. The default directory is give by CMAKE_INSTALL_PREFIX."
327 )
328
329 assert_project_set_group_and_permissions_on_install_base_dir()
330
331 if ("${${PROJECT_NAME}_SET_INSTALL_RPATH_DEFAULT}" STREQUAL "")
332 set(${PROJECT_NAME}_SET_INSTALL_RPATH_DEFAULT TRUE)
333 else()
334 set(${PROJECT_NAME}_SET_INSTALL_RPATH_DEFAULT FALSE)
335 endif()
336 advanced_set(
337 ${PROJECT_NAME}_SET_INSTALL_RPATH ${${PROJECT_NAME}_SET_INSTALL_RPATH_DEFAULT}
338 CACHE BOOL
339 "If TRUE, then set RPATH on installed binaries will set to ${PROJECT_NAME}_INSTALL_LIB_DIR automatically"
340 )
341
342 if ("${CMAKE_INSTALL_RPATH_USE_LINK_PATH_DEFAULT}" STREQUAL "")
343 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH_DEFAULT TRUE)
344 else()
345 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH_DEFAULT FALSE)
346 endif()
347 advanced_set(
348 CMAKE_INSTALL_RPATH_USE_LINK_PATH ${CMAKE_INSTALL_RPATH_USE_LINK_PATH_DEFAULT}
349 CACHE BOOL
350 "If set to TRUE, then the RPATH for external shared libs will be embedded in installed libs and execs."
351 )
352
353 advanced_set(${PROJECT_NAME}_EXTRA_LINK_FLAGS ""
354 CACHE STRING
355 "Extra flags added to the end of every linked executable"
356 )
357
358 # OpenMP is similar to a TPL in some respects, but requires only compiler
359 # flags to enable
360
361 option(${PROJECT_NAME}_ENABLE_OpenMP
362 "Build with OpenMP support." OFF)
363
364 if (CMAKE_GENERATOR STREQUAL "Ninja")
365 if("${${PROJECT_NAME}_WRITE_NINJA_MAKEFILES_DEFAULT}" STREQUAL "")
366 set(${PROJECT_NAME}_WRITE_NINJA_MAKEFILES_DEFAULT ON)
367 endif()
368 set(${PROJECT_NAME}_WRITE_NINJA_MAKEFILES
369 ${${PROJECT_NAME}_WRITE_NINJA_MAKEFILES_DEFAULT} CACHE BOOL
370 "Generate dummy makefiles to call ninja in every build subdirectory (requires CMake 3.7.0 or newer)." )
371 endif()
372 if ("${${PROJECT_NAME}_WRITE_NINJA_MAKEFILES}" STREQUAL "")
373 set(${PROJECT_NAME}_WRITE_NINJA_MAKEFILES OFF)
374 endif()
375
376 advanced_set(${PROJECT_NAME}_PARALLEL_COMPILE_JOBS_LIMIT "" CACHE STRING
377 "If not empty '', gives an integer for the max number of object compile jobs for Ninja builds. (Default empty for no limit)")
378
379 advanced_set(${PROJECT_NAME}_PARALLEL_LINK_JOBS_LIMIT "" CACHE STRING
380 "If not empty '', gives an integer for the max number of lib and exe link jobs for Ninja builds. (Default empty for no limit)")
381
382 if (CMAKE_BUILD_TYPE STREQUAL "DEBUG")
383 set(${PROJECT_NAME}_ENABLE_DEBUG_DEFAULT ON)
384 else()
385 set(${PROJECT_NAME}_ENABLE_DEBUG_DEFAULT OFF)
386 endif()
387 set(${PROJECT_NAME}_ENABLE_DEBUG ${${PROJECT_NAME}_ENABLE_DEBUG_DEFAULT} CACHE BOOL
388 "Enable debug checking for ${PROJECT_NAME} packages. Off by default unless CMAKE_BUILD_TYPE=\"DEBUG\"." )
389
390 if (${PROJECT_NAME}_ENABLE_DEBUG)
391 set(${PROJECT_NAME}_ENABLE_CONFIGURE_DEBUG_DEFAULT ON)
392 else()
393 set(${PROJECT_NAME}_ENABLE_CONFIGURE_DEBUG_DEFAULT OFF)
394 endif()
395 set(${PROJECT_NAME}_ENABLE_CONFIGURE_DEBUG
396 ${${PROJECT_NAME}_ENABLE_CONFIGURE_DEBUG_DEFAULT} CACHE BOOL
397 "Enable debug checking of the process which finds errors in the project's CMake files (off by default unless ${PROJECT_NAME}_ENABLE_DEBUG=ON)." )
398
399 if ("${${PROJECT_NAME}_CHECK_FOR_UNPARSED_ARGUMENTS_DEFAULT}" STREQUAL "")
400 set(${PROJECT_NAME}_CHECK_FOR_UNPARSED_ARGUMENTS_DEFAULT "WARNING")
401 endif()
402 advanced_set(${PROJECT_NAME}_CHECK_FOR_UNPARSED_ARGUMENTS
403 ${${PROJECT_NAME}_CHECK_FOR_UNPARSED_ARGUMENTS_DEFAULT}
404 CACHE STRING
405 "Determines how unparsed arguments for TriBITS functions that use cmake_parase_aruments() internally are handled. Valid choices are 'WARNING', 'SEND_ERROR', and 'FATAL_ERROR'. The default is 'SEND_ERROR'."
406 )
407 if (
408 (NOT ${PROJECT_NAME}_CHECK_FOR_UNPARSED_ARGUMENTS STREQUAL "WARNING")
409 AND
410 (NOT ${PROJECT_NAME}_CHECK_FOR_UNPARSED_ARGUMENTS STREQUAL "SEND_ERROR")
411 AND
412 (NOT ${PROJECT_NAME}_CHECK_FOR_UNPARSED_ARGUMENTS STREQUAL "FATAL_ERROR")
413 )
414 message(FATAL_ERROR "Error, the value of"
415 " ${PROJECT_NAME}_CHECK_FOR_UNPARSED_ARGUMENTS ="
416 " '${${PROJECT_NAME}_CHECK_FOR_UNPARSED_ARGUMENTS}' is invalid!"
417 " Valid values include 'WARNING', 'SEND_ERROR', and 'FATAL_ERROR'"
418 )
419 endif()
420
421 set(${PROJECT_NAME}_ENABLE_TEUCHOS_TIME_MONITOR ON
422 CACHE BOOL
423 "Enable support for Teuchos Time Monitors in all Trilinos packages that support it."
424 )
425
426 advanced_set(${PROJECT_NAME}_SHOW_DEPRECATED_WARNINGS ON
427 CACHE BOOL
428 "Show warnings about deprecated code"
429 )
430
431 advanced_set(${PROJECT_NAME}_HIDE_DEPRECATED_CODE OFF
432 CACHE BOOL
433 "Show warnings about deprecated code"
434 )
435
436 advanced_set(${PROJECT_NAME}_VERBOSE_CONFIGURE OFF
437 CACHE BOOL
438 "Make the ${PROJECT_NAME} configure process verbose."
439 )
440
441 advanced_option(${PROJECT_NAME}_DUMP_LINK_LIBS
442 "Dump the link libraries for every library and executable created."
443 "${${PROJECT_NAME}_VERBOSE_CONFIGURE}" )
444
445 advanced_set(${PROJECT_NAME}_TRACE_FILE_PROCESSING
446 ${${PROJECT_NAME}_VERBOSE_CONFIGURE}
447 CACHE BOOL
448 "Print out when all of the various files get processed."
449 )
450
451 advanced_set(${PROJECT_NAME}_ENABLE_EXPLICIT_INSTANTIATION ON
452 CACHE BOOL
453 "Enable explicit template instantiation in all packages that support it"
454 )
455
456 advanced_set(${PROJECT_NAME}_AUTOGENERATE_TEST_RESOURCE_FILE OFF
457 CACHE BOOL
458 "Auto-generate a resource spec file for use with CTest."
459 )
460
461 advanced_set(${PROJECT_NAME}_CUDA_NUM_GPUS 1
462 CACHE STRING
463 "Number of GPUS to make available in the auto-generated resource spec file."
464 )
465
466 advanced_set(${PROJECT_NAME}_CUDA_SLOTS_PER_GPU 1
467 CACHE STRING
468 "Number of slots per GPU in the auto-generated resource spec file."
469 )
470
471 set(CTEST_RESOURCE_SPEC_FILE_DOC_EXTRA "")
472 if (${PROJECT_NAME}_AUTOGENERATE_TEST_RESOURCE_FILE)
473 set(CTEST_RESOURCE_SPEC_FILE_DEFAULT ${CMAKE_BINARY_DIR}/ctest_resources.json)
474 if ("${CTEST_RESOURCE_SPEC_FILE}" STREQUAL "")
475 set(CTEST_RESOURCE_SPEC_FILE_DOC_EXTRA
476 " This file is autogenerated by default since ${PROJECT_NAME}_AUTOGENERATE_TEST_RESOURCE_FILE=${${PROJECT_NAME}_AUTOGENERATE_TEST_RESOURCE_FILE}!" )
477 endif()
478 else()
479 set(CTEST_RESOURCE_SPEC_FILE_DEFAULT "")
480 endif()
481
482 advanced_set(CTEST_RESOURCE_SPEC_FILE
483 "${CTEST_RESOURCE_SPEC_FILE_DEFAULT}"
484 CACHE FILEPATH
485 "Resource spec file for CTest.${CTEST_RESOURCE_SPEC_FILE_DOC_EXTRA}"
486 )
487
488 if (USE_XSDK_DEFAULTS)
489 # Need to set BUILD_SHARED_LIBS default here based on USE_XSDK_DEFAULTS
490 # and not in tribits_setup_env() in case there is logic in TriBITS or
491 # project-specific files that depends on this var getting set here!
492 set(BUILD_SHARED_LIBS_DEFAULT TRUE)
493 if ("${BUILD_SHARED_LIBS}" STREQUAL "")
494 message("-- " "XSDK: Setting default BUILD_SHARED_LIBS=TRUE")
495 endif()
496 else()
497 set(BUILD_SHARED_LIBS_DEFAULT FALSE)
498 endif()
499 set(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS_DEFAULT}
500 CACHE BOOL "Build shared libraries or not.")
501
502 if ("${${PROJECT_NAME}_TPL_SYSTEM_INCLUDE_DIRS_DEFAULT}" STREQUAL "")
503 set(${PROJECT_NAME}_TPL_SYSTEM_INCLUDE_DIRS_DEFAULT FALSE)
504 endif()
505 advanced_set(${PROJECT_NAME}_TPL_SYSTEM_INCLUDE_DIRS
506 ${${PROJECT_NAME}_TPL_SYSTEM_INCLUDE_DIRS_DEFAULT}
507 CACHE BOOL
508 "If set TRUE, then 'SYSTEM' will be passed into include_directories() for TPL includes.")
509
510 if ("${${PROJECT_NAME}_IMPORTED_NO_SYSTEM_DEFAULT}" STREQUAL "")
511 set(${PROJECT_NAME}_IMPORTED_NO_SYSTEM_DEFAULT FALSE)
512 endif()
513 advanced_set(${PROJECT_NAME}_IMPORTED_NO_SYSTEM
514 ${${PROJECT_NAME}_IMPORTED_NO_SYSTEM_DEFAULT}
515 CACHE BOOL
516 "If set TRUE, then set IMPORTED_NO_SYSTEM property on all exported libraries.")
517
518 if (CMAKE_VERSION VERSION_LESS 3.23 AND ${PROJECT_NAME}_IMPORTED_NO_SYSTEM)
519 message(FATAL_ERROR "Error, setting ${PROJECT_NAME}_IMPORTED_NO_SYSTEM='${${PROJECT_NAME}_IMPORTED_NO_SYSTEM}' for CMake version '${CMAKE_VERSION}' < 3.23 is not allowed!")
520 endif()
521
522 advanced_set(TPL_FIND_SHARED_LIBS ON CACHE BOOL
523 "If ON, then the TPL system will find shared libs if they exist, otherwise will only find static libs." )
524
525 advanced_set(${PROJECT_NAME}_LINK_SEARCH_START_STATIC OFF CACHE BOOL
526 "If ON, then the property LINK_SEARCH_START_STATIC will be added to all executables." )
527
528 advanced_set(${PROJECT_NAME}_LIBRARY_NAME_PREFIX ""
529 CACHE STRING
530 "Prefix for all ${PROJECT_NAME} library names. If set to, for example, 'prefix_',
531 libraries will be named and installed as 'prefix_<libname>.*'. Default is '' (no prefix)."
532 )
533
534 if ("${${PROJECT_NAME}_MUST_FIND_ALL_TPL_LIBS_DEFAULT}" STREQUAL "")
535 set(${PROJECT_NAME}_MUST_FIND_ALL_TPL_LIBS_DEFAULT FALSE)
536 endif()
537 advanced_set( ${PROJECT_NAME}_MUST_FIND_ALL_TPL_LIBS
538 ${${PROJECT_NAME}_MUST_FIND_ALL_TPL_LIBS_DEFAULT}
539 CACHE BOOL
540 "If set to TRUE, then all of the TPL libs must be found for every enabled TPL."
541 )
542
543 if ("${${PROJECT_NAME}_USE_GNUINSTALLDIRS_DEFAULT}" STREQUAL "")
544 set(${PROJECT_NAME}_USE_GNUINSTALLDIRS_DEFAULT FALSE) # Maintain backward compatibility
545 endif()
546 advanced_set( ${PROJECT_NAME}_USE_GNUINSTALLDIRS
547 ${${PROJECT_NAME}_USE_GNUINSTALLDIRS_DEFAULT}
548 CACHE BOOL
549 "If set to TRUE, then CMake GNUInstallDris modules is used to pick standard install paths by default."
550 )
551
552 if ("${${PROJECT_NAME}_INSTALL_LIBRARIES_AND_HEADERS_DEFAULT}" STREQUAL "")
553 # Assume the TriBITS project wants to install headers and libraries by default
554 set(${PROJECT_NAME}_INSTALL_LIBRARIES_AND_HEADERS_DEFAULT ON)
555 endif()
556
557 advanced_set(${PROJECT_NAME}_INSTALL_LIBRARIES_AND_HEADERS
558 ${${PROJECT_NAME}_INSTALL_LIBRARIES_AND_HEADERS_DEFAULT}
559 CACHE BOOL
560 "Install libraries and headers (default is ${${PROJECT_NAME}_INSTALL_LIBRARIES_AND_HEADERS_DEFAULT}). NOTE: Shared libraries are always installed since they are needed by executables."
561 )
562
563 # Creating <Package>Config.cmake files is currently *very* expensive for large
564 # TriBITS projects so we disable this by default for TriBITS.
565 if ("${${PROJECT_NAME}_ENABLE_INSTALL_CMAKE_CONFIG_FILES_DEFAULT}" STREQUAL "")
566 set(${PROJECT_NAME}_ENABLE_INSTALL_CMAKE_CONFIG_FILES_DEFAULT OFF)
567 endif()
568 advanced_set(${PROJECT_NAME}_ENABLE_INSTALL_CMAKE_CONFIG_FILES
569 ${${PROJECT_NAME}_ENABLE_INSTALL_CMAKE_CONFIG_FILES_DEFAULT}
570 CACHE BOOL
571 "Determines if ${PROJECT_NAME}Config.cmake and <PACKAGE>Config.cmake files are created or not."
572 )
573
574 if ("${${PROJECT_NAME}_SKIP_INSTALL_PROJECT_CMAKE_CONFIG_FILES_DEFAULT}" STREQUAL "")
575 set(${PROJECT_NAME}_SKIP_INSTALL_PROJECT_CMAKE_CONFIG_FILES_DEFAULT OFF)
576 endif()
577 advanced_set(${PROJECT_NAME}_SKIP_INSTALL_PROJECT_CMAKE_CONFIG_FILES
578 ${${PROJECT_NAME}_SKIP_INSTALL_PROJECT_CMAKE_CONFIG_FILES_DEFAULT}
579 CACHE BOOL
580 "Skip installing the file ${PROJECT_NAME}Config.cmake."
581 )
582
583 if (NOT ${PROJECT_NAME}_GENERATE_EXPORT_FILE_DEPENDENCIES_DEFAULT)
584 # We need to generate the dependency logic for export dependency files if
585 # asked.
586 if (${PROJECT_NAME}_ENABLE_INSTALL_CMAKE_CONFIG_FILES)
587 set(${PROJECT_NAME}_GENERATE_EXPORT_FILE_DEPENDENCIES_DEFAULT ON)
588 else()
589 set(${PROJECT_NAME}_GENERATE_EXPORT_FILE_DEPENDENCIES_DEFAULT OFF)
590 endif()
591 endif()
592 advanced_set(${PROJECT_NAME}_GENERATE_EXPORT_FILE_DEPENDENCIES
593 ${${PROJECT_NAME}_GENERATE_EXPORT_FILE_DEPENDENCIES_DEFAULT} CACHE BOOL
594 "Generate packages dependency data-structures needed for dependency export files." )
595
596 # ${PROJECT_NAME}_ELEVATE_SS_TO_PS is depreciated!
597 if (${PROJECT_NAME}_ELEVATE_SS_TO_PS_DEFAULT)
598 if (${PROJECT_NAME}_VERBOSE_CONFIGURE)
599 message("-- " "WARNING: ${PROJECT_NAME}_ELEVATE_SS_TO_PS_DEFAULT is deprecated."
600 " Use ${PROJECT_NAME}_ELEVATE_ST_TO_PT_DEFAULT instead!")
601 endif()
602 set(${PROJECT_NAME}_ELEVATE_ST_TO_PT_DEFAULT ON)
603 endif()
604
605 if ("${${PROJECT_NAME}_ELEVATE_ST_TO_PT_DEFAULT}" STREQUAL "")
606 set(${PROJECT_NAME}_ELEVATE_ST_TO_PT_DEFAULT OFF)
607 endif()
608 advanced_set( ${PROJECT_NAME}_ELEVATE_ST_TO_PT
609 ${${PROJECT_NAME}_ELEVATE_ST_TO_PT_DEFAULT}
610 CACHE BOOL
611 "Elevate all defined ST packages to PT packages." )
612
613 if ("${${PROJECT_NAME}_ENABLE_CPACK_PACKAGING_DEFAULT}" STREQUAL "")
614 set(${PROJECT_NAME}_ENABLE_CPACK_PACKAGING_DEFAULT OFF)
615 endif()
616 advanced_set( ${PROJECT_NAME}_ENABLE_CPACK_PACKAGING
617 ${${PROJECT_NAME}_ENABLE_CPACK_PACKAGING_DEFAULT}
618 CACHE BOOL
619 "Enable support for creating a distribution using CPack" )
620
621 if ("${${PROJECT_NAME}_EXCLUDE_DISABLED_SUBPACKAGES_FROM_DISTRIBUTION_DEFAULT}" STREQUAL "")
622 set(${PROJECT_NAME}_EXCLUDE_DISABLED_SUBPACKAGES_FROM_DISTRIBUTION_DEFAULT TRUE)
623 endif()
624 advanced_set( ${PROJECT_NAME}_EXCLUDE_DISABLED_SUBPACKAGES_FROM_DISTRIBUTION
625 ${${PROJECT_NAME}_EXCLUDE_DISABLED_SUBPACKAGES_FROM_DISTRIBUTION_DEFAULT}
626 CACHE BOOL
627 "Excluded disabled packages from the CPack-generated distribution.")
628
629 if ("${${PROJECT_NAME}_ENABLE_SECONDARY_TESTED_CODE_DEFAULT}" STREQUAL "")
630 set(${PROJECT_NAME}_ENABLE_SECONDARY_TESTED_CODE_DEFAULT OFF)
631 endif()
632 advanced_set(
633 ${PROJECT_NAME}_ENABLE_SECONDARY_TESTED_CODE
634 ${${PROJECT_NAME}_ENABLE_SECONDARY_TESTED_CODE_DEFAULT}
635 CACHE BOOL
636 "Allow Secondary Tested (ST) packages and code to be implicitly enabled." )
637
638 if ("${${PROJECT_NAME}_TEST_CATEGORIES_DEFAULT}" STREQUAL "")
639 set(${PROJECT_NAME}_TEST_CATEGORIES_DEFAULT NIGHTLY)
640 endif()
641 advanced_set(${PROJECT_NAME}_TEST_CATEGORIES
642 ${${PROJECT_NAME}_TEST_CATEGORIES_DEFAULT}
643 CACHE STRING
644 "List of categories of tests to enable: '${${PROJECT_NAME}_VALID_CATEGORIES_STR}' (default `${${PROJECT_NAME}_TEST_CATEGORIES_DEFAULT}`)."
645 )
646 tribits_get_invalid_categories(${PROJECT_NAME}_TEST_CATEGORIES)
647
648 if (NOT GIT_EXECUTABLE)
649 set(${PROJECT_NAME}_GENERATE_REPO_VERSION_FILE_DEFAULT OFF)
650 elseif ("${${PROJECT_NAME}_GENERATE_REPO_VERSION_FILE_DEFAULT}" STREQUAL "" )
651 set(${PROJECT_NAME}_GENERATE_REPO_VERSION_FILE_DEFAULT OFF)
652 endif()
653 advanced_set(
654 ${PROJECT_NAME}_GENERATE_REPO_VERSION_FILE
655 ${${PROJECT_NAME}_GENERATE_REPO_VERSION_FILE_DEFAULT}
656 CACHE BOOL
657 "Generate the ${PROJECT_NAME}RepoVersion.txt file.")
658
659 tribits_advanced_set_cache_var_and_default(${PROJECT_NAME}_SHOW_GIT_COMMIT_PARENTS
660 BOOL OFF "Show parents' commit info in the repo version output.")
661
662 if ("${${PROJECT_NAME}_GENERATE_VERSION_DATE_FILES_DEFAULT}" STREQUAL "")
663 set(${PROJECT_NAME}_GENERATE_VERSION_DATE_FILES_DEFAULT OFF)
664 endif()
665 advanced_set(
666 ${PROJECT_NAME}_GENERATE_VERSION_DATE_FILES
667 ${${PROJECT_NAME}_GENERATE_VERSION_DATE_FILES_DEFAULT}
668 CACHE BOOL
669 "Generate VersionDate.cmake and <RepoName>_version_date.h files.")
670
671 if ("${DART_TESTING_TIMEOUT_DEFAULT}" STREQUAL "")
672 set(DART_TESTING_TIMEOUT_DEFAULT 1500)
673 endif()
674 advanced_set(
675 DART_TESTING_TIMEOUT ${DART_TESTING_TIMEOUT_DEFAULT}
676 CACHE STRING
677 "Raw CMake/CTest global default test timeout (default 1500). (NOTE: Does not impact timeouts of tests that have the TIMEOUT property set on a test-by-test basis.)"
678 )
679 # NOTE: 1500 is the CMake default set in Modules/CTest.cmake. We need to
680 # set the default here because we need to be able to scale it correctly in
681 # case the user does not explicitly set this var in the cache.
682
683 advanced_set(${PROJECT_NAME}_SCALE_TEST_TIMEOUT 1.0 CACHE STRING
684 "Scale factor for global DART_TESTING_TIMEOUT and individual test TIMEOUT (default 1.0)."
685 )
686 # NOTE: This value is 1.0, *NOT* 1! This is used in tribits_scale_timeout()
687 # and there are unit tests that rely on this default!
688
689 advanced_set(${PROJECT_NAME}_REL_CPU_SPEED 1.0 CACHE STRING
690 "Relative CPU speed of the computer used to scale performance tests (default 1.0)."
691 )
692
693 if ("${${PROJECT_NAME}_ENABLE_DEVELOPMENT_MODE_DEFAULT}" STREQUAL "")
694 set(${PROJECT_NAME}_ENABLE_DEVELOPMENT_MODE_DEFAULT ON)
695 endif()
696 advanced_set( ${PROJECT_NAME}_ENABLE_DEVELOPMENT_MODE
697 ${${PROJECT_NAME}_ENABLE_DEVELOPMENT_MODE_DEFAULT}
698 CACHE BOOL
699 "Determines if a variety of development mode checks are turned on by default or not."
700 )
701
702 if (NOT "${${PROJECT_NAME}_ASSERT_MISSING_PACKAGES}" STREQUAL "")
703 tribits_deprecated("Warning, ${PROJECT_NAME}_ASSERT_MISSING_PACKAGES="
704 "'${${PROJECT_NAME}_ASSERT_MISSING_PACKAGES}' is set and is no"
705 " longer supported! Please set"
706 " ${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES instead (see build ref)!" )
707 if (${PROJECT_NAME}_ASSERT_MISSING_PACKAGES)
708 set(${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES_DEFAULT FATAL_ERROR)
709 else()
710 set(${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES_DEFAULT IGNORE)
711 endif()
712 endif()
713
714 if ("${${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES_DEFAULT}" STREQUAL "")
715 if (${PROJECT_NAME}_ENABLE_DEVELOPMENT_MODE)
716 set(${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES_DEFAULT FATAL_ERROR)
717 else()
718 set(${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES_DEFAULT IGNORE)
719 endif()
720 endif()
721
722 set(${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES_ERROR_VALUES_LIST
723 "FATAL_ERROR" "SEND_ERROR" )
724 set(${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES_VALUES_LIST
725 ${${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES_ERROR_VALUES_LIST}
726 "WARNING" "NOTICE" "IGNORE" "OFF" )
727 tribits_add_enum_cache_var( ${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES
728 DEFAULT_VAL ${${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES_DEFAULT}
729 DOC_STRING
730 "Assert that all external and internal dependencies are defined in the project"
731 ALLOWED_STRINGS_LIST
732 ${${PROJECT_NAME}_ASSERT_DEFINED_DEPENDENCIES_VALUES_LIST}
733 IS_ADVANCED )
734
735 if ("${${PROJECT_NAME}_ASSERT_CORRECT_TRIBITS_USAGE_DEFAULT}" STREQUAL "")
736 if (${PROJECT_NAME}_ENABLE_DEVELOPMENT_MODE)
737 set(${PROJECT_NAME}_ASSERT_CORRECT_TRIBITS_USAGE_DEFAULT FATAL_ERROR)
738 else()
739 set(${PROJECT_NAME}_ASSERT_CORRECT_TRIBITS_USAGE_DEFAULT IGNORE)
740 endif()
741 endif()
742 set(${PROJECT_NAME}_ASSERT_CORRECT_TRIBITS_USAGE_VALUES_LIST
743 "FATAL_ERROR" "SEND_ERROR" "WARNING" "IGNORE" "OFF")
744 tribits_add_enum_cache_var( ${PROJECT_NAME}_ASSERT_CORRECT_TRIBITS_USAGE
745 DEFAULT_VAL "${${PROJECT_NAME}_ASSERT_CORRECT_TRIBITS_USAGE_DEFAULT}"
746 DOC_STRING
747 "Assert correct usage of TriBITS"
748 ALLOWED_STRINGS_LIST
749 ${${PROJECT_NAME}_ASSERT_CORRECT_TRIBITS_USAGE_VALUES_LIST}
750 IS_ADVANCED )
751
752 advanced_set( ${PROJECT_NAME}_WARN_ABOUT_MISSING_EXTERNAL_PACKAGES
753 FALSE CACHE BOOL
754 "If set to TRUE, a 'NOTE' is printed for each missing package that is ignored." )
755
756 advanced_set( ${PROJECT_NAME}_ENABLE_STRONG_C_COMPILE_WARNINGS
757 ${${PROJECT_NAME}_ENABLE_DEVELOPMENT_MODE}
758 CACHE BOOL "Enable strong compiler warnings for C code for supported compilers." )
759
760 advanced_set( ${PROJECT_NAME}_ENABLE_STRONG_CXX_COMPILE_WARNINGS
761 ${${PROJECT_NAME}_ENABLE_DEVELOPMENT_MODE}
762 CACHE BOOL "Enable strong compiler warnings for C++ code for supported compilers." )
763
764 multiline_set( ENABLE_SHADOW_WARNINGS_DOC
765 "Turn ON or OFF shadowing warnings for all packages where strong warnings have"
766 " not been explicitly disabled. Setting the empty '' let's each package decide." )
767 set_cache_on_off_empty( ${PROJECT_NAME}_ENABLE_SHADOW_WARNINGS ""
768 "${ENABLE_SHADOW_WARNINGS_DOC}" )
769 mark_as_advanced(${PROJECT_NAME}_ENABLE_SHADOW_WARNINGS)
770
771 advanced_set( ${PROJECT_NAME}_ENABLE_COVERAGE_TESTING OFF
772 CACHE BOOL "Enable support for coverage testing by setting needed compiler/linker options." )
773
774 advanced_set( ${PROJECT_NAME}_ENABLE_CHECKED_STL OFF
775 CACHE BOOL "Turn on checked STL checking (e.g. -D_GLIBCXX_DEBUG) or not." )
776
777 advanced_set( ${PROJECT_NAME}_ENABLE_DEBUG_SYMBOLS OFF
778 CACHE BOOL "Turn on debugging symbols (e.g. -g) or not if not a full debug build." )
779
780 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
781 set(${PROJECT_NAME}_WARNINGS_AS_ERRORS_FLAGS_DEFAULT "-Werror")
782 else()
783 set(${PROJECT_NAME}_WARNINGS_AS_ERRORS_FLAGS_DEFAULT "")
784 endif()
785
786 advanced_set( ${PROJECT_NAME}_WARNINGS_AS_ERRORS_FLAGS
787 "${${PROJECT_NAME}_WARNINGS_AS_ERRORS_FLAGS_DEFAULT}"
788 CACHE STRING "Flags for treating warnings as errors (for all compilers, -Werror by default for GNU). To turn off warnings as errors set to ''")
789
790 advanced_set(${PROJECT_NAME}_ENABLE_CIRCULAR_REF_DETECTION_FAILURE OFF CACHE BOOL
791 "If test output complaining about circular references is found, then the test will fail." )
792
793 advanced_set(${PROJECT_NAME}_DEPS_DEFAULT_OUTPUT_DIR ""
794 CACHE FILEPATH
795 "If set to non-null, this is the default directory where package dependency files will be written.")
796
797 if (${PROJECT_NAME}_DEPS_DEFAULT_OUTPUT_DIR)
798 set(${PROJECT_NAME}_DEPS_XML_OUTPUT_FILE_DEFAULT
799 "${${PROJECT_NAME}_DEPS_DEFAULT_OUTPUT_DIR}/${${PROJECT_NAME}_PACKAGE_DEPS_XML_FILE_NAME}")
800 else()
801 set(${PROJECT_NAME}_DEPS_XML_OUTPUT_FILE_DEFAULT "")
802 endif()
803 advanced_set(${PROJECT_NAME}_DEPS_XML_OUTPUT_FILE
804 "${${PROJECT_NAME}_DEPS_XML_OUTPUT_FILE_DEFAULT}"
805 CACHE STRING
806 "Output XML file containing ${PROJECT_NAME} dependenices used by tools (if not empty)." )
807
808 if(${PROJECT_NAME}_DEPS_DEFAULT_OUTPUT_DIR AND
809 ${PROJECT_NAME}_DEPS_XML_OUTPUT_FILE AND Python3_EXECUTABLE
810 )
811 set(${PROJECT_NAME}_CDASH_DEPS_XML_OUTPUT_FILE_DEFAULT
812 "${${PROJECT_NAME}_DEPS_DEFAULT_OUTPUT_DIR}/${${PROJECT_NAME}_CDASH_SUBPROJECT_DEPS_XML_FILE_NAME}" )
813 else()
814 set(${PROJECT_NAME}_CDASH_DEPS_XML_OUTPUT_FILE_DEFAULT "")
815 endif()
816 advanced_set(${PROJECT_NAME}_CDASH_DEPS_XML_OUTPUT_FILE
817 "${${PROJECT_NAME}_CDASH_DEPS_XML_OUTPUT_FILE_DEFAULT}"
818 CACHE STRING
819 "Output XML file used by CDash in ${PROJECT_NAME}-independent format (if not empty)." )
820
821 if(${PROJECT_NAME}_DEPS_DEFAULT_OUTPUT_DIR AND
822 ${PROJECT_NAME}_DEPS_XML_OUTPUT_FILE AND Python3_EXECUTABLE
823 )
824 set(${PROJECT_NAME}_DEPS_HTML_OUTPUT_FILE_DEFAULT
825 "${${PROJECT_NAME}_DEPS_DEFAULT_OUTPUT_DIR}/${${PROJECT_NAME}_PACKAGE_DEPS_TABLE_HTML_FILE_NAME}" )
826 else()
827 set(${PROJECT_NAME}_DEPS_HTML_OUTPUT_FILE_DEFAULT "")
828 endif()
829 advanced_set(${PROJECT_NAME}_DEPS_HTML_OUTPUT_FILE
830 "${${PROJECT_NAME}_DEPS_HTML_OUTPUT_FILE_DEFAULT}"
831 CACHE STRING
832 "HTML ${PROJECT_NAME} dependenices file that will be written to (if not empty)." )
833
834 #
835 # Extra repositories
836 #
837
838 assert_defined(${PROJECT_NAME}_EXTRA_EXTERNAL_REPOS_FILE_NAME)
839
840 set(DEFAULT_EXTRA_REPOS_FILE
841 "${PROJECT_SOURCE_DIR}/cmake/${${PROJECT_NAME}_EXTRA_EXTERNAL_REPOS_FILE_NAME}")
842
843 if (EXISTS ${DEFAULT_EXTRA_REPOS_FILE})
844 #message("${DEFAULT_EXTRA_REPOS_FILE} does exist!")
845 set(${PROJECT_NAME}_EXTRAREPOS_FILE_DEFAULT ${DEFAULT_EXTRA_REPOS_FILE})
846 else()
847 #message("${DEFAULT_EXTRA_REPOS_FILE} does *NOT* exist!")
848 set(${PROJECT_NAME}_EXTRAREPOS_FILE_DEFAULT)
849 endif()
850
851 advanced_set(${PROJECT_NAME}_EXTRAREPOS_FILE
852 "${${PROJECT_NAME}_EXTRAREPOS_FILE_DEFAULT}"
853 CACHE STRING
854 "File containing the list of extra repositories containing add-on packages to process")
855 #print_var(${PROJECT_NAME}_EXTRAREPOS_FILE)
856
857 advanced_set(${PROJECT_NAME}_ENABLE_KNOWN_EXTERNAL_REPOS_TYPE
858 ""
859 CACHE STRING
860 "Type of testing to pull in extra repositories (Continuous, or Nightly)" )
861
862 advanced_set(${PROJECT_NAME}_IGNORE_MISSING_EXTRA_REPOSITORIES
863 FALSE CACHE BOOL
864 "Set if to ignore missing extra repositories (or fail hard)" )
865
866 # Even if a project does not support an extra repos file, it can always
867 # support extra repositories defined by the user by the very nature of
868 # Tribits.
869
870 advanced_set(${PROJECT_NAME}_PRE_REPOSITORIES
871 ""
872 CACHE STRING
873 "List of pre-extra repositories that contain extra ${PROJECT_NAME} packages."
874 )
875 split("${${PROJECT_NAME}_PRE_REPOSITORIES}" "," ${PROJECT_NAME}_PRE_REPOSITORIES)
876
877 advanced_set(${PROJECT_NAME}_EXTRA_REPOSITORIES
878 ""
879 CACHE STRING
880 "List of post-extra repositories that contain extra ${PROJECT_NAME} packages."
881 )
882 split("${${PROJECT_NAME}_EXTRA_REPOSITORIES}" "," ${PROJECT_NAME}_EXTRA_REPOSITORIES)
883
884 if ("${${PROJECT_NAME}_CHECK_EXTRAREPOS_EXIST}" STREQUAL "")
885 set(${PROJECT_NAME}_CHECK_EXTRAREPOS_EXIST TRUE)
886 endif()
887
888 tribits_get_and_process_extra_repositories_lists()
889
890 advanced_set(${PROJECT_NAME}_INSTALLATION_DIR
891 "" CACHE STRING
892 "Location of an installed version of ${PROJECT_NAME} that will be built against during installation testing"
893 )
894
895 #
896 # More options
897 #
898
899 if("${${PROJECT_NAME}_INSTALLATION_DIR}" STREQUAL "")
900 set(${PROJECT_NAME}_ENABLE_INSTALLATION_TESTING_DEFAULT OFF)
901 else()
902 set(${PROJECT_NAME}_ENABLE_INSTALLATION_TESTING_DEFAULT ON)
903 endif()
904
905 advanced_set(${PROJECT_NAME}_ENABLE_INSTALLATION_TESTING
906 ${${PROJECT_NAME}_ENABLE_INSTALLATION_TESTING_DEFAULT}
907 CACHE STRING
908 "Enable testing against an installed version of ${PROJECT_NAME}."
909 )
910
911 advanced_option(${PROJECT_NAME}_SHORTCIRCUIT_AFTER_DEPENDENCY_HANDLING
912 "Short-circuit after dependency handling is complete"
913 OFF )
914
915 advanced_option(${PROJECT_NAME}_TRACE_DEPENDENCY_HANDLING_ONLY
916 "Only trace dependency handling. Don't configure to build anything!"
917 OFF )
918
919 advanced_set(${PROJECT_NAME}_ENABLE_CONFIGURE_TIMING
920 FALSE CACHE BOOL
921 "Set to 'ON' to see configure times (Unix/Linux systems only)" )
922
923 advanced_set(${PROJECT_NAME}_ENABLE_PACKAGE_CONFIGURE_TIMING
924 FALSE CACHE BOOL
925 "Set to 'ON' to see configure times for individual packages" )
926
927 if ("${${PROJECT_NAME}_SHOW_TEST_START_END_DATE_TIME_DEFAULT}"
928 STREQUAL ""
929 )
930 set(${PROJECT_NAME}_SHOW_TEST_START_END_DATE_TIME_DEFAULT OFF)
931 endif()
932 advanced_set(${PROJECT_NAME}_SHOW_TEST_START_END_DATE_TIME
933 ${${PROJECT_NAME}_SHOW_TEST_START_END_DATE_TIME_DEFAULT}
934 CACHE BOOL
935 "Set to 'ON' to see start and end date/time for advanced tests." )
936
937 if ("${${PROJECT_NAME}_SHOW_MACHINE_LOAD_IN_TEST_DEFAULT}"
938 STREQUAL ""
939 )
940 set(${PROJECT_NAME}_SHOW_MACHINE_LOAD_IN_TEST_DEFAULT OFF)
941 endif()
942 advanced_set(${PROJECT_NAME}_SHOW_MACHINE_LOAD_IN_TEST
943 ${${PROJECT_NAME}_SHOW_MACHINE_LOAD_IN_TEST_DEFAULT}
944 CACHE BOOL
945 "Set to 'ON' to see the machine load for advanced tests." )
946
947 if ("${TRIBITS_HANDLE_TRIBITS_DEPRECATED_CODE_DEFAULT}" STREQUAL "")
948 set(TRIBITS_HANDLE_TRIBITS_DEPRECATED_CODE_DEFAULT "DEPRECATION")
949 endif()
950
951 tribits_add_enum_cache_var(TRIBITS_HANDLE_TRIBITS_DEPRECATED_CODE
952 DEFAULT_VAL "${TRIBITS_HANDLE_TRIBITS_DEPRECATED_CODE_DEFAULT}"
953 DOC_STRING "Mode for dealing with usage of TriBITS deprecated functionality"
954 ALLOWED_STRINGS_LIST ${TRIBITS_HANDLE_TRIBITS_DEPRECATED_CODE_ALL_VALID_VALUES}
955 IS_ADVANCED
956 )
957
958 mark_as_advanced(BUILD_TESTING)
959 mark_as_advanced(CMAKE_BACKWARDS_COMPATIBILITY)
960 mark_as_advanced(DART_TESTING_TIMEOUT)
961 mark_as_advanced(EXECUTABLE_OUTPUT_PATH)
962 mark_as_advanced(LIBRARY_OUTPUT_PATH)
963 mark_as_advanced(CMAKE_OSX_ARCHITECTURES)
964 mark_as_advanced(CMAKE_OSX_SYSROOT)
965
966 endmacro()
967
968
969 macro(tribits_setup_installation_paths)
970
971 #
972 # A) Determine if we are going to be using default paths from GNUInstallDirs module
973 #
974
975 set(TRIBITS_USE_GNUINSTALLDIRS TRUE)
976
977 if (NOT ${PROJECT_NAME}_USE_GNUINSTALLDIRS)
978 # For backward compatibility and unit testing
979 set(TRIBITS_USE_GNUINSTALLDIRS FALSE)
980 endif()
981
982 #
983 # B) Pick the defaults for the install dirs
984 #
985
986 if (TRIBITS_USE_GNUINSTALLDIRS)
987 include(GNUInstallDirs)
988 set(${PROJECT_NAME}_INSTALL_INCLUDE_DIR_DEFAULT ${CMAKE_INSTALL_INCLUDEDIR})
989 set(${PROJECT_NAME}_INSTALL_LIB_DIR_DEFAULT ${CMAKE_INSTALL_LIBDIR})
990 set(${PROJECT_NAME}_INSTALL_RUNTIME_DIR_DEFAULT ${CMAKE_INSTALL_BINDIR})
991 set(${PROJECT_NAME}_INSTALL_EXAMPLE_DIR_DEFAULT "example")
992 else()
993 set(${PROJECT_NAME}_INSTALL_INCLUDE_DIR_DEFAULT "include")
994 set(${PROJECT_NAME}_INSTALL_LIB_DIR_DEFAULT "lib")
995 set(${PROJECT_NAME}_INSTALL_RUNTIME_DIR_DEFAULT "bin")
996 set(${PROJECT_NAME}_INSTALL_EXAMPLE_DIR_DEFAULT "example")
997 endif()
998
999 #
1000 # C) Set the cache variables for the install dirs
1001 #
1002
1003 advanced_set( ${PROJECT_NAME}_INSTALL_INCLUDE_DIR
1004 ${${PROJECT_NAME}_INSTALL_INCLUDE_DIR_DEFAULT}
1005 CACHE PATH
1006 "Location where the headers will be installed. If given as a STRING type and relative path, it will be relative to ${CMAKE_INSTALL_PREFIX}. If given as an absolute path, it will used as such. Default is 'include'"
1007 )
1008
1009 advanced_set( ${PROJECT_NAME}_INSTALL_LIB_DIR
1010 ${${PROJECT_NAME}_INSTALL_LIB_DIR_DEFAULT}
1011 CACHE PATH
1012 "Location where the libraries will be installed. If given as a STRING type relative path, it will be relative to ${CMAKE_INSTALL_PREFIX}. If given as an absolute path, it will used as such. Default is 'lib'"
1013 )
1014
1015 advanced_set( ${PROJECT_NAME}_INSTALL_RUNTIME_DIR
1016 ${${PROJECT_NAME}_INSTALL_RUNTIME_DIR_DEFAULT}
1017 CACHE PATH
1018 "Location where the runtime DLLs and designated programs will be installed. If given as a STRING type relative path, it will be relative to ${CMAKE_INSTALL_PREFIX}. If given as an absolute path, it will used as such. Default is 'bin'"
1019 )
1020
1021 advanced_set(${PROJECT_NAME}_INSTALL_EXAMPLE_DIR
1022 ${${PROJECT_NAME}_INSTALL_EXAMPLE_DIR_DEFAULT}
1023 CACHE PATH
1024 "Location where assorted examples will be installed. If given as a STRING type relative path, it will be relative to ${CMAKE_INSTALL_PREFIX}. If given as an absolute path, it will used as such. Default is 'example'"
1025 )
1026
1027 #
1028 # D) Setup RPATH handling
1029 #
1030
1031 print_var(${PROJECT_NAME}_SET_INSTALL_RPATH)
1032 print_var(CMAKE_INSTALL_RPATH_USE_LINK_PATH)
1033
1034 if (${PROJECT_NAME}_SET_INSTALL_RPATH)
1035 if ("${CMAKE_INSTALL_RPATH}" STREQUAL "")
1036 message("-- " "Setting default for CMAKE_INSTALL_RPATH pointing to ${PROJECT_NAME}_INSTALL_LIB_DIR")
1037 assert_defined(CMAKE_INSTALL_PREFIX)
1038 assert_defined(${PROJECT_NAME}_INSTALL_LIB_DIR)
1039 if (IS_ABSOLUTE ${${PROJECT_NAME}_INSTALL_LIB_DIR})
1040 set(CMAKE_INSTALL_RPATH
1041 "${PROJECT_NAME}_INSTALL_LIB_DIR}" )
1042 else()
1043 set(CMAKE_INSTALL_RPATH
1044 "${CMAKE_INSTALL_PREFIX}/${${PROJECT_NAME}_INSTALL_LIB_DIR}" )
1045 endif()
1046 endif()
1047 if (CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
1048 if ("${CMAKE_MACOSX_RPATH}" STREQUAL "")
1049 message("-- " "Setting default CMAKE_MACOSX_RPATH=TRUE")
1050 set(CMAKE_MACOSX_RPATH TRUE)
1051 endif()
1052 print_var(CMAKE_MACOSX_RPATH)
1053 endif()
1054 endif()
1055 string(REPLACE ":" ";" CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_RPATH}")
1056 print_var(CMAKE_INSTALL_RPATH)
1057
1058 #
1059 # E) Set permissions on created installation directories
1060 #
1061
1062 if (
1063 (NOT "${${PROJECT_NAME}_MAKE_INSTALL_GROUP_READABLE}" STREQUAL "")
1064 OR
1065 (NOT "${${PROJECT_NAME}_MAKE_INSTALL_WORLD_READABLE}" STREQUAL "")
1066 )
1067
1068 print_var(${PROJECT_NAME}_MAKE_INSTALL_GROUP_READABLE)
1069 print_var(${PROJECT_NAME}_MAKE_INSTALL_WORLD_READABLE)
1070
1071 # Group permissions
1072 if (${PROJECT_NAME}_MAKE_INSTALL_WORLD_READABLE
1073 OR ${PROJECT_NAME}_MAKE_INSTALL_GROUP_READABLE
1074 )
1075 set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS_GROUP
1076 GROUP_READ GROUP_EXECUTE)
1077 else()
1078 set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS_GROUP) # Empty
1079 endif()
1080
1081 # World permissions
1082 if (${PROJECT_NAME}_MAKE_INSTALL_WORLD_READABLE)
1083 set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS_WORLD
1084 WORLD_READ WORLD_EXECUTE)
1085 else()
1086 set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS_WORLD) # Empty
1087 endif()
1088
1089 # Directory permissions
1090 set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS
1091 OWNER_READ OWNER_WRITE OWNER_EXECUTE
1092 ${CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS_GROUP}
1093 ${CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS_WORLD}
1094 )
1095
1096 # Print the permissions in a way that allows for strong testing
1097 string(REPLACE ";" " " CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS_W_SPACES
1098 "${CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS}" )
1099 message("-- " "CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS = "
1100 "(${CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS_W_SPACES})")
1101
1102 endif()
1103
1104 endmacro()
1105
1106
1107 # Read in the Project's native repositories.
1108 #
1109 # On output, the variable ${PRJOECT_NAME}_NATIVE_REPOSITORIES is set.
1110 #
1111 macro(tribits_read_in_native_repositories)
1112 if (${PROJECT_NAME}_NATIVE_REPO_FILE_OVERRRIDE)
1113 if (IS_ABSOLUTE ${${PROJECT_NAME}_NATIVE_REPO_FILE_OVERRRIDE})
1114 set(NATIVE_REPO_FILE ${${PROJECT_NAME}_NATIVE_REPO_FILE_OVERRRIDE})
1115 else()
1116 set(NATIVE_REPO_FILE
1117 ${PROJECT_SOURCE_DIR}/${${PROJECT_NAME}_NATIVE_REPO_FILE_OVERRRIDE})
1118 endif()
1119 else()
1120 set(NATIVE_REPO_FILE ${PROJECT_SOURCE_DIR}/cmake/NativeRepositoriesList.cmake)
1121 endif()
1122 if (EXISTS ${NATIVE_REPO_FILE})
1123 tribits_trace_file_processing(PROJECT INCLUDE "${NATIVE_REPO_FILE}")
1124 include(${NATIVE_REPO_FILE})
1125 else()
1126 set(${PROJECT_NAME}_NATIVE_REPOSITORIES ".")
1127 endif()
1128 endmacro()
1129
1130
1131 # Combine native and extra repos lists into a single list.
1132 #
1133 # Combines ${PROJECT_NAME}_PRE_REPOSITORIES
1134 # ${PROJECT_NAME}_NATIVE_REPOSITORIES and ${PROJECT_NAME}_EXTRA_REPOSITORIES
1135 # into a single list ${PROJECT_NAME}_ALL_REPOSITORIES.
1136 #
1137 macro(tribits_combine_native_and_extra_repos)
1138 assert_defined(${PROJECT_NAME}_PRE_REPOSITORIES)
1139 assert_defined(${PROJECT_NAME}_NATIVE_REPOSITORIES)
1140 assert_defined(${PROJECT_NAME}_EXTRA_REPOSITORIES)
1141 set( ${PROJECT_NAME}_ALL_REPOSITORIES
1142 ${${PROJECT_NAME}_PRE_REPOSITORIES}
1143 ${${PROJECT_NAME}_NATIVE_REPOSITORIES}
1144 ${${PROJECT_NAME}_EXTRA_REPOSITORIES}
1145 )
1146 endmacro()
1147
1148
1149 # Process extra repo extra options files
1150 #
1151 macro(tribits_process_extra_repos_options_files)
1152 # Loop through the Repositories, set their base directories and run their
1153 # options setup callback functions.
1154 foreach(REPO ${${PROJECT_NAME}_ALL_REPOSITORIES})
1155 tribits_get_repo_name_dir(${REPO} REPO_NAME REPO_DIR)
1156 tribits_set_base_repo_dir(${PROJECT_SOURCE_DIR} ${REPO_DIR} ${REPO_NAME}_SOURCE_DIR)
1157 tribits_set_base_repo_dir(${PROJECT_BINARY_DIR} ${REPO_DIR} ${REPO_NAME}_BINARY_DIR)
1158 if (${PROJECT_NAME}_VERBOSE_CONFIGURE)
1159 message("Processing extra options call-backs for ${REPO}")
1160 print_var(${REPO_NAME}_SOURCE_DIR)
1161 print_var(${REPO_NAME}_BINARY_DIR)
1162 endif()
1163 tribits_repository_setup_extra_options_runner(${REPO_NAME})
1164 endforeach()
1165 endmacro()
1166
1167
1168 # Copy an simple text file to the binary dir to be included in the tarball
1169 #
1170 macro(tribits_copy_installer_resource _varname _source _destination)
1171 set("${_varname}" "${_destination}")
1172 if (EXISTS "${_destination}")
1173 file(REMOVE_RECURSE "${_destination}")
1174 ENDIF ()
1175 configure_file(
1176 "${_source}"
1177 "${_destination}"
1178 COPYONLY)
1179 endmacro()
1180
1181
1182 # Get the versions of all the git repos
1183 #
1184 function(tribits_generate_repo_version_file_string projectRepoVersionFileStrOut)
1185
1186 set(projectRepoVersionFileStr "")
1187
1188 tribits_generate_single_repo_version_string(
1189 ${CMAKE_CURRENT_SOURCE_DIR} singleRepoVersionStr
1190 INCLUDE_COMMIT_PARENTS ${${PROJECT_NAME}_SHOW_GIT_COMMIT_PARENTS})
1191 string(APPEND projectRepoVersionFileStr
1192 "*** Base Git Repo: ${PROJECT_NAME}\n"
1193 "${singleRepoVersionStr}\n" )
1194
1195 set(extraRepoIdx 0)
1196 foreach(extraRepo ${${PROJECT_NAME}_ALL_EXTRA_REPOSITORIES})
1197
1198 if (${PROJECT_NAME}_ALL_EXTRA_REPOSITORIES_DIRS)
1199 # Read from an extra repo file with potentially different dir.
1200 list(GET ${PROJECT_NAME}_ALL_EXTRA_REPOSITORIES_DIRS ${extraRepoIdx}
1201 extraRepoDir )
1202 else()
1203 # Not read from extra repo file so dir is same as name
1204 set(extraRepoDir ${extraRepo})
1205 endif()
1206
1207 tribits_generate_single_repo_version_string(
1208 "${CMAKE_CURRENT_SOURCE_DIR}/${extraRepoDir}" singleRepoVersionStr
1209 INCLUDE_COMMIT_PARENTS ${${PROJECT_NAME}_SHOW_GIT_COMMIT_PARENTS})
1210 string(APPEND projectRepoVersionFileStr
1211 "*** Git Repo: ${extraRepoDir}\n"
1212 "${singleRepoVersionStr}\n" )
1213
1214 math(EXPR extraRepoIdx "${extraRepoIdx}+1")
1215
1216 endforeach()
1217
1218 set(${projectRepoVersionFileStrOut} ${projectRepoVersionFileStr} PARENT_SCOPE)
1219
1220 endfunction()
1221
1222
1223 # Generate the project repos version file and print to stdout
1224 #
1225 # This function is designed so that it can be unit tested from inside of a
1226 # cmake -P script.
1227 #
1228 function(tribits_generate_repo_version_output_and_file)
1229 # Get the repos versions
1230 tribits_generate_repo_version_file_string(projectRepoVersionFileStr)
1231 # Print the versions
1232 message("\n${PROJECT_NAME} repos versions:\n"
1233 "--------------------------------------------------------------------------------\n"
1234 "${projectRepoVersionFileStr}"
1235 " --------------------------------------------------------------------------------\n"
1236 )
1237 #) Write out the version file
1238 file(WRITE
1239 "${CMAKE_CURRENT_BINARY_DIR}/${${PROJECT_NAME}_REPO_VERSION_FILE_NAME}"
1240 "${projectRepoVersionFileStr}")
1241 endfunction()
1242
1243
1244 # Create project dependencies file and create install target for these
1245 #
1246 # NOTE: Before calling this function, the extra repos datastructure must be
1247 # filled out!
1248 #
1249 # NOTE: This function cannot be called in a cmake -P script because it has a
1250 # call to install()! That is why this function is separated out from
1251 # tribits_generate_repo_version_output_and_file().
1252 #
1253 function(tribits_generate_repo_version_output_and_file_and_install)
1254
1255 #
1256 # A) Create the ${PROJECT_NAME}RepoVersion.txt file if requested
1257 #
1258
1259 print_var(${PROJECT_NAME}_GENERATE_REPO_VERSION_FILE)
1260 if (${PROJECT_NAME}_GENERATE_REPO_VERSION_FILE)
1261
1262 # A) Make sure that there is a .git dir in the project before generating
1263 if (EXISTS "${PROJECT_SOURCE_DIR}/.git")
1264 set(PROJECT_SOURCE_IS_GIT_REPO TRUE)
1265 else()
1266 set(PROJECT_SOURCE_IS_GIT_REPO FALSE)
1267 endif()
1268 if (PROJECT_SOURCE_IS_GIT_REPO)
1269 # Get repo versions, print to stdout and write file
1270 tribits_generate_repo_version_output_and_file()
1271 # Add install target for this file
1272 install(
1273 FILES "${CMAKE_CURRENT_BINARY_DIR}/${${PROJECT_NAME}_REPO_VERSION_FILE_NAME}"
1274 DESTINATION "." )
1275 else()
1276 message("\nNOTE: Skipping generation of ${${PROJECT_NAME}_REPO_VERSION_FILE_NAME}"
1277 " because project source is not a git repo!")
1278 endif()
1279
1280 # B) Install the repo version file if it is in source tree which it will
1281 # be for a tarball (see tribits_setup_packaging_and_distribution()).
1282 set(REPO_VERSION_FILE_IN_SOURCE_TREE
1283 ${CMAKE_CURRENT_SOURCE_DIR}/${${PROJECT_NAME}_REPO_VERSION_FILE_NAME})
1284 if (EXISTS ${REPO_VERSION_FILE_IN_SOURCE_TREE})
1285 install(
1286 FILES "${REPO_VERSION_FILE_IN_SOURCE_TREE}"
1287 DESTINATION "." )
1288 endif()
1289
1290 endif()
1291
1292 endfunction()
1293
1294
1295 # Adjust package enable logic and print out before and after state
1296 #
1297 # On output sets:
1298 #
1299 # * ${PROJECT_NAME}_NUM_ENABLED_PACKAGES: Number of enabled packages (local variable)
1300 # * ${PROJECT_NAME}_ENABLE_${PACKAGE_NAME}: Enable status of PACKAGE_NAME (local variable)
1301 # ToDo: Fill in others as well!
1302 #
1303 macro(tribits_adjust_and_print_package_dependencies)
1304 tribits_config_code_start_timer(ADJUST_PACKAGE_DEPS_TIME_START_SECONDS)
1305 tribits_print_enables_before_adjust_package_enables()
1306 tribits_adjust_package_enables()
1307 tribits_print_enables_after_adjust_package_enables()
1308 tribits_handle_project_extra_link_flags_as_a_tpl()
1309 tribits_set_up_enabled_only_dependencies()
1310 tribits_config_code_stop_timer(ADJUST_PACKAGE_DEPS_TIME_START_SECONDS
1311 "\nTotal time to adjust package and TPL enables")
1312 endmacro()
1313
1314
1315 # Tack on ${PROJECT_NAME}_EXTRA_LINK_LIBS as a TPL that every downstream
1316 # external and internal package depends on
1317 #
1318 macro(tribits_handle_project_extra_link_flags_as_a_tpl)
1319
1320 if (${PROJECT_NAME}_EXTRA_LINK_FLAGS)
1321
1322 set(lastLibTplName ${PROJECT_NAME}TribitsLastLib)
1323
1324 # Define the TPL ${PROJECT_NAME}TribitsLastLib and its find module
1325 set(${lastLibTplName}_FINDMOD
1326 "${${PROJECT_NAME}_TRIBITS_DIR}/common_tpls/FindTPLProjectLastLib.cmake")
1327
1328 # Tack on ${PROJECT_NAME}TribitsLastLib as a dependency to all packages
1329 foreach(packageName ${${PROJECT_NAME}_DEFINED_PACKAGES})
1330 tribits_get_package_enable_status(${packageName} packageEnable "")
1331 list(APPEND ${packageName}_LIB_DEFINED_DEPENDENCIES ${lastLibTplName})
1332 if (packageEnable)
1333 list(APPEND ${packageName}_LIB_ENABLED_DEPENDENCIES ${lastLibTplName})
1334 endif()
1335 endforeach()
1336
1337 # Prepend ${PROJECT_NAME}TribitsLastLib to the list of packages
1338 list(PREPEND ${PROJECT_NAME}_DEFINED_TPLS ${lastLibTplName})
1339 list(PREPEND ${PROJECT_NAME}_DEFINED_TOPLEVEL_PACKAGES ${lastLibTplName})
1340 list(PREPEND ${PROJECT_NAME}_DEFINED_PACKAGES ${lastLibTplName})
1341 set(TPL_ENABLE_${lastLibTplName} ON)
1342 set(${lastLibTplName}_PACKAGE_BUILD_STATUS EXTERNAL)
1343
1344 endif()
1345
1346 endmacro()
1347
1348
1349 #
1350 # Macros for setting up the standard environment
1351 #
1352
1353
1354 macro(tribits_setup_env)
1355
1356 tribits_config_code_start_timer(SETUP_ENV_TIME_START_SECONDS)
1357
1358 if (${PROJECT_NAME}_VERBOSE_CONFIGURE)
1359 set(TRIBITS_SETUP_ENV_DEBUG TRUE)
1360 endif()
1361
1362 # Apply XSDK defaults
1363
1364 if ("${${PROJECT_NAME}_TRIBITS_XSDK_DIR}" STREQUAL "")
1365 set(${PROJECT_NAME}_TRIBITS_XSDK_DIR "${${PROJECT_NAME}_TRIBITS_DIR}/xsdk")
1366 endif()
1367 if (EXISTS "${${PROJECT_NAME}_TRIBITS_XSDK_DIR}")
1368 set(USE_XSDK_DEFAULTS_DEFAULT FALSE) # Set to TRUE for Trilinos 13.0.0?
1369 set(XSDK_ENABLE_C ${${PROJECT_NAME}_ENABLE_C})
1370 set(XSDK_ENABLE_CXX ${${PROJECT_NAME}_ENABLE_CXX})
1371 set(XSDK_ENABLE_Fortran ${${PROJECT_NAME}_ENABLE_Fortran})
1372 include("${${PROJECT_NAME}_TRIBITS_XSDK_DIR}/XSDKDefaults.cmake")
1373 # NOTE: BUILD_SHARED_LIBS was set in
1374 # tribits_define_global_options_and_define_extra_repos() based on
1375 # USE_XSDK_DEFAULTS in case there is logic in TriBITS that depends on this
1376 # var getting set there.
1377 endif()
1378
1379 # BUILD_SHARED_LIBS
1380 print_var(BUILD_SHARED_LIBS)
1381
1382 # Set to release build by default
1383
1384 if ("${CMAKE_BUILD_TYPE}" STREQUAL "")
1385 message(STATUS "Setting CMAKE_BUILD_TYPE=RELEASE since it was not set ...")
1386 set(CMAKE_BUILD_TYPE RELEASE CACHE STRING
1387 "Type of build to perform (i.e. DEBUG, RELEASE, NONE)" )
1388 else()
1389 string(TOUPPER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_UP)
1390 list(FIND CMAKE_BUILD_TYPES_LIST ${CMAKE_BUILD_TYPE_UP} BUILD_TYPE_IDX)
1391 if (BUILD_TYPE_IDX EQUAL -1)
1392 message(SEND_ERROR "Error, the given CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
1393 " is not in the list of valid values \"${CMAKE_BUILD_TYPES_LIST}\"!")
1394 endif()
1395 endif()
1396 print_var(CMAKE_BUILD_TYPE)
1397
1398 # Override the silly CMAKE_CONFIGURATION_TYPES variable. This is needed for
1399 # MSVS! Later, we Override CMAKE_CONFIGURATION_TYPES to just one
1400 # configuration after the compiler checks (see below).
1401 if (CMAKE_CONFIGURATION_TYPES)
1402 if (CMAKE_BUILD_TYPE STREQUAL "DEBUG")
1403 set(CMAKE_CONFIGURATION_TYPE "Debug")
1404 elseif(CMAKE_BUILD_TYPE STREQUAL "RELEASE")
1405 set(CMAKE_CONFIGURATION_TYPE "Release")
1406 else()
1407 set(CMAKE_CONFIGURATION_TYPE "Release")
1408 endif()
1409 else()
1410 set(CMAKE_CONFIGURATION_TYPE "")
1411 endif()
1412 if (TRIBITS_SETUP_ENV_DEBUG)
1413 print_var(CMAKE_CONFIGURATION_TYPE)
1414 endif()
1415
1416 # Set up MPI if MPI is being used
1417
1418 if ("${TPL_ENABLE_MPI}" STREQUAL "")
1419 # If TPL_ENABLE_MPI is undefined or empty because this project does not
1420 # define an MPI TPL, then explicitly disable it.
1421 set(TPL_ENABLE_MPI FALSE)
1422 endif()
1423
1424 if (TPL_ENABLE_MPI)
1425 tribits_setup_mpi()
1426 endif()
1427
1428 # Enable compilers
1429
1430 assert_defined(${PROJECT_NAME}_ENABLE_C)
1431 if (${PROJECT_NAME}_ENABLE_C)
1432 enable_language(C)
1433 include(CMakeDetermineCCompiler)
1434 print_var(CMAKE_C_COMPILER_ID)
1435 print_var(CMAKE_C_COMPILER_VERSION)
1436 # See CMake/Modules/CMakeCXXCompilerId.cpp.in in the CMake source
1437 # directory for a listing of known compiler types.
1438 endif()
1439
1440 assert_defined(${PROJECT_NAME}_ENABLE_CXX)
1441 if (${PROJECT_NAME}_ENABLE_CXX)
1442 enable_language(CXX)
1443 include(CMakeDetermineCXXCompiler)
1444 print_var(CMAKE_CXX_COMPILER_ID)
1445 print_var(CMAKE_CXX_COMPILER_VERSION)
1446 # See CMake/Modules/CMakeCXXCompilerId.cpp.in in the CMake source
1447 # directory for a listing of known compiler types.
1448 endif()
1449
1450 assert_defined(${PROJECT_NAME}_ENABLE_Fortran)
1451 if (${PROJECT_NAME}_ENABLE_Fortran)
1452 enable_language(Fortran)
1453 endif()
1454
1455 # Do some project-specific tweaks for compiler options, etc.
1456 set(PROJECT_COMPILER_CONFIG_FILE
1457 # Can be used for things like Kokkos.
1458 "${${PROJECT_NAME}_SOURCE_DIR}/cmake/ProjectCompilerPostConfig.cmake"
1459 CACHE FILEPATH
1460 "Allow for project-specific compiler settings."
1461 )
1462 if (EXISTS "${PROJECT_COMPILER_CONFIG_FILE}")
1463 tribits_trace_file_processing(PROJECT INCLUDE "${PROJECT_COMPILER_CONFIG_FILE}")
1464 include("${PROJECT_COMPILER_CONFIG_FILE}")
1465 endif()
1466
1467 # Set up C++ language standard selection.
1468 if (NOT CMAKE_CXX_STANDARD)
1469 set(CMAKE_CXX_STANDARD 11)
1470 elseif (NOT CMAKE_CXX_STANDARD MATCHES "^(11|14|17|20)$")
1471 message(FATAL_ERROR "CMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD} is not 11, 14, 17, or 20.")
1472 ENDIF ()
1473 set(${PROJECT_NAME}_CXX_STANDARD_FEATURE cxx_std_${CMAKE_CXX_STANDARD})
1474 if (NOT DEFINED CMAKE_CXX_STANDARD_REQUIRED)
1475 set(CMAKE_CXX_STANDARD_REQUIRED ON)
1476 ENDIF ()
1477 if (NOT DEFINED CMAKE_CXX_EXTENSIONS)
1478 set(CMAKE_CXX_EXTENSIONS OFF)
1479 ENDIF ()
1480
1481 # Set up for strong compiler warnings and warnings as errors
1482
1483 include(TribitsSetupBasicCompileLinkFlags)
1484 tribits_setup_basic_compile_link_flags()
1485
1486 #
1487 # The compilers are set, the environment is known to CMake. Now set the
1488 # installation paths and options.
1489 #
1490 tribits_setup_installation_paths()
1491
1492 # Set up Windows interface stuff
1493
1494 if (MSVC)
1495 add_definitions(-D_CRT_SECURE_NO_DEPRECATE
1496 -D_CRT_NONSTDC_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS)
1497 set(WIN_INTERFACE_INCL ${${PROJECT_NAME}_TRIBITS_DIR}/win_interface/include)
1498 if (EXISTS "${WIN_INTERFACE_INCL}")
1499 include_directories("${WIN_INTERFACE_INCL}")
1500 if (TRIBITS_SETUP_ENV_DEBUG)
1501 message("-- Adding win_interface/include ...")
1502 endif()
1503 endif()
1504 endif()
1505
1506 if (WIN32 AND NOT CYGWIN)
1507 set(NATIVE_MS_WINDOWS TRUE)
1508 else()
1509 set(NATIVE_MS_WINDOWS FALSE)
1510 endif()
1511
1512 # Probe for non-standard headers
1513
1514 if (${PROJECT_NAME}_ENABLE_CXX)
1515 check_include_file_cxx(sys/time.h HAVE_SYS_TIME_H)
1516 check_include_file_cxx(time.h HAVE_TIME_H)
1517 check_include_file_cxx(stdint.h HAVE_STDINT_H)
1518 check_include_file_cxx(inttypes.h HAVE_INTTYPES_H)
1519 endif()
1520
1521 set(HAVE_ALGORITHM TRUE)
1522 set(HAVE_CASSERT TRUE)
1523 set(HAVE_CCTYPE TRUE)
1524 set(HAVE_CERRNO TRUE)
1525 set(HAVE_CLIMITS TRUE)
1526 set(HAVE_CMATH TRUE)
1527 set(HAVE_COMPLEX TRUE)
1528 set(HAVE_CSTDARG TRUE)
1529 set(HAVE_CSTDIO TRUE)
1530 set(HAVE_CSTDLIB TRUE)
1531 set(HAVE_CSTRING TRUE)
1532 set(HAVE_IOMANIP TRUE)
1533 set(HAVE_IOSTREAM TRUE)
1534 set(HAVE_ITERATOR TRUE)
1535 set(HAVE_LIST TRUE)
1536 set(HAVE_MAP TRUE)
1537 set(HAVE_MEMORY TRUE)
1538 set(HAVE_MUTABLE TRUE)
1539 set(HAVE_NAMESPACES TRUE)
1540 set(HAVE_NEW_FOR_SCOPING TRUE)
1541 set(HAVE_NUMERIC TRUE)
1542 set(HAVE_NUMERIC_LIMITS TRUE)
1543 set(HAVE_POW TRUE)
1544 set(HAVE_SET TRUE)
1545 set(HAVE_SSTREAM TRUE)
1546 set(HAVE_FSTREAM TRUE)
1547 set(HAVE_STDEXCEPT TRUE)
1548 set(HAVE_STRING TRUE)
1549 set(HAVE_VECTOR TRUE)
1550
1551 # 2008/12/20: rabartl: Above: All of these defines should be removed
1552 # because we decided that we were going to assume that all compilers
1553 # have these C++98 standard features. We will deal with cases where
1554 # this is not true but we should not assume the worst right from the
1555 # beginning.
1556
1557 # Find Perl
1558
1559 find_package(Perl)
1560
1561 # Do Fortran stuff
1562
1563 include(TribitsFortranMangling)
1564
1565 # Get BLAS name mangling
1566 #
1567 # ToDo: Make this a project-specific specialization
1568
1569 include(TribitsBLASMangling)
1570
1571 # Set up some MPI info
1572
1573 if (TPL_ENABLE_MPI)
1574 set(HAVE_MPI TRUE)
1575 else()
1576 set(HAVE_MPI FALSE)
1577 endif()
1578
1579 # OpenMP isn't really a TPL because support is built into the compiler.
1580 if(${PROJECT_NAME}_ENABLE_OpenMP)
1581 find_package(OpenMP)
1582 if(OPENMP_FOUND)
1583 tribits_set_openmp_flags(CXX)
1584 tribits_set_openmp_flags(C)
1585 if(OpenMP_Fortran_FLAGS)
1586 tribits_set_openmp_flags(Fortran)
1587 else()
1588 # Older versions of FindOpenMP.cmake don't find Fortran flags. Mike H said this is safe.
1589 set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${OpenMP_C_FLAGS}")
1590 endif()
1591 else()
1592 message(FATAL_ERROR "Could not find OpenMP, try setting OpenMP_C_FLAGS and OpenMP_CXX_FLAGS directly")
1593 endif(OPENMP_FOUND)
1594 endif(${PROJECT_NAME}_ENABLE_OpenMP)
1595
1596 # Check if we need the math library or not and find the right one
1597 if (NOT NATIVE_MS_WINDOWS)
1598 include(MathLibraryNeeded)
1599 endif()
1600
1601 # Check for isnan and isinf support
1602 if (${PROJECT_NAME}_ENABLE_CXX)
1603 include(FiniteValue)
1604 endif()
1605
1606 # Check for Doxygen/dot - We can use variables set in this check to
1607 # enable/disable the graphical dependency graphs in doxygen Doxyfiles.
1608 include(FindDoxygen)
1609
1610 # You have to override the configuration types for MSVS after the compiler
1611 # checks!
1612 set(CMAKE_CONFIGURATION_TYPES ${CMAKE_CONFIGURATION_TYPE}
1613 CACHE STRING
1614 "Override by TriBITS (see TribitsDevelopersGuilde.*)"
1615 FORCE)
1616 if (CMAKE_CONFIGURATION_TYPES)
1617 print_var(CMAKE_CONFIGURATION_TYPES)
1618 endif()
1619
1620 tribits_config_code_stop_timer(SETUP_ENV_TIME_START_SECONDS
1621 "\nTotal time to probe and setup the environment")
1622
1623 # Set ninja compile and link parallel job limits
1624
1625 if (${PROJECT_NAME}_PARALLEL_COMPILE_JOBS_LIMIT)
1626 set_property(GLOBAL APPEND PROPERTY JOB_POOLS
1627 compile_job_pool=${${PROJECT_NAME}_PARALLEL_COMPILE_JOBS_LIMIT})
1628 set(CMAKE_JOB_POOL_COMPILE compile_job_pool)
1629 endif()
1630
1631 if (${PROJECT_NAME}_PARALLEL_LINK_JOBS_LIMIT)
1632 set_property(GLOBAL APPEND PROPERTY JOB_POOLS
1633 link_job_pool=${${PROJECT_NAME}_PARALLEL_LINK_JOBS_LIMIT})
1634 set(CMAKE_JOB_POOL_LINK link_job_pool)
1635 endif()
1636
1637 endmacro()
1638
1639
1640 macro(tribits_set_openmp_flags LANG)
1641 if (NOT "${OpenMP_${LANG}_FLAGS_OVERRIDE}" STREQUAL "")
1642 set(CMAKE_${LANG}_FLAGS "${CMAKE_${LANG}_FLAGS} ${OpenMP_${LANG}_FLAGS_OVERRIDE}")
1643 else()
1644 set(CMAKE_${LANG}_FLAGS "${CMAKE_${LANG}_FLAGS} ${OpenMP_${LANG}_FLAGS}")
1645 endif()
1646 endmacro()
1647
1648
1649 # Set mapping of labels to subprojects (i.e. TriBITS packages) for local CTest
1650 # only
1651 #
1652 # NOTE: This macro is only used define mapping of labels to subprojects for
1653 # running ctest locally. This results in summarizing the tests run for each
1654 # subproject (TriBITS package) if any tests were run. Therefore, it is
1655 # harmless to define the mapping for every TriBITS package. Only TriBITS
1656 # packages will be listed in the summary if they had one or more tests run.
1657 #
1658 macro(tribits_set_labels_to_subprojects_mapping)
1659 set(CTEST_LABELS_FOR_SUBPROJECTS ${${PROJECT_NAME}_DEFINED_INTERNAL_TOPLEVEL_PACKAGES})
1660 endmacro()
1661
1662
1663 # Macro to turn on CTest support
1664 #
1665 macro(tribits_include_ctest_support)
1666
1667 set(DART_TESTING_TIMEOUT_IN ${DART_TESTING_TIMEOUT})
1668
1669 if (DART_TESTING_TIMEOUT_IN)
1670 tribits_scale_timeout(${DART_TESTING_TIMEOUT} DART_TESTING_TIMEOUT)
1671 if (NOT DART_TESTING_TIMEOUT STREQUAL DART_TESTING_TIMEOUT_IN)
1672 message("-- DART_TESTING_TIMEOUT=${DART_TESTING_TIMEOUT_IN} being scaled by ${PROJECT_NAME}_SCALE_TEST_TIMEOUT=${${PROJECT_NAME}_SCALE_TEST_TIMEOUT} to ${DART_TESTING_TIMEOUT}")
1673 endif()
1674 # Have to set DART_TESTING_TIMEOUT in cache or CMake will not put in right
1675 # 'TimeOut' in DartConfiguration.tcl file!
1676 set(DART_TESTING_TIMEOUT ${DART_TESTING_TIMEOUT} CACHE STRING "" FORCE)
1677 endif()
1678
1679 # Set up CTEst/CDash subprojects
1680 tribits_set_labels_to_subprojects_mapping()
1681 # NOTE: We do this after all of the packages have been defined but before
1682 # the DartConfiguration.tcl file has been created.
1683
1684 include(CTest) # Generates file DartConfiguration.tcl with 'TimeOut' set!
1685
1686 if (DART_TESTING_TIMEOUT_IN)
1687 # Put DART_TESTING_TIMEOUT back to user input value to avoid scaling this
1688 # up and up on recofigures!
1689 set(DART_TESTING_TIMEOUT ${DART_TESTING_TIMEOUT_IN} CACHE STRING
1690 "Original value set by user reset by TriBITS after scaling" FORCE)
1691 endif()
1692
1693 tribits_configure_ctest_custom(${${PROJECT_NAME}_SOURCE_DIR}
1694 ${${PROJECT_NAME}_BINARY_DIR})
1695
1696 tribits_add_test_helpers_init()
1697
1698 endmacro()
1699 # NOTE: The above logic with DART_TESTING_TIMEOUT is a huge hack. For some
1700 # reason, on the first configure CMake will not put the local value of the
1701 # scaled DART_TESTING_TIMEOUT variable into the DartConfiguration.tcl.
1702 # Instead, it uses the value of DART_TESTING_TIMEOUT that is in the cache.
1703 # But on reconfigures, CMake uses the value of the local variable
1704 # DART_TESTING_TIMEOUT and ignores the value in the cache (very irritating).
1705 # Therefore, to get CMake to put in the right value for 'TimeOut', you have to
1706 # force-set DART_TESTING_TIMEOUT in the cache on the first configure. But to
1707 # avoid rescaling DART_TESTING_TIMEOUT up and up on reconfigures, you have to
1708 # force-set DART_TESTING_TIMEOUT back to the user's input value. The only
1709 # disadvantage of this approach (other than it is a hack to get around a CMake
1710 # bug) is that you loose the user's documentation string, in case they set
1711 # that with a set( ... CACHE ...) statement in an input *.cmake file.
1712
1713
1714 # Determines if a package should be processed
1715 #
1716 function(tribits_determine_if_process_package PACKAGE_NAME
1717 PROCESS_PACKAGE_OUT PACKAGE_ENABLE_STR_OUT
1718 )
1719
1720 set(PROCESS_PACKAGE FALSE)
1721 set(PACKAGE_ENABLE_STR "")
1722
1723 if (${PACKAGE_NAME}_SUBPACKAGES)
1724 # Process the package if any of the subpackages are enable
1725 foreach(TRIBITS_SUBPACKAGE ${${PACKAGE_NAME}_SUBPACKAGES})
1726 set(SUBPACKAGE_FULLNAME ${PACKAGE_NAME}${TRIBITS_SUBPACKAGE})
1727 if (${PROJECT_NAME}_ENABLE_${SUBPACKAGE_FULLNAME})
1728 set(PROCESS_PACKAGE TRUE)
1729 append_string_var_with_sep(PACKAGE_ENABLE_STR ", " ${TRIBITS_SUBPACKAGE})
1730 endif()
1731 endforeach()
1732 else()
1733 # If the package itself is enabled, of course process it
1734 if (${PROJECT_NAME}_ENABLE_${PACKAGE_NAME})
1735 set(PROCESS_PACKAGE TRUE)
1736 append_string_var_with_sep(PACKAGE_ENABLE_STR ", " "Libs")
1737 endif()
1738 endif()
1739
1740 # If subpackages or package is enabled, then check tests/examples
1741 if (PROCESS_PACKAGE)
1742 if (${PACKAGE_NAME}_ENABLE_TESTS)
1743 append_string_var_with_sep(PACKAGE_ENABLE_STR ", " "Tests")
1744 endif()
1745 if (${PACKAGE_NAME}_ENABLE_EXAMPLES)
1746 append_string_var_with_sep(PACKAGE_ENABLE_STR ", " "Examples")
1747 endif()
1748 endif()
1749
1750 set(${PROCESS_PACKAGE_OUT} ${PROCESS_PACKAGE} PARENT_SCOPE)
1751 set(${PACKAGE_ENABLE_STR_OUT} ${PACKAGE_ENABLE_STR} PARENT_SCOPE)
1752
1753 endfunction()
1754
1755
1756 # Reads in the project's version file into the current scope
1757 #
1758 macro(tribits_project_read_version_file PROJECT_SOURCE_DIR_IN)
1759 set(PROJECT_VERSION_FILE ${PROJECT_SOURCE_DIR_IN}/Version.cmake)
1760 if (EXISTS ${PROJECT_VERSION_FILE})
1761 # Set REPOSITORY_NAME in case Version.cmake is written generically!
1762 set(REPOSITORY_NAME ${PROJECT_NAME})
1763 tribits_trace_file_processing(PROJECT INCLUDE "${PROJECT_VERSION_FILE}")
1764 include(${PROJECT_VERSION_FILE})
1765 endif()
1766 endmacro()
1767
1768
1769 # Read in and the Repository's specific Version.cmake file and then configure
1770 # its ${REPO_NAME}_version.h file.
1771 #
1772 # The file ${REPO_NAME}_version.h is only configured if the repository contains
1773 # the files Version.cmake and Copyright.txt
1774 #
1775 # NOTE: This is done as a function so that the read-in version variables don't
1776 # bleed into the outer scope.
1777 #
1778 function(tribits_repository_configure_version_header_file
1779 REPOSITORY_NAME REPOSITORY_DIR ADD_INSTALL_TARGET
1780 OUTPUT_VERSION_HEADER_FILE
1781 )
1782
1783 if (TRIBITS_REPOSITORY_CONFIGURE_VERSION_HEADER_FILE_DEBUG_DUMP)
1784 message("TRIBITS_REPOSITORY_CONFIGURE_VERSION_HEADER_FILE: "
1785 "'${REPOSITORY_NAME}' '${REPOSITORY_DIR}"
1786 " '${OUTPUT_VERSION_HEADER_FILE}'")
1787 endif()
1788
1789 string(TOUPPER ${REPOSITORY_NAME} REPOSITORY_NAME_UC)
1790
1791 tribits_set_base_repo_dir(${PROJECT_SOURCE_DIR} ${REPOSITORY_DIR}
1792 REPOSITORY_ABS_DIR)
1793
1794 set(REPOSITORY_VERSION_FILE ${REPOSITORY_ABS_DIR}/Version.cmake)
1795 set(REPOSITORY_COPYRIGHT_FILE ${REPOSITORY_ABS_DIR}/Copyright.txt)
1796
1797 if (EXISTS ${REPOSITORY_VERSION_FILE} AND EXISTS ${REPOSITORY_COPYRIGHT_FILE})
1798
1799 # Read the copyright header info
1800 tribits_trace_file_processing(REPOSITORY READ "${REPOSITORY_COPYRIGHT_FILE}")
1801 file(READ "${REPOSITORY_COPYRIGHT_FILE}" REPOSITORY_COPYRIGHT_HEADER)
1802
1803 # Read the version variables and translate into standard form
1804 tribits_trace_file_processing(REPOSITORY INCLUDE "${REPOSITORY_VERSION_FILE}")
1805 include(${REPOSITORY_VERSION_FILE})
1806 set(REPOSITORY_MAJOR_VERSION ${${REPOSITORY_NAME}_MAJOR_VERSION})
1807 set(REPOSITORY_MAJOR_MINOR_VERSION ${${REPOSITORY_NAME}_MAJOR_MINOR_VERSION})
1808 set(REPOSITORY_VERSION_STRING ${${REPOSITORY_NAME}_VERSION_STRING})
1809
1810 # Configure the file with everything set
1811 if (TRIBITS_REPOSITORY_CONFIGURE_VERSION_HEADER_FILE_DEBUG_DUMP)
1812 message("-- Writing the file ${OUTPUT_VERSION_HEADER_FILE} ...")
1813 endif()
1814 tribits_trace_file_processing(REPOSITORY CONFIGURE "${OUTPUT_VERSION_HEADER_FILE}")
1815 configure_file(
1816 ${${PROJECT_NAME}_TRIBITS_DIR}/${TRIBITS_CMAKE_PACKAGE_ARCH_DIR}/Tribits_version.h.in
1817 ${OUTPUT_VERSION_HEADER_FILE})
1818
1819 if (ADD_INSTALL_TARGET)
1820 # Install version header file
1821 tribits_install_headers(HEADERS ${OUTPUT_VERSION_HEADER_FILE})
1822 endif()
1823
1824 endif()
1825
1826 endfunction()
1827
1828
1829 # Configure each of the Repositories' version header file
1830 #
1831 function(tribits_repository_configure_all_version_header_files)
1832 #print_var(ARGN)
1833 foreach(REPO ${ARGN})
1834 tribits_get_repo_name_dir(${REPO} REPO_NAME REPO_DIR)
1835 if (${PROJECT_NAME}_VERBOSE_CONFIGURE)
1836 message("Considering configuring version file for '${REPO_NAME}'")
1837 endif()
1838 tribits_repository_configure_version_header_file( ${REPO_NAME} ${REPO_DIR} TRUE
1839 "${${PROJECT_NAME}_BINARY_DIR}/${REPO_DIR}/${REPO_NAME}_version.h")
1840 endforeach()
1841 endfunction()
1842
1843
1844 # Generate the VersionDate.cmake and ${REPO_NAME}_version_date.h files for a
1845 # TriBITS Repository
1846 #
1847 # NOTE: This is done as a function so that the read-in version variables don't
1848 # bleed into the outer scope.
1849 #
1850 function(tribits_repository_configure_version_date_files
1851 REPOSITORY_NAME REPOSITORY_DIR ADD_INSTALL_TARGET
1852 )
1853
1854 if (TRIBITS_REPOSITORY_CONFIGURE_VERSION_DATE_FILES_DEBUG_DUMP)
1855 message("TRIBITS_REPOSITORY_CONFIGURE_VERSION_DATE_FILES: "
1856 "'${REPOSITORY_NAME}' '${REPOSITORY_DIR}" )
1857 endif()
1858
1859 string(TOUPPER ${REPOSITORY_NAME} REPOSITORY_NAME_UC)
1860
1861 tribits_set_base_repo_dir(${PROJECT_SOURCE_DIR} ${REPOSITORY_DIR}
1862 REPO_SOURCE_ABS_DIR)
1863
1864 tribits_set_base_repo_dir(${PROJECT_BINARY_DIR} ${REPOSITORY_DIR}
1865 REPO_BINARY_ABS_DIR)
1866
1867 set(REPO_GIT_VERSION_DATE)
1868 if (NOT IS_DIRECTORY "${REPO_SOURCE_ABS_DIR}/.git")
1869 message("-- NOTE: Can't fill in version date files for ${REPOSITORY_NAME} since"
1870 " ${REPO_SOURCE_ABS_DIR}/.git/ does not exist!")
1871 elseif (GIT_VERSION_STRING VERSION_LESS "2.10.0")
1872 message("-- NOTE: Can't fill in version date files for ${REPOSITORY_NAME} since"
1873 " GIT_VERSION_STRING=${GIT_VERSION_STRING} < 2.10.0")
1874 else()
1875 # Generate the version date integer
1876 tribits_get_raw_git_commit_utc_time("${REPO_SOURCE_ABS_DIR}" "HEAD"
1877 REPO_GIT_COMMIT_UTC_TIME)
1878 tribits_get_version_date_from_raw_git_commit_utc_time("${REPO_GIT_COMMIT_UTC_TIME}"
1879 REPO_GIT_VERSION_DATE )
1880 endif()
1881
1882 if (REPO_GIT_VERSION_DATE)
1883 # Configure the VersionDate.cmake file in the repo binary dir and include it
1884 set(REPO_VERSION_DATE_CMAKE_FILE "${REPO_BINARY_ABS_DIR}/VersionDate.cmake")
1885 configure_file(
1886 "${${PROJECT_NAME}_TRIBITS_DIR}/${TRIBITS_CMAKE_PACKAGE_ARCH_DIR}/VersionDate.cmake.in"
1887 "${REPO_VERSION_DATE_CMAKE_FILE}" )
1888 tribits_trace_file_processing(REPOSITORY INCLUDE "${REPO_VERSION_DATE_CMAKE_FILE}")
1889 include(${REPO_VERSION_DATE_CMAKE_FILE})
1890 endif()
1891
1892 # Configure the <RepoName>_version_date.h file in the repo binary dir
1893 if (REPO_GIT_VERSION_DATE)
1894 set(REPOSITORY_VERSION_DATE_MACRO_DEF
1895 "#define ${REPOSITORY_NAME_UC}_VERSION_DATE ${REPO_GIT_VERSION_DATE}" )
1896 else()
1897 set(REPOSITORY_VERSION_DATE_MACRO_DEF
1898 "#undef ${REPOSITORY_NAME_UC}_VERSION_DATE" )
1899 endif()
1900 set(REPO_VERSION_DATE_HEADER_FILE "${REPO_BINARY_ABS_DIR}/${REPOSITORY_NAME}_version_date.h")
1901 tribits_trace_file_processing(REPOSITORY CONFIGURE "${REPO_VERSION_DATE_HEADER_FILE}")
1902 configure_file(
1903 "${${PROJECT_NAME}_TRIBITS_DIR}/${TRIBITS_CMAKE_PACKAGE_ARCH_DIR}/Tribits_version_date.h.in"
1904 "${REPO_VERSION_DATE_HEADER_FILE}" )
1905
1906 # Add the install target for <RepoName>_version_date.h
1907 if (ADD_INSTALL_TARGET)
1908 tribits_install_headers(HEADERS ${REPO_VERSION_DATE_HEADER_FILE})
1909 endif()
1910
1911 endfunction()
1912
1913
1914 # Configure each of the Repositories' version date files
1915 #
1916 function(tribits_repository_configure_all_version_date_files)
1917 #print_var(ARGN)
1918 if (${PROJECT_NAME}_GENERATE_VERSION_DATE_FILES)
1919 foreach(REPO ${ARGN})
1920 tribits_get_repo_name_dir(${REPO} REPO_NAME REPO_DIR)
1921 if (${PROJECT_NAME}_VERBOSE_CONFIGURE)
1922 message("Considering configuring version date files for '${REPO_NAME}'")
1923 endif()
1924 tribits_repository_configure_version_date_files(${REPO_NAME} ${REPO_DIR} TRUE)
1925 endforeach()
1926 endif()
1927 endfunction()
1928
1929
1930 # Configure the enabled packages
1931 #
1932 # This macro actually calls add_subdirectory(<packageDir>) on the enabled
1933 # TriBITS packages.
1934 #
1935 macro(tribits_configure_enabled_packages)
1936
1937 tribits_config_code_start_timer(CONFIGURE_PACKAGES_TIME_START_SECONDS)
1938
1939 #
1940 # A) Global variable initialization
1941 #
1942
1943 global_null_set(${PROJECT_NAME}_LIBRARIES "")
1944 global_null_set(${PROJECT_NAME}_ETI_PACKAGES "")
1945
1946 #
1947 # B) Define the source and binary directories for all of the packages that
1948 # have been enabled. These are used to allow packages to refer to each
1949 # other even downstream packages (which is pretty messed up really).
1950 #
1951
1952 tribits_filter_package_list_from_var(${PROJECT_NAME}_DEFINED_TOPLEVEL_PACKAGES
1953 INTERNAL ON NONEMPTY ${PROJECT_NAME}_enabledInternalTopLevelPackages)
1954
1955 foreach(TRIBITS_PACKAGE IN LISTS ${PROJECT_NAME}_enabledInternalTopLevelPackages)
1956
1957 # Get all the package sources independent of whether they are enabled or not.
1958 # There are some messed up packages that grab parts out of unrelated
1959 # downstream packages that might not even be enabled. To support this,
1960 # allow this.
1961
1962 tribits_determine_if_process_package(${TRIBITS_PACKAGE}
1963 PROCESS_PACKAGE PACKAGE_ENABLE_STR)
1964
1965 if (PROCESS_PACKAGE)
1966
1967 if (${TRIBITS_PACKAGE}_SPECIFIED_BINARY_DIR)
1968 if (${PROJECT_NAME}_VERBOSE_CONFIGURE)
1969 print_var(${TRIBITS_PACKAGE}_SPECIFIED_BINARY_DIR)
1970 endif()
1971 if(IS_ABSOLUTE ${${TRIBITS_PACKAGE}_SPECIFIED_BINARY_DIR})
1972 set(${TRIBITS_PACKAGE}_BINARY_DIR ${${TRIBITS_PACKAGE}_SPECIFIED_BINARY_DIR})
1973 else()
1974 set(${TRIBITS_PACKAGE}_BINARY_DIR
1975 ${CMAKE_CURRENT_BINARY_DIR}/${${TRIBITS_PACKAGE}_SPECIFIED_BINARY_DIR})
1976 endif()
1977 else()
1978 set(${TRIBITS_PACKAGE}_BINARY_DIR
1979 ${CMAKE_CURRENT_BINARY_DIR}/${${TRIBITS_PACKAGE}_REL_SOURCE_DIR})
1980 endif()
1981 if (${PROJECT_NAME}_VERBOSE_CONFIGURE)
1982 print_var(${TRIBITS_PACKAGE}_BINARY_DIR)
1983 endif()
1984
1985 endif()
1986
1987 endforeach()
1988
1989 #
1990 # C) Loop over all of the packages and process their CMakeLists.txt files if
1991 # they are enabled or if any of their subpackages are enabled.
1992 #
1993
1994 # Include these here so they don't need to be included in each package's
1995 # CMakeLists.txt files.
1996 include(TribitsPackageMacros)
1997 include(TribitsSubPackageMacros)
1998 include(AddSubdirectories)
1999
2000 set(CONFIGURED_A_PACKAGE FALSE)
2001 set(ENABLED_PACKAGE_LIBS_TARGETS)
2002
2003 # Tell packages that are also repos they are being processed as a package.
2004 set(TRIBITS_PROCESSING_PACKAGE TRUE)
2005
2006 foreach(TRIBITS_PACKAGE IN LISTS ${PROJECT_NAME}_enabledInternalTopLevelPackages)
2007
2008 tribits_determine_if_process_package(${TRIBITS_PACKAGE}
2009 PROCESS_PACKAGE PACKAGE_ENABLE_STR)
2010
2011 if (PROCESS_PACKAGE)
2012
2013 message("Processing enabled top-level package: ${TRIBITS_PACKAGE} (${PACKAGE_ENABLE_STR})")
2014
2015 if (NOT ${PROJECT_NAME}_TRACE_DEPENDENCY_HANDLING_ONLY)
2016
2017 tribits_package_config_code_start_timer(PROCESS_THIS_PACKAGE_TIME_START_SECONDS)
2018
2019 set(PACKAGE_NAME ${TRIBITS_PACKAGE}) # Used in CMake code in downstream package
2020 set(PARENT_PACKAGE_NAME ${TRIBITS_PACKAGE})
2021 string(TOUPPER "${PARENT_PACKAGE_NAME}" PARENT_PACKAGE_NAME_UC)
2022
2023 if (NOT EXISTS ${${TRIBITS_PACKAGE}_SOURCE_DIR}/CMakeLists.txt)
2024 message(FATAL_ERROR
2025 "Error, the file ${${TRIBITS_PACKAGE}_SOURCE_DIR}/CMakeLists.txt does not exist!")
2026 endif()
2027
2028 if (${PROJECT_NAME}_VERBOSE_CONFIGURE)
2029 print_var(${TRIBITS_PACKAGE}_SOURCE_DIR)
2030 print_var(${TRIBITS_PACKAGE}_BINARY_DIR)
2031 endif()
2032
2033 set(TRIBITS_PACKAGE_CMAKELIST_FILE
2034 "${${TRIBITS_PACKAGE}_SOURCE_DIR}/CMakeLists.txt")
2035 tribits_trace_file_processing(PACKAGE ADD_SUBDIR
2036 "${TRIBITS_PACKAGE_CMAKELIST_FILE}")
2037 if (NOT ${TRIBITS_PACKAGE}_SOURCE_DIR STREQUAL ${PROJECT_NAME}_SOURCE_DIR)
2038 add_subdirectory(${${TRIBITS_PACKAGE}_SOURCE_DIR}
2039 ${${TRIBITS_PACKAGE}_BINARY_DIR})
2040 else()
2041 include("${TRIBITS_PACKAGE_CMAKELIST_FILE}")
2042 endif()
2043 if ((NOT ${PACKAGE_NAME}_TRIBITS_PACKAGE_POSTPROCESS) AND
2044 (NOT TARGET ${PACKAGE_NAME}::all_libs)
2045 )
2046 tribits_report_invalid_tribits_usage(
2047 "ERROR: Forgot to call tribits_package_postprocess() in"
2048 " ${TRIBITS_PACKAGE_CMAKELIST_FILE}")
2049 endif()
2050
2051 list(APPEND ENABLED_PACKAGE_LIBS_TARGETS ${TRIBITS_PACKAGE}::all_libs)
2052 list(APPEND ${PROJECT_NAME}_LIBRARIES ${${TRIBITS_PACKAGE}_LIBRARIES})
2053
2054 tribits_package_config_code_stop_timer(PROCESS_THIS_PACKAGE_TIME_START_SECONDS
2055 "-- Total time to configure top-level package ${TRIBITS_PACKAGE}")
2056
2057 endif()
2058
2059 set(CONFIGURED_A_PACKAGE TRUE)
2060
2061 endif()
2062
2063 endforeach()
2064
2065 #
2066 # D) Loop backwards over ETI packages if ETI is enabled
2067 #
2068
2069 if (NOT ${PROJECT_NAME}_TRACE_DEPENDENCY_HANDLING_ONLY)
2070
2071 # Do this regardless of whether project level ETI is enabled
2072 if("${${PROJECT_NAME}_ETI_PACKAGES}" STREQUAL "")
2073 message("\nNo ETI support requested by packages.\n")
2074 else()
2075 #if(${PROJECT_NAME}_VERBOSE_CONFIGURE)
2076 message("\nProcessing explicit instantiation support for enabled packages ...\n")
2077 #endif()
2078 set(REVERSE_ETI_LIST ${${PROJECT_NAME}_ETI_PACKAGES})
2079 list(REVERSE REVERSE_ETI_LIST)
2080 foreach(PACKAGE_NAME ${REVERSE_ETI_LIST})
2081 message("Processing ETI support: ${PACKAGE_NAME}")
2082 tribits_package_config_code_start_timer(PROCESS_ETI_START_SECONDS)
2083 set(ETIFILE
2084 ${${PACKAGE_NAME}_SOURCE_DIR}/cmake/ExplicitInstantiationSupport.cmake)
2085 if(NOT EXISTS "${ETIFILE}")
2086 message(FATAL_ERROR
2087 "Could not find ${PACKAGE_NAME} ETI support file ${ETIFILE}")
2088 endif()
2089 tribits_trace_file_processing(PACKAGE INCLUDE "${ETIFILE}")
2090 include("${ETIFILE}")
2091 tribits_package_config_code_stop_timer(PROCESS_ETI_START_SECONDS
2092 "-- Time to process ETI support for package ${PACKAGE_NAME}")
2093 endforeach()
2094 endif()
2095
2096 endif()
2097
2098 #
2099 # E) Check if no packages are enabled and if that is allowed
2100 #
2101
2102 advanced_set( ${PROJECT_NAME}_ALLOW_NO_PACKAGES ON
2103 CACHE BOOL "Allow configuration to finish even if no packages are enabled")
2104
2105 if (NOT CONFIGURED_A_PACKAGE)
2106 if (${PROJECT_NAME}_ALLOW_NO_PACKAGES)
2107 set(MSG_TYPE WARNING)
2108 else()
2109 set(MSG_TYPE ERROR)
2110 endif()
2111 message(
2112 "\n***"
2113 "\n*** ${MSG_TYPE}: There were no packages configured so no libraries"
2114 " or tests/examples will be built!"
2115 "\n***\n"
2116 )
2117 if (NOT ${PROJECT_NAME}_ALLOW_NO_PACKAGES)
2118 message(SEND_ERROR "Stopping configure!")
2119 endif()
2120 else()
2121 assert_and_touch_defined(${PROJECT_NAME}_ALLOW_NO_PACKAGES)
2122 endif()
2123
2124 #
2125 # F) Process the global variables and other cleanup
2126 #
2127
2128 if (NOT ${PROJECT_NAME}_TRACE_DEPENDENCY_HANDLING_ONLY)
2129
2130 remove_global_duplicates(${PROJECT_NAME}_LIBRARIES)
2131
2132 # Add global 'libs' target
2133 if(ENABLED_PACKAGE_LIBS_TARGETS)
2134 list(REVERSE ENABLED_PACKAGE_LIBS_TARGETS)
2135 # Make it so when no packages are enabled it is not a cmake error
2136 if (NOT TARGET ${PROJECT_NAME}_libs)
2137 add_custom_target(${PROJECT_NAME}_libs)
2138 add_dependencies(${PROJECT_NAME}_libs ${ENABLED_PACKAGE_LIBS_TARGETS})
2139 endif()
2140 add_custom_target(libs)
2141 add_dependencies(libs ${ENABLED_PACKAGE_LIBS_TARGETS})
2142 endif()
2143
2144 # Add empty <PackageName>_libs targets for top-level packages if asked
2145 if (${PROJECT_NAME}_DEFINE_MISSING_PACKAGE_LIBS_TARGETS)
2146 foreach(TRIBITS_PACKAGE ${${PROJECT_NAME}_DEFINED_INTERNAL_TOPLEVEL_PACKAGES})
2147 if (NOT TARGET ${TRIBITS_PACKAGE}_libs)
2148 add_custom_target(${TRIBITS_PACKAGE}_libs
2149 COMMENT "Dummy target for ${TRIBITS_PACKAGE}_libs that builds nothing!")
2150 endif()
2151 endforeach()
2152 endif()
2153 # NOTE: For motivation for above, see the comment about the setting of
2154 # ${PROJECT_NAME}_DEFINE_MISSING_PACKAGE_LIBS_TARGETS=ON in
2155 # package-by-package mode in tribits_ctest_driver(). This option is
2156 # purposefully not documented and not defined as a cache variable since it
2157 # is an internal TriBITS implementation detail.
2158
2159 endif()
2160
2161 tribits_config_code_stop_timer(CONFIGURE_PACKAGES_TIME_START_SECONDS
2162 "\nTotal time to configure enabled packages")
2163
2164 endmacro()
2165
2166
2167 # Create custom 'install_package_by_package' target
2168 #
2169 function(tribits_add_install_package_by_package_target)
2170
2171 set(TRIBITS_ENABLED_PACKAGES_BINARY_DIRS)
2172 foreach(TRIBITS_PACKAGE ${${PROJECT_NAME}_DEFINED_INTERNAL_TOPLEVEL_PACKAGES})
2173 list(APPEND TRIBITS_ENABLED_PACKAGES_BINARY_DIRS "${${TRIBITS_PACKAGE}_BINARY_DIR}")
2174 endforeach()
2175
2176 set(tribits_install_src
2177 "${${PROJECT_NAME}_TRIBITS_DIR}/${TRIBITS_CMAKE_INSTALLATION_FILES_DIR}")
2178
2179 configure_file(
2180 "${tribits_install_src}/cmake_pbp_install.cmake.in"
2181 cmake_pbp_install.cmake
2182 @ONLY )
2183
2184 advanced_set(${PROJECT_NAME}_INSTALL_PBP_RUNNER "" CACHE FILEPATH
2185 "Program used to run cmake -P cmake_pbp_install.cmake to change user for 'install_package_by_package' target")
2186
2187 add_custom_target(install_package_by_package
2188 ${${PROJECT_NAME}_INSTALL_PBP_RUNNER}
2189 ${CMAKE_COMMAND} -P cmake_pbp_install.cmake
2190 WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
2191 )
2192
2193 endfunction()
2194
2195
2196 macro(tribits_setup_for_installation)
2197
2198 # Set up to install <Package>Config.cmake, <Project>Config.cmake, and export
2199 # makefiles.
2200 add_subdirectory(
2201 "${${PROJECT_NAME}_TRIBITS_DIR}/core/installation/add_project_install_commands"
2202 add_project_install_commands)
2203
2204 # Set up for fixing group and permissions after the install
2205 add_subdirectory(
2206 "${${PROJECT_NAME}_TRIBITS_DIR}/core/installation/add_install_group_and_perms_fixups"
2207 add_install_group_and_perms_fixups)
2208
2209 # Create custom 'install_package_by_package' target
2210 tribits_add_install_package_by_package_target()
2211
2212 endmacro()
2213
2214 # LocalWords:
2215 # LocalWords: Sandia SANDIA Redistributions
2216 # LocalWords: tribits TriBITS TRIBITS
2217 # LocalWords: cmake CMake CMAKE CMakeCache CMakeFiles
2218 # LocalWords: ctest CPACK
2219 # LocalWords: foreach endforeach endif endmacro
2220 # LocalWords: BOOL
2221 # LocalWords: libs LIBS config PackageName SUBPACKAGES nonenabled