1 # Copyright (C) 2013-2015 CEA/DEN, EDF R&D, OPEN CASCADE
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.
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.
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
17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 # SALOME_CHECK_EQUAL_PATHS(result path1 path2)
22 # Check if two paths are identical, resolving links. If the paths do not exist a simple
23 # text comparison is performed.
24 # result is a boolean.
26 MACRO(SALOME_CHECK_EQUAL_PATHS varRes path1 path2)
29 GET_FILENAME_COMPONENT(_tmp1 "${path1}" REALPATH)
35 GET_FILENAME_COMPONENT(_tmp2 "${path2}" REALPATH)
40 IF("${_tmp1}" STREQUAL "${_tmp2}")
43 # MESSAGE(${${varRes}})
47 # SALOME_FIND_PACKAGE(englobingPackageName standardPackageName modus [onlyTryQuietly])
49 # example: SALOME_FIND_PACKAGE(SalomeVTK VTK CONFIG)
51 # Encapsulate the call to the standard FIND_PACKAGE(standardPackageName) passing all the options
52 # given when calling the command FIND_PACKAGE(SimanIOXyz). Those options are stored implicitly in
53 # CMake variables: Xyz_FIND_QUIETLY, Xyz_FIND_REQUIRED, etc ...
55 # If a list of components was specified when invoking the initial FIND_PACKAGE(SimanIOXyz ...) this is
56 # also handled properly.
58 # Modus is either MODULE or CONFIG (cf standard FIND_PACKAGE() documentation).
59 # The last argument is optional and if set to TRUE will force the search to be OPTIONAL and QUIET.
60 # If the package is looked for in CONFIG mode, the standard system paths are skipped. If you still want a
61 # system installation to be found in this mode, you have to set the ROOT_DIR variable explicitly to /usr (for
64 # This macro is to be called from within the FindSimanIOXyz.cmake files (where Xyz is some package to be detected).
67 MACRO(SALOME_FIND_PACKAGE englobPkg stdPkg mode)
68 SET(_OPT_ARG ${ARGV3})
69 # Only bother if the package was not already found:
70 # Some old packages use the lower case version - standard should be to always use
72 STRING(TOUPPER ${stdPkg} stdPkgUC)
73 IF(NOT (${stdPkg}_FOUND OR ${stdPkgUC}_FOUND))
74 IF(${englobPkg}_FIND_QUIETLY OR _OPT_ARG)
75 SET(_tmp_quiet "QUIET")
79 IF(${englobPkg}_FIND_REQUIRED AND NOT _OPT_ARG)
80 SET(_tmp_req "REQUIRED")
84 IF(${englobPkg}_FIND_VERSION_EXACT)
85 SET(_tmp_exact "EXACT")
90 # Call the CMake FIND_PACKAGE() command:
91 STRING(TOLOWER ${stdPkg} _pkg_lc)
92 IF(("${mode}" STREQUAL "NO_MODULE") OR ("${mode}" STREQUAL "CONFIG"))
93 # Hope to find direclty a CMake config file, indicating the SALOME CMake file
94 # paths (the command already looks in places like "share/cmake", etc ... by default)
95 # Note the options NO_CMAKE_BUILDS_PATH, NO_CMAKE_PACKAGE_REGISTRY to avoid (under Windows)
96 # looking into a previous CMake build done via a GUI, or into the Win registry.
97 # NO_CMAKE_SYSTEM_PATH and NO_SYSTEM_ENVIRONMENT_PATH ensure any _system_ files like 'xyz-config.cmake'
98 # don't get loaded (typically Boost). To force their loading, set the XYZ_ROOT_DIR variable to '/usr'.
99 # See documentation of FIND_PACKAGE() for full details.
101 # Do we need to call the signature using components?
102 IF(${englobPkg}_FIND_COMPONENTS)
103 FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact}
104 NO_MODULE ${_tmp_quiet} ${_tmp_req} COMPONENTS ${${englobPkg}_FIND_COMPONENTS}
105 NO_CMAKE_BUILDS_PATH NO_CMAKE_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PATH
106 NO_SYSTEM_ENVIRONMENT_PATH)
108 FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact}
109 NO_MODULE ${_tmp_quiet} ${_tmp_req}
110 NO_CMAKE_BUILDS_PATH NO_CMAKE_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PATH
111 NO_SYSTEM_ENVIRONMENT_PATH)
113 MARK_AS_ADVANCED(${stdPkg}_DIR)
115 ELSEIF("${mode}" STREQUAL "MODULE")
117 # Do we need to call the signature using components?
118 IF(${englobPkg}_FIND_COMPONENTS)
119 FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact}
120 MODULE ${_tmp_quiet} ${_tmp_req} COMPONENTS ${${englobPkg}_FIND_COMPONENTS})
122 FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact}
123 MODULE ${_tmp_quiet} ${_tmp_req})
128 MESSAGE(FATAL_ERROR "Invalid mode argument in the call to the macro SALOME_FIND_PACKAGE. Should be CONFIG or MODULE.")
136 ####################################################################
137 # SALOME_FIND_PACKAGE_DETECT_CONFLICTS(pkg referenceVariable upCount)
138 # pkg : name of the system package to be detected
139 # referenceVariable: variable containing a path that can be browsed up to
140 # retrieve the package root directory (xxx_ROOT_DIR)
141 # upCount : number of times we have to go up from the path <referenceVariable>
142 # to obtain the package root directory.
144 # For example: SALOME_FIND_PACKAGE_DETECT_CONFLICTS(SWIG SWIG_EXECUTABLE 2)
146 # Generic detection (and conflict check) procedure for package XYZ:
147 # 1. Load a potential env variable XYZ_ROOT_DIR as a default choice for the cache entry XYZ_ROOT_DIR
148 # If empty, load a potential XYZ_ROOT_DIR_EXP as default value (path exposed by another package depending
150 # 2. Invoke FIND_PACKAGE() in this order:
151 # * in CONFIG mode first (if possible): priority is given to a potential
152 # "XYZ-config.cmake" file
153 # * then switch to the standard MODULE mode, appending on CMAKE_PREFIX_PATH
154 # the above XYZ_ROOT_DIR variable
155 # 3. Extract the path actually found into a temp variable _XYZ_TMP_DIR
156 # 4. Warn if XYZ_ROOT_DIR is set and doesn't match what was found (e.g. when CMake found the system installation
157 # instead of what is pointed to by XYZ_ROOT_DIR - happens when a typo in the content of XYZ_ROOT_DIR).
158 # 5. Conflict detection:
159 # * check the temp variable against a potentially existing XYZ_ROOT_DIR_EXP
160 # 6. Finally expose what was *actually* found in XYZ_ROOT_DIR.
161 # 7. Specific stuff: for example exposing a prerequisite of XYZ to the rest of the world for future
162 # conflict detection. This is added after the call to the macro by the callee.
164 MACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS pkg referenceVariable upCount)
169 # Package name, upper case
170 STRING(TOUPPER ${pkg} pkg_UC)
173 ## 1. Load environment or any previously detected root dir for the package
175 IF(DEFINED ENV{${pkg_UC}_ROOT_DIR})
176 FILE(TO_CMAKE_PATH "$ENV{${pkg_UC}_ROOT_DIR}" _${pkg_UC}_ROOT_DIR_ENV)
177 SET(_dflt_value "${_${pkg_UC}_ROOT_DIR_ENV}")
179 # will be blank if no package was previously loaded:
180 SET(_dflt_value "${${pkg_UC}_ROOT_DIR_EXP}")
183 # Detect if the variable has been set on the command line or elsewhere:
184 IF(DEFINED ${pkg_UC}_ROOT_DIR)
185 SET(_var_already_there TRUE)
187 SET(_var_already_there FALSE)
190 SET(${pkg_UC}_ROOT_DIR "${_dflt_value}" CACHE PATH "Path to ${pkg_UC} directory")
193 ## 2. Find package - try CONFIG mode first (i.e. looking for XYZ-config.cmake)
196 # Override the variable - don't append to it, as it would give precedence
197 # to what was stored there before!
198 SET(CMAKE_PREFIX_PATH "${${pkg_UC}_ROOT_DIR}")
200 # Try find_package in config mode. This has the priority, but is
201 # performed QUIET and not REQUIRED:
202 SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} NO_MODULE TRUE)
204 IF (${pkg_UC}_FOUND OR ${pkg}_FOUND)
205 MESSAGE(STATUS "Found ${pkg} in CONFIG mode!")
208 # Otherwise try the standard way (module mode, with the standard CMake Find*** macro):
209 # We do it quietly to produce our own error message, except if we are in debug mode:
210 IF(SALOME_CMAKE_DEBUG)
211 SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} MODULE FALSE)
213 SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} MODULE TRUE)
216 # Set the "FOUND" variable for the SALOME wrapper:
217 IF(${pkg_UC}_FOUND OR ${pkg}_FOUND)
218 SET(SALOME${pkg_UC}_FOUND TRUE)
220 SET(SALOME${pkg_UC}_FOUND FALSE)
221 IF(NOT Salome${pkg}_FIND_QUIETLY)
222 IF(Salome${pkg}_FIND_REQUIRED)
223 MESSAGE(FATAL_ERROR "Package ${pkg} couldn't be found - did you set the corresponing root dir correctly? "
224 "It currently contains ${pkg_UC}_ROOT_DIR=${${pkg_UC}_ROOT_DIR} "
225 "Append -DSALOME_CMAKE_DEBUG=ON on the command line if you want to see the original CMake error.")
227 MESSAGE(WARNING "Package ${pkg} couldn't be found - did you set the corresponing root dir correctly? "
228 "It currently contains ${pkg_UC}_ROOT_DIR=${${pkg_UC}_ROOT_DIR} "
229 "Append -DSALOME_CMAKE_DEBUG=ON on the command line if you want to see the original CMake error.")
234 IF (${pkg_UC}_FOUND OR ${pkg}_FOUND)
235 ## 3. Set the root dir which was finally retained by going up "upDir" times
236 ## from the given reference path. The variable "referenceVariable" may be a list.
237 ## In this case we take its first element.
239 # First test if the variable exists, warn otherwise:
240 IF(NOT DEFINED ${referenceVariable})
241 MESSAGE(WARNING "${pkg}: the reference variable '${referenceVariable}' used when calling the macro "
242 "SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS() is not defined.")
245 LIST(LENGTH ${referenceVariable} _tmp_len)
247 LIST(GET ${referenceVariable} 0 _tmp_ROOT_DIR)
249 # Note the double de-reference of "referenceVariable":
250 SET(_tmp_ROOT_DIR "${${referenceVariable}}")
253 FOREACH(_unused RANGE 1 ${upCount})
254 GET_FILENAME_COMPONENT(_tmp_ROOT_DIR "${_tmp_ROOT_DIR}" PATH)
259 ## 4. Warn if CMake found something not located under ENV(XYZ_ROOT_DIR)
261 IF(DEFINED ENV{${pkg_UC}_ROOT_DIR})
262 SALOME_CHECK_EQUAL_PATHS(_res "${_tmp_ROOT_DIR}" "${_${pkg_UC}_ROOT_DIR_ENV}")
264 MESSAGE(WARNING "${pkg} was found, but not at the path given by the "
265 "environment ${pkg_UC}_ROOT_DIR! Is the variable correctly set? "
266 "The two paths are: ${_tmp_ROOT_DIR} and: ${_${pkg_UC}_ROOT_DIR_ENV}")
269 MESSAGE(STATUS "${pkg} found directory matches what was specified in the ${pkg_UC}_ROOT_DIR variable, all good!")
272 IF(NOT _var_already_there)
273 MESSAGE(STATUS "Variable ${pkg_UC}_ROOT_DIR was not explicitly defined. "
274 "An installation was found anyway: ${_tmp_ROOT_DIR}")
279 ## 5. Conflict detection
280 ## From another prerequisite using the package:
282 IF(${pkg_UC}_ROOT_DIR_EXP)
283 SALOME_CHECK_EQUAL_PATHS(_res "${_tmp_ROOT_DIR}" "${${pkg_UC}_ROOT_DIR_EXP}")
285 MESSAGE(WARNING "Warning: ${pkg}: detected version conflicts with a previously found ${pkg}!"
286 " The two paths are " ${_tmp_ROOT_DIR} " vs " ${${pkg_UC}_ROOT_DIR_EXP})
288 MESSAGE(STATUS "${pkg} directory matches what was previously exposed by another prereq, all good!")
293 ## 6. Save the detected installation
295 SET(${pkg_UC}_ROOT_DIR "${_tmp_ROOT_DIR}")
298 MESSAGE(STATUS "${pkg} was not found.")
301 SET(Salome${pkg}_FOUND "${pkg}_FOUND")
302 ENDMACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS)