X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=salome_adm%2Fcmake_files%2FSalomeMacros.cmake;h=7f48f7ba41990948ac17d818eee2df7b4380ba46;hb=ba520e13dc005608c3d624f6296cd026d6126820;hp=454bb47e6c5bc880fd567f0037528c5c878c8984;hpb=10b71812e88652602f090a7e2e1bcd5710ff0f51;p=modules%2Fkernel.git diff --git a/salome_adm/cmake_files/SalomeMacros.cmake b/salome_adm/cmake_files/SalomeMacros.cmake index 454bb47e6..7f48f7ba4 100755 --- a/salome_adm/cmake_files/SalomeMacros.cmake +++ b/salome_adm/cmake_files/SalomeMacros.cmake @@ -211,14 +211,13 @@ MACRO(SALOME_CHECK_EQUAL_PATHS varRes path1 path2) ENDMACRO() #### -# SALOME_UPDATE_FLAG_AND_LOG_PACKAGE(pkg flag) +# 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 if it is not found. -# If the package was not found, the macro explicitly turns off the flag. -# The global variables are read again by SALOME_PACKAGE_REPORT to produce a summary report -# of the detection status, and of the modified flags. -MACRO(SALOME_UPDATE_FLAG_AND_LOG_PACKAGE pkg flag) +# 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) @@ -241,42 +240,87 @@ MACRO(SALOME_UPDATE_FLAG_AND_LOG_PACKAGE pkg flag) LIST(APPEND _SALOME_OPTIONAL_PACKAGES_flags ${flag}) ENDIF() - # If the package was not found, force the cache flag to OFF - IF(NOT isFound) - SET(${flag} OFF) - ENDIF() -ENDMACRO(SALOME_UPDATE_FLAG_AND_LOG_PACKAGE) +ENDMACRO(SALOME_LOG_OPTIONAL_PACKAGE) #### -# SALOME_PACKAGE_REPORT() +# 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. # -MACRO(SALOME_PACKAGE_REPORT) +# 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 "") - 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) - IF(_pkg_found) - SET(_found_msg "Found") - SET(_flag_msg "") - ELSE() - SET(_found_msg "NOT Found") - SET(_flag_msg " - ${_pkg_flag} has been switched OFF.") - ENDIF() + 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() + MESSAGE(STATUS " * ${_pkg_name} -> ${_found_msg}${_flag_msg}") + ENDFOREACH() + ENDIF(DEFINED _SALOME_OPTIONAL_PACKAGES_names) MESSAGE(STATUS "") MESSAGE(STATUS "") -ENDMACRO(SALOME_PACKAGE_REPORT) + + # 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]) @@ -443,8 +487,12 @@ MACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS pkg referenceVariable upCount) ENDIF() # Otherwise try the standard way (module mode, with the standard CMake Find*** macro): - # We do it quietly to produce our own error message: - SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} MODULE TRUE) + # 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) @@ -454,10 +502,12 @@ MACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS pkg referenceVariable upCount) 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 ${pkg_UC}_ROOT_DIR=${${pkg_UC}_ROOT_DIR}") + "It currently contains ${pkg_UC}_ROOT_DIR=${${pkg_UC}_ROOT_DIR} " + "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 ${pkg_UC}_ROOT_DIR=${${pkg_UC}_ROOT_DIR}") + "It currently contains ${pkg_UC}_ROOT_DIR=${${pkg_UC}_ROOT_DIR} " + "Append -DSALOME_CMAKE_DEBUG=ON on the command line if you want to see the original CMake error.") ENDIF() ENDIF() ENDIF() @@ -467,10 +517,10 @@ MACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS pkg referenceVariable upCount) ## 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 and is not empty: - IF((NOT DEFINED ${referenceVariable}) OR ("${${referenceVariable}}" STREQUAL "")) + # 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() does not exist or is empty.") + "SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS() is not defined.") ENDIF() LIST(LENGTH ${referenceVariable} _tmp_len) @@ -480,9 +530,8 @@ MACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS pkg referenceVariable upCount) # Note the double de-reference of "referenceVariable": SET(_tmp_ROOT_DIR "${${referenceVariable}}") ENDIF() - IF(${upCount}) - MATH(EXPR _rge "${upCount}-1") - FOREACH(_unused RANGE ${_rge}) + IF(${upCount}) + FOREACH(_unused RANGE 1 ${upCount}) GET_FILENAME_COMPONENT(_tmp_ROOT_DIR "${_tmp_ROOT_DIR}" PATH) ENDFOREACH() ENDIF() @@ -568,3 +617,188 @@ MACRO(SALOME_XVERSION pkg) OUTPUT_VARIABLE ${_pkg_UC}_XVERSION) 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: +# - If in arguments is set keyword CHECK all argument after checked for directory, +# else if NOT_CHECK macro accumulates arguments without checking. +# By default all arguments without keyword must be checked. +# +MACRO(SALOME_ACCUMULATE_ENVIRONMENT envvar) + SET(_is_check ON) + FOREACH(_item ${ARGN}) + IF(${_item} STREQUAL "NOT_CHECK") + 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" _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}) + SET(_${PROJECT_NAME}_EXTRA_ENV_FULL "${_${PROJECT_NAME}_EXTRA_ENV_FULL}\nSET\(${PROJECT_NAME}_EXTRA_ENV_${_res} ${_${PROJECT_NAME}_EXTRA_ENV_${_res}}\)") + 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