|
|
#
|
|
|
# sciqlop_macros.cmake
|
|
|
#
|
|
|
# The following functions or macros are defined in this document:
|
|
|
# - SUBDIRLIST
|
|
|
# - SCIQLOP_SET_TO_PARENT_SCOPE
|
|
|
# - SCIQLOP_PROCESS_EXTERN_DEPENDENCIES
|
|
|
# - SCIQLOP_COPY_TO_TARGET
|
|
|
# - SCIQLOP_READ_FILE
|
|
|
# - SCIQLOP_FIND_QT
|
|
|
# - SCIQLOP_ADD_EXTERN_DEPENDENCY
|
|
|
|
|
|
#
|
|
|
# Define a macro to retrieve all subdirectory names of a specific directory
|
|
|
#
|
|
|
MACRO(SUBDIRLIST result curdir)
|
|
|
FILE(GLOB children RELATIVE ${curdir} ${curdir}/*)
|
|
|
SET(dirlist "")
|
|
|
FOREACH(child ${children})
|
|
|
IF(IS_DIRECTORY ${curdir}/${child})
|
|
|
LIST(APPEND dirlist ${child})
|
|
|
ENDIF()
|
|
|
ENDFOREACH()
|
|
|
SET(${result} ${dirlist})
|
|
|
ENDMACRO()
|
|
|
|
|
|
# SCIQLOP_SET_TO_PARENT_SCOPE(variable)
|
|
|
#
|
|
|
# Set the given variable to the parent scope.
|
|
|
#
|
|
|
MACRO (SCIQLOP_SET_TO_PARENT_SCOPE variable)
|
|
|
SET(${variable} ${${variable}} PARENT_SCOPE)
|
|
|
ENDMACRO (SCIQLOP_SET_TO_PARENT_SCOPE)
|
|
|
|
|
|
MACRO(SCIQLOP_FIND_QT)
|
|
|
# Find includes in corresponding build directories
|
|
|
set(CMAKE_INCLUDE_CURRENT_DIR ON)
|
|
|
# Instruct CMake to run moc automatically when needed.
|
|
|
set(CMAKE_AUTOMOC ON)
|
|
|
|
|
|
# Find Qt5 and the modules asked
|
|
|
FOREACH(component ${ARGN})
|
|
|
FIND_PACKAGE(Qt5${component} QUIET REQUIRED)
|
|
|
INCLUDE_DIRECTORIES(${Qt5${component}_INCLUDE_DIRS})
|
|
|
ENDFOREACH(component)
|
|
|
ENDMACRO(SCIQLOP_FIND_QT)
|
|
|
|
|
|
# SCIQLOP_PROCESS_EXTERN_DEPENDENCIES(externFile externLibraries externSharedLibraries)
|
|
|
#
|
|
|
# Process the dependencies file for the modules. Each line of this file must
|
|
|
# contain the parameters to pass to the FIND_PACKAGE function. This function
|
|
|
# will append the libraries of the extern dependency found to the variable
|
|
|
# passed as a second parameter, and add the include directories of the extern
|
|
|
# dependency to the global include directories. Moreover, the extern shared
|
|
|
# libraries are stored in the variable passed as a third parameter. These shared
|
|
|
# libraries can then be copied to a target output path by using the
|
|
|
# SCIQLOP_COPY_TO_TARGET function.
|
|
|
#
|
|
|
# Examples:
|
|
|
#
|
|
|
# SCIQLOP_PROCESS_MODULE_DEPENDENCIES("path/to/extern.dependencies"
|
|
|
# EXTERN_LIBRARIES
|
|
|
# EXTERN_SHARED_LIBRARIES)
|
|
|
#
|
|
|
FUNCTION (SCIQLOP_PROCESS_EXTERN_DEPENDENCIES externFile librariesVar sharedLibrariesVar)
|
|
|
|
|
|
SCIQLOP_READ_FILE(${externFile} externDependencies)
|
|
|
SET (externLibraries)
|
|
|
SET (externSharedLibraries)
|
|
|
FOREACH (externDependency ${externDependencies})
|
|
|
# Check if the line is a comment (begins with #)
|
|
|
STRING(REGEX MATCH "^ *#.*$" matched "${externDependency}")
|
|
|
IF (NOT matched)
|
|
|
STRING(REGEX REPLACE " +" ";" externDependency "${externDependency}")
|
|
|
SCIQLOP_ADD_EXTERN_DEPENDENCY(externLibraries externSharedLibraries ${externDependency})
|
|
|
ENDIF()
|
|
|
ENDFOREACH()
|
|
|
|
|
|
LIST (APPEND ${librariesVar} ${externLibraries})
|
|
|
SCIQLOP_SET_TO_PARENT_SCOPE(${librariesVar})
|
|
|
|
|
|
LIST (APPEND ${sharedLibrariesVar} ${externSharedLibraries})
|
|
|
SCIQLOP_SET_TO_PARENT_SCOPE(${sharedLibrariesVar})
|
|
|
ENDFUNCTION (SCIQLOP_PROCESS_EXTERN_DEPENDENCIES)
|
|
|
|
|
|
# SCIQLOP_COPY_TO_TARGET copy the given files to the given target output path.
|
|
|
#
|
|
|
# The first parameter must be RUNTIME or LIBRARY, and it indicates the type of
|
|
|
# the target.
|
|
|
#
|
|
|
# The second parameter is the name of the target where the files must be copied.
|
|
|
# The RUNTIME_OUTPUT_DIRECTORY or LIBRARY_OUTPUT_DIRECTORY target properties
|
|
|
# will be used to find the output path of the copy. If these properties are
|
|
|
# empty, then the EXECUTABLE_OUTPUT_PATH or LIBRARY_OUTPUT_PATH variables will
|
|
|
# be used.
|
|
|
#
|
|
|
# The rest of the parameters are the files that must be copied.
|
|
|
FUNCTION (SCIQLOP_COPY_TO_TARGET runtimeOrLibrary targetName)
|
|
|
# Check RUNTIME or LIBRARY argument
|
|
|
IF (${runtimeOrLibrary} STREQUAL "RUNTIME")
|
|
|
SET (targetProperty "RUNTIME_OUTPUT_DIRECTORY")
|
|
|
SET (pathProperty ${EXECUTABLE_OUTPUT_PATH})
|
|
|
ELSEIF (${runtimeOrLibrary} STREQUAL "LIBRARY")
|
|
|
SET (targetProperty "LIBRARY_OUTPUT_DIRECTORY")
|
|
|
SET (pathProperty ${LIBRARY_OUTPUT_PATH})
|
|
|
ELSE ()
|
|
|
MESSAGE (FATAL "The first parameter of COPY_TO_TARGET must be either RUNTIME or LIBRARY, not \"${runtimeOrLibrary}\"")
|
|
|
ENDIF ()
|
|
|
|
|
|
# Select the output directory
|
|
|
GET_TARGET_PROPERTY(OUTPUT_DIR ${targetName} ${targetProperty})
|
|
|
IF (OUTPUT_DIR STREQUAL "OUTPUT_DIR-NOTFOUND")
|
|
|
SET (OUTPUT_DIR ${pathProperty})
|
|
|
ENDIF ()
|
|
|
|
|
|
# Retrieve the list of files to copy by listing the rest of the macro
|
|
|
# arguments
|
|
|
FOREACH (arg ${ARGN})
|
|
|
LIST(APPEND fileList ${arg})
|
|
|
ENDFOREACH()
|
|
|
|
|
|
# Only copy if the list isn't empty
|
|
|
IF (fileList)
|
|
|
FILE(COPY ${fileList} DESTINATION ${OUTPUT_DIR})
|
|
|
ENDIF()
|
|
|
ENDFUNCTION (SCIQLOP_COPY_TO_TARGET)
|
|
|
|
|
|
# SCIQLOP_READ_FILE(file contents)
|
|
|
#
|
|
|
# Read the given file line by line and store the resulting list inside the
|
|
|
# contents variable.
|
|
|
#
|
|
|
# /!\ If the file contains semicolons, the macro will escape them before
|
|
|
# returning the list.
|
|
|
#
|
|
|
# From <http://public.kitware.com/pipermail/cmake/2007-May/014222.html>
|
|
|
FUNCTION (SCIQLOP_READ_FILE file contentsVar)
|
|
|
FILE (READ ${file} contents)
|
|
|
|
|
|
# Convert file contents into a CMake list (where each element in the list
|
|
|
# is one line of the file)
|
|
|
#
|
|
|
STRING(REGEX REPLACE ";" "\\\\;" contents "${contents}")
|
|
|
STRING(REGEX REPLACE "\n" ";" contents "${contents}")
|
|
|
|
|
|
# Return file contents as a list
|
|
|
SET (${contentsVar} "${contents}" PARENT_SCOPE)
|
|
|
ENDFUNCTION (SCIQLOP_READ_FILE)
|
|
|
|
|
|
# SCIQLOP_ADD_EXTERN_DEPENDENCY(externLibrariesVar externSharedLibrariesVar dependencyName [EXTRA FIND_PACKAGE ARGS])
|
|
|
#
|
|
|
# SCIQLOP_ADD_EXTERN_DEPENDENCY can be used to add a dependency residing in the
|
|
|
# extern subdirectory to a module.
|
|
|
#
|
|
|
# The first parameter is the name of the variable where the found libraries will
|
|
|
# be added.
|
|
|
#
|
|
|
# The second parameter is the name of the variable where the found shared
|
|
|
# libraries will be added.
|
|
|
#
|
|
|
# The third parameter is the name of the dependency, and the rest of the
|
|
|
# arguments are the same than the FIND_PACKAGE command. In fact they are passed
|
|
|
# as-is to the command.
|
|
|
#
|
|
|
# If the dependency is found, then INCLUDE_DIRECTORIES is called for the
|
|
|
# dependency include directories, and the libraries are added to the
|
|
|
# externLibrariesVar variable. Moreover, if the dependency is a shared library,
|
|
|
# then the dynamic libraries are added to the externSharedLibrariesVar so that
|
|
|
# they can be copied and installed alongside the module. The libraries in this
|
|
|
# variable are ordered so that the real library is before the symlinks to the
|
|
|
# library, so that the copy and install works as expected.
|
|
|
FUNCTION (SCIQLOP_ADD_EXTERN_DEPENDENCY externLibrariesVar externSharedLibrariesVar dependencyName)
|
|
|
STRING (TOUPPER ${dependencyName} upperDependencyName)
|
|
|
|
|
|
FIND_PACKAGE(${dependencyName} ${ARGN})
|
|
|
IF (${upperDependencyName}_FOUND)
|
|
|
# Add the include directories of the dependency
|
|
|
INCLUDE_DIRECTORIES(${${upperDependencyName}_INCLUDE_DIRS})
|
|
|
|
|
|
# Add the libraries to the externLibrariesVar variable and export it to
|
|
|
# the parent scope
|
|
|
LIST(APPEND ${externLibrariesVar} ${${upperDependencyName}_LIBRARIES})
|
|
|
SCIQLOP_SET_TO_PARENT_SCOPE(${externLibrariesVar})
|
|
|
|
|
|
# Find the shared libraries
|
|
|
LIST(APPEND ${externSharedLibrariesVar} ${${upperDependencyName}_SHARED_LIBRARIES})
|
|
|
|
|
|
# Export the externSharedLibrariesVar variable to the parent scope
|
|
|
SCIQLOP_SET_TO_PARENT_SCOPE(${externSharedLibrariesVar})
|
|
|
ENDIF ()
|
|
|
ENDFUNCTION (SCIQLOP_ADD_EXTERN_DEPENDENCY)
|
|
|
|
