From c4b0d2db0d4ca70cc579b93f87edc4939f348607 Mon Sep 17 00:00:00 2001 From: Anthony Geay Date: Mon, 3 Sep 2018 16:55:58 +0200 Subject: [PATCH] It s magic --- cmake/SalomeMacros.cmake | 2060 +++++++++++++++++++------------------- 1 file changed, 1032 insertions(+), 1028 deletions(-) mode change 100644 => 100755 cmake/SalomeMacros.cmake diff --git a/cmake/SalomeMacros.cmake b/cmake/SalomeMacros.cmake old mode 100644 new mode 100755 index d91eb4c..ae3c547 --- a/cmake/SalomeMacros.cmake +++ b/cmake/SalomeMacros.cmake @@ -1,1028 +1,1032 @@ -# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# -# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com -# -# Author: A.Geay, V. Sandler, A. Bruneton -# - -#---------------------------------------------------------------------------- -# LIST_CONTAINS is a macro useful for determining whether a list has a -# particular entry -#---------------------------------------------------------------------------- -MACRO(LIST_CONTAINS var value) - SET(${var}) - FOREACH(value2 ${ARGN}) - IF(${value} STREQUAL "${value2}") - SET(${var} TRUE) - ENDIF (${value} STREQUAL "${value2}") - ENDFOREACH (value2) -ENDMACRO(LIST_CONTAINS) - -#---------------------------------------------------------------------------- -# The PARSE_ARGUMENTS macro will take the arguments of another macro and -# define several variables. -# -# USAGE: PARSE_ARGUMENTS(prefix arg_names options arg1 arg2...) -# -# ARGUMENTS: -# -# prefix: IN: a prefix to put on all variables it creates. -# -# arg_names: IN: a list of names. -# For each item in arg_names, PARSE_ARGUMENTS will create a -# variable with that name, prefixed with prefix_. Each variable will be filled -# with the arguments that occur after the given arg_name is encountered -# up to the next arg_name or the end of the arguments. All options are -# removed from these lists. PARSE_ARGUMENTS also creates a -# prefix_DEFAULT_ARGS variable containing the list of all arguments up -# to the first arg_name encountered. -# -# options: IN: a list of options. -# For each item in options, PARSE_ARGUMENTS will create a -# variable with that name, prefixed with prefix_. So, for example, if prefix is -# MY_MACRO and options is OPTION1;OPTION2, then PARSE_ARGUMENTS will -# create the variables MY_MACRO_OPTION1 and MY_MACRO_OPTION2. These -# variables will be set to true if the option exists in the command line -# or false otherwise. -# arg_names and options lists should be quoted. -# -# The rest of PARSE_ARGUMENTS are arguments from another macro to be parsed. -#---------------------------------------------------------------------------- -MACRO(PARSE_ARGUMENTS prefix arg_names option_names) - SET(DEFAULT_ARGS) - FOREACH(arg_name ${arg_names}) - SET(${prefix}_${arg_name}) - ENDFOREACH(arg_name) - FOREACH(option ${option_names}) - SET(${prefix}_${option} FALSE) - ENDFOREACH(option) - SET(current_arg_name DEFAULT_ARGS) - SET(current_arg_list) - FOREACH(arg ${ARGN}) - LIST_CONTAINS(is_arg_name ${arg} ${arg_names}) - IF (is_arg_name) - SET(${prefix}_${current_arg_name} ${current_arg_list}) - SET(current_arg_name ${arg}) - SET(current_arg_list) - ELSE (is_arg_name) - LIST_CONTAINS(is_option ${arg} ${option_names}) - IF (is_option) - SET(${prefix}_${arg} TRUE) - ELSE (is_option) - SET(current_arg_list ${current_arg_list} ${arg}) - ENDIF (is_option) - ENDIF (is_arg_name) - ENDFOREACH(arg) - SET(${prefix}_${current_arg_name} ${current_arg_list}) -ENDMACRO(PARSE_ARGUMENTS) - -#---------------------------------------------------------------------------- -# SALOME_INSTALL_SCRIPTS is a macro useful for installing scripts. -# -# USAGE: SALOME_INSTALL_SCRIPTS(file_list path [WORKING_DIRECTORY dir] [DEF_PERMS] [TARGET_NAME name]) -# -# ARGUMENTS: -# file_list: IN : list of files to be installed. This list should be quoted. -# path: IN : full pathname for installing. -# -# By default files to be installed as executable scripts. -# If DEF_PERMS option is provided, than permissions for installed files are -# only OWNER_WRITE, OWNER_READ, GROUP_READ, and WORLD_READ. -# WORKING_DIRECTORY option may be used to specify the relative or absolute -# path to the directory containing source files listed in file_list argument. -# If TARGET_NAME option is specified, the name of the target being created -# with this macro is returned via the given variable. -#---------------------------------------------------------------------------- -MACRO(SALOME_INSTALL_SCRIPTS file_list path) - PARSE_ARGUMENTS(SALOME_INSTALL_SCRIPTS "WORKING_DIRECTORY;TARGET_NAME" "DEF_PERMS" ${ARGN}) - SET(PERMS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ) - IF(NOT SALOME_INSTALL_SCRIPTS_DEF_PERMS) - SET(PERMS ${PERMS} OWNER_EXECUTE GROUP_EXECUTE WORLD_EXECUTE) - ENDIF(NOT SALOME_INSTALL_SCRIPTS_DEF_PERMS) - SET(_all_pyc) - SET(_all_pyo) - FOREACH(file ${file_list}) - SET(PREFIX "") - SET(_source_prefix "") - GET_FILENAME_COMPONENT(file_name ${file} NAME) - IF(NOT IS_ABSOLUTE ${file}) - IF(SALOME_INSTALL_SCRIPTS_WORKING_DIRECTORY) - SET(PREFIX "${SALOME_INSTALL_SCRIPTS_WORKING_DIRECTORY}/") - ENDIF(SALOME_INSTALL_SCRIPTS_WORKING_DIRECTORY) - SET(_source_prefix "${CMAKE_CURRENT_SOURCE_DIR}/") - ENDIF(NOT IS_ABSOLUTE ${file}) - INSTALL(FILES ${PREFIX}${file} DESTINATION ${path} PERMISSIONS ${PERMS}) - GET_FILENAME_COMPONENT(ext ${file} EXT) - GET_FILENAME_COMPONENT(we_ext ${file} NAME_WE) - - IF(ext STREQUAL .py) - # Generate and install the pyc and pyo - # [ABN] Important: we avoid references or usage of CMAKE_INSTALL_PREFIX which is not correctly set - # when using CPack. - SET(_pyc_file "${CMAKE_CURRENT_BINARY_DIR}/${we_ext}.cpython-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}.pyc") - SET(_pyo_file "${CMAKE_CURRENT_BINARY_DIR}/${we_ext}.cpython-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}.opt-1.pyc") - LIST(APPEND _all_pyc ${_pyc_file}) - LIST(APPEND _all_pyo ${_pyo_file}) - ADD_CUSTOM_COMMAND( - OUTPUT ${_pyc_file} ${_pyo_file} - COMMAND ${PYTHON_EXECUTABLE} -c "from py_compile import compile; compile('${_source_prefix}${file}', '${_pyc_file}', doraise=True, optimize=0); compile('${_source_prefix}${file}', '${_pyo_file}', doraise=True, optimize=1)" - DEPENDS ${PREFIX}${file} - VERBATIM - ) - # Install the .pyo and the .pyc - INSTALL(FILES ${_pyc_file} DESTINATION ${path}/__pycache__ PERMISSIONS ${PERMS}) - INSTALL(FILES ${_pyo_file} DESTINATION ${path}/__pycache__ PERMISSIONS ${PERMS}) - ENDIF(ext STREQUAL .py) - - # get relative path (from CMAKE_SOURCE_DIR to CMAKE_CURRENT_SOURCE_DIR) - STRING(REGEX REPLACE ${CMAKE_SOURCE_DIR} "" rel_dir ${CMAKE_CURRENT_SOURCE_DIR}) - # convert "/" to "_" - IF(rel_dir) - STRING(REGEX REPLACE "/" "_" unique_name ${rel_dir}) - ELSE(rel_dir) - SET(unique_name _) - ENDIF(rel_dir) - - ENDFOREACH(file ${file_list}) - # Generate only one target for all requested Python script compilation. - # Make sure that the target name is unique too. - IF(_all_pyc) - SET(_cnt 0) - WHILE(TARGET "PYCOMPILE${unique_name}_${_cnt}") - MATH(EXPR _cnt ${_cnt}+1) - ENDWHILE() - SET(_target_name "PYCOMPILE${unique_name}_${_cnt}") - ADD_CUSTOM_TARGET(${_target_name} ALL DEPENDS ${_all_pyc} ${_all_pyo}) - IF(SALOME_INSTALL_SCRIPTS_TARGET_NAME) - SET(${SALOME_INSTALL_SCRIPTS_TARGET_NAME} ${_target_name}) - ENDIF(SALOME_INSTALL_SCRIPTS_TARGET_NAME) - ENDIF() -ENDMACRO(SALOME_INSTALL_SCRIPTS) - -#---------------------------------------------------------------------------- -# SALOME_CONFIGURE_FILE is a macro useful for copying a file to another location -# and modify its contents. -# -# USAGE: SALOME_CONFIGURE_FILE(in_file out_file [INSTALL dir]) -# -# ARGUMENTS: -# in_file: IN : input file (if relative path is given, full file path is computed from current source dir). -# out_file: IN : output file (if relative path is given, full file path is computed from current build dir). -# If INSTALL is specified, then 'out_file' will be installed to the 'dir' directory. -#---------------------------------------------------------------------------- -MACRO(SALOME_CONFIGURE_FILE IN_FILE OUT_FILE) - IF(IS_ABSOLUTE ${IN_FILE}) - SET(_in_file ${IN_FILE}) - ELSE() - SET(_in_file ${CMAKE_CURRENT_SOURCE_DIR}/${IN_FILE}) - ENDIF() - IF(IS_ABSOLUTE ${OUT_FILE}) - SET(_out_file ${OUT_FILE}) - ELSE() - SET(_out_file ${CMAKE_CURRENT_BINARY_DIR}/${OUT_FILE}) - ENDIF() - MESSAGE(STATUS "Creation of ${_out_file}") - CONFIGURE_FILE(${_in_file} ${_out_file} @ONLY) - PARSE_ARGUMENTS(SALOME_CONFIGURE_FILE "INSTALL" "" ${ARGN}) - IF(SALOME_CONFIGURE_FILE_INSTALL) - INSTALL(FILES ${_out_file} DESTINATION ${SALOME_CONFIGURE_FILE_INSTALL}) - ENDIF(SALOME_CONFIGURE_FILE_INSTALL) -ENDMACRO(SALOME_CONFIGURE_FILE) - - -####################################################################################### -# Useful macros for SALOME own package detection system -# - -### -# SALOME_CHECK_EQUAL_PATHS(result path1 path2) -# Check if two paths are identical, resolving links. If the paths do not exist a simple -# text comparison is performed. -# result is a boolean. -### -MACRO(SALOME_CHECK_EQUAL_PATHS varRes path1 path2) - SET("${varRes}" OFF) - IF(EXISTS "${path1}") - GET_FILENAME_COMPONENT(_tmp1 "${path1}" REALPATH) - ELSE() - SET(_tmp1 "${path1}") - ENDIF() - - IF(EXISTS "${path2}") - GET_FILENAME_COMPONENT(_tmp2 "${path2}" REALPATH) - ELSE() - SET(_tmp2 "${path2}") - ENDIF() - - IF("${_tmp1}" STREQUAL "${_tmp2}") - SET("${varRes}" ON) - ENDIF() -# MESSAGE(${${varRes}}) -ENDMACRO() - -#### -# SALOME_LOG_OPTIONAL_PACKAGE(pkg flag) -# -# Register in global variables the detection status (found or not) of the optional package 'pkg' -# and the configuration flag that should be turned off to avoid detection of the package. -# The global variables are read again by SALOME_PACKAGE_REPORT_AND_CHECK to produce -# a summary report of the detection status and stops the process if necessary. -MACRO(SALOME_LOG_OPTIONAL_PACKAGE pkg flag) - # Was the package found - STRING(TOUPPER ${pkg} _pkg_UC) - IF(${pkg}_FOUND OR ${_pkg_UC}_FOUND) - SET(_isFound TRUE) - ELSE() - SET(_isFound FALSE) - ENDIF() - - # Is the package already in the list? Then update its status: - LIST(FIND _SALOME_OPTIONAL_PACKAGES_names ${pkg} _result) - IF(NOT ${_result} EQUAL -1) - LIST(REMOVE_AT _SALOME_OPTIONAL_PACKAGES_found ${_result}) - LIST(REMOVE_AT _SALOME_OPTIONAL_PACKAGES_flags ${_result}) - LIST(INSERT _SALOME_OPTIONAL_PACKAGES_found ${_result} ${_isFound}) - LIST(INSERT _SALOME_OPTIONAL_PACKAGES_flags ${_result} ${flag}) - ELSE() - # Otherwise insert it - LIST(APPEND _SALOME_OPTIONAL_PACKAGES_names ${pkg}) - LIST(APPEND _SALOME_OPTIONAL_PACKAGES_found ${_isFound}) - LIST(APPEND _SALOME_OPTIONAL_PACKAGES_flags ${flag}) - ENDIF() - -ENDMACRO(SALOME_LOG_OPTIONAL_PACKAGE) - -#### -# SALOME_JUSTIFY_STRING() -# -# Justifies the string specified as an argument to the given length -# adding required number of spaces to the end. Does noting if input -# string is longer as required length. -# Puts the result to the output variable. -# -# USAGE: SALOME_JUSTIFY_STRING(input length result) -# -# ARGUMENTS: -# input [in] input string -# length [in] required length of resulting string -# result [out] name of variable where the result string is put to -# -MACRO(SALOME_JUSTIFY_STRING input length result) - SET(${result} ${input}) - STRING(LENGTH ${input} _input_length) - MATH(EXPR _nb_spaces "${length}-${_input_length}-1") - IF (_nb_spaces GREATER 0) - FOREACH(_idx RANGE ${_nb_spaces}) - SET(${result} "${${result}} ") - ENDFOREACH() - ENDIF() -ENDMACRO(SALOME_JUSTIFY_STRING) - -#### -# SALOME_PACKAGE_REPORT_AND_CHECK() -# -# Print a quick summary of the detection of optional prerequisites. -# If a package was not found, the configuration is stopped. The summary also indicates -# which flag should be turned off to skip the detection of the package. -# -# If optional JUSTIFY argument is specified, names of packages -# are left-justified to the given length; default value is 10. -# -# USAGE: SALOME_PACKAGE_REPORT_AND_CHECK([JUSTIFY length]) -# -MACRO(SALOME_PACKAGE_REPORT_AND_CHECK) - SET(_will_fail OFF) - PARSE_ARGUMENTS(SALOME_PACKAGE_REPORT "JUSTIFY" "" ${ARGN}) - IF(SALOME_PACKAGE_REPORT_JUSTIFY) - SET(_length ${SALOME_PACKAGE_REPORT_JUSTIFY}) - ELSE() - SET(_length 23) - ENDIF() - MESSAGE(STATUS "") - MESSAGE(STATUS " Optional packages - Detection report ") - MESSAGE(STATUS " ==================================== ") - MESSAGE(STATUS "") - IF(DEFINED _SALOME_OPTIONAL_PACKAGES_names) - LIST(LENGTH _SALOME_OPTIONAL_PACKAGES_names _list_len) - # Another CMake stupidity - FOREACH(... RANGE r) generates r+1 numbers ... - MATH(EXPR _range "${_list_len}-1") - FOREACH(_idx RANGE ${_range}) - LIST(GET _SALOME_OPTIONAL_PACKAGES_names ${_idx} _pkg_name) - LIST(GET _SALOME_OPTIONAL_PACKAGES_found ${_idx} _pkg_found) - LIST(GET _SALOME_OPTIONAL_PACKAGES_flags ${_idx} _pkg_flag) - SALOME_JUSTIFY_STRING(${_pkg_name} ${_length} _pkg_name) - IF(_pkg_found) - SET(_found_msg "Found") - SET(_flag_msg "") - ELSE() - SET(_will_fail ON) - SET(_found_msg "NOT Found") - SET(_flag_msg " - ${_pkg_flag} can be switched OFF to skip this prerequisite.") - ENDIF() - - MESSAGE(STATUS " * ${_pkg_name} -> ${_found_msg}${_flag_msg}") - ENDFOREACH() - ENDIF(DEFINED _SALOME_OPTIONAL_PACKAGES_names) - MESSAGE(STATUS "") - MESSAGE(STATUS "") - - # Failure if some packages were missing: - IF(_will_fail) - MESSAGE(FATAL_ERROR "Some required prerequisites have NOT been found. Take a look at the report above to fix this.") - ENDIF() -ENDMACRO(SALOME_PACKAGE_REPORT_AND_CHECK) - -#### -# SALOME_FIND_PACKAGE(englobingPackageName standardPackageName modus [onlyTryQuietly]) -# -# example: SALOME_FIND_PACKAGE(SalomeVTK VTK CONFIG) -# -# Encapsulate the call to the standard FIND_PACKAGE(standardPackageName) passing all the options -# given when calling the command FIND_PACKAGE(SalomeXYZ). Those options are stored implicitly in -# CMake variables: xyz__FIND_QUIETLY, xyz_FIND_REQUIRED, etc ... -# -# If a list of components was specified when invoking the initial FIND_PACKAGE(SalomeXyz ...) this is -# also handled properly. -# -# Modus is either MODULE or CONFIG (cf standard FIND_PACKAGE() documentation). -# The last argument is optional and if set to TRUE will force the search to be OPTIONAL and QUIET. -# If the package is looked for in CONFIG mode, the standard system paths are skipped. If you still want a -# system installation to be found in this mode, you have to set the ROOT_DIR variable explicitly to /usr (for -# example). -# -# This macro is to be called from within the FindSalomeXXXX.cmake file. -# -#### -MACRO(SALOME_FIND_PACKAGE englobPkg stdPkg mode) - SET(_OPT_ARG ${ARGV3}) - # Only bother if the package was not already found: - # Some old packages use the lower case version - standard should be to always use - # upper case: - STRING(TOUPPER ${stdPkg} stdPkgUC) - IF(NOT (${stdPkg}_FOUND OR ${stdPkgUC}_FOUND)) - IF(${englobPkg}_FIND_QUIETLY OR _OPT_ARG) - SET(_tmp_quiet "QUIET") - ELSE() - SET(_tmp_quiet) - ENDIF() - IF(${englobPkg}_FIND_REQUIRED AND NOT _OPT_ARG) - SET(_tmp_req "REQUIRED") - ELSE() - SET(_tmp_req) - ENDIF() - IF(${englobPkg}_FIND_VERSION_EXACT) - SET(_tmp_exact "EXACT") - ELSE() - SET(_tmp_exact) - ENDIF() - - # Call the CMake FIND_PACKAGE() command: - STRING(TOLOWER ${stdPkg} _pkg_lc) - IF(("${mode}" STREQUAL "NO_MODULE") OR ("${mode}" STREQUAL "CONFIG")) - # Hope to find direclty a CMake config file, indicating the SALOME CMake file - # paths (the command already looks in places like "share/cmake", etc ... by default) - # Note the options NO_CMAKE_BUILDS_PATH, NO_CMAKE_PACKAGE_REGISTRY to avoid (under Windows) - # looking into a previous CMake build done via a GUI, or into the Win registry. - # NO_CMAKE_SYSTEM_PATH and NO_SYSTEM_ENVIRONMENT_PATH ensure any _system_ files like 'xyz-config.cmake' - # don't get loaded (typically Boost). To force their loading, set the XYZ_ROOT_DIR variable to '/usr'. - # See documentation of FIND_PACKAGE() for full details. - - # Do we need to call the signature using components? - IF(${englobPkg}_FIND_COMPONENTS) - FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} - NO_MODULE ${_tmp_quiet} ${_tmp_req} COMPONENTS ${${englobPkg}_FIND_COMPONENTS} - PATH_SUFFIXES "salome_adm/cmake_files" "adm_local/cmake_files" "adm/cmake" - NO_CMAKE_BUILDS_PATH NO_CMAKE_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PATH - NO_SYSTEM_ENVIRONMENT_PATH) - ELSE() - FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} - NO_MODULE ${_tmp_quiet} ${_tmp_req} - PATH_SUFFIXES "salome_adm/cmake_files" "adm_local/cmake_files" "adm/cmake" - NO_CMAKE_BUILDS_PATH NO_CMAKE_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PATH - NO_SYSTEM_ENVIRONMENT_PATH) - ENDIF() - MARK_AS_ADVANCED(${stdPkg}_DIR) - - ELSEIF("${mode}" STREQUAL "MODULE") - - # Do we need to call the signature using components? - IF(${englobPkg}_FIND_COMPONENTS) - FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} - MODULE ${_tmp_quiet} ${_tmp_req} COMPONENTS ${${englobPkg}_FIND_COMPONENTS}) - ELSE() - FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} - MODULE ${_tmp_quiet} ${_tmp_req}) - ENDIF() - - ELSE() - - MESSAGE(FATAL_ERROR "Invalid mode argument in the call to the macro SALOME_FIND_PACKAGE. Should be CONFIG or MODULE.") - - ENDIF() - - ENDIF() -ENDMACRO() - - -#################################################################### -# SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS(pkg referenceVariable upCount) -# pkg : name of the system package to be detected -# referenceVariable: variable containing a path that can be browsed up to -# retrieve the package root directory (xxx_ROOT_DIR) -# upCount : number of times we have to go up from the path -# to obtain the package root directory. -# If this is a path to a file, going up one time gives the directory containing the file -# going up 2 times gives the parent directory. -# -# For example: SALOME_FIND_PACKAGE_DETECT_CONFLICTS(SWIG SWIG_EXECUTABLE 2) -# with SWIG_EXECUTABLE set to '/usr/bin/swig' -# will produce '/usr' -# -# Generic detection (and conflict check) procedure for package XYZ: -# 1. Load a potential env variable XYZ_ROOT_DIR as a default choice for the cache entry XYZ_ROOT_DIR -# If empty, load a potential XYZ_ROOT_DIR_EXP as default value (path exposed by another package depending -# directly on XYZ) -# 2. Invoke FIND_PACKAGE() in this order: -# * in CONFIG mode first (if possible): priority is given to a potential -# "XYZ-config.cmake" file -# * then switch to the standard MODULE mode, appending on CMAKE_PREFIX_PATH -# the above XYZ_ROOT_DIR variable -# 3. Extract the path actually found into a temp variable _XYZ_TMP_DIR -# 4. Warn if XYZ_ROOT_DIR is set and doesn't match what was found (e.g. when CMake found the system installation -# instead of what is pointed to by XYZ_ROOT_DIR - happens when a typo in the content of XYZ_ROOT_DIR). -# 5. Conflict detection: -# * check the temp variable against a potentially existing XYZ_ROOT_DIR_EXP -# 6. Finally expose what was *actually* found in XYZ_ROOT_DIR. -# 7. Specific stuff: for example exposing a prerequisite of XYZ to the rest of the world for future -# conflict detection. This is added after the call to the macro by the callee. -# -MACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS pkg referenceVariable upCount) - ## - ## 0. Initialization - ## - PARSE_ARGUMENTS(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS "ENVVAR" "" ${ARGN}) - - # Package name, upper case - STRING(TOUPPER ${pkg} pkg_UC) - - ## - ## 1. Load environment or any previously detected root dir for the package - ## - SET(_envvar ${pkg_UC}_ROOT_DIR) - IF(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS_ENVVAR) - SET(_envvar "${SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS_ENVVAR}") - ENDIF() - IF(DEFINED ENV{${_envvar}}) - FILE(TO_CMAKE_PATH "$ENV{${_envvar}}" _${pkg_UC}_ROOT_DIR_ENV) - SET(_dflt_value "${_${pkg_UC}_ROOT_DIR_ENV}") - ELSE() - # will be blank if no package was previously loaded: - SET(_dflt_value "${${pkg_UC}_ROOT_DIR_EXP}") - ENDIF() - # Detect if the variable has been set on the command line or elsewhere: - IF(DEFINED ${_envvar}) - SET(_var_already_there TRUE) - ELSE() - SET(_var_already_there FALSE) - ENDIF() - # Make cache entry - SET(${_envvar} "${_dflt_value}" CACHE PATH "Path to ${pkg_UC} directory") - - ## - ## 2. Find package - try CONFIG mode first (i.e. looking for XYZ-config.cmake) - ## - - # Override the variable - don't append to it, as it would give precedence - # to what was stored there before! - IF(DEFINED ${_envvar}) - SET(CMAKE_PREFIX_PATH "${${_envvar}}") - ENDIF() - - # Try find_package in config mode. This has the priority, but is - # performed QUIET and not REQUIRED: - SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} NO_MODULE TRUE) - - IF (${pkg_UC}_FOUND OR ${pkg}_FOUND) - MESSAGE(STATUS "Found ${pkg} in CONFIG mode!") - ENDIF() - - # Otherwise try the standard way (module mode, with the standard CMake Find*** macro): - # We do it quietly to produce our own error message, except if we are in debug mode: - IF(SALOME_CMAKE_DEBUG) - SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} MODULE FALSE) - ELSE() - SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} MODULE TRUE) - ENDIF() - - # Set the "FOUND" variable for the SALOME wrapper: - IF(${pkg_UC}_FOUND OR ${pkg}_FOUND) - SET(SALOME${pkg_UC}_FOUND TRUE) - ELSE() - SET(SALOME${pkg_UC}_FOUND FALSE) - IF(NOT Salome${pkg}_FIND_QUIETLY) - IF(Salome${pkg}_FIND_REQUIRED) - MESSAGE(FATAL_ERROR "Package ${pkg} couldn't be found - did you set the corresponing root dir correctly? " - "It currently contains ${_envvar}=${${_envvar}} " - "Append -DSALOME_CMAKE_DEBUG=ON on the command line if you want to see the original CMake error.") - ELSE() - MESSAGE(WARNING "Package ${pkg} couldn't be found - did you set the corresponing root dir correctly? " - "It currently contains ${_envvar}=${${_envvar}} " - "Append -DSALOME_CMAKE_DEBUG=ON on the command line if you want to see the original CMake error.") - ENDIF() - ENDIF() - ENDIF() - - IF (${pkg_UC}_FOUND OR ${pkg}_FOUND) - ## 3. Set the root dir which was finally retained by going up "upDir" times - ## from the given reference path. The variable "referenceVariable" may be a list. - ## In this case we take its first element. - - # First test if the variable exists, warn otherwise: - IF(NOT DEFINED ${referenceVariable}) - MESSAGE(WARNING "${pkg}: the reference variable '${referenceVariable}' used when calling the macro " - "SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS() is not defined.") - ENDIF() - - LIST(LENGTH ${referenceVariable} _tmp_len) - IF(_tmp_len) - LIST(GET ${referenceVariable} 0 _tmp_ROOT_DIR) - ELSE() - # Note the double de-reference of "referenceVariable": - SET(_tmp_ROOT_DIR "${${referenceVariable}}") - ENDIF() - # Up cound can be reset by detection procedure - SET(_upCount ${upCount}) - IF(DEFINED ${pkg_UC}_UPCOUNT) - SET(_upCount ${${pkg_UC}_UPCOUNT}) - ENDIF() - IF(${_upCount}) - FOREACH(_unused RANGE 1 ${_upCount}) - GET_FILENAME_COMPONENT(_tmp_ROOT_DIR "${_tmp_ROOT_DIR}" PATH) - ENDFOREACH() - ENDIF() - - ## - ## 4. Warn if CMake found something not located under ENV(XYZ_ROOT_DIR) - ## - IF(DEFINED ENV{${_envvar}}) - SALOME_CHECK_EQUAL_PATHS(_res "${_tmp_ROOT_DIR}" "${_${pkg_UC}_ROOT_DIR_ENV}") - IF(NOT _res) - MESSAGE(WARNING "${pkg} was found, but not at the path given by the " - "environment ${_envvar}! Is the variable correctly set? " - "The two paths are: ${_tmp_ROOT_DIR} and: ${_${pkg_UC}_ROOT_DIR_ENV}") - - ELSE() - MESSAGE(STATUS "${pkg} found directory matches what was specified in the ${_envvar} variable, all good!") - ENDIF() - ELSE() - IF(NOT _var_already_there) - MESSAGE(STATUS "Variable ${_envvar} was not explicitly defined. " - "An installation was found anyway: ${_tmp_ROOT_DIR}") - ENDIF() - ENDIF() - - ## - ## 5. Conflict detection - ## From another prerequisite using the package: - ## - IF(${pkg_UC}_ROOT_DIR_EXP) - SALOME_CHECK_EQUAL_PATHS(_res "${_tmp_ROOT_DIR}" "${${pkg_UC}_ROOT_DIR_EXP}") - IF(NOT _res) - MESSAGE(WARNING "Warning: ${pkg}: detected version conflicts with a previously found ${pkg}!" - " The two paths are " ${_tmp_ROOT_DIR} " vs " ${${pkg_UC}_ROOT_DIR_EXP}) - ELSE() - MESSAGE(STATUS "${pkg} directory matches what was previously exposed by another prereq, all good!") - ENDIF() - ENDIF() - - ## - ## 6. Save the detected installation - ## - SET(${_envvar} "${_tmp_ROOT_DIR}") - - ELSE() - MESSAGE(STATUS "${pkg} was not found.") - ENDIF() - - SET(Salome${pkg}_FOUND "${pkg}_FOUND") -ENDMACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS) - - -#################################################################### -# SALOME_ADD_MPI_TO_HDF5() -# -# Overload the HDF5 flags so that they also contain MPI references. -# This is to be used when HDF5 was compiled with MPI support; -MACRO(SALOME_ADD_MPI_TO_HDF5) - SET(HDF5_INCLUDE_DIRS ${HDF5_INCLUDE_DIRS} ${MPI_INCLUDE_DIRS}) - SET(HDF5_DEFINITIONS "${HDF5_DEFINITIONS} ${MPI_DEFINITIONS}") - SET(HDF5_LIBRARIES ${HDF5_LIBRARIES} ${MPI_LIBRARIES}) -ENDMACRO(SALOME_ADD_MPI_TO_HDF5) - -#################################################################### -# SALOME_TOHEXA() -# Convert a number (smaller than 16) into hexadecimal representation -# with a leading 0. -MACRO(SALOME_TOHEXA num result) - SET(_hexa_map a b c d e f) - IF(${num} LESS 10) - SET(${result} "0${num}") - ELSE() - MATH(EXPR _res "${num}-10" ) - LIST(GET _hexa_map ${_res} _out) - SET(${result} "0${_out}") - ENDIF() -ENDMACRO(SALOME_TOHEXA) - -#################################################################### -# SALOME_XVERSION() -# -# Computes hexadecimal version of SALOME package -# -# USAGE: SALOME_XVERSION(package) -# -# ARGUMENTS: -# -# package: IN: SALOME package name -# -# The macro reads SALOME package version from PACKAGE_VERSION variable -# (note package name in uppercase as assumed for SALOME modules); -# hexadecimal version value in form 0xAABBCC (where AA, BB and CC are -# major, minor and maintenance components of package version in -# hexadecimal form) is put to the PACKAGE_XVERSION variable -MACRO(SALOME_XVERSION pkg) - STRING(TOUPPER ${pkg} _pkg_UC) - IF(${_pkg_UC}_VERSION) - SET(_major) - SET(_minor) - SET(_patch) - SALOME_TOHEXA(${${_pkg_UC}_MAJOR_VERSION} _major) - SALOME_TOHEXA(${${_pkg_UC}_MINOR_VERSION} _minor) - SALOME_TOHEXA(${${_pkg_UC}_PATCH_VERSION} _patch) - SET(${_pkg_UC}_XVERSION "0x${_major}${_minor}${_patch}") - ENDIF() -ENDMACRO(SALOME_XVERSION) - - -######################################################################### -# SALOME_ACCUMULATE_HEADERS() -# -# This macro is called in the various FindSalomeXYZ.cmake modules to accumulate -# internally the list of include headers to be saved for future export. -# The full set of include is saved in a variable called -# _${PROJECT_NAME}_EXTRA_HEADERS -# -MACRO(SALOME_ACCUMULATE_HEADERS lst) - FOREACH(l IN LISTS ${lst}) - LIST(FIND _${PROJECT_NAME}_EXTRA_HEADERS "${l}" _res) - IF(_res EQUAL "-1") - IF(NOT "${l}" STREQUAL "/usr/include") - LIST(APPEND _${PROJECT_NAME}_EXTRA_HEADERS "${l}") - ENDIF() - ENDIF() - ENDFOREACH() -ENDMACRO(SALOME_ACCUMULATE_HEADERS) - -######################################################################### -# SALOME_ACCUMULATE_ENVIRONMENT() -# -# USAGE: SALOME_ACCUMULATE_ENVIRONMENT(envvar value [value ...]) -# -# ARGUMENTS: -# envvar [in] environment variable name, e.g. PATH -# value [in] value(s) to be added to environment variable -# -# This macro is called in the various FindSalomeXYZ.cmake modules to -# accumulate environment variables, to be used later to run some command -# in proper environment. -# -# 1. Each envrironment variable is stored in specific CMake variable -# _${PROJECT_NAME}_EXTRA_ENV_, where is name of variable. -# 2. Full list of environment variable names is stored in CMake variable -# _${PROJECT_NAME}_EXTRA_ENV. -# -# Notes: -# - The arguments list can include optional CHECK or NOCHECK keywords: -# * For all arguments following CHECK keyword the macro perform an -# additional check (see below); this is the default mode, it is suitable -# for path variables (PATH, LD_LIBRARY_PATH, etc). -# * For all arguments following NOCHECK keyword, no additional check is -# performed. -# Checking an argument means that we check: -# - That the path actually exists -# - That this is not a standard system path (starting with "/usr"); this avoids -# polluting LD_LIBRARY_PATH or PATH with things like "/usr/lib64" ... -# -MACRO(SALOME_ACCUMULATE_ENVIRONMENT envvar) - SET(_is_check ON) - FOREACH(_item ${ARGN}) - IF(${_item} STREQUAL "NOCHECK") - SET(_is_check OFF) - ELSEIF(${_item} STREQUAL "CHECK") - SET(_is_check ON) - ELSE() - IF(_is_check) - IF(NOT IS_DIRECTORY ${_item}) - IF(TARGET ${_item}) - GET_TARGET_PROPERTY(_item ${_item} LOCATION) - ENDIF() - GET_FILENAME_COMPONENT(_item ${_item} PATH) - ENDIF() - IF(EXISTS ${_item}) - STRING(REGEX MATCH "^(/usr|/lib|/bin)" _usr_find ${_item}) - LIST(FIND _${PROJECT_NAME}_EXTRA_ENV_${envvar} ${_item} _res) - IF(NOT _usr_find AND _res EQUAL -1) - LIST(APPEND _${PROJECT_NAME}_EXTRA_ENV_${envvar} ${_item}) - ENDIF() - ENDIF() - ELSE(_is_check) - LIST(FIND _${PROJECT_NAME}_EXTRA_ENV_${envvar} ${_item} _res) - IF( _res EQUAL -1) - LIST(APPEND _${PROJECT_NAME}_EXTRA_ENV_${envvar} ${_item}) - ENDIF() - ENDIF(_is_check) - ENDIF() - ENDFOREACH() - - LIST(FIND _${PROJECT_NAME}_EXTRA_ENV ${envvar} _res) - IF(_res EQUAL -1) - LIST(APPEND _${PROJECT_NAME}_EXTRA_ENV ${envvar}) - ENDIF() - SET(_${PROJECT_NAME}_EXTRA_ENV_FULL "SET\(${PROJECT_NAME}_EXTRA_ENV ${_${PROJECT_NAME}_EXTRA_ENV}\)") - FOREACH(_res ${_${PROJECT_NAME}_EXTRA_ENV}) - STRING(REPLACE "${CMAKE_INSTALL_PREFIX}" "\${PACKAGE_PREFIX_DIR}" _res_path "${_${PROJECT_NAME}_EXTRA_ENV_${_res}}") - SET(_${PROJECT_NAME}_EXTRA_ENV_FULL "${_${PROJECT_NAME}_EXTRA_ENV_FULL}\nSET\(${PROJECT_NAME}_EXTRA_ENV_${_res} ${_res_path}\)") - ENDFOREACH() -ENDMACRO(SALOME_ACCUMULATE_ENVIRONMENT) - -######################################################################### -# SALOME_GENERATE_ENVIRONMENT_SCRIPT() -# -# USAGE: SALOME_GENERATE_ENVIRONMENT_SCRIPT(output script cmd opts) -# -# ARGUMENTS: -# output [out] output command, e.g. for creation of target. -# script [in] output environement script name -# cmd [in] input command, e.g. sphinx or python command. -# opts [in] options for input command (cmd). -# -# This macro is called when it's necessary to use given environment to run some command. -# Macro generates environement script using previously created variables -# _${PROJECT_NAME}_EXTRA_ENV_, where is name of variable and -# _${PROJECT_NAME}_EXTRA_ENV (see marco SALOME_ACCUMULATE_ENVIRONMENT); -# and puts generated command in proper environment into argument. -# -# Notes: -# - If