From ed9513b993ed6a2790972c9f11248e3d9d5f0fd1 Mon Sep 17 00:00:00 2001 From: rnv Date: Wed, 10 Aug 2016 18:33:09 +0300 Subject: [PATCH] Merge 'abn/configuration' into master branch. --- CMakeLists.txt | 13 +- CMakeModules/FindGraphviz.cmake | 79 -- CMakeModules/FindSalomeDoxygen.cmake | 44 - CMakeModules/FindSalomeGraphviz.cmake | 33 - CMakeModules/FindSalomePythonInterp.cmake | 48 - CMakeModules/FindSalomePythonLibs.cmake | 56 -- CMakeModules/FindSalomeSphinx.cmake | 46 - CMakeModules/FindSphinx.cmake | 55 -- CMakeModules/SalomeDocumentationMacros.cmake | 112 --- CMakeModules/SalomeMacros.cmake | 957 ------------------- CMakeModules/SalomeSetupPlatform.cmake | 183 ---- 11 files changed, 10 insertions(+), 1616 deletions(-) delete mode 100644 CMakeModules/FindGraphviz.cmake delete mode 100644 CMakeModules/FindSalomeDoxygen.cmake delete mode 100644 CMakeModules/FindSalomeGraphviz.cmake delete mode 100644 CMakeModules/FindSalomePythonInterp.cmake delete mode 100644 CMakeModules/FindSalomePythonLibs.cmake delete mode 100644 CMakeModules/FindSalomeSphinx.cmake delete mode 100644 CMakeModules/FindSphinx.cmake delete mode 100644 CMakeModules/SalomeDocumentationMacros.cmake delete mode 100644 CMakeModules/SalomeMacros.cmake delete mode 100644 CMakeModules/SalomeSetupPlatform.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index 512fb92..5ba22a8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,9 +33,16 @@ SET(${PROJECT_NAME_UC}_VERSION ${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION}.${${PROJECT_NAME_UC}_PATCH_VERSION}) SET(${PROJECT_NAME_UC}_VERSION_DEV 1) -# Our own set of macros: -# ================== -LIST(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules") +# Common CMake macros +# =================== +SET(CONFIGURATION_ROOT_DIR $ENV{CONFIGURATION_ROOT_DIR} CACHE PATH "Path to the Salome CMake configuration files") +IF(EXISTS ${CONFIGURATION_ROOT_DIR}) + LIST(APPEND CMAKE_MODULE_PATH "${CONFIGURATION_ROOT_DIR}/cmake") + INCLUDE(SalomeMacros) +ELSE() + MESSAGE(FATAL_ERROR "We absolutely need the Salome CMake configuration files, please define CONFIGURATION_ROOT_DIR !") +ENDIF() + INCLUDE(SalomeSetupPlatform) INCLUDE(SalomeMacros) diff --git a/CMakeModules/FindGraphviz.cmake b/CMakeModules/FindGraphviz.cmake deleted file mode 100644 index cc3de0d..0000000 --- a/CMakeModules/FindGraphviz.cmake +++ /dev/null @@ -1,79 +0,0 @@ -# - Graphviz detection -# -# Output variables: GRAPHVIZ_EXECUTABLE - where is executable 'dot' takes place. -# GRAPHVIZ_INCLUDE_DIRS - where to find headers. -# GRAPHVIZ_LIBRARIES - where to get libraries. -# GRAPHVIZ_VERSION - Graphviz version -# GRAPHVIZ_DEFINITIONS - Graphviz definitions -# GRAPHVIZ_FOUND - True if Graphviz was found. -# -########################################################################### -# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE -# -# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -# -# 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 -# - -FIND_PROGRAM(GRAPHVIZ_EXECUTABLE dot) - -FIND_PATH(GRAPHVIZ_INCLUDE_DIR NAMES graphviz/cgraph.h) -SET(GRAPHVIZ_INCLUDE_DIRS ${GRAPHVIZ_INCLUDE_DIR} ${GRAPHVIZ_INCLUDE_DIR}/graphviz) - -IF(GRAPHVIZ_EXECUTABLE) - IF(NOT CMAKE_PREFIX_PATH) # Case where dot is in the path and -DGRAPHVIZ_ROOT_DIR not defined. - GET_FILENAME_COMPONENT(GRAPHVIZ_EXECUTABLE_DIR ${GRAPHVIZ_EXECUTABLE} PATH) - GET_FILENAME_COMPONENT(GRAPHVIZ_EXECUTABLE_DIR ${GRAPHVIZ_EXECUTABLE_DIR} PATH) - SET(CMAKE_PREFIX_PATH "${GRAPHVIZ_EXECUTABLE_DIR}") - ENDIF(NOT CMAKE_PREFIX_PATH) -ENDIF(GRAPHVIZ_EXECUTABLE) - -FIND_LIBRARY(GRAPHVIZ_cdt_LIBRARY NAMES cdt PATH_SUFFIXES bin) -FIND_LIBRARY(GRAPHVIZ_graph_LIBRARY NAMES cgraph PATH_SUFFIXES bin) -FIND_LIBRARY(GRAPHVIZ_gvc_LIBRARY NAMES gvc PATH_SUFFIXES bin) -FIND_LIBRARY(GRAPHVIZ_pathplan_LIBRARY NAMES pathplan PATH_SUFFIXES bin) - -SET(GRAPHVIZ_LIBRARIES - ${GRAPHVIZ_cdt_LIBRARY} - ${GRAPHVIZ_graph_LIBRARY} - ${GRAPHVIZ_gvc_LIBRARY} - ${GRAPHVIZ_pathplan_LIBRARY} - ) - -IF(GRAPHVIZ_EXECUTABLE) - EXECUTE_PROCESS(COMMAND ${GRAPHVIZ_EXECUTABLE} "-V" ERROR_VARIABLE GRAPHVIZ_VERSION ERROR_STRIP_TRAILING_WHITESPACE) - STRING(REGEX REPLACE ".* ([0-9.]+) .*" "\\1" GRAPHVIZ_VERSION "${GRAPHVIZ_VERSION}") -ENDIF() - -SET(GRAPHVIZ_DEFINITIONS) -IF("${GRAPHVIZ_VERSION}" VERSION_LESS "2.36.0") - SET(GRAPHVIZ_DEFINITIONS -DWITH_CGRAPH) -ENDIF() - -## Don't detect cgraph on Windows -#IF(NOT WIN32) -# FIND_LIBRARY(GRAPHVIZ_cgraph_LIBRARY NAMES cgraph PATH_SUFFIXES bin) -# SET(GRAPHVIZ_LIBRARIES ${GRAPHVIZ_cgraph_LIBRARY}) -#ENDIF() - -# Handle the standard arguments of the find_package() command: -INCLUDE(FindPackageHandleStandardArgs) -FIND_PACKAGE_HANDLE_STANDARD_ARGS(Graphviz REQUIRED_VARS - GRAPHVIZ_EXECUTABLE - GRAPHVIZ_LIBRARIES - GRAPHVIZ_INCLUDE_DIRS) diff --git a/CMakeModules/FindSalomeDoxygen.cmake b/CMakeModules/FindSalomeDoxygen.cmake deleted file mode 100644 index 53ce831..0000000 --- a/CMakeModules/FindSalomeDoxygen.cmake +++ /dev/null @@ -1,44 +0,0 @@ -# Copyright (C) 2013-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: Adrien Bruneton -# - -# Doxygen detection for salome -# -# !! Please read the generic detection procedure in SalomeMacros.cmake !! -# -# Additional variables: -# -# DOXYGEN_SUPPORT_STL (string) [advanced] : set to YES if doxygen properly manages STL files -# or to NO otherwise (version 1.4.4 or older); see description of -# BUILTIN_STL_SUPPORT configuration variable in the doxygen documentation - -SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS(Doxygen DOXYGEN_EXECUTABLE 2) -IF(DOXYGEN_FOUND) - IF(DOXYGEN_VERSION VERSION_LESS "1.4.5") - SET(DOXYGEN_SUPPORT_STL NO) - ELSE() - SET(DOXYGEN_SUPPORT_STL YES) - ENDIF() -ENDIF() -MARK_AS_ADVANCED(DOXYGEN_SUPPORT_STL) - -IF(DOXYGEN_FOUND) - SALOME_ACCUMULATE_ENVIRONMENT(PATH ${DOXYGEN_EXECUTABLE}) -ENDIF() diff --git a/CMakeModules/FindSalomeGraphviz.cmake b/CMakeModules/FindSalomeGraphviz.cmake deleted file mode 100644 index 157c24f..0000000 --- a/CMakeModules/FindSalomeGraphviz.cmake +++ /dev/null @@ -1,33 +0,0 @@ -# Copyright (C) 2013-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: Adrien Bruneton -# - -# Graphviz detection for salome -# -# !! Please read the generic detection procedure in SalomeMacros.cmake !! -# - -SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS(Graphviz GRAPHVIZ_EXECUTABLE 2) -MARK_AS_ADVANCED(GRAPHVIZ_EXECUTABLE GRAPHVIZ_LIBRARIES GRAPHVIZ_INCLUDE_DIRS) - -IF(GRAPHVIZ_FOUND) - SALOME_ACCUMULATE_ENVIRONMENT(PATH ${GRAPHVIZ_EXECUTABLE}) - SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH ${GRAPHVIZ_LIBRARIES}) -ENDIF() \ No newline at end of file diff --git a/CMakeModules/FindSalomePythonInterp.cmake b/CMakeModules/FindSalomePythonInterp.cmake deleted file mode 100644 index 23f229d..0000000 --- a/CMakeModules/FindSalomePythonInterp.cmake +++ /dev/null @@ -1,48 +0,0 @@ -# Copyright (C) 2013-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: Adrien Bruneton -# - -# Python interpreter detection for SALOME -# -# !! Please read the generic detection procedure in SalomeMacros.cmake !! -# - -# Make sure the detection of both libs and interpreter (if both needed) occur in the correct order: -IF(SALOMEPYTHONLIBS_FOUND AND NOT SALOMEPYTHONINTERP_FOUND) - MESSAGE(FATAL_ERROR "Developer error -> Python interpreter should be detected/required before Python libs!") -ENDIF() - -# Use the PYTHON_ROOT_DIR if PYTHONINTERP_ROOT_DIR is not defined: -SET(PYTHON_ROOT_DIR "$ENV{PYTHON_ROOT_DIR}" CACHE PATH "Path to the Python installation (libs+interpreter)") -IF(EXISTS "${PYTHON_ROOT_DIR}" AND (NOT PYTHONINTERP_ROOT_DIR)) - # Extract sub-directory "paraview-x.xx": - MESSAGE(STATUS "Setting PYTHONINTERP_ROOT_DIR to: ${PYTHON_ROOT_DIR}") - SET(PYTHONINTERP_ROOT_DIR "${PYTHON_ROOT_DIR}" CACHE PATH "Path to PythonInterp directory") -ENDIF() -SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS(PythonInterp PYTHON_EXECUTABLE 1) - -IF(SALOMEPYTHONINTERP_FOUND) - SET(PYTHON_PYTHONPATH "${PYTHON_ROOT_DIR}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}") - GET_FILENAME_COMPONENT(_python_bin "${PYTHON_EXECUTABLE}" NAME ) - SET(PYTHONBIN "${_python_bin}" CACHE STRING "Name of Python interpreter") - SALOME_ACCUMULATE_ENVIRONMENT(PATH ${PYTHON_EXECUTABLE}) - SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH ${PYTHON_PYTHONPATH}) -ENDIF() - diff --git a/CMakeModules/FindSalomePythonLibs.cmake b/CMakeModules/FindSalomePythonLibs.cmake deleted file mode 100644 index 36473f2..0000000 --- a/CMakeModules/FindSalomePythonLibs.cmake +++ /dev/null @@ -1,56 +0,0 @@ -# Copyright (C) 2013-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: Adrien Bruneton -# - -# Python libraries detection for SALOME -# -# !! Please read the generic detection procedure in SalomeMacros.cmake !! -# - -# Use the PYTHON_ROOT_DIR if PYTHONLIBS_ROOT_DIR is not defined: -SET(PYTHON_ROOT_DIR "$ENV{PYTHON_ROOT_DIR}" CACHE PATH "Path to the Python installation (libs+interpreter)") -IF(EXISTS "${PYTHON_ROOT_DIR}" AND (NOT PYTHONLIBS_ROOT_DIR)) - MESSAGE(STATUS "Setting PYTHONLIBS_ROOT_DIR to: ${PYTHON_ROOT_DIR}") - SET(PYTHONLIBS_ROOT_DIR "${PYTHON_ROOT_DIR}" CACHE PATH "Path to PythonLibs directory") -ENDIF() -IF (SALOMEPYTHONINTERP_FOUND AND NOT "${PYTHON_VERSION_STRING}" STREQUAL "") - # Trying to search libraries with same version as an interpreter version - SET(PythonLibs_FIND_VERSION ${PYTHON_VERSION_STRING}) - SET(PythonLibs_FIND_VERSION_MAJOR ${PYTHON_VERSION_MAJOR}) -ENDIF() -IF(WIN32) - set(CMAKE_LIBRARY_PATH "${PYTHON_ROOT_DIR}/libs") -ENDIF() -SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS(PythonLibs PYTHON_INCLUDE_DIR 2) - -IF(SALOMEPYTHONLIBS_FOUND) - SALOME_ACCUMULATE_HEADERS(PYTHON_INCLUDE_DIR) - SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH ${PYTHON_LIBRARIES}) -ENDIF() - -## Specifics -- check matching version with Interpreter if already detected: -IF (SALOMEPYTHONLIBS_FOUND AND SALOMEPYTHONINTERP_FOUND) - # Now ensure versions are matching - IF("${PYTHONLIBS_VERSION_STRING}" STREQUAL "${PYTHON_VERSION_STRING}") - MESSAGE(STATUS "Python libs and interpreter versions are matching: ${PYTHONLIBS_VERSION_STRING}") - ELSE() - MESSAGE(FATAL_ERROR "Python libs and interpreter versions are NOT matching: ${PYTHONLIBS_VERSION_STRING} vs ${PYTHON_VERSION_STRING}") - ENDIF() -ENDIF() diff --git a/CMakeModules/FindSalomeSphinx.cmake b/CMakeModules/FindSalomeSphinx.cmake deleted file mode 100644 index 31e9a60..0000000 --- a/CMakeModules/FindSalomeSphinx.cmake +++ /dev/null @@ -1,46 +0,0 @@ -# Copyright (C) 2013-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 -# - -# Sphinx detection for Salome -# -# !! Please read the generic detection procedure in SalomeMacros.cmake !! -# - -SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS(Sphinx SPHINX_EXECUTABLE 2) - -# Also retrieve paths to DOCUTILS and SETUPTOOLS: -SET(SETUPTOOLS_ROOT_DIR "$ENV{SETUPTOOLS_ROOT_DIR}" CACHE PATH "Path to the Setuptools installation") -SET(DOCUTILS_ROOT_DIR "$ENV{DOCUTILS_ROOT_DIR}" CACHE PATH "Path to the Docutils installation") - -# Ensure the command is run with the given PYTHONPATH -IF(WIN32 AND NOT CYGWIN) - SET(SPHINX_EXECUTABLE ${SPHINX_EXECUTABLE}) - SET(SPHINX_APIDOC_EXECUTABLE ${SPHINX_APIDOC_EXECUTABLE}) -ELSE() - SET(SPHINX_EXECUTABLE /usr/bin/env PYTHONPATH="${SPHINX_PYTHONPATH}:$$PYTHONPATH" ${SPHINX_EXECUTABLE}) - SET(SPHINX_APIDOC_EXECUTABLE /usr/bin/env PYTHONPATH="${SPHINX_PYTHONPATH}:$$PYTHONPATH" ${SPHINX_APIDOC_EXECUTABLE}) -ENDIF() - -MARK_AS_ADVANCED(SPHINX_EXECUTABLE) - -IF(SPHINX_FOUND) - SALOME_ACCUMULATE_ENVIRONMENT(PATH ${SPHINX_EXECUTABLE}) - SALOME_ACCUMULATE_ENVIRONMENT(PATH ${SPHINX_APIDOC_EXECUTABLE}) - SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH ${SPHINX_PYTHONPATH}) -ENDIF() diff --git a/CMakeModules/FindSphinx.cmake b/CMakeModules/FindSphinx.cmake deleted file mode 100644 index 26aa3f0..0000000 --- a/CMakeModules/FindSphinx.cmake +++ /dev/null @@ -1,55 +0,0 @@ -# - Sphinx detection -# -# Output variables: -# SPHINX_EXECUTABLE - path to the Sphinx executable -# SPHINX_PYTHONPATH - path to the Sphinx Python modules -# -########################################################################### -# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE -# -# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -# -# 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 -# - -FIND_PROGRAM(SPHINX_EXECUTABLE sphinx-build PATH_SUFFIXES Scripts) -FIND_PROGRAM(SPHINX_APIDOC_EXECUTABLE sphinx-apidoc PATH_SUFFIXES Scripts) - -# Get root dir locally, going up two levels from the exec: -GET_FILENAME_COMPONENT(_tmp_ROOT_DIR "${SPHINX_EXECUTABLE}" PATH) -GET_FILENAME_COMPONENT(_tmp_ROOT_DIR "${_tmp_ROOT_DIR}" PATH) -IF(WIN32) - SET(SPHINX_PYTHONPATH "${_tmp_ROOT_DIR}/lib/site-packages") -ELSE() - SET(SPHINX_PYTHONPATH "${_tmp_ROOT_DIR}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages") -ENDIF() - -# Handle the standard arguments of the find_package() command: -INCLUDE(FindPackageHandleStandardArgs) -FIND_PACKAGE_HANDLE_STANDARD_ARGS(Sphinx REQUIRED_VARS SPHINX_EXECUTABLE SPHINX_APIDOC_EXECUTABLE) - -IF(SPHINX_EXECUTABLE) - EXECUTE_PROCESS(COMMAND ${SPHINX_EXECUTABLE} "--version" OUTPUT_VARIABLE SPHINX_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) - STRING(REGEX REPLACE ".* ([0-9.]+)$" "\\1" SPHINX_VERSION "${SPHINX_VERSION}" ) - MESSAGE(STATUS "Sphinx version is ${SPHINX_VERSION}") - IF(SPHINX_VERSION VERSION_LESS "1.3") - SET(SPHINX_THEME "default") - ELSE() - SET(SPHINX_THEME "classic") - ENDIF() -ENDIF(SPHINX_EXECUTABLE) diff --git a/CMakeModules/SalomeDocumentationMacros.cmake b/CMakeModules/SalomeDocumentationMacros.cmake deleted file mode 100644 index b23f251..0000000 --- a/CMakeModules/SalomeDocumentationMacros.cmake +++ /dev/null @@ -1,112 +0,0 @@ -# Copyright (C) 2013-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: Roman NIKOLAEV -# - -#---------------------------------------------------------------------------- -# SALOME_ADD_SPHINX_DOC is a macro useful for generating sphinx documentation -# -# USAGE: SALOME_ADD_SPHINX_DOC(sphinx_type sphinx_name src_dir cfg_dir) -# -# ARGUMENTS: -# -# sphinx_type: IN - type of the sphinx generator, use one of the following types: -# -# html - to make standalone HTML files -# dirhtml - to make HTML files named index.html in directories -# singlehtml - to make a single large HTML file -# pickle - to make pickle files -# json - to make JSON files -# htmlhelp - to make HTML files and a HTML help project -# qthelp - to make HTML files and a qthelp project" -# devhelp to make HTML files and a Devhelp project" -# epub to make an epub" -# latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter -# latexpdf to make LaTeX files and run them through pdflatex" -# text to make text files" -# man to make manual pages" -# texinfo to make Texinfo files" -# info to make Texinfo files and run them through makeinfo -# gettext to make PO message catalogs" -# changes to make an overview of all changed/added/deprecated items -# linkcheck to check all external links for integrity" -# doctest to run all doctests embedded in the documentation (if enabled)\ -# -# sphinx_name: IN - documentation target name -# -# src_dir : IN - path to directory that contains the sphinx source files -# -# cfg_dir : IN - path to directory that contains sphinx configuration file (if not specified, -# it is considered equal to src_dir) -# -# ADDITIONAL SETTINGS: -# -# Also you can set these variables to define additional sphinx settings: -# -# SPHINXOPTS - sphinx executable options -# PAPER - LaTeX paper type ("a4" by default) -# BUILDDIR - local sphinx build directory ("_build" by default) -#---------------------------------------------------------------------------- - -MACRO(SALOME_ADD_SPHINX_DOC sphinx_type sphinx_name src_dir cfg_dir) - - # Get type and additional settings - SET(SPHINX_TYPE ${sphinx_type}) - IF(${SPHINX_TYPE} STREQUAL "") - SET(SPHINX_TYPE html) - ENDIF(${SPHINX_TYPE} STREQUAL "") - - IF("${PAPER}" STREQUAL "") - SET(PAPER a4) - ENDIF() - - IF("${BUILDDIR}" STREQUAL "") - SET(BUILDDIR _build) - ENDIF() - - SET(SPHINX_CFG ${cfg_dir}) - IF("${SPHINX_CFG}" STREQUAL "") - SET(SPHINX_CFG ${src_dir}) - ENDIF() - - # Initialize internal variables - SET(PAPEROPT_a4 -D latex_paper_size=a4) - SET(PAPEROPT_letter -D latex_paper_size=letter) - SET(ALLSPHINXOPTS -d ${BUILDDIR}/doctrees ${PAPEROPT_${PAPER}} ${SPHINXOPTS}) - SET(I18NSPHINXOPTS ${PAPEROPT_${PAPER}} ${SPHINXOPTS}) - - SET(ALLSPHINXOPTS ${ALLSPHINXOPTS} ${src_dir}) - SET(I18NSPHINXOPTS ${I18NSPHINXOPTS} ${src_dir}) - - # Set internal out directory - SET(_OUT_DIR ${SPHINX_TYPE}) - IF(${SPHINX_TYPE} STREQUAL "gettext") - SET(_OUT_DIR gettext) - SET(ALLSPHINXOPTS ${I18NSPHINXOPTS}) - ENDIF(${SPHINX_TYPE} STREQUAL "gettext") - - # Build sphinx command - SET(_CMD_OPTIONS -b ${SPHINX_TYPE} -c ${SPHINX_CFG} ${ALLSPHINXOPTS} ${BUILDDIR}/${_OUT_DIR}) - - # This macro mainly prepares the environment in which sphinx should run: - # this sets the PYTHONPATH and LD_LIBRARY_PATH to include OMNIORB, DOCUTILS, SETUPTOOLS, etc ... - SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd env_script "${SPHINX_EXECUTABLE}" "${_CMD_OPTIONS}") - ADD_CUSTOM_TARGET(${sphinx_name} ALL ${_cmd}) - -ENDMACRO(SALOME_ADD_SPHINX_DOC) diff --git a/CMakeModules/SalomeMacros.cmake b/CMakeModules/SalomeMacros.cmake deleted file mode 100644 index 2581731..0000000 --- a/CMakeModules/SalomeMacros.cmake +++ /dev/null @@ -1,957 +0,0 @@ -# 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]) -# -# 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. -#---------------------------------------------------------------------------- -MACRO(SALOME_INSTALL_SCRIPTS file_list path) - PARSE_ARGUMENTS(SALOME_INSTALL_SCRIPTS "WORKING_DIRECTORY" "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) - SET(_all_subdirs) - 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}.pyc") - SET(_pyo_file "${CMAKE_CURRENT_BINARY_DIR}/${we_ext}.pyo") - LIST(APPEND _all_pyc ${_pyc_file}) - LIST(APPEND _all_pyo ${_pyo_file}) - ADD_CUSTOM_COMMAND( - OUTPUT ${_pyc_file} - COMMAND ${PYTHON_EXECUTABLE} -c "import py_compile ; py_compile.compile('${_source_prefix}${file}', '${_pyc_file}', doraise=True )" - DEPENDS ${PREFIX}${file} - VERBATIM - ) - ADD_CUSTOM_COMMAND( - OUTPUT ${_pyo_file} - COMMAND ${PYTHON_EXECUTABLE} -O -c "import py_compile ; py_compile.compile('${_source_prefix}${file}', '${_pyo_file}', doraise=True )" - DEPENDS ${PREFIX}${file} - VERBATIM - ) - # Install the .pyo and the .pyc - INSTALL(FILES ${_pyc_file} DESTINATION ${path} PERMISSIONS ${PERMS}) - INSTALL(FILES ${_pyo_file} DESTINATION ${path} PERMISSIONS ${PERMS}) - ENDIF(ext STREQUAL .py) - - # get relativa 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() - ADD_CUSTOM_TARGET("PYCOMPILE${unique_name}_${_cnt}" ALL DEPENDS ${_all_pyc} ${_all_pyo}) - 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_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