CMakeModules/libbatchMacros.cmake

   1 #  Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
   2 #
   3 #  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 #  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 #
   6 #  This library is free software; you can redistribute it and/or
   7 #  modify it under the terms of the GNU Lesser General Public
   8 #  License as published by the Free Software Foundation; either
   9 #  version 2.1 of the License.
  10 #
  11 #  This library is distributed in the hope that it will be useful,
  12 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 #  Lesser General Public License for more details.
  15 #
  16 #  You should have received a copy of the GNU Lesser General Public
  17 #  License along with this library; if not, write to the Free Software
  18 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 #
  20 #  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 #
  22
  23 #
  24 # Set of macros to identify local shell commands for file deletion,
  25 # file copy, etc ... (under Windows and Unix).
  26 #
  27 MACRO(FIND_LOCAL_COMMAND VAR UNIX_COMMAND WIN32_COMMAND)
  28     IF (WIN32)
  29         FIND_PROGRAM(${VAR} ${WIN32_COMMAND})
  30     ELSE (WIN32)
  31         FIND_PROGRAM(${VAR} ${UNIX_COMMAND})
  32     ENDIF (WIN32)
  33     IF (${VAR})
  34         MESSAGE(STATUS "${VAR} found : ${${VAR}}")
  35     ELSE (${VAR})
  36         MESSAGE(STATUS "${VAR} not found, local submission might not work properly")
  37     ENDIF (${VAR})
  38 ENDMACRO(FIND_LOCAL_COMMAND)
  39
  40 MACRO(FIND_LOCAL_COMMAND_WIN32_DEF VAR UNIX_COMMAND WIN32_DEFAULT)
  41     IF (WIN32)
  42         SET(${VAR} ${WIN32_DEFAULT} CACHE STRING "${VAR}")
  43         MESSAGE(STATUS "${VAR} found : using '${${VAR}}' (Windows default)")
  44     ELSE (WIN32)
  45         FIND_LOCAL_COMMAND(${VAR} ${UNIX_COMMAND} ${WIN32_DEFAULT})
  46     ENDIF (WIN32)
  47 ENDMACRO(FIND_LOCAL_COMMAND_WIN32_DEF)
  48
  49 MACRO(EVAL VAR)
  50    IF(${ARGN})
  51      SET(${VAR} TRUE)
  52    ELSE(${ARGN})
  53      SET(${VAR} FALSE)
  54    ENDIF(${ARGN})
  55 ENDMACRO(EVAL)
  56
  57 MACRO(LIBBATCH_FIND_ALL_LOCAL_COMMANDS)
  58   MESSAGE(STATUS "Looking for commands needed for local submission...")
  59
  60   FIND_LOCAL_COMMAND_WIN32_DEF(LIBBATCH_RM_COMMAND rm del)
  61   FIND_LOCAL_COMMAND(LIBBATCH_SH_COMMAND sh cmd.exe)
  62   FIND_LOCAL_COMMAND_WIN32_DEF(LIBBATCH_CP_COMMAND cp copy)
  63   FIND_LOCAL_COMMAND_WIN32_DEF(LIBBATCH_MKDIR_COMMAND mkdir mkdir)
  64   FIND_LOCAL_COMMAND(LIBBATCH_RSH_COMMAND rsh rsh)
  65   FIND_LOCAL_COMMAND(LIBBATCH_RCP_COMMAND rcp rcp)
  66   FIND_LOCAL_COMMAND(LIBBATCH_SSH_COMMAND ssh plink)
  67   FIND_LOCAL_COMMAND(LIBBATCH_SCP_COMMAND scp pscp)
  68
  69   EVAL (HAS_SH LIBBATCH_SH_COMMAND AND LIBBATCH_CP_COMMAND AND LIBBATCH_RM_COMMAND AND LIBBATCH_MKDIR_COMMAND)
  70   EVAL (HAS_RSH LIBBATCH_RSH_COMMAND AND LIBBATCH_RCP_COMMAND)
  71   EVAL (HAS_SSH LIBBATCH_SSH_COMMAND AND LIBBATCH_SCP_COMMAND)
  72
  73   # Mark shell commands as advanced options
  74   # and assign the names without the LIBBATCH_ in front:
  75   SET (_cmds "RM;SH;CP;MKDIR;RSH;RCP;SSH;SCP")
  76   FOREACH(_cmd ${_cmds})
  77     MARK_AS_ADVANCED(LIBBATCH_${_cmd}_COMMAND)
  78     SET(${_cmd}_COMMAND ${LIBBATCH_${_cmd}_COMMAND})
  79   ENDFOREACH()
  80 ENDMACRO()
  81
  82 #
  83 # Display configuration summary
  84 #
  85 MACRO(LIBBATCH_SUMMARY)
  86   MESSAGE(STATUS "")
  87   MESSAGE(STATUS "**************** Libbatch Summary *******")
  88   MESSAGE(STATUS "")
  89   IF (LIBBATCH_LOCAL_SUBMISSION)
  90     MESSAGE(STATUS "Local submission .................... Yes")
  91   ELSE()
  92     MESSAGE(STATUS "Local submission .......... Not requested")
  93   ENDIF()
  94
  95   IF (LIBBATCH_PYTHON_WRAPPING)
  96     IF (PYTHONINTERP_FOUND AND PYTHONLIBS_FOUND AND SWIG_FOUND)
  97       MESSAGE(STATUS "Python wrapping ..................... Yes")
  98     ELSE()
  99       MESSAGE(STATUS "Python wrapping ............... Python libs (or Swig) not found")
 100     ENDIF()
 101   ELSE()
 102     MESSAGE(STATUS "Python wrapping ........... Not requested")
 103   ENDIF()
 104
 105   MESSAGE(STATUS "")
 106   MESSAGE(STATUS "************** End Summary **************")
 107   MESSAGE(STATUS "")
 108 ENDMACRO()
 109
 110 ###
 111 # SALOME_CHECK_EQUAL_PATHS(result path1 path2)
 112 #  Check if two paths are identical, resolving links. If the paths do not exist a simple
 113 #  text comparison is performed.
 114 #  result is a boolean.
 115 ###
 116 MACRO(SALOME_CHECK_EQUAL_PATHS varRes path1 path2)
 117   SET("${varRes}" OFF)
 118   IF(EXISTS "${path1}")
 119     GET_FILENAME_COMPONENT(_tmp1 "${path1}" REALPATH)
 120   ELSE()
 121     SET(_tmp1 "${path1}")
 122   ENDIF()
 123
 124   IF(EXISTS "${path2}")
 125     GET_FILENAME_COMPONENT(_tmp2 "${path2}" REALPATH)
 126   ELSE()
 127     SET(_tmp2 "${path2}")
 128   ENDIF()
 129
 130   IF("${_tmp1}" STREQUAL "${_tmp2}")
 131     SET("${varRes}" ON)
 132   ENDIF()
 133 #  MESSAGE(${${varRes}})
 134 ENDMACRO()
 135
 136
 137 ####
 138 # SALOME_FIND_PACKAGE(englobingPackageName standardPackageName modus)
 139 # Encapsulate the call to the standard FIND_PACKAGE(standardPackageName) passing all the options
 140 # given when calling the command FIND_PACKAGE(customPackageName)
 141 # Modus is either MODULE or CONFIG (cf standard FIND_PACKAGE() documentation).
 142 # This macro is to be called from within the FindCustomPackage.cmake file.
 143 ####
 144 MACRO(SALOME_FIND_PACKAGE englobPkg stdPkg mode)
 145   # Only bother if the package was not already found:
 146   # Some old packages use the lower case version - standard should be to always use
 147   # upper case:
 148   STRING(TOUPPER ${stdPkg} stdPkgUC)
 149   IF(NOT (${stdPkg}_FOUND OR ${stdPkgUC}_FOUND))
 150     IF(${englobPkg}_FIND_QUIETLY)
 151       SET(_tmp_quiet "QUIET")
 152     ELSE()
 153       SET(_tmp_quiet)
 154     ENDIF()
 155     IF(${englobPkg}_FIND_REQUIRED)
 156       SET(_tmp_req "REQUIRED")
 157     ELSE()
 158       SET(_tmp_req)
 159     ENDIF()
 160     IF(${englobPkg}_FIND_VERSION_EXACT)
 161       SET(_tmp_exact "EXACT")
 162     ELSE()
 163       SET(_tmp_exact)
 164     ENDIF()
 165     IF(${englobPkg}_FIND_COMPONENTS)
 166       STRING(REPLACE ";" " " _tmp_compo ${${englobPkg}_FIND_COMPONENTS})
 167     ELSE()
 168       SET(_tmp_compo)
 169     ENDIF()
 170
 171     # Call the root FIND_PACKAGE():
 172     #MESSAGE("blabla ${englobPkg} / ${${englobPkg}_FIND_VERSION_EXACT} / ${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} ${mode}")
 173     IF(_tmp_compo)
 174       FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} ${mode} ${_tmp_quiet} ${_tmp_req} COMPONENTS ${_tmp_compo})
 175     ELSE()
 176       FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} ${mode} ${_tmp_quiet} ${_tmp_req})
 177     ENDIF()
 178   ENDIF()
 179 ENDMACRO()
 180
 181 ####################################################################"
 182 # SALOME_FIND_PACKAGE_DETECT_CONFLICTS(pkg referenceVariable upCount)
 183 #    pkg              : name of the system package to be detected
 184 #    referenceVariable: variable containing a path that can be browsed up to
 185 # retrieve the package root directory (xxx_ROOT_DIR)
 186 #    upCount          : number of times we have to go up from the path <referenceVariable>
 187 # to obtain the package root directory.
 188 #
 189 # For example:  SALOME_FIND_PACKAGE_DETECT_CONFLICTS(SWIG SWIG_EXECUTABLE 2)
 190 #
 191 # Generic detection (and conflict check) procedure for package XYZ:
 192 # 1. Load a potential env variable XYZ_ROOT_DIR as a default choice for the cache entry XYZ_ROOT_DIR
 193 #    If empty, load a potential XYZ_ROOT_DIR_EXP as default value (path exposed by another package depending
 194 # directly on XYZ)
 195 # 2. Invoke FIND_PACKAGE() in this order:
 196 #    * in CONFIG mode first (if possible): priority is given to a potential
 197 #    "XYZ-config.cmake" file
 198 #    * then switch to the standard MODULE mode, appending on CMAKE_PREFIX_PATH
 199 # the above XYZ_ROOT_DIR variable
 200 # 3. Extract the path actually found into a temp variable _XYZ_TMP_DIR
 201 # 4. Warn if XYZ_ROOT_DIR is set and doesn't match what was found (e.g. when CMake found the system installation
 202 #    instead of what is pointed to by XYZ_ROOT_DIR - happens when a typo in the content of XYZ_ROOT_DIR).
 203 # 5. Conflict detection:
 204 #    * check the temp variable against a potentially existing XYZ_ROOT_DIR_EXP
 205 # 6. Finally expose what was *actually* found in XYZ_ROOT_DIR.
 206 # 7. Specific stuff: for example exposing a prerequisite of XYZ to the rest of the world for future
 207 # conflict detection. This is added after the call to the macro by the callee.
 208 #
 209 MACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS pkg referenceVariable upCount)
 210   STRING(TOUPPER ${pkg} pkg_UC)
 211
 212   # 1. Load environment or any previously detected root dir for the package
 213   IF(DEFINED ENV{${pkg_UC}_ROOT_DIR})
 214     FILE(TO_CMAKE_PATH "$ENV{${pkg_UC}_ROOT_DIR}" _${pkg_UC}_ROOT_DIR_ENV)
 215     SET(_dflt_value "${_${pkg_UC}_ROOT_DIR_ENV}")
 216   ELSE()
 217     # will be blank if no package was previously loaded
 218     SET(_dflt_value "${${pkg_UC}_ROOT_DIR_EXP}")
 219   ENDIF()
 220
 221   #   Make cache entry
 222   SET(${pkg_UC}_ROOT_DIR "${_dflt_value}" CACHE PATH "Path to ${pkg_UC} directory")
 223
 224   # 2. Find package - config mode first (i.e. looking for XYZ-config.cmake)
 225   IF(EXISTS "${${pkg_UC}_ROOT_DIR}")
 226     # Hope to find direclty a CMake config file there
 227     SET(_CONF_DIR "${${pkg_UC}_ROOT_DIR}/share/cmake")
 228
 229     # Try find_package in config mode with a hard-coded guess. This
 230     # has the priority.
 231     FIND_PACKAGE(${pkg} NO_MODULE QUIET PATHS "${_CONF_DIR}")
 232     MARK_AS_ADVANCED(${pkg}_DIR)
 233
 234     IF (NOT ${pkg_UC}_FOUND)
 235       SET(CMAKE_PREFIX_PATH "${${pkg_UC}_ROOT_DIR}")
 236     ELSE()
 237       MESSAGE(STATUS "Found ${pkg} in CONFIG mode!")
 238     ENDIF()
 239   ENDIF()
 240
 241   # Otherwise try the standard way (module mode, with the standard CMake Find*** macro):
 242   SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} MODULE)
 243   #MESSAGE("dbg ${pkg_UC} / ${PTHREAD_FOUND} / ${${pkg_UC}_FOUND}")
 244   # Set the "FOUND" variable for the SALOME wrapper:
 245   IF(${pkg_UC}_FOUND OR ${pkg}_FOUND)
 246     SET(SALOME${pkg_UC}_FOUND TRUE)
 247   ELSE()
 248     SET(SALOME${pkg_UC}_FOUND FALSE)
 249   ENDIF()
 250
 251   IF (${pkg_UC}_FOUND OR ${pkg}_FOUND)
 252     # 3. Set the root dir which was finally retained by going up "upDir" times
 253     # from the given reference path. The variable "referenceVariable" may be a list
 254     # - we take its first element.
 255     #   Note the double de-reference of "referenceVariable":
 256     LIST(LENGTH "${${referenceVariable}}" _tmp_len)
 257     IF(_tmp_len)
 258        LIST(GET "${${referenceVariable}}" 0 _tmp_ROOT_DIR)
 259     ELSE()
 260        SET(_tmp_ROOT_DIR "${${referenceVariable}}")
 261     ENDIF()
 262     IF(${upCount})
 263       MATH(EXPR _rge "${upCount}-1")
 264       FOREACH(_unused RANGE ${_rge})
 265         GET_FILENAME_COMPONENT(_tmp_ROOT_DIR "${_tmp_ROOT_DIR}" PATH)
 266       ENDFOREACH()
 267     ENDIF()
 268
 269     # 4. Warn if CMake found something not located under ENV(XYZ_ROOT_DIR)
 270     IF(DEFINED ENV{${pkg_UC}_ROOT_DIR})
 271       SALOME_CHECK_EQUAL_PATHS(_res "${_tmp_ROOT_DIR}" "${_${pkg_UC}_ROOT_DIR_ENV}")
 272       IF(NOT _res)
 273         MESSAGE(WARNING "${pkg} was found, but not at the path given by the "
 274             "environment ${pkg_UC}_ROOT_DIR! Is the variable correctly set? "
 275             "The two paths are: ${_tmp_ROOT_DIR} and: ${_${pkg_UC}_ROOT_DIR_ENV}")
 276
 277       ELSE()
 278         MESSAGE(STATUS "${pkg} found directory matches what was specified in the ${pkg_UC}_ROOT_DIR variable, all good!")
 279       ENDIF()
 280     ELSE()
 281         MESSAGE(STATUS "Environment variable ${pkg_UC}_ROOT_DIR is not defined. The system installation was found.")
 282     ENDIF()
 283
 284     # 5. Conflict detection
 285     # 5.1  From another prerequisite using the package
 286     IF(${pkg_UC}_ROOT_DIR_EXP)
 287         SALOME_CHECK_EQUAL_PATHS(_res "${_tmp_ROOT_DIR}" "${${pkg_UC}_ROOT_DIR_EXP}")
 288         IF(NOT _res)
 289            MESSAGE(WARNING "Warning: ${pkg}: detected version conflicts with a previously found ${pkg}!"
 290                             "The two paths are " ${_tmp_ROOT_DIR} " vs " ${${pkg_UC}_ROOT_DIR_EXP})
 291         ELSE()
 292             MESSAGE(STATUS "${pkg} directory matches what was previously exposed by another prereq, all good!")
 293         ENDIF()
 294     ENDIF()
 295
 296     # 6. Save the found installation
 297     #
 298     SET(${pkg_UC}_ROOT_DIR "${_tmp_ROOT_DIR}")
 299
 300   ELSE()
 301     MESSAGE(STATUS "${pkg} was not found.")
 302   ENDIF()
 303 ENDMACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS)