cmake/SalomeMacros.cmake

   1 # Copyright (C) 2012-2024  CEA, EDF, OPEN CASCADE
   2 #
   3 # This library is free software; you can redistribute it and/or
   4 # modify it under the terms of the GNU Lesser General Public
   5 # License as published by the Free Software Foundation; either
   6 # version 2.1 of the License, or (at your option) any later version.
   7 #
   8 # This library is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 # Lesser General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU Lesser General Public
  14 # License along with this library; if not, write to the Free Software
  15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 #
  17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 #
  19 # Author: A.Geay, V. Sandler, A. Bruneton
  20 #
  21
  22 #----------------------------------------------------------------------------
  23 # Set-up global policies
  24 #----------------------------------------------------------------------------
  25 CMAKE_POLICY(SET CMP0003 NEW)   # Ensure proper linker behavior
  26 IF(WIN32)
  27   CMAKE_POLICY(SET CMP0020 OLD) # Disable automatic linking to qtmain.lib
  28 ENDIF(WIN32)
  29 CMAKE_POLICY(SET CMP0053 NEW)   # For correct Qt 5 detection procedure
  30 IF(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12)
  31   CMAKE_POLICY(SET CMP0074 NEW) # Use ROOT variables when detecting packages
  32 ENDIF()
  33 IF(CMAKE_VERSION VERSION_GREATER_EQUAL 3.18)
  34   CMAKE_POLICY(SET CMP0057 NEW)
  35 ENDIF()
  36 #----------------------------------------------------------------------------
  37 # LIST_CONTAINS is a macro useful for determining whether a list has a
  38 # particular entry
  39 #----------------------------------------------------------------------------
  40 MACRO(LIST_CONTAINS var value)
  41   SET(${var})
  42   FOREACH(value2 ${ARGN})
  43     IF(${value} STREQUAL "${value2}")
  44       SET(${var} TRUE)
  45     ENDIF (${value} STREQUAL "${value2}")
  46   ENDFOREACH (value2)
  47 ENDMACRO(LIST_CONTAINS)
  48
  49 #----------------------------------------------------------------------------
  50 # The PARSE_ARGUMENTS macro will take the arguments of another macro and
  51 # define several variables.
  52 #
  53 # USAGE:  PARSE_ARGUMENTS(prefix arg_names options arg1 arg2...)
  54 #
  55 # ARGUMENTS:
  56 #
  57 # prefix: IN: a prefix to put on all variables it creates.
  58 #
  59 # arg_names: IN: a list of names.
  60 # For each item in arg_names, PARSE_ARGUMENTS will create a
  61 # variable with that name, prefixed with prefix_. Each variable will be filled
  62 # with the arguments that occur after the given arg_name is encountered
  63 # up to the next arg_name or the end of the arguments. All options are
  64 # removed from these lists. PARSE_ARGUMENTS also creates a
  65 # prefix_DEFAULT_ARGS variable containing the list of all arguments up
  66 # to the first arg_name encountered.
  67 #
  68 # options: IN: a list of options.
  69 # For each item in options, PARSE_ARGUMENTS will create a
  70 # variable with that name, prefixed with prefix_. So, for example, if prefix is
  71 # MY_MACRO and options is OPTION1;OPTION2, then PARSE_ARGUMENTS will
  72 # create the variables MY_MACRO_OPTION1 and MY_MACRO_OPTION2. These
  73 # variables will be set to true if the option exists in the command line
  74 # or false otherwise.
  75 # arg_names and options lists should be quoted.
  76 #
  77 # The rest of PARSE_ARGUMENTS are arguments from another macro to be parsed.
  78 #----------------------------------------------------------------------------
  79 MACRO(PARSE_ARGUMENTS prefix arg_names option_names)
  80   SET(DEFAULT_ARGS)
  81   FOREACH(arg_name ${arg_names})
  82     SET(${prefix}_${arg_name})
  83   ENDFOREACH(arg_name)
  84   FOREACH(option ${option_names})
  85     SET(${prefix}_${option} FALSE)
  86   ENDFOREACH(option)
  87   SET(current_arg_name DEFAULT_ARGS)
  88   SET(current_arg_list)
  89   FOREACH(arg ${ARGN})
  90     LIST_CONTAINS(is_arg_name ${arg} ${arg_names})
  91     IF (is_arg_name)
  92       SET(${prefix}_${current_arg_name} ${current_arg_list})
  93       SET(current_arg_name ${arg})
  94       SET(current_arg_list)
  95     ELSE (is_arg_name)
  96       LIST_CONTAINS(is_option ${arg} ${option_names})
  97       IF (is_option)
  98       SET(${prefix}_${arg} TRUE)
  99       ELSE (is_option)
 100       SET(current_arg_list ${current_arg_list} ${arg})
 101       ENDIF (is_option)
 102     ENDIF (is_arg_name)
 103   ENDFOREACH(arg)
 104   SET(${prefix}_${current_arg_name} ${current_arg_list})
 105 ENDMACRO(PARSE_ARGUMENTS)
 106
 107 #----------------------------------------------------------------------------
 108 # SALOME_INSTALL_SCRIPTS is a macro useful for installing scripts.
 109 #
 110 # USAGE: SALOME_INSTALL_SCRIPTS(file_list path [WORKING_DIRECTORY dir] [DEF_PERMS] [TARGET_NAME name])
 111 #
 112 # ARGUMENTS:
 113 # file_list: IN : list of files to be installed. This list should be quoted.
 114 # path: IN : full pathname for installing.
 115 #
 116 # By default files to be installed as executable scripts.
 117 # If DEF_PERMS option is provided, than permissions for installed files are
 118 # only OWNER_WRITE, OWNER_READ, GROUP_READ, and WORLD_READ.
 119 # WORKING_DIRECTORY option may be used to specify the relative or absolute
 120 # path to the directory containing source files listed in file_list argument.
 121 # If TARGET_NAME option is specified, the name of the target being created
 122 # with this macro is returned via the given variable.
 123 #----------------------------------------------------------------------------
 124 MACRO(SALOME_INSTALL_SCRIPTS file_list path)
 125   PARSE_ARGUMENTS(SALOME_INSTALL_SCRIPTS "WORKING_DIRECTORY;TARGET_NAME;EXTRA_DPYS" "DEF_PERMS" ${ARGN})
 126   SET(PERMS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
 127   IF(NOT SALOME_INSTALL_SCRIPTS_DEF_PERMS)
 128     SET(PERMS ${PERMS} OWNER_EXECUTE GROUP_EXECUTE WORLD_EXECUTE)
 129   ENDIF(NOT SALOME_INSTALL_SCRIPTS_DEF_PERMS)
 130   SET(_all_pyc)
 131   SET(_all_pyo)
 132   FOREACH(file ${file_list})
 133     SET(PREFIX "")
 134     SET(_source_prefix "")
 135     GET_FILENAME_COMPONENT(file_name ${file} NAME)
 136     IF(NOT IS_ABSOLUTE ${file})
 137       SET(_source_prefix "${CMAKE_CURRENT_SOURCE_DIR}/")
 138       IF(SALOME_INSTALL_SCRIPTS_WORKING_DIRECTORY)
 139         SET(PREFIX "${SALOME_INSTALL_SCRIPTS_WORKING_DIRECTORY}/")
 140         SET(_source_prefix "${SALOME_INSTALL_SCRIPTS_WORKING_DIRECTORY}/")
 141       ENDIF(SALOME_INSTALL_SCRIPTS_WORKING_DIRECTORY)
 142     ENDIF(NOT IS_ABSOLUTE ${file})
 143     INSTALL(FILES ${PREFIX}${file} DESTINATION ${path} PERMISSIONS ${PERMS})
 144     GET_FILENAME_COMPONENT(ext ${file} EXT)
 145     GET_FILENAME_COMPONENT(we_ext ${file} NAME_WE)
 146
 147     IF(ext STREQUAL .py)
 148       # Generate and install the pyc and pyo
 149       # [ABN] Important: we avoid references or usage of CMAKE_INSTALL_PREFIX which is not correctly set
 150       # when using CPack.
 151       SET(_pyc_file "${CMAKE_CURRENT_BINARY_DIR}/${we_ext}.cpython-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}.pyc")
 152       SET(_pyo_file "${CMAKE_CURRENT_BINARY_DIR}/${we_ext}.cpython-${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}.opt-1.pyc")
 153       LIST(APPEND _all_pyc ${_pyc_file})
 154       LIST(APPEND _all_pyo ${_pyo_file})
 155       ADD_CUSTOM_COMMAND(
 156         OUTPUT ${_pyc_file} ${_pyo_file}
 157         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)"
 158         DEPENDS ${PREFIX}${file}
 159         VERBATIM
 160       )
 161       # Install the .pyo and the .pyc
 162       INSTALL(FILES ${_pyc_file} DESTINATION ${path}/__pycache__ PERMISSIONS ${PERMS})
 163       INSTALL(FILES ${_pyo_file} DESTINATION ${path}/__pycache__ PERMISSIONS ${PERMS})
 164     ENDIF(ext STREQUAL .py)
 165
 166   # get relative path (from CMAKE_SOURCE_DIR to CMAKE_CURRENT_SOURCE_DIR)
 167   STRING(REGEX REPLACE ${CMAKE_SOURCE_DIR} "" rel_dir ${CMAKE_CURRENT_SOURCE_DIR})
 168   # convert "/" to "_"
 169   IF(rel_dir)
 170     STRING(REGEX REPLACE "/" "_" unique_name ${rel_dir})
 171   ELSE(rel_dir)
 172     SET(unique_name _)
 173   ENDIF(rel_dir)
 174
 175   ENDFOREACH(file ${file_list})
 176   # Generate only one target for all requested Python script compilation.
 177   # Make sure that the target name is unique too.
 178   IF(_all_pyc)
 179      SET(_cnt 0)
 180      WHILE(TARGET "PYCOMPILE${unique_name}_${_cnt}")
 181        MATH(EXPR _cnt ${_cnt}+1)
 182      ENDWHILE()
 183      SET(_target_name "PYCOMPILE${unique_name}_${_cnt}")
 184      ADD_CUSTOM_TARGET(${_target_name} ALL DEPENDS ${_all_pyc} ${_all_pyo})
 185      IF(SALOME_INSTALL_SCRIPTS_TARGET_NAME)
 186        SET(${SALOME_INSTALL_SCRIPTS_TARGET_NAME} ${_target_name})
 187      ENDIF(SALOME_INSTALL_SCRIPTS_TARGET_NAME)
 188      IF(SALOME_INSTALL_SCRIPTS_EXTRA_DPYS)
 189        ADD_DEPENDENCIES(${_target_name} ${SALOME_INSTALL_SCRIPTS_EXTRA_DPYS})
 190      ENDIF(SALOME_INSTALL_SCRIPTS_EXTRA_DPYS)
 191   ENDIF()
 192 ENDMACRO(SALOME_INSTALL_SCRIPTS)
 193
 194 #----------------------------------------------------------------------------
 195 # SALOME_CONFIGURE_FILE is a macro useful for copying a file to another location
 196 # and modify its contents.
 197 #
 198 # USAGE: SALOME_CONFIGURE_FILE(in_file out_file [INSTALL dir [EXEC_PERMS]])
 199 #
 200 # ARGUMENTS:
 201 # in_file: IN : input file (if relative path is given, full file path is computed from current source dir).
 202 # out_file: IN : output file (if relative path is given, full file path is computed from current build dir).
 203 # If INSTALL is specified, then 'out_file' will be installed to the 'dir' directory.
 204 # In this case, EXEC_PERMS can be used to set execution permission for installed file.
 205 #----------------------------------------------------------------------------
 206 MACRO(SALOME_CONFIGURE_FILE IN_FILE OUT_FILE)
 207   IF(IS_ABSOLUTE ${IN_FILE})
 208     SET(_in_file ${IN_FILE})
 209   ELSE()
 210     SET(_in_file ${CMAKE_CURRENT_SOURCE_DIR}/${IN_FILE})
 211   ENDIF()
 212   IF(IS_ABSOLUTE  ${OUT_FILE})
 213     SET(_out_file ${OUT_FILE})
 214   ELSE()
 215     SET(_out_file ${CMAKE_CURRENT_BINARY_DIR}/${OUT_FILE})
 216   ENDIF()
 217   MESSAGE(STATUS "Creation of ${_out_file}")
 218   CONFIGURE_FILE(${_in_file} ${_out_file} @ONLY)
 219   PARSE_ARGUMENTS(SALOME_CONFIGURE_FILE "INSTALL" "EXEC_PERMS" ${ARGN})
 220   IF(SALOME_CONFIGURE_FILE_INSTALL)
 221     SET(PERMS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
 222     IF(SALOME_CONFIGURE_FILE_EXEC_PERMS)
 223       SET(PERMS ${PERMS} OWNER_EXECUTE GROUP_EXECUTE WORLD_EXECUTE)
 224     ENDIF(SALOME_CONFIGURE_FILE_EXEC_PERMS)
 225     INSTALL(FILES ${_out_file} DESTINATION ${SALOME_CONFIGURE_FILE_INSTALL} PERMISSIONS ${PERMS})
 226   ENDIF(SALOME_CONFIGURE_FILE_INSTALL)
 227 ENDMACRO(SALOME_CONFIGURE_FILE)
 228
 229
 230 #######################################################################################
 231 # Useful macros for SALOME own package detection system
 232 #
 233
 234 ###
 235 # SALOME_CHECK_EQUAL_PATHS(result path1 path2)
 236 #  Check if two paths are identical, resolving links. If the paths do not exist a simple
 237 #  text comparison is performed.
 238 #  result is a boolean.
 239 ###
 240 MACRO(SALOME_CHECK_EQUAL_PATHS varRes path1 path2)
 241   SET("${varRes}" OFF)
 242   IF(EXISTS "${path1}")
 243     GET_FILENAME_COMPONENT(_tmp1 "${path1}" REALPATH)
 244   ELSE()
 245     SET(_tmp1 "${path1}")
 246   ENDIF()
 247
 248   IF(EXISTS "${path2}")
 249     GET_FILENAME_COMPONENT(_tmp2 "${path2}" REALPATH)
 250   ELSE()
 251     SET(_tmp2 "${path2}")
 252   ENDIF()
 253
 254   IF("${_tmp1}" STREQUAL "${_tmp2}")
 255     SET("${varRes}" ON)
 256   ENDIF()
 257 #  MESSAGE(${${varRes}})
 258 ENDMACRO()
 259
 260 ####
 261 # SALOME_LOG_OPTIONAL_PACKAGE(pkg flag)
 262 #
 263 # Register in global variables the detection status (found or not) of the optional package 'pkg'
 264 # and the configuration flag that should be turned off to avoid detection of the package.
 265 # The global variables are read again by SALOME_PACKAGE_REPORT_AND_CHECK to produce
 266 # a summary report of the detection status and stops the process if necessary.
 267 MACRO(SALOME_LOG_OPTIONAL_PACKAGE pkg flag)
 268   # Was the package found
 269   STRING(TOUPPER ${pkg} _pkg_UC)
 270   IF(${pkg}_FOUND OR ${_pkg_UC}_FOUND)
 271     SET(_isFound TRUE)
 272   ELSE()
 273     SET(_isFound FALSE)
 274   ENDIF()
 275
 276   # Is the package already in the list? Then update its status:
 277   LIST(FIND _SALOME_OPTIONAL_PACKAGES_names ${pkg} _result)
 278   IF(NOT ${_result} EQUAL -1)
 279     LIST(REMOVE_AT _SALOME_OPTIONAL_PACKAGES_found ${_result})
 280     LIST(REMOVE_AT _SALOME_OPTIONAL_PACKAGES_flags ${_result})
 281     LIST(INSERT    _SALOME_OPTIONAL_PACKAGES_found ${_result} ${_isFound})
 282     LIST(INSERT    _SALOME_OPTIONAL_PACKAGES_flags ${_result} ${flag})
 283   ELSE()
 284     # Otherwise insert it
 285     LIST(APPEND _SALOME_OPTIONAL_PACKAGES_names ${pkg})
 286     LIST(APPEND _SALOME_OPTIONAL_PACKAGES_found ${_isFound})
 287     LIST(APPEND _SALOME_OPTIONAL_PACKAGES_flags ${flag})
 288   ENDIF()
 289
 290 ENDMACRO(SALOME_LOG_OPTIONAL_PACKAGE)
 291
 292 ####
 293 # SALOME_JUSTIFY_STRING()
 294 #
 295 # Justifies the string specified as an argument to the given length
 296 # adding required number of spaces to the end. Does noting if input
 297 # string is longer as required length.
 298 # Puts the result to the output variable.
 299 #
 300 # USAGE: SALOME_JUSTIFY_STRING(input length result)
 301 #
 302 # ARGUMENTS:
 303 #   input  [in] input string
 304 #   length [in] required length of resulting string
 305 #   result [out] name of variable where the result string is put to
 306 #
 307 MACRO(SALOME_JUSTIFY_STRING input length result)
 308   SET(${result} ${input})
 309   STRING(LENGTH ${input} _input_length)
 310   MATH(EXPR _nb_spaces "${length}-${_input_length}-1")
 311   IF (_nb_spaces GREATER 0)
 312     FOREACH(_idx RANGE ${_nb_spaces})
 313       SET(${result} "${${result}} ")
 314     ENDFOREACH()
 315   ENDIF()
 316 ENDMACRO(SALOME_JUSTIFY_STRING)
 317
 318 ####
 319 # SALOME_PACKAGE_REPORT_AND_CHECK()
 320 #
 321 # Print a quick summary of the detection of optional prerequisites.
 322 # If a package was not found, the configuration is stopped. The summary also indicates
 323 # which flag should be turned off to skip the detection of the package.
 324 #
 325 # If optional JUSTIFY argument is specified, names of packages
 326 # are left-justified to the given length; default value is 10.
 327 #
 328 # USAGE: SALOME_PACKAGE_REPORT_AND_CHECK([JUSTIFY length])
 329 #
 330 MACRO(SALOME_PACKAGE_REPORT_AND_CHECK)
 331   SET(_will_fail OFF)
 332   PARSE_ARGUMENTS(SALOME_PACKAGE_REPORT "JUSTIFY" "" ${ARGN})
 333   IF(SALOME_PACKAGE_REPORT_JUSTIFY)
 334     SET(_length ${SALOME_PACKAGE_REPORT_JUSTIFY})
 335   ELSE()
 336     SET(_length 23)
 337   ENDIF()
 338   IF(DEFINED _SALOME_OPTIONAL_PACKAGES_names)
 339     MESSAGE(STATUS "")
 340     MESSAGE(STATUS "  Optional packages - Detection report ")
 341     MESSAGE(STATUS "  ==================================== ")
 342     MESSAGE(STATUS "")
 343     LIST(LENGTH _SALOME_OPTIONAL_PACKAGES_names _list_len)
 344     # Another CMake stupidity - FOREACH(... RANGE r) generates r+1 numbers ...
 345     MATH(EXPR _range "${_list_len}-1")
 346     FOREACH(_idx RANGE ${_range})
 347       LIST(GET _SALOME_OPTIONAL_PACKAGES_names ${_idx} _pkg_name)
 348       LIST(GET _SALOME_OPTIONAL_PACKAGES_found ${_idx} _pkg_found)
 349       LIST(GET _SALOME_OPTIONAL_PACKAGES_flags ${_idx} _pkg_flag)
 350       SALOME_JUSTIFY_STRING(${_pkg_name} ${_length} _pkg_name)
 351       IF(_pkg_found)
 352         SET(_found_msg "Found")
 353         SET(_flag_msg "")
 354       ELSE()
 355         SET(_will_fail ON)
 356         SET(_found_msg "NOT Found")
 357         SET(_flag_msg " - ${_pkg_flag} can be switched OFF to skip this prerequisite.")
 358       ENDIF()
 359
 360       MESSAGE(STATUS "  * ${_pkg_name}  ->  ${_found_msg}${_flag_msg}")
 361     ENDFOREACH()
 362     MESSAGE(STATUS "")
 363     MESSAGE(STATUS "")
 364   ENDIF(DEFINED _SALOME_OPTIONAL_PACKAGES_names)
 365
 366   # Failure if some packages were missing:
 367   IF(_will_fail)
 368     MESSAGE(FATAL_ERROR "Some required prerequisites have NOT been found. Take a look at the report above to fix this.")
 369   ENDIF()
 370 ENDMACRO(SALOME_PACKAGE_REPORT_AND_CHECK)
 371
 372 ####
 373 # SALOME_FIND_PACKAGE(englobingPackageName standardPackageName modus [onlyTryQuietly])
 374 #
 375 # example:  SALOME_FIND_PACKAGE(SalomeVTK VTK CONFIG)
 376 #
 377 # Encapsulate the call to the standard FIND_PACKAGE(standardPackageName) passing all the options
 378 # given when calling the command FIND_PACKAGE(SalomeXYZ). Those options are stored implicitly in
 379 # CMake variables: xyz__FIND_QUIETLY, xyz_FIND_REQUIRED, etc ...
 380 #
 381 # If a list of components was specified when invoking the initial FIND_PACKAGE(SalomeXyz ...) this is
 382 # also handled properly.
 383 #
 384 # Modus is either MODULE or CONFIG (cf standard FIND_PACKAGE() documentation).
 385 # The last argument is optional and if set to TRUE will force the search to be OPTIONAL and QUIET.
 386 # If the package is looked for in CONFIG mode, the standard system paths are skipped. If you still want a
 387 # system installation to be found in this mode, you have to set the ROOT_DIR variable explicitly to /usr (for
 388 # example).
 389 #
 390 # This macro is to be called from within the FindSalomeXXXX.cmake file.
 391 #
 392 ####
 393 MACRO(SALOME_FIND_PACKAGE englobPkg stdPkg mode)
 394   SET(_OPT_ARG ${ARGV3})
 395   # Only bother if the package was not already found:
 396   # Some old packages use the lower case version - standard should be to always use
 397   # upper case:
 398   STRING(TOUPPER ${stdPkg} stdPkgUC)
 399   IF(NOT (${stdPkg}_FOUND OR ${stdPkgUC}_FOUND))
 400     IF(${englobPkg}_FIND_QUIETLY OR _OPT_ARG)
 401       SET(_tmp_quiet "QUIET")
 402     ELSE()
 403       SET(_tmp_quiet)
 404     ENDIF()
 405     IF(${englobPkg}_FIND_REQUIRED AND NOT _OPT_ARG)
 406       SET(_tmp_req "REQUIRED")
 407     ELSE()
 408       SET(_tmp_req)
 409     ENDIF()
 410     IF(${englobPkg}_FIND_VERSION_EXACT)
 411       SET(_tmp_exact "EXACT")
 412     ELSE()
 413       SET(_tmp_exact)
 414     ENDIF()
 415
 416     # Call the CMake FIND_PACKAGE() command:
 417     STRING(TOLOWER ${stdPkg} _pkg_lc)
 418     IF(("${mode}" STREQUAL "NO_MODULE") OR ("${mode}" STREQUAL "CONFIG"))
 419       # Hope to find direclty a CMake config file, indicating the SALOME CMake file
 420       # paths (the command already looks in places like "share/cmake", etc ... by default)
 421       # Note the options NO_CMAKE_BUILDS_PATH, NO_CMAKE_PACKAGE_REGISTRY to avoid (under Windows)
 422       # looking into a previous CMake build done via a GUI, or into the Win registry.
 423       # NO_CMAKE_SYSTEM_PATH and NO_SYSTEM_ENVIRONMENT_PATH ensure any _system_ files like 'xyz-config.cmake'
 424       # don't get loaded (typically Boost). To force their loading, set the XYZ_ROOT_DIR variable to '/usr'.
 425       # See documentation of FIND_PACKAGE() for full details.
 426
 427       # Do we need to call the signature using components?
 428       IF(${englobPkg}_FIND_COMPONENTS)
 429         FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact}
 430               NO_MODULE ${_tmp_quiet} ${_tmp_req} COMPONENTS ${${englobPkg}_FIND_COMPONENTS}
 431               PATH_SUFFIXES "salome_adm/cmake_files" "adm_local/cmake_files" "adm/cmake"
 432               NO_CMAKE_BUILDS_PATH NO_CMAKE_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PATH
 433                 NO_SYSTEM_ENVIRONMENT_PATH)
 434       ELSE()
 435         FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact}
 436               NO_MODULE ${_tmp_quiet} ${_tmp_req}
 437               PATH_SUFFIXES "salome_adm/cmake_files" "adm_local/cmake_files" "adm/cmake"
 438               NO_CMAKE_BUILDS_PATH NO_CMAKE_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PATH
 439                  NO_SYSTEM_ENVIRONMENT_PATH)
 440       ENDIF()
 441       MARK_AS_ADVANCED(${stdPkg}_DIR)
 442
 443     ELSEIF("${mode}" STREQUAL "MODULE")
 444
 445       # Do we need to call the signature using components?
 446       IF(${englobPkg}_FIND_COMPONENTS)
 447         FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact}
 448               MODULE ${_tmp_quiet} ${_tmp_req} COMPONENTS ${${englobPkg}_FIND_COMPONENTS})
 449       ELSE()
 450         FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact}
 451               MODULE ${_tmp_quiet} ${_tmp_req})
 452       ENDIF()
 453
 454     ELSE()
 455
 456       MESSAGE(FATAL_ERROR "Invalid mode argument in the call to the macro SALOME_FIND_PACKAGE. Should be CONFIG or MODULE.")
 457
 458     ENDIF()
 459
 460   ENDIF()
 461 ENDMACRO()
 462
 463
 464 ####################################################################
 465 # SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS(pkg referenceVariable upCount)
 466 #    pkg              : name of the system package to be detected
 467 #    referenceVariable: variable containing a path that can be browsed up to
 468 # retrieve the package root directory (xxx_ROOT_DIR)
 469 #    upCount          : number of times we have to go up from the path <referenceVariable>
 470 # to obtain the package root directory.
 471 # If this is a path to a file, going up one time gives the directory containing the file
 472 # going up 2 times gives the parent directory.
 473 #
 474 # For example:  SALOME_FIND_PACKAGE_DETECT_CONFLICTS(SWIG SWIG_EXECUTABLE 2)
 475 #     with SWIG_EXECUTABLE set to '/usr/bin/swig'
 476 #     will produce '/usr'
 477 #
 478 # Generic detection (and conflict check) procedure for package XYZ:
 479 # 1. Load a potential env variable XYZ_ROOT_DIR as a default choice for the cache entry XYZ_ROOT_DIR
 480 #    If empty, load a potential XYZ_ROOT_DIR_EXP as default value (path exposed by another package depending
 481 # directly on XYZ)
 482 # 2. Invoke FIND_PACKAGE() in this order:
 483 #    * in CONFIG mode first (if possible): priority is given to a potential
 484 #    "XYZ-config.cmake" file
 485 #    * then switch to the standard MODULE mode, appending on CMAKE_PREFIX_PATH
 486 # the above XYZ_ROOT_DIR variable
 487 # 3. Extract the path actually found into a temp variable _XYZ_TMP_DIR
 488 # 4. Warn if XYZ_ROOT_DIR is set and doesn't match what was found (e.g. when CMake found the system installation
 489 #    instead of what is pointed to by XYZ_ROOT_DIR - happens when a typo in the content of XYZ_ROOT_DIR).
 490 # 5. Conflict detection:
 491 #    * check the temp variable against a potentially existing XYZ_ROOT_DIR_EXP
 492 # 6. Finally expose what was *actually* found in XYZ_ROOT_DIR.
 493 # 7. Specific stuff: for example exposing a prerequisite of XYZ to the rest of the world for future
 494 # conflict detection. This is added after the call to the macro by the callee.
 495 #
 496 MACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS pkg referenceVariable upCount)
 497   ##
 498   ## 0. Initialization
 499   ##
 500   PARSE_ARGUMENTS(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS "ENVVAR" "" ${ARGN})
 501
 502   # Package name, upper case
 503   STRING(TOUPPER ${pkg} pkg_UC)
 504
 505   ##
 506   ## 1. Load environment or any previously detected root dir for the package
 507   ##
 508   SET(_envvar ${pkg_UC}_ROOT_DIR)
 509   IF(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS_ENVVAR)
 510     SET(_envvar "${SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS_ENVVAR}")
 511   ENDIF()
 512   IF(DEFINED ENV{${_envvar}})
 513     FILE(TO_CMAKE_PATH "$ENV{${_envvar}}" _${pkg_UC}_ROOT_DIR_ENV)
 514     SET(_dflt_value "${_${pkg_UC}_ROOT_DIR_ENV}")
 515   ELSE()
 516     # will be blank if no package was previously loaded:
 517     SET(_dflt_value "${${pkg_UC}_ROOT_DIR_EXP}")
 518   ENDIF()
 519   # Detect if the variable has been set on the command line or elsewhere:
 520   IF(DEFINED ${_envvar})
 521      SET(_var_already_there TRUE)
 522   ELSE()
 523      SET(_var_already_there FALSE)
 524   ENDIF()
 525   #   Make cache entry
 526   SET(${_envvar} "${_dflt_value}" CACHE PATH "Path to ${pkg_UC} directory")
 527
 528   ##
 529   ## 2. Find package - try CONFIG mode first (i.e. looking for XYZ-config.cmake)
 530   ##
 531
 532   # Override the variable - don't append to it, as it would give precedence
 533   # to what was stored there before!
 534   IF(DEFINED ${_envvar})
 535     SET(CMAKE_PREFIX_PATH "${${_envvar}}")
 536   ENDIF()
 537
 538   # Try find_package in config mode. This has the priority, but is
 539   # performed QUIET and not REQUIRED:
 540   SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} NO_MODULE TRUE)
 541
 542   IF (${pkg_UC}_FOUND OR ${pkg}_FOUND)
 543     MESSAGE(STATUS "Found ${pkg} in CONFIG mode!")
 544   ENDIF()
 545
 546   # Otherwise try the standard way (module mode, with the standard CMake Find*** macro):
 547   # We do it quietly to produce our own error message, except if we are in debug mode:
 548   IF(SALOME_CMAKE_DEBUG)
 549     SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} MODULE FALSE)
 550   ELSE()
 551     SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} MODULE TRUE)
 552   ENDIF()
 553
 554   # Set the "FOUND" variable for the SALOME wrapper:
 555   IF(${pkg_UC}_FOUND OR ${pkg}_FOUND)
 556     SET(SALOME${pkg_UC}_FOUND TRUE)
 557   ELSE()
 558     SET(SALOME${pkg_UC}_FOUND FALSE)
 559     IF(NOT Salome${pkg}_FIND_QUIETLY)
 560       IF(Salome${pkg}_FIND_REQUIRED)
 561          MESSAGE(FATAL_ERROR "Package ${pkg} couldn't be found - did you set the corresponing root dir correctly? "
 562          "It currently contains ${_envvar}=${${_envvar}}  "
 563          "Append -DSALOME_CMAKE_DEBUG=ON on the command line if you want to see the original CMake error.")
 564       ELSE()
 565          MESSAGE(WARNING "Package ${pkg} couldn't be found - did you set the corresponing root dir correctly? "
 566          "It currently contains ${_envvar}=${${_envvar}}  "
 567          "Append -DSALOME_CMAKE_DEBUG=ON on the command line if you want to see the original CMake error.")
 568       ENDIF()
 569     ENDIF()
 570   ENDIF()
 571
 572   IF (${pkg_UC}_FOUND OR ${pkg}_FOUND)
 573     ## 3. Set the root dir which was finally retained by going up "upDir" times
 574     ## from the given reference path. The variable "referenceVariable" may be a list.
 575     ## In this case we take its first element.
 576
 577     # First test if the variable exists, warn otherwise:
 578     IF(NOT DEFINED ${referenceVariable})
 579       MESSAGE(WARNING "${pkg}: the reference variable '${referenceVariable}' used when calling the macro "
 580       "SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS() is not defined.")
 581     ENDIF()
 582
 583     LIST(LENGTH ${referenceVariable} _tmp_len)
 584     IF(_tmp_len)
 585        LIST(GET ${referenceVariable} 0 _tmp_ROOT_DIR)
 586     ELSE()
 587        #  Note the double de-reference of "referenceVariable":
 588        SET(_tmp_ROOT_DIR "${${referenceVariable}}")
 589     ENDIF()
 590     # Up count can be reset by detection procedure
 591     SET(_upCount ${upCount})
 592     IF(DEFINED ${pkg_UC}_UPCOUNT)
 593       SET(_upCount ${${pkg_UC}_UPCOUNT})
 594     ENDIF()
 595     IF(${_upCount} GREATER 0)
 596       FOREACH(_unused RANGE 1 ${_upCount})
 597         GET_FILENAME_COMPONENT(_tmp_ROOT_DIR "${_tmp_ROOT_DIR}" PATH)
 598       ENDFOREACH()
 599     ENDIF()
 600
 601     ##
 602     ## 4. Warn if CMake found something not located under ENV(XYZ_ROOT_DIR)
 603     ##
 604     IF(DEFINED ENV{${_envvar}})
 605       SALOME_CHECK_EQUAL_PATHS(_res "${_tmp_ROOT_DIR}" "${_${pkg_UC}_ROOT_DIR_ENV}")
 606       IF(NOT _res)
 607         MESSAGE(WARNING "${pkg} was found, but not at the path given by the "
 608             "environment ${_envvar}! Is the variable correctly set? "
 609             "The two paths are: ${_tmp_ROOT_DIR} and: ${_${pkg_UC}_ROOT_DIR_ENV}")
 610
 611       ELSE()
 612         MESSAGE(STATUS "${pkg} found directory matches what was specified in the ${_envvar} variable, all good!")
 613       ENDIF()
 614     ELSE()
 615         IF(NOT _var_already_there)
 616           MESSAGE(STATUS "Variable ${_envvar} was not explicitly defined. "
 617           "An installation was found anyway: ${_tmp_ROOT_DIR}")
 618         ENDIF()
 619     ENDIF()
 620
 621     ##
 622     ## 5. Conflict detection
 623     ##     From another prerequisite using the package:
 624     ##
 625     IF(${pkg_UC}_ROOT_DIR_EXP)
 626         SALOME_CHECK_EQUAL_PATHS(_res "${_tmp_ROOT_DIR}" "${${pkg_UC}_ROOT_DIR_EXP}")
 627         IF(NOT _res)
 628            MESSAGE(WARNING "Warning: ${pkg}: detected version conflicts with a previously found ${pkg}!"
 629                            " The two paths are " ${_tmp_ROOT_DIR} " vs " ${${pkg_UC}_ROOT_DIR_EXP})
 630         ELSE()
 631             MESSAGE(STATUS "${pkg} directory matches what was previously exposed by another prereq, all good!")
 632         ENDIF()
 633     ENDIF()
 634
 635     ##
 636     ## 6. Save the detected installation
 637     ##
 638     SET(${_envvar} "${_tmp_ROOT_DIR}")
 639
 640   ELSE()
 641     MESSAGE(STATUS "${pkg} was not found.")
 642   ENDIF()
 643
 644   SET(Salome${pkg}_FOUND "${pkg}_FOUND")
 645 ENDMACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS)
 646
 647
 648 ####################################################################
 649 # SALOME_ADD_MPI_TO_HDF5()
 650 #
 651 # Overload the HDF5 flags so that they also contain MPI references.
 652 # This is to be used when HDF5 was compiled with MPI support;
 653 MACRO(SALOME_ADD_MPI_TO_HDF5)
 654   SET(HDF5_INCLUDE_DIRS ${HDF5_INCLUDE_DIRS} ${MPI_INCLUDE_DIRS})
 655   SET(HDF5_DEFINITIONS "${HDF5_DEFINITIONS} ${MPI_DEFINITIONS}")
 656   SET(HDF5_LIBRARIES ${HDF5_LIBRARIES} ${MPI_LIBRARIES})
 657 ENDMACRO(SALOME_ADD_MPI_TO_HDF5)
 658
 659 ####################################################################
 660 # SALOME_TOHEXA()
 661 # Convert a number (smaller than 16) into hexadecimal representation
 662 # with a leading 0.
 663 MACRO(SALOME_TOHEXA num result)
 664   SET(_hexa_map a b c d e f)
 665   IF(${num} LESS 10)
 666     SET(${result} "0${num}")
 667   ELSE()
 668     MATH(EXPR _res "${num}-10" )
 669     LIST(GET _hexa_map ${_res} _out)
 670     SET(${result} "0${_out}")
 671   ENDIF()
 672 ENDMACRO(SALOME_TOHEXA)
 673
 674 ####################################################################
 675 # SALOME_XVERSION()
 676 #
 677 # Computes hexadecimal version of SALOME package
 678 #
 679 # USAGE: SALOME_XVERSION(package)
 680 #
 681 # ARGUMENTS:
 682 #
 683 # package: IN: SALOME package name
 684 #
 685 # The macro reads SALOME package version from PACKAGE_VERSION variable
 686 # (note package name in uppercase as assumed for SALOME modules);
 687 # hexadecimal version value in form 0xAABBCC (where AA, BB and CC are
 688 # major, minor and maintenance components of package version in
 689 # hexadecimal form) is put to the PACKAGE_XVERSION variable
 690 MACRO(SALOME_XVERSION pkg)
 691   STRING(TOUPPER ${pkg} _pkg_UC)
 692   IF(${_pkg_UC}_VERSION)
 693     SET(_major)
 694     SET(_minor)
 695     SET(_patch)
 696     SALOME_TOHEXA(${${_pkg_UC}_MAJOR_VERSION} _major)
 697     SALOME_TOHEXA(${${_pkg_UC}_MINOR_VERSION} _minor)
 698     SALOME_TOHEXA(${${_pkg_UC}_PATCH_VERSION} _patch)
 699     SET(${_pkg_UC}_XVERSION "0x${_major}${_minor}${_patch}")
 700   ENDIF()
 701 ENDMACRO(SALOME_XVERSION)
 702
 703
 704 #########################################################################
 705 # SALOME_ACCUMULATE_HEADERS()
 706 #
 707 # This macro is called in the various FindSalomeXYZ.cmake modules to accumulate
 708 # internally the list of include headers to be saved for future export.
 709 # The full set of include is saved in a variable called
 710 #      _${PROJECT_NAME}_EXTRA_HEADERS
 711 #
 712 MACRO(SALOME_ACCUMULATE_HEADERS lst)
 713   FOREACH(l IN LISTS ${lst})
 714     LIST(FIND _${PROJECT_NAME}_EXTRA_HEADERS "${l}" _res)
 715     IF(_res EQUAL "-1")
 716       IF(NOT "${l}" STREQUAL "/usr/include")
 717         LIST(APPEND _${PROJECT_NAME}_EXTRA_HEADERS "${l}")
 718       ENDIF()
 719     ENDIF()
 720   ENDFOREACH()
 721 ENDMACRO(SALOME_ACCUMULATE_HEADERS)
 722
 723 #########################################################################
 724 # SALOME_ACCUMULATE_ENVIRONMENT()
 725 #
 726 # USAGE: SALOME_ACCUMULATE_ENVIRONMENT(envvar value [value ...])
 727 #
 728 # ARGUMENTS:
 729 #   envvar [in] environment variable name, e.g. PATH
 730 #   value  [in] value(s) to be added to environment variable
 731 #
 732 # This macro is called in the various FindSalomeXYZ.cmake modules to
 733 # accumulate environment variables, to be used later to run some command
 734 # in proper environment.
 735 #
 736 # 1. Each envrironment variable is stored in specific CMake variable
 737 #    _${PROJECT_NAME}_EXTRA_ENV_<var>, where <var> is name of variable.
 738 # 2. Full list of environment variable names is stored in CMake variable
 739 #    _${PROJECT_NAME}_EXTRA_ENV.
 740 #
 741 # Notes:
 742 # - The arguments list can include optional CHECK or NOCHECK keywords:
 743 #   * For all arguments following CHECK keyword the macro perform an
 744 #     additional check (see below); this is the default mode, it is suitable
 745 #     for path variables (PATH, LD_LIBRARY_PATH, etc).
 746 #   * For all arguments following NOCHECK keyword, no additional check is
 747 #     performed.
 748 #   Checking an argument means that we check:
 749 #    - That the path actually exists
 750 #    - That this is not a standard system path (starting with "/usr"); this avoids
 751 #   polluting LD_LIBRARY_PATH or PATH with things like "/usr/lib64" ...
 752 #
 753 MACRO(SALOME_ACCUMULATE_ENVIRONMENT envvar)
 754   SET(_is_check ON)
 755   FOREACH(_item ${ARGN})
 756     IF(${_item} STREQUAL "NOCHECK")
 757       SET(_is_check OFF)
 758     ELSEIF(${_item} STREQUAL "CHECK")
 759       SET(_is_check ON)
 760     ELSE()
 761       IF(_is_check)
 762         IF(NOT IS_DIRECTORY ${_item})
 763           IF(TARGET ${_item})
 764             GET_TARGET_PROPERTY(_target_type ${_item} TYPE)
 765             IF(NOT ${_target_type} STREQUAL "INTERFACE_LIBRARY")
 766               GET_TARGET_PROPERTY(_item ${_item} LOCATION)
 767             ENDIF()
 768           ENDIF()
 769           GET_FILENAME_COMPONENT(_item ${_item} PATH)
 770         ENDIF()
 771         IF(EXISTS ${_item})
 772           STRING(REGEX MATCH "^(/usr|/lib|/bin)" _usr_find ${_item})
 773           LIST(FIND _${PROJECT_NAME}_EXTRA_ENV_${envvar} ${_item} _res)
 774           IF(NOT _usr_find AND _res EQUAL -1)
 775               LIST(APPEND _${PROJECT_NAME}_EXTRA_ENV_${envvar} ${_item})
 776           ENDIF()
 777         ENDIF()
 778       ELSE(_is_check)
 779         LIST(FIND _${PROJECT_NAME}_EXTRA_ENV_${envvar} ${_item} _res)
 780         IF( _res EQUAL -1)
 781           LIST(APPEND _${PROJECT_NAME}_EXTRA_ENV_${envvar} ${_item})
 782         ENDIF()
 783       ENDIF(_is_check)
 784     ENDIF()
 785   ENDFOREACH()
 786
 787   LIST(FIND _${PROJECT_NAME}_EXTRA_ENV ${envvar} _res)
 788   IF(_res EQUAL -1)
 789     LIST(APPEND _${PROJECT_NAME}_EXTRA_ENV ${envvar})
 790   ENDIF()
 791   SET(_${PROJECT_NAME}_EXTRA_ENV_FULL "SET\(${PROJECT_NAME}_EXTRA_ENV ${_${PROJECT_NAME}_EXTRA_ENV}\)")
 792   FOREACH(_res ${_${PROJECT_NAME}_EXTRA_ENV})
 793     STRING(REPLACE "${CMAKE_INSTALL_PREFIX}" "\${PACKAGE_PREFIX_DIR}" _res_path "${_${PROJECT_NAME}_EXTRA_ENV_${_res}}")
 794     SET(_${PROJECT_NAME}_EXTRA_ENV_FULL "${_${PROJECT_NAME}_EXTRA_ENV_FULL}\nSET\(${PROJECT_NAME}_EXTRA_ENV_${_res} ${_res_path}\)")
 795   ENDFOREACH()
 796 ENDMACRO(SALOME_ACCUMULATE_ENVIRONMENT)
 797
 798 #########################################################################
 799 # SALOME_GENERATE_ENVIRONMENT_SCRIPT()
 800 #
 801 # USAGE: SALOME_GENERATE_ENVIRONMENT_SCRIPT(output script cmd opts)
 802 #
 803 # ARGUMENTS:
 804 #   output [out] output command, e.g. for creation of target.
 805 #   script [in]  output environement script name
 806 #   cmd    [in]  input command, e.g. sphinx or python command.
 807 #   opts   [in]  options for input command (cmd).
 808 #
 809 # This macro is called when it's necessary to use given environment to run some command.
 810 # Macro generates environement script using previously created variables
 811 # _${PROJECT_NAME}_EXTRA_ENV_<var>, where <var> is name of variable and
 812 # _${PROJECT_NAME}_EXTRA_ENV (see marco SALOME_ACCUMULATE_ENVIRONMENT);
 813 # and puts generated command in proper environment into <output> argument. To ignore
 814 # _${PROJECT_NAME}_EXTRA_ENV_<var> and _${PROJECT_NAME}_EXTRA_ENV variables set
 815 # environment variable 'SALOME_HAS_GLOBAL_ENV=1'
 816 #
 817 # NAMED ARGUMENTS:
 818 #  CONTEXT: is used under Windows platform only to generate command file. See explanations
 819 #           below.
 820 #  CONTEXT_NAME: is used under Windows platform only to generate command file. See
 821 #                explanations below.
 822 #  ADDITIONAL_VARIABLES: list of the additional variables to write into environment script.
 823 #                        Each item of this list should be in the 'Variable=Value' format.
 824 #
 825 #
 826 # Notes:
 827 # - If <script> is specified as relative path, it is computed from the current build
 828 #   directory.
 829 # - If CONTEXT variables is passed into this macro, then on
 830 #   Windows platform command file looks like:
 831 #   =================================================
 832 #   IF SET_${CONTEXT}_VARS == 1 GOTO ${CONTEXT_NAME}
 833 #    @SET VAR1=VAR1_VALUE;%VAR1%
 834 #    .........
 835 #    .........
 836 #    .........
 837 #    @SET VARN=VARN_VALUE;%VARN%
 838 #    @SET SET_${CONTEXT}_VARS = 1
 839 #   :${CONTEXT_NAME}
 840 #   =================================================
 841 #   By default CONTEXT_NAME is equal to 'END'
 842 #
 843 MACRO(SALOME_GENERATE_ENVIRONMENT_SCRIPT output script cmd opts)
 844   PARSE_ARGUMENTS(SALOME_GENERATE_ENVIRONMENT_SCRIPT "CONTEXT;CONTEXT_NAME;ADDITIONAL_VARIABLES" "" ${ARGN})
 845
 846   IF(IS_ABSOLUTE ${script})
 847     SET(_script ${script})
 848   ELSE()
 849     SET(_script ${CMAKE_CURRENT_BINARY_DIR}/${script})
 850   ENDIF()
 851
 852   IF(WIN32)
 853     SET(_ext "bat")
 854     SET(_call_cmd "call")
 855   ELSE()
 856     SET(_ext "sh")
 857     SET(_call_cmd ".")
 858   ENDIF()
 859
 860   SET(_ctx "END")
 861   IF(SALOME_GENERATE_ENVIRONMENT_SCRIPT_CONTEXT_NAME)
 862     SET(_ctx "${SALOME_GENERATE_ENVIRONMENT_SCRIPT_CONTEXT_NAME}")
 863   ENDIF()
 864
 865   SET(_env "")
 866   IF(WIN32 AND SALOME_GENERATE_ENVIRONMENT_SCRIPT_CONTEXT)
 867     SET(_env "IF ${_env}\"%SET_${SALOME_GENERATE_ENVIRONMENT_SCRIPT_CONTEXT}_VARS%\"==\"1\" GOTO ${_ctx}\n")
 868   ENDIF()
 869   IF (NOT "$ENV{SALOME_HAS_GLOBAL_ENV}" STREQUAL "1")
 870     FOREACH(_item ${_${PROJECT_NAME}_EXTRA_ENV})
 871       FOREACH(_val ${_${PROJECT_NAME}_EXTRA_ENV_${_item}})
 872         SALOME_DO_VAR_SUBSTITUTION(_env ${_item} ${_val})
 873       ENDFOREACH()
 874     ENDFOREACH()
 875   ENDIF()
 876
 877   # Additional variables
 878   IF(SALOME_GENERATE_ENVIRONMENT_SCRIPT_ADDITIONAL_VARIABLES)
 879     FOREACH(_item ${SALOME_GENERATE_ENVIRONMENT_SCRIPT_ADDITIONAL_VARIABLES})
 880       STRING(REGEX MATCHALL "([^=]+|[^=]+$)" a_list "${_item}")
 881       LIST(LENGTH a_list a_list_len)
 882       IF(NOT ${a_list_len} EQUAL 2)
 883         MESSAGE(FATAL_ERROR  "Each item of ${ADDITIONAL_VARIABLES} list should be in 'Variable=Value' format")
 884       ENDIF()
 885       LIST(GET a_list 0 _item)
 886       LIST(GET a_list 1 _val)
 887       SALOME_DO_VAR_SUBSTITUTION(_env ${_item} ${_val})
 888     ENDFOREACH()
 889   ENDIF()
 890
 891   IF(WIN32 AND SALOME_GENERATE_ENVIRONMENT_SCRIPT_CONTEXT)
 892      SET(_env "${_env}@SET SET_${SALOME_GENERATE_ENVIRONMENT_SCRIPT_CONTEXT}_VARS=1\n")
 893      SET(_env "${_env}:${_ctx}\n" )
 894   ENDIF()
 895
 896   IF(NOT "${_env}" STREQUAL "")
 897     SET(_script ${_script}.${_ext})
 898     FILE(WRITE ${_script} "${_env}")
 899     SET(${output} ${_call_cmd} ${_script} && ${cmd} ${opts})
 900   ELSE()
 901     SET(${output} ${cmd} ${opts})
 902   ENDIF()
 903
 904 ENDMACRO(SALOME_GENERATE_ENVIRONMENT_SCRIPT)
 905
 906 #########################################################################
 907 # SALOME_GENERATE_TESTS_ENVIRONMENT()
 908 #
 909 # USAGE: SALOME_GENERATE_TESTS_ENVIRONMENT(output)
 910 #
 911 # ARGUMENTS:
 912 #   output [out] output environement variable.
 913 #
 914 # This macro generates <output> variable to use given environment to run some tests.
 915 # Macro generates environement variable using previously created variables
 916 # _${PROJECT_NAME}_EXTRA_ENV_<var>, where <var> is name of variable and
 917 # _${PROJECT_NAME}_EXTRA_ENV (see marco SALOME_ACCUMULATE_ENVIRONMENT);
 918 # and puts this variable into <output> argument.
 919 #
 920 MACRO(SALOME_GENERATE_TESTS_ENVIRONMENT output)
 921  SET(_env)
 922  SET(_WIN_LD_LIBRARY OFF)
 923  FOREACH(_item ${_${PROJECT_NAME}_EXTRA_ENV})
 924    IF(${_item} STREQUAL "LD_LIBRARY_PATH")
 925      SET(_WIN_LD_LIBRARY ON)
 926    ENDIF()
 927    SET(_env_${_item})
 928    FOREACH(_val ${_${PROJECT_NAME}_EXTRA_ENV_${_item}})
 929      IF(WIN32)
 930        STRING(REPLACE "/" "\\" _val "${_val}")
 931        SET(_env_${_item} "${_val};${_env_${_item}}")
 932      ELSE()
 933        SET(_env_${_item} "${_val}:${_env_${_item}}")
 934      ENDIF()
 935    ENDFOREACH()
 936  ENDFOREACH()
 937
 938  IF(_WIN_LD_LIBRARY AND WIN32)
 939    SET(_env_PATH "${_env_PATH}$ENV{LD_LIBRARY_PATH};${_env_LD_LIBRARY_PATH}")
 940  ENDIF()
 941
 942  IF(WIN32)
 943    SET(sep ",")
 944  ELSE()
 945    SET(sep ";")
 946  ENDIF()
 947
 948  FOREACH(_item ${_${PROJECT_NAME}_EXTRA_ENV})
 949    IF(WIN32)
 950      IF(NOT ${_item} STREQUAL "LD_LIBRARY_PATH")
 951        SET(_env "${_item}=$ENV{${_item}};${_env_${_item}}${sep}${_env}")
 952      ENDIF()
 953    ELSE()
 954      STRING(REPLACE ";" ":" _iii "$ENV{${_item}}")
 955      SET(_env "${_item}=${_iii}:${_env_${_item}}${sep}${_env}")
 956    ENDIF()
 957  ENDFOREACH()
 958
 959  # Get module name as substring of "Salome<ModuleName>"
 960  STRING(REGEX MATCH "^Salome" _is_salome_project ${PROJECT_NAME})
 961  IF(_is_salome_project)
 962    STRING(SUBSTRING "${PROJECT_NAME}" 6 -1 PRNAME)
 963  ELSE()
 964    SET(PRNAME ${PROJECT_NAME})
 965  ENDIF()
 966  SET(_env "${PRNAME}_ROOT_DIR=${CMAKE_INSTALL_PREFIX}${sep}${_env}")
 967
 968  # Creating follow string for Windows environement:
 969  # "VAR1_ENV=1\;2\;3\;...\;...\;...;VAR2_ENV=1\;2\;3\;...\;...\;...;VAR3_ENV=1\;2\;3\;...\;...\;...;..."
 970  IF(WIN32)
 971    STRING(REGEX REPLACE "\\\\*;" "\\\\;" _env "${_env}")
 972    STRING(REGEX REPLACE "\\\\*;*," ";" _env "${_env}")
 973  ENDIF()
 974
 975  SET(${output} "${_env}")
 976
 977 ENDMACRO(SALOME_GENERATE_TESTS_ENVIRONMENT)
 978
 979 #########################################################################
 980 # SALOME_APPEND_LIST_OF_LIST()
 981 #
 982 # USAGE: SALOME_APPEND_LIST_OF_LIST(result element_list)
 983 #
 984 # Build a list of lists. The element_list is first parsed to convert it
 985 # from
 986 #     a;b;c;d;e
 987 # to
 988 #     a,b,c,d,e
 989 #
 990 # It is then added to the big list 'result'. Hence 'result' looks like:
 991 #     a,b,c,d,e;f,g,h; ...
 992 #
 993 MACRO(SALOME_APPEND_LIST_OF_LIST result element_list)
 994   SET(_tmp_res)
 995   STRING(REPLACE ";" "," _tmp_res "${${element_list}}")
 996
 997   # Yet another CMake stupidity - LIST(LENGTH ";" var) returns 0
 998   STRING(LENGTH result _list_len)
 999   IF(NOT _list_len EQUAL 0)
1000     SET(${result} "${${result}}${_tmp_res};")  # LIST(APPEND ...) doesn't handle well empty elements!?
1001   ELSE()
1002     SET(${result} "${_tmp_res};")              # to avoid redundant ';' at the beginning of the list
1003   ENDIF()
1004
1005 ENDMACRO(SALOME_APPEND_LIST_OF_LIST)
1006
1007 #########################################################################
1008 # SALOME_CONFIGURE_PREPARE()
1009 #
1010 # USAGE: SALOME_CONFIGURE_PREPARE(pkg1 pkg2 ...)
1011 #
1012 # Prepare the variable that will be used to configure the file Salome<MODULE>Config.cmake,
1013 # namely:
1014 #    - _PREREQ_LIST      : the list of level 1 external prerequisites
1015 #    - _PREREQ_DIR_LIST  : their corresponding CMake directories (i.e. where the CMake configuration
1016 #    file for this package can be found, if there is any!)
1017 #    - _PREREQ_COMPO_LIST: the list of components requested when this package was invoked
1018 #
1019 # All this information is built from the package_list, the list of level 1 packages for this module.
1020 # Only the packages found in CONFIG mode are retained.
1021 #
1022 MACRO(SALOME_CONFIGURE_PREPARE)
1023   SET(_tmp_prereq "${ARGV}")
1024   SET(_PREREQ_LIST)
1025   SET(_PREREQ_DIR_LIST)
1026   SET(_PREREQ_COMPO_LIST)
1027   FOREACH(_prereq IN LISTS _tmp_prereq)
1028     IF(${_prereq}_DIR)
1029       SET(_PREREQ_LIST "${_PREREQ_LIST} ${_prereq}")
1030       FILE(TO_CMAKE_PATH ${${_prereq}_DIR} CURR_DIR)
1031       SET(_PREREQ_DIR_LIST "${_PREREQ_DIR_LIST} \"${CURR_DIR}\"")
1032       SALOME_APPEND_LIST_OF_LIST(_PREREQ_COMPO_LIST Salome${_prereq}_COMPONENTS)
1033     ENDIF()
1034   ENDFOREACH()
1035 ENDMACRO(SALOME_CONFIGURE_PREPARE)
1036
1037 #######################################################################
1038 #
1039 # From a version string like "2.7.12+" extract the major, minor and patch number
1040 # taking ONLY the numerical part.
1041 # This macro was created to treat Ubuntu Python version number where the libs are
1042 # version 2.7.12+ and the interp is 2.7.12 ...
1043 #
1044 MACRO(SALOME_EXTRACT_VERSION version_string major minor patch)
1045   IF(${version_string} MATCHES "[0-9]+[^0-9.]*\\.[0-9]+[^0-9.]*\\.*[0-9]*[^0-9]*[0-9]*")
1046     STRING(REGEX REPLACE "^([0-9]+)[^0-9.]*\\.[0-9]+[^0-9.]*\\.*[0-9]*[^0-9]*[0-9]*$" "\\1" ${major} "${version_string}")
1047     STRING(REGEX REPLACE "^[0-9]+[^0-9.]*\\.([0-9]+)[^0-9.]*\\.*[0-9]*[^0-9]*[0-9]*$" "\\1" ${minor} "${version_string}")
1048
1049     IF(${version_string} MATCHES "[0-9]+[^0-9.]*\\.[0-9]+[^0-9.]*\\.[0-9]+[^0-9]*[0-9]*")
1050         # X.Y.Z format (python 3.5.2 ...)
1051         STRING(REGEX REPLACE "^[0-9]+[^0-9.]*\\.[0-9]+[^0-9.]*\\.([0-9]+)[^0-9]*[0-9]*$" "\\1" ${patch} "${version_string}")
1052     ELSE()
1053         # X.Y format (python 3.5 ...)
1054         SET(${patch} "0")
1055     ENDIF()
1056   ELSE()
1057     MESSAGE("MACRO(SALOME_EXTRACT_VERSION ${version_string} ${major} ${minor} ${patch}")
1058     MESSAGE(FATAL_ERROR "Problem parsing version string, I can't parse it properly.")
1059   ENDIF()
1060 ENDMACRO(SALOME_EXTRACT_VERSION)
1061
1062 #######################################################################
1063 #
1064 # This macro checks that swig files were generated.
1065 # It is requared under Windows platform, because sometimes under Windows platform
1066 # the genetarion of the swig wrappings tooks long time. And seems swig opens
1067 # file at the begining of generation process and after that swig
1068 # begins the generation of the content. In its turn Microsoft Visual Studio
1069 # tryes to compile file immediately after creation and as a result compilation breaks.
1070 MACRO(SWIG_CHECK_GENERATION swig_module)
1071   IF(WIN32)
1072     SET(SCRIPT
1073 "@echo off
1074 :check
1075 ( (call ) >> @SWIG_GEN_FILE_NAME@ ) 2>null && (
1076   echo The file @SWIG_GEN_FILE_NAME@ was created. & goto :eof
1077 ) || (
1078   echo The file @SWIG_GEN_FILE_NAME@ is still being created !!! & goto :check
1079 )
1080 :eof")
1081     SET(W_LIST)
1082     LIST(LENGTH swig_generated_sources NB_GEN_FILES)
1083     IF(NOT ${NB_GEN_FILES})
1084       LIST(LENGTH swig_generated_file_fullname NB_GEN_FILES)
1085       SET(W_LIST ${swig_generated_file_fullname})
1086     ELSE()
1087       SET(W_LIST ${swig_generated_sources})
1088     ENDIF()
1089     IF(${NB_GEN_FILES})
1090       LIST(GET W_LIST 0 SWIG_GEN_FILE_NAME)
1091       STRING(CONFIGURE ${SCRIPT} SCRIPT)
1092       GET_FILENAME_COMPONENT(SWIG_GEN_FILE_NAME_DIR ${SWIG_GEN_FILE_NAME} DIRECTORY)
1093       GET_FILENAME_COMPONENT(SWIG_GEN_FILE_NAME_WE ${SWIG_GEN_FILE_NAME} NAME_WE)
1094       SET(SCRIPT_FILE_NAME ${SWIG_GEN_FILE_NAME_DIR}/${SWIG_GEN_FILE_NAME_WE}.bat)
1095       FILE(WRITE ${SCRIPT_FILE_NAME} ${SCRIPT})
1096       ADD_CUSTOM_TARGET(${SWIG_MODULE_${swig_module}_REAL_NAME}_ready
1097                         DEPENDS ${SWIG_GEN_FILE_NAME}
1098                         COMMAND ${SCRIPT_FILE_NAME}
1099                         COMMENT "Waiting for swig wrappings !!!")
1100       ADD_DEPENDENCIES(${SWIG_MODULE_${swig_module}_REAL_NAME} ${SWIG_MODULE_${swig_module}_REAL_NAME}_ready)
1101     ELSE()
1102        MESSAGE(FATAL "swig sources for targer ${swig_module} are not found !!!")
1103      ENDIF()
1104   ENDIF()
1105 ENDMACRO(SWIG_CHECK_GENERATION)
1106
1107 #########################################################################
1108 # SALOME_DO_VAR_SUBSTITUTION()
1109 #
1110 # USAGE: SALOME_DO_VAR_SUBSTITUTION(env variable value)
1111 #
1112 # ARGUMENTS:
1113 #   env      [out]: output script.
1114 #   variable  [in]: varable name
1115 #   value     [in]: variable value
1116 #
1117 # This macro concatenate variable value into script, like this:
1118 # on Linux:
1119 # export variable=value:${varuable}
1120 #
1121 # or on Windows:
1122 # SET variable=value;${varuable}
1123 #
1124 # Platform dependat variables PATH (Windows),
1125 # DYLD_LIBRARY_PATH (Apple), LD_LIBRARY_PATH (Linux), should be
1126 # passed in Linux naming style, i.e. LD_LIBRARY_PATH. Macro
1127 # converts this variable into platform scpecific variable.
1128 #
1129 MACRO(SALOME_DO_VAR_SUBSTITUTION env variable value)
1130   SET(_item ${variable})
1131   SET(_val ${value})
1132   IF(WIN32)
1133     IF(${_item} STREQUAL "LD_LIBRARY_PATH")
1134       SET(_item PATH)
1135     ENDIF()
1136       STRING(REPLACE "/" "\\" ${env} "${${env}}@SET ${_item}=${_val};%${_item}%\n")
1137     ELSEIF(APPLE)
1138       IF(${_item} STREQUAL "LD_LIBRARY_PATH")
1139         SET(${env} "${${env}} export DYLD_LIBRARY_PATH=${_val}:\${DYLD_LIBRARY_PATH}\n")
1140       ELSE()
1141         SET(${env} "${${env}} export ${_item}=${_val}:\${${_item}}\n")
1142       ENDIF()
1143     ELSE()
1144        SET(${env} "${${env}} export ${_item}=${_val}:\${${_item}}\n")
1145   ENDIF()
1146 ENDMACRO(SALOME_DO_VAR_SUBSTITUTION)
1147
1148 #########################################################################
1149 # SALOME_SETUP_VERSION()
1150 #
1151 # USAGE: SALOME_SETUP_VERSION(version [DEVELOPMENT])
1152 #
1153 # ARGUMENTS:
1154 #   version   [in] Version decriptor (string).
1155 #
1156 # OPTIONS:
1157 #   DEVELOPMENT    Forces setting development flag.
1158 #
1159 # The macro sets the following variables:
1160 # - PROJECTNAME_MAJOR_VERSION - major version number
1161 # - PROJECTNAME_MINOR_VERSION - minor version number
1162 # - PROJECTNAME_PATCH_VERSION - release version number
1163 # - PROJECTNAME_VERSION       - full qualified version
1164 # - PROJECTNAME_VERSION_DEV   - development flag (0 value for released version)
1165 # - PROJECTNAME_XVERSION      - hexadecimal representation of version
1166 # - PROJECTNAME_GIT_SHA1      - git commit's sha1
1167 #
1168 FUNCTION(SALOME_SETUP_VERSION version)
1169   # parse arguments
1170   PARSE_ARGUMENTS(SALOME_SETUP_VERSION "" "DEVELOPMENT" ${ARGN})
1171   # project name in upper case (if not set in master CMakeLists.txt)
1172   STRING(TOUPPER ${PROJECT_NAME} _pkg_uc)
1173   # parse version component
1174   STRING (REGEX REPLACE "[.]" ";" _components "${version}")
1175   LIST(LENGTH _components _length)
1176   IF(${_length} GREATER 0)
1177     LIST(GET _components 0 _major)
1178     LIST(REMOVE_AT _components 0)
1179   ELSE()
1180     SET(_major 0)
1181   ENDIF()
1182   LIST(LENGTH _components _length)
1183   IF(${_length} GREATER 0)
1184     LIST(GET _components 0 _minor)
1185     LIST(REMOVE_AT _components 0)
1186   ELSE()
1187     SET(_minor 0)
1188   ENDIF()
1189   LIST(LENGTH _components _length)
1190   IF(${_length} GREATER 0)
1191     LIST(GET _components 0 _patch)
1192     LIST(REMOVE_AT _components 0)
1193   ELSE()
1194     SET(_patch 0)
1195   ENDIF()
1196   # set project version: 'major', 'minor' and 'patch' components
1197   SET(${_pkg_uc}_MAJOR_VERSION ${_major} PARENT_SCOPE)
1198   SET(${_pkg_uc}_MINOR_VERSION ${_minor} PARENT_SCOPE)
1199   SET(${_pkg_uc}_PATCH_VERSION ${_patch} PARENT_SCOPE)
1200   SET(${_pkg_uc}_VERSION       ${_major}.${_minor}.${_patch} PARENT_SCOPE)
1201   # set 'development' flag
1202   IF(SALOME_SETUP_VERSION_DEVELOPMENT)
1203     SET(${_pkg_uc}_VERSION_DEV 1 PARENT_SCOPE)
1204   ELSE()
1205     SET(${_pkg_uc}_VERSION_DEV 0 PARENT_SCOPE)
1206   ENDIF()
1207   # set hexa representation of version
1208   SALOME_TOHEXA(${_major} _major_h)
1209   SALOME_TOHEXA(${_minor} _minor_h)
1210   SALOME_TOHEXA(${_patch} _patch_h)
1211   SET(${_pkg_uc}_XVERSION "0x${_major_h}${_minor_h}${_patch_h}" PARENT_SCOPE)
1212   # detect git sha1
1213   EXECUTE_PROCESS(COMMAND git describe --dirty --tags --match=V* --always
1214     WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
1215     OUTPUT_VARIABLE _git_version
1216     ERROR_QUIET
1217     OUTPUT_STRIP_TRAILING_WHITESPACE)
1218   IF(_git_version)
1219     SET(${_pkg_uc}_GIT_SHA1 "${_git_version}" PARENT_SCOPE)
1220   ELSE(_)
1221     SET(${_pkg_uc}_GIT_SHA1 "unknown" PARENT_SCOPE)
1222   ENDIF()
1223   string(TIMESTAMP ${_pkg_uc}_TMP_CONFIG_TIME "%Y/%m/%d %H:%M:%S")
1224   set(${_pkg_uc}_CONFIG_TIME ${${_pkg_uc}_TMP_CONFIG_TIME} PARENT_SCOPE)
1225   unset(${_pkg_uc}_TMP_CONFIG_TIME)
1226 ENDFUNCTION()