diff options
Diffstat (limited to 'cmake')
| -rw-r--r-- | cmake/FindConfig++.cmake | 23 | ||||
| -rw-r--r-- | cmake/FindGpgme.cmake | 437 | ||||
| -rw-r--r-- | cmake/FindLibArchive.cmake | 83 | ||||
| -rw-r--r-- | cmake/FindPackageHandleStandardArgs.cmake | 611 | ||||
| -rw-r--r-- | cmake/FindPackageMessage.cmake | 48 | ||||
| -rw-r--r-- | cmake/FlagsOverrides.cmake | 13 |
6 files changed, 1215 insertions, 0 deletions
diff --git a/cmake/FindConfig++.cmake b/cmake/FindConfig++.cmake new file mode 100644 index 00000000..ceccfa58 --- /dev/null +++ b/cmake/FindConfig++.cmake @@ -0,0 +1,23 @@ +FIND_PATH(CONFIG++_INCLUDE_DIR libconfig.h++ ${CMAKE_INCLUDE_PATH} ${CMAKE_INSTALL_PREFIX}/include) + +FIND_LIBRARY(CONFIG++_LIBRARY NAMES config++ PATH ${CMAKE_LIBRARY_PATH} ${CMAKE_INSTALL_PREFIX}/lib) + +IF (CONFIG++_INCLUDE_DIR AND CONFIG++_LIBRARY) + SET(CONFIG++_FOUND TRUE) +ENDIF ( CONFIG++_INCLUDE_DIR AND CONFIG++_LIBRARY) + +IF (CONFIG++_FOUND) + IF (NOT CONFIG++_FIND_QUIETLY) + MESSAGE(STATUS "Found Config++: ${CONFIG++_LIBRARY}") + ENDIF (NOT CONFIG++_FIND_QUIETLY) +ELSE(CONFIG++_FOUND) + IF (Config++_FIND_REQUIRED) + IF(NOT CONFIG++_INCLUDE_DIR) + MESSAGE(FATAL_ERROR "Could not find LibConfig++ header file!") + ENDIF(NOT CONFIG++_INCLUDE_DIR) + + IF(NOT CONFIG++_LIBRARY) + MESSAGE(FATAL_ERROR "Could not find LibConfig++ library file!") + ENDIF(NOT CONFIG++_LIBRARY) + ENDIF (Config++_FIND_REQUIRED) +ENDIF (CONFIG++_FOUND)
\ No newline at end of file diff --git a/cmake/FindGpgme.cmake b/cmake/FindGpgme.cmake new file mode 100644 index 00000000..d3987d0e --- /dev/null +++ b/cmake/FindGpgme.cmake @@ -0,0 +1,437 @@ +# - Try to find the gpgme library +# +# Algorithm: +# - Windows: +# On Windows, there's three gpgme variants: gpgme{,-glib,-qt}. +# - The variant used determines the event loop integration possible: +# - gpgme: no event loop integration possible, only synchronous operations supported +# - gpgme-glib: glib event loop integration possible, only asynchronous operations supported +# - gpgme-qt: qt event loop integration possible, only asynchronous operations supported +# - GPGME_{VANILLA,GLIB,QT}_{FOUND,LIBRARIES} will be set for each of the above +# - GPGME_INCLUDES is the same for all of the above +# - GPGME_FOUND is set if any of the above was found +# - *nix: +# There's also three variants: gpgme{,-pthread,-pth}. +# - The variant used determines the multithreaded use possible: +# - gpgme: no multithreading support available +# - gpgme-pthread: multithreading available using POSIX threads +# - gpgme-pth: multithreading available using GNU PTH (cooperative multithreading) +# - GPGME_{VANILLA,PTH,PTHREAD}_{FOUND,LIBRARIES} will be set for each of the above +# - GPGME_INCLUDES is the same for all of the above +# - GPGME_FOUND is set if any of the above was found +# +# GPGME_LIBRARY_DIR - the directory where the libraries are located + +# +# THIS IS ALMOST A 1:1 COPY OF FindAssuan.cmake in kdepim. +# Any changes here likely apply there, too. +# + +find_package(PkgConfig) + +#if this is built-in, please replace, if it isn't, export into a MacroToBool.cmake of it's own +macro( macro_bool_to_bool FOUND_VAR ) + foreach( _current_VAR ${ARGN} ) + if ( ${FOUND_VAR} ) + set( ${_current_VAR} TRUE ) + else() + set( ${_current_VAR} FALSE ) + endif() + endforeach() +endmacro() + +#HACK: local copy... +MACRO(MACRO_BOOL_TO_01 FOUND_VAR ) + FOREACH (_current_VAR ${ARGN}) + IF(${FOUND_VAR}) + SET(${_current_VAR} 1) + ELSE(${FOUND_VAR}) + SET(${_current_VAR} 0) + ENDIF(${FOUND_VAR}) + ENDFOREACH(_current_VAR) +ENDMACRO(MACRO_BOOL_TO_01) + +pkg_search_module(PC_GPGME gpgme) + +if (PC_GPGME_FOUND) + set(GPGME_INCLUDES ${PC_GPGME_INCLUDE_DIRS}) + set(GPGME_LIBRARIES ${PC_GPGME_LINK_LIBRARIES}) + set(GPGME_VERSION ${PC_GPGME_VERSION}) + set(GPGME_LIBRARY_DIR ${PC_GPGME_LIBRARY_DIR}) +elseif ( WIN32 ) + + # On Windows, we don't have a gpgme-config script, so we need to + # look for the stuff ourselves: + + # in cmake, AND and OR have the same precedence, there's no + # subexpressions, and expressions are evaluated short-circuit'ed + # IOW: CMake if() suxx. + # Starting with CMake 2.6.3 you can group if expressions with (), but we + # don't require 2.6.3 but 2.6.2, we can't use it. Alex + set( _seem_to_have_cached_gpgme false ) + if ( GPGME_INCLUDES ) + if ( GPGME_VANILLA_LIBRARIES OR GPGME_QT_LIBRARIES OR GPGME_GLIB_LIBRARIES ) + set( _seem_to_have_cached_gpgme true ) + endif() + endif() + + if ( _seem_to_have_cached_gpgme ) + + macro_bool_to_bool( GPGME_VANILLA_LIBRARIES GPGME_VANILLA_FOUND ) + macro_bool_to_bool( GPGME_GLIB_LIBRARIES GPGME_GLIB_FOUND ) + macro_bool_to_bool( GPGME_QT_LIBRARIES GPGME_QT_FOUND ) + # this would have been preferred: + #set( GPGME_*_FOUND macro_bool_to_bool(GPGME_*_LIBRARIES) ) + + if ( GPGME_VANILLA_FOUND OR GPGME_GLIB_FOUND OR GPGME_QT_FOUND ) + set( GPGME_FOUND true ) + else() + set( GPGME_FOUND false ) + endif() + + else() + + set( GPGME_FOUND false ) + set( GPGME_VANILLA_FOUND false ) + set( GPGME_GLIB_FOUND false ) + set( GPGME_QT_FOUND false ) + + find_path( GPGME_INCLUDES gpgme.h + ${CMAKE_INCLUDE_PATH} + ${CMAKE_INSTALL_PREFIX}/include + ) + + find_library( _gpgme_vanilla_lib NAMES gpgme libgpgme gpgme-11 libgpgme-11 + PATHS + ${CMAKE_LIBRARY_PATH} + ${CMAKE_INSTALL_PREFIX}/lib + ) + + find_library( _gpgme_glib_lib NAMES gpgme-glib libgpgme-glib gpgme-glib-11 libgpgme-glib-11 + PATHS + ${CMAKE_LIBRARY_PATH} + ${CMAKE_INSTALL_PREFIX}/lib + ) + + find_library( _gpgme_qt_lib NAMES gpgme-qt libgpgme-qt gpgme-qt-11 libgpgme-qt-11 + PATHS + ${CMAKE_LIBRARY_PATH} + ${CMAKE_INSTALL_PREFIX}/lib + ) + + find_library( _gpg_error_lib NAMES gpg-error libgpg-error gpg-error-0 libgpg-error-0 + PATHS + ${CMAKE_LIBRARY_PATH} + ${CMAKE_INSTALL_PREFIX}/lib + ) + + set( GPGME_INCLUDES ${GPGME_INCLUDES} ) + + if ( _gpgme_vanilla_lib AND _gpg_error_lib ) + set( GPGME_VANILLA_LIBRARIES ${_gpgme_vanilla_lib} ${_gpg_error_lib} ) + set( GPGME_VANILLA_FOUND true ) + set( GPGME_FOUND true ) + endif() + + if ( _gpgme_glib_lib AND _gpg_error_lib ) + set( GPGME_GLIB_LIBRARIES ${_gpgme_glib_lib} ${_gpg_error_lib} ) + set( GPGME_GLIB_FOUND true ) + set( GPGME_FOUND true ) + endif() + + if ( _gpgme_qt_lib AND _gpg_error_lib ) + set( GPGME_QT_LIBRARIES ${_gpgme_qt_library} ${_gpg_error_lib} ) + set( GPGME_QT_FOUND true ) + set( GPGME_FOUND true ) + endif() + + endif() + + # these are Unix-only: + set( GPGME_PTHREAD_FOUND false ) + set( GPGME_PTH_FOUND false ) + set( HAVE_GPGME_PTHREAD 0 ) + set( HAVE_GPGME_PTH 0 ) + + macro_bool_to_01( GPGME_FOUND HAVE_GPGME ) + macro_bool_to_01( GPGME_VANILLA_FOUND HAVE_GPGME_VANILLA ) + macro_bool_to_01( GPGME_GLIB_FOUND HAVE_GPGME_GLIB ) + macro_bool_to_01( GPGME_QT_FOUND HAVE_GPGME_QT ) + +else() # not WIN32 + + # On *nix, we have the gpgme-config script which can tell us all we + # need to know: + + # see WIN32 case for an explanation of what this does: + set( _seem_to_have_cached_gpgme false ) + if ( GPGME_INCLUDES ) + if ( GPGME_VANILLA_LIBRARIES OR GPGME_PTHREAD_LIBRARIES OR GPGME_PTH_LIBRARIES ) + set( _seem_to_have_cached_gpgme true ) + endif() + endif() + + if ( _seem_to_have_cached_gpgme ) + + macro_bool_to_bool( GPGME_VANILLA_LIBRARIES GPGME_VANILLA_FOUND ) + macro_bool_to_bool( GPGME_PTHREAD_LIBRARIES GPGME_PTHREAD_FOUND ) + macro_bool_to_bool( GPGME_PTH_LIBRARIES GPGME_PTH_FOUND ) + + if ( GPGME_VANILLA_FOUND OR GPGME_PTHREAD_FOUND OR GPGME_PTH_FOUND ) + set( GPGME_FOUND true ) + else() + set( GPGME_FOUND false ) + endif() + + else() + + set( GPGME_FOUND false ) + set( GPGME_VANILLA_FOUND false ) + set( GPGME_PTHREAD_FOUND false ) + set( GPGME_PTH_FOUND false ) + + find_program( _GPGMECONFIG_EXECUTABLE NAMES gpgme-config ) + + # if gpgme-config has been found + if ( _GPGMECONFIG_EXECUTABLE ) + + message( STATUS "Found gpgme-config at ${_GPGMECONFIG_EXECUTABLE}" ) + + execute_process(COMMAND ${_GPGMECONFIG_EXECUTABLE} --version OUTPUT_VARIABLE GPGME_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) + + set( _GPGME_MIN_VERSION "1.4.3" ) + + if ( ${GPGME_VERSION} VERSION_LESS ${_GPGME_MIN_VERSION} ) + + message( STATUS "The installed version of gpgme is too old: ${GPGME_VERSION} (required: >= ${_GPGME_MIN_VERSION})" ) + + else() + + message( STATUS "Found gpgme v${GPGME_VERSION}, checking for flavors..." ) + + execute_process(COMMAND ${_GPGMECONFIG_EXECUTABLE} --libs OUTPUT_VARIABLE _gpgme_config_vanilla_libs RESULT_VARIABLE _ret OUTPUT_STRIP_TRAILING_WHITESPACE) + if ( _ret ) + set( _gpgme_config_vanilla_libs ) + endif() + + execute_process(COMMAND ${_GPGMECONFIG_EXECUTABLE} --thread=pthread --libs OUTPUT_VARIABLE _gpgme_config_pthread_libs RESULT_VARIABLE _ret OUTPUT_STRIP_TRAILING_WHITESPACE) + if ( _ret ) + set( _gpgme_config_pthread_libs ) + endif() + + # append -lgpg-error to the list of libraries, if necessary + foreach ( _flavour vanilla pthread ) + if ( _gpgme_config_${_flavour}_libs AND NOT _gpgme_config_${_flavour}_libs MATCHES "lgpg-error") + set( _gpgme_config_${_flavour}_libs "${_gpgme_config_${_flavour}_libs} -lgpg-error" ) + endif() + endforeach() + + if ( _gpgme_config_vanilla_libs OR _gpgme_config_pthread_libs ) + + execute_process(COMMAND ${_GPGMECONFIG_EXECUTABLE} --cflags OUTPUT_VARIABLE _GPGME_CFLAGS OUTPUT_STRIP_TRAILING_WHITESPACE) + + if ( _GPGME_CFLAGS ) + string( REGEX REPLACE "(\r?\n)+$" " " _GPGME_CFLAGS "${_GPGME_CFLAGS}" ) + string( REGEX REPLACE " *-I" ";" GPGME_INCLUDES "${_GPGME_CFLAGS}" ) + endif() + + foreach ( _flavour vanilla pthread ) + if ( _gpgme_config_${_flavour}_libs ) + + set( _gpgme_library_dirs ) + set( _gpgme_library_names ) + string( TOUPPER "${_flavour}" _FLAVOUR ) + + string( REGEX REPLACE " +" ";" _gpgme_config_${_flavour}_libs "${_gpgme_config_${_flavour}_libs}" ) + + foreach( _flag ${_gpgme_config_${_flavour}_libs} ) + if ( "${_flag}" MATCHES "^-L" ) + string( REGEX REPLACE "^-L" "" _dir "${_flag}" ) + file( TO_CMAKE_PATH "${_dir}" _dir ) + set( _gpgme_library_dirs ${_gpgme_library_dirs} "${_dir}" ) + elseif( "${_flag}" MATCHES "^-l" ) + string( REGEX REPLACE "^-l" "" _name "${_flag}" ) + set( _gpgme_library_names ${_gpgme_library_names} "${_name}" ) + endif() + endforeach() + + set( GPGME_${_FLAVOUR}_FOUND true ) + + foreach( _name ${_gpgme_library_names} ) + set( _gpgme_${_name}_lib ) + + # if -L options were given, look only there + if ( _gpgme_library_dirs ) + find_library( _gpgme_${_name}_lib NAMES ${_name} PATHS ${_gpgme_library_dirs} NO_DEFAULT_PATH ) + endif() + + # if not found there, look in system directories + if ( NOT _gpgme_${_name}_lib ) + find_library( _gpgme_${_name}_lib NAMES ${_name} ) + endif() + + # if still not found, then the whole flavor isn't found + if ( NOT _gpgme_${_name}_lib ) + if ( GPGME_${_FLAVOUR}_FOUND ) + set( GPGME_${_FLAVOUR}_FOUND false ) + set( _not_found_reason "dependent library ${_name} wasn't found" ) + endif() + endif() + + set( _gpgme_${_flavour}_lib ${_gpgme_${_flavour}_lib} "${_gpgme_${_name}_lib}" ) + endforeach() + + #check_c_library_exists_explicit( gpgme gpgme_check_version "${_GPGME_CFLAGS}" "${GPGME_LIBRARIES}" GPGME_FOUND ) + if ( GPGME_${_FLAVOUR}_FOUND ) + message( STATUS " Found flavor '${_flavour}', checking whether it's usable...yes" ) + else() + message( STATUS " Found flavor '${_flavour}', checking whether it's usable...no" ) + message( STATUS " (${_not_found_reason})" ) + endif() + endif() + + endforeach( _flavour ) + + # ensure that they are cached + # This comment above doesn't make sense, the four following lines seem to do nothing. Alex + set( GPGME_INCLUDES ${GPGME_INCLUDES} ) + set( GPGME_VANILLA_LIBRARIES ${GPGME_VANILLA_LIBRARIES} ) + set( GPGME_PTHREAD_LIBRARIES ${GPGME_PTHREAD_LIBRARIES} ) + set( GPGME_PTH_LIBRARIES ${GPGME_PTH_LIBRARIES} ) + + if ( GPGME_VANILLA_FOUND OR GPGME_PTHREAD_FOUND OR GPGME_PTH_FOUND ) + set( GPGME_FOUND true ) + else() + set( GPGME_FOUND false ) + endif() + + endif() + + endif() + + else() + + # ensure that they are cached + # This comment above doesn't make sense, the four following lines seem to do nothing. Alex + set( GPGME_INCLUDES ${GPGME_INCLUDES} ) + set( GPGME_VANILLA_LIBRARIES ${GPGME_VANILLA_LIBRARIES} ) + set( GPGME_PTHREAD_LIBRARIES ${GPGME_PTHREAD_LIBRARIES} ) + set( GPGME_PTH_LIBRARIES ${GPGME_PTH_LIBRARIES} ) + + find_path( GPGME_INCLUDES gpgme.h + ${CMAKE_INCLUDE_PATH} + ${CMAKE_INSTALL_PREFIX}/include + ) + + find_library( _gpgme_vanilla_lib NAMES gpgme libgpgme gpgme-11 libgpgme-11 + PATHS + ${CMAKE_LIBRARY_PATH} + ${CMAKE_INSTALL_PREFIX}/lib + ) + + find_library( _gpgme_glib_lib NAMES gpgme-glib libgpgme-glib gpgme-glib-11 libgpgme-glib-11 + PATHS + ${CMAKE_LIBRARY_PATH} + ${CMAKE_INSTALL_PREFIX}/lib + ) + + find_library( _gpgme_qt_lib NAMES gpgme-qt libgpgme-qt gpgme-qt-11 libgpgme-qt-11 + PATHS + ${CMAKE_LIBRARY_PATH} + ${CMAKE_INSTALL_PREFIX}/lib + ) + + find_library( _gpg_error_lib NAMES gpg-error libgpg-error gpg-error-0 libgpg-error-0 + PATHS + ${CMAKE_LIBRARY_PATH} + ${CMAKE_INSTALL_PREFIX}/lib + ) + + set( GPGME_INCLUDES ${GPGME_INCLUDES} ) + + if ( _gpgme_vanilla_lib AND _gpg_error_lib ) + set( GPGME_VANILLA_LIBRARIES ${_gpgme_vanilla_lib} ${_gpg_error_lib} ) + set( GPGME_VANILLA_FOUND true ) + set( GPGME_FOUND true ) + endif() + + if ( _gpgme_glib_lib AND _gpg_error_lib ) + set( GPGME_GLIB_LIBRARIES ${_gpgme_vanilla_lib} ${_gpg_error_lib} ) + set( GPGME_GLIB_FOUND true ) + set( GPGME_FOUND true ) + endif() + + if ( _gpgme_qt_lib AND _gpg_error_lib ) + set( GPGME_QT_LIBRARIES ${_gpgme_vanilla_lib} ${_gpg_error_lib} ) + set( GPGME_QT_FOUND true ) + set( GPGME_FOUND true ) + endif() + + if ( GPGME_VANILLA_FOUND OR GPGME_PTHREAD_FOUND OR GPGME_PTH_FOUND ) + set( GPGME_FOUND true ) + else() + set( GPGME_FOUND false ) + endif() + + endif() + + endif() + + # these are Windows-only: + set( GPGME_GLIB_FOUND false ) + set( GPGME_QT_FOUND false ) + set( HAVE_GPGME_GLIB 0 ) + set( HAVE_GPGME_QT 0 ) + + macro_bool_to_01( GPGME_FOUND HAVE_GPGME ) + macro_bool_to_01( GPGME_VANILLA_FOUND HAVE_GPGME_VANILLA ) + macro_bool_to_01( GPGME_PTHREAD_FOUND HAVE_GPGME_PTHREAD ) + macro_bool_to_01( GPGME_PTH_FOUND HAVE_GPGME_PTH ) + +endif() # WIN32 | Unix + + +set( _gpgme_flavours "" ) + +if ( GPGME_VANILLA_FOUND ) + set( _gpgme_flavours "${_gpgme_flavours} vanilla" ) +endif() + +if ( GPGME_GLIB_FOUND ) + set( _gpgme_flavours "${_gpgme_flavours} Glib" ) +endif() + +if ( GPGME_QT_FOUND ) + set( _gpgme_flavours "${_gpgme_flavours} Qt" ) +endif() + +if ( GPGME_PTHREAD_FOUND ) + set( _gpgme_flavours "${_gpgme_flavours} pthread" ) +endif() + +if ( GPGME_PTH_FOUND ) + set( _gpgme_flavours "${_gpgme_flavours} pth" ) +endif() + +if(NOT GPGME_LIBRARIES) + # determine the library in one of the found flavors, can be reused e.g. by FindQgpgme.cmake, Alex + set(GPGME_LIBRARIES "") + foreach(_current_flavour vanilla glib qt pth pthread) + if(NOT GPGME_LIBRARY_DIR) + get_filename_component(GPGME_LIBRARY_DIR "${_gpgme_${_current_flavour}_lib}" PATH) + list(APPEND GPGME_LIBRARIES "${_gpgme_${_current_flavour}_lib}") + endif() + endforeach() + +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Gpgme + REQUIRED_VARS GPGME_LIBRARIES + VERSION_VAR GPGME_VERSION) + +if ( WIN32 ) + set( _gpgme_homepage "https://www.gpg4win.org" ) +else() + set( _gpgme_homepage "https://www.gnupg.org/related_software/gpgme" ) +endif() diff --git a/cmake/FindLibArchive.cmake b/cmake/FindLibArchive.cmake new file mode 100644 index 00000000..ec692112 --- /dev/null +++ b/cmake/FindLibArchive.cmake @@ -0,0 +1,83 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindLibArchive +-------------- + +Find libarchive library and headers. +Libarchive is multi-format archive and compression library. + +The module defines the following variables: + +:: + + LibArchive_FOUND - true if libarchive was found + LibArchive_INCLUDE_DIRS - include search path + LibArchive_LIBRARIES - libraries to link + LibArchive_VERSION - libarchive 3-component version number + +The module defines the following ``IMPORTED`` targets: + +:: + + LibArchive::LibArchive - target for linking against libarchive + +.. versionadded:: 3.6 + Support for new libarchive 3.2 version string format. + +.. versionadded:: 3.17 + Provides an imported target. + +#]=======================================================================] + +find_path(LibArchive_INCLUDE_DIR + NAMES archive.h + PATHS + "[HKEY_LOCAL_MACHINE\\SOFTWARE\\GnuWin32\\LibArchive;InstallPath]/include" + DOC "libarchive include directory" + ) + +find_library(LibArchive_LIBRARY + NAMES archive libarchive + PATHS + "[HKEY_LOCAL_MACHINE\\SOFTWARE\\GnuWin32\\LibArchive;InstallPath]/lib" + DOC "libarchive library" + ) + +mark_as_advanced(LibArchive_INCLUDE_DIR LibArchive_LIBRARY) + +# Extract the version number from the header. +if(LibArchive_INCLUDE_DIR AND EXISTS "${LibArchive_INCLUDE_DIR}/archive.h") + # The version string appears in one of three known formats in the header: + # #define ARCHIVE_LIBRARY_VERSION "libarchive 2.4.12" + # #define ARCHIVE_VERSION_STRING "libarchive 2.8.4" + # #define ARCHIVE_VERSION_ONLY_STRING "3.2.0" + # Match any format. + set(_LibArchive_VERSION_REGEX "^#define[ \t]+ARCHIVE[_A-Z]+VERSION[_A-Z]*[ \t]+\"(libarchive +)?([0-9]+)\\.([0-9]+)\\.([0-9]+)[^\"]*\".*$") + file(STRINGS "${LibArchive_INCLUDE_DIR}/archive.h" _LibArchive_VERSION_STRING LIMIT_COUNT 1 REGEX "${_LibArchive_VERSION_REGEX}") + if(_LibArchive_VERSION_STRING) + string(REGEX REPLACE "${_LibArchive_VERSION_REGEX}" "\\2.\\3.\\4" LibArchive_VERSION "${_LibArchive_VERSION_STRING}") + endif() + unset(_LibArchive_VERSION_REGEX) + unset(_LibArchive_VERSION_STRING) +endif() + +include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) +find_package_handle_standard_args(LibArchive + REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR + VERSION_VAR LibArchive_VERSION + ) +unset(LIBARCHIVE_FOUND) + +if(LibArchive_FOUND) + set(LibArchive_INCLUDE_DIRS ${LibArchive_INCLUDE_DIR}) + set(LibArchive_LIBRARIES ${LibArchive_LIBRARY}) + + if (NOT TARGET LibArchive::LibArchive) + add_library(LibArchive::LibArchive UNKNOWN IMPORTED) + set_target_properties(LibArchive::LibArchive PROPERTIES + IMPORTED_LOCATION "${LibArchive_LIBRARY}" + INTERFACE_INCLUDE_DIRECTORIES "${LibArchive_INCLUDE_DIR}") + endif () +endif()
\ No newline at end of file diff --git a/cmake/FindPackageHandleStandardArgs.cmake b/cmake/FindPackageHandleStandardArgs.cmake new file mode 100644 index 00000000..e86c77d8 --- /dev/null +++ b/cmake/FindPackageHandleStandardArgs.cmake @@ -0,0 +1,611 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindPackageHandleStandardArgs +----------------------------- + +This module provides functions intended to be used in :ref:`Find Modules` +implementing :command:`find_package(<PackageName>)` calls. + +.. command:: find_package_handle_standard_args + + This command handles the ``REQUIRED``, ``QUIET`` and version-related + arguments of :command:`find_package`. It also sets the + ``<PackageName>_FOUND`` variable. The package is considered found if all + variables listed contain valid results, e.g. valid filepaths. + + There are two signatures: + + .. code-block:: cmake + + find_package_handle_standard_args(<PackageName> + (DEFAULT_MSG|<custom-failure-message>) + <required-var>... + ) + + find_package_handle_standard_args(<PackageName> + [FOUND_VAR <result-var>] + [REQUIRED_VARS <required-var>...] + [VERSION_VAR <version-var>] + [HANDLE_VERSION_RANGE] + [HANDLE_COMPONENTS] + [CONFIG_MODE] + [NAME_MISMATCHED] + [REASON_FAILURE_MESSAGE <reason-failure-message>] + [FAIL_MESSAGE <custom-failure-message>] + ) + + The ``<PackageName>_FOUND`` variable will be set to ``TRUE`` if all + the variables ``<required-var>...`` are valid and any optional + constraints are satisfied, and ``FALSE`` otherwise. A success or + failure message may be displayed based on the results and on + whether the ``REQUIRED`` and/or ``QUIET`` option was given to + the :command:`find_package` call. + + The options are: + + ``(DEFAULT_MSG|<custom-failure-message>)`` + In the simple signature this specifies the failure message. + Use ``DEFAULT_MSG`` to ask for a default message to be computed + (recommended). Not valid in the full signature. + + ``FOUND_VAR <result-var>`` + .. deprecated:: 3.3 + + Specifies either ``<PackageName>_FOUND`` or + ``<PACKAGENAME>_FOUND`` as the result variable. This exists only + for compatibility with older versions of CMake and is now ignored. + Result variables of both names are always set for compatibility. + + ``REQUIRED_VARS <required-var>...`` + Specify the variables which are required for this package. + These may be named in the generated failure message asking the + user to set the missing variable values. Therefore these should + typically be cache entries such as ``FOO_LIBRARY`` and not output + variables like ``FOO_LIBRARIES``. + + .. versionchanged:: 3.18 + If ``HANDLE_COMPONENTS`` is specified, this option can be omitted. + + ``VERSION_VAR <version-var>`` + Specify the name of a variable that holds the version of the package + that has been found. This version will be checked against the + (potentially) specified required version given to the + :command:`find_package` call, including its ``EXACT`` option. + The default messages include information about the required + version and the version which has been actually found, both + if the version is ok or not. + + ``HANDLE_VERSION_RANGE`` + .. versionadded:: 3.19 + + Enable handling of a version range, if one is specified. Without this + option, a developer warning will be displayed if a version range is + specified. + + ``HANDLE_COMPONENTS`` + Enable handling of package components. In this case, the command + will report which components have been found and which are missing, + and the ``<PackageName>_FOUND`` variable will be set to ``FALSE`` + if any of the required components (i.e. not the ones listed after + the ``OPTIONAL_COMPONENTS`` option of :command:`find_package`) are + missing. + + ``CONFIG_MODE`` + Specify that the calling find module is a wrapper around a + call to ``find_package(<PackageName> NO_MODULE)``. This implies + a ``VERSION_VAR`` value of ``<PackageName>_VERSION``. The command + will automatically check whether the package configuration file + was found. + + ``REASON_FAILURE_MESSAGE <reason-failure-message>`` + .. versionadded:: 3.16 + + Specify a custom message of the reason for the failure which will be + appended to the default generated message. + + ``FAIL_MESSAGE <custom-failure-message>`` + Specify a custom failure message instead of using the default + generated message. Not recommended. + + ``NAME_MISMATCHED`` + .. versionadded:: 3.17 + + Indicate that the ``<PackageName>`` does not match + ``${CMAKE_FIND_PACKAGE_NAME}``. This is usually a mistake and raises a + warning, but it may be intentional for usage of the command for components + of a larger package. + +Example for the simple signature: + +.. code-block:: cmake + + find_package_handle_standard_args(LibXml2 DEFAULT_MSG + LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR) + +The ``LibXml2`` package is considered to be found if both +``LIBXML2_LIBRARY`` and ``LIBXML2_INCLUDE_DIR`` are valid. +Then also ``LibXml2_FOUND`` is set to ``TRUE``. If it is not found +and ``REQUIRED`` was used, it fails with a +:command:`message(FATAL_ERROR)`, independent whether ``QUIET`` was +used or not. If it is found, success will be reported, including +the content of the first ``<required-var>``. On repeated CMake runs, +the same message will not be printed again. + +.. note:: + + If ``<PackageName>`` does not match ``CMAKE_FIND_PACKAGE_NAME`` for the + calling module, a warning that there is a mismatch is given. The + ``FPHSA_NAME_MISMATCHED`` variable may be set to bypass the warning if using + the old signature and the ``NAME_MISMATCHED`` argument using the new + signature. To avoid forcing the caller to require newer versions of CMake for + usage, the variable's value will be used if defined when the + ``NAME_MISMATCHED`` argument is not passed for the new signature (but using + both is an error).. + +Example for the full signature: + +.. code-block:: cmake + + find_package_handle_standard_args(LibArchive + REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR + VERSION_VAR LibArchive_VERSION) + +In this case, the ``LibArchive`` package is considered to be found if +both ``LibArchive_LIBRARY`` and ``LibArchive_INCLUDE_DIR`` are valid. +Also the version of ``LibArchive`` will be checked by using the version +contained in ``LibArchive_VERSION``. Since no ``FAIL_MESSAGE`` is given, +the default messages will be printed. + +Another example for the full signature: + +.. code-block:: cmake + + find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4) + find_package_handle_standard_args(Automoc4 CONFIG_MODE) + +In this case, a ``FindAutmoc4.cmake`` module wraps a call to +``find_package(Automoc4 NO_MODULE)`` and adds an additional search +directory for ``automoc4``. Then the call to +``find_package_handle_standard_args`` produces a proper success/failure +message. + +.. command:: find_package_check_version + + .. versionadded:: 3.19 + + Helper function which can be used to check if a ``<version>`` is valid + against version-related arguments of :command:`find_package`. + + .. code-block:: cmake + + find_package_check_version(<version> <result-var> + [HANDLE_VERSION_RANGE] + [RESULT_MESSAGE_VARIABLE <message-var>] + ) + + The ``<result-var>`` will hold a boolean value giving the result of the check. + + The options are: + + ``HANDLE_VERSION_RANGE`` + Enable handling of a version range, if one is specified. Without this + option, a developer warning will be displayed if a version range is + specified. + + ``RESULT_MESSAGE_VARIABLE <message-var>`` + Specify a variable to get back a message describing the result of the check. + +Example for the usage: + +.. code-block:: cmake + + find_package_check_version(1.2.3 result HANDLE_VERSION_RANGE + RESULT_MESSAGE_VARIABLE reason) + if (result) + message (STATUS "${reason}") + else() + message (FATAL_ERROR "${reason}") + endif() +#]=======================================================================] + +include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake) + + +cmake_policy(PUSH) +# numbers and boolean constants +cmake_policy (SET CMP0012 NEW) +# IN_LIST operator +cmake_policy (SET CMP0057 NEW) + + +# internal helper macro +macro(_FPHSA_FAILURE_MESSAGE _msg) + set (__msg "${_msg}") + if (FPHSA_REASON_FAILURE_MESSAGE) + string(APPEND __msg "\n Reason given by package: ${FPHSA_REASON_FAILURE_MESSAGE}\n") + endif() + if (${_NAME}_FIND_REQUIRED) + message(FATAL_ERROR "${__msg}") + else () + if (NOT ${_NAME}_FIND_QUIETLY) + message(STATUS "${__msg}") + endif () + endif () +endmacro() + + +# internal helper macro to generate the failure message when used in CONFIG_MODE: +macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE) + # <PackageName>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found: + if(${_NAME}_CONFIG) + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing:${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})") + else() + # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version. + # List them all in the error message: + if(${_NAME}_CONSIDERED_CONFIGS) + set(configsText "") + list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount) + math(EXPR configsCount "${configsCount} - 1") + foreach(currentConfigIndex RANGE ${configsCount}) + list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename) + list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version) + string(APPEND configsText "\n ${filename} (version ${version})") + endforeach() + if (${_NAME}_NOT_FOUND_MESSAGE) + if (FPHSA_REASON_FAILURE_MESSAGE) + string(PREPEND FPHSA_REASON_FAILURE_MESSAGE "${${_NAME}_NOT_FOUND_MESSAGE}\n ") + else() + set(FPHSA_REASON_FAILURE_MESSAGE "${${_NAME}_NOT_FOUND_MESSAGE}") + endif() + else() + string(APPEND configsText "\n") + endif() + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:${configsText}") + + else() + # Simple case: No Config-file was found at all: + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}") + endif() + endif() +endmacro() + + +function(FIND_PACKAGE_CHECK_VERSION version result) + cmake_parse_arguments (PARSE_ARGV 2 FPCV "HANDLE_VERSION_RANGE;NO_AUTHOR_WARNING_VERSION_RANGE" "RESULT_MESSAGE_VARIABLE" "") + + if (FPCV_UNPARSED_ARGUMENTS) + message (FATAL_ERROR "find_package_check_version(): ${FPCV_UNPARSED_ARGUMENTS}: unexpected arguments") + endif() + if ("RESULT_MESSAGE_VARIABLE" IN_LIST FPCV_KEYWORDS_MISSING_VALUES) + message (FATAL_ERROR "find_package_check_version(): RESULT_MESSAGE_VARIABLE expects an argument") + endif() + + set (${result} FALSE PARENT_SCOPE) + if (FPCV_RESULT_MESSAGE_VARIABLE) + unset (${FPCV_RESULT_MESSAGE_VARIABLE} PARENT_SCOPE) + endif() + + if (_CMAKE_FPHSA_PACKAGE_NAME) + set (package "${_CMAKE_FPHSA_PACKAGE_NAME}") + elseif (CMAKE_FIND_PACKAGE_NAME) + set (package "${CMAKE_FIND_PACKAGE_NAME}") + else() + message (FATAL_ERROR "find_package_check_version(): Cannot be used outside a 'Find Module'") + endif() + + if (NOT FPCV_NO_AUTHOR_WARNING_VERSION_RANGE + AND ${package}_FIND_VERSION_RANGE AND NOT FPCV_HANDLE_VERSION_RANGE) + message(AUTHOR_WARNING + "`find_package()` specify a version range but the option " + "HANDLE_VERSION_RANGE` is not passed to `find_package_check_version()`. " + "Only the lower endpoint of the range will be used.") + endif() + + + set (version_ok FALSE) + unset (version_msg) + + if (FPCV_HANDLE_VERSION_RANGE AND ${package}_FIND_VERSION_RANGE) + if ((${package}_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" + AND version VERSION_GREATER_EQUAL ${package}_FIND_VERSION_MIN) + AND ((${package}_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" + AND version VERSION_LESS_EQUAL ${package}_FIND_VERSION_MAX) + OR (${package}_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" + AND version VERSION_LESS ${package}_FIND_VERSION_MAX))) + set (version_ok TRUE) + set(version_msg "(found suitable version \"${version}\", required range is \"${${package}_FIND_VERSION_RANGE}\")") + else() + set(version_msg "Found unsuitable version \"${version}\", required range is \"${${package}_FIND_VERSION_RANGE}\"") + endif() + elseif (DEFINED ${package}_FIND_VERSION) + if(${package}_FIND_VERSION_EXACT) # exact version required + # count the dots in the version string + string(REGEX REPLACE "[^.]" "" version_dots "${version}") + # add one dot because there is one dot more than there are components + string(LENGTH "${version_dots}." version_dots) + if (version_dots GREATER ${package}_FIND_VERSION_COUNT) + # Because of the C++ implementation of find_package() ${package}_FIND_VERSION_COUNT + # is at most 4 here. Therefore a simple lookup table is used. + if (${package}_FIND_VERSION_COUNT EQUAL 1) + set(version_regex "[^.]*") + elseif (${package}_FIND_VERSION_COUNT EQUAL 2) + set(version_regex "[^.]*\\.[^.]*") + elseif (${package}_FIND_VERSION_COUNT EQUAL 3) + set(version_regex "[^.]*\\.[^.]*\\.[^.]*") + else() + set(version_regex "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*") + endif() + string(REGEX REPLACE "^(${version_regex})\\..*" "\\1" version_head "${version}") + if (NOT ${package}_FIND_VERSION VERSION_EQUAL version_head) + set(version_msg "Found unsuitable version \"${version}\", but required is exact version \"${${package}_FIND_VERSION}\"") + else () + set(version_ok TRUE) + set(version_msg "(found suitable exact version \"${_FOUND_VERSION}\")") + endif () + else () + if (NOT ${package}_FIND_VERSION VERSION_EQUAL version) + set(version_msg "Found unsuitable version \"${version}\", but required is exact version \"${${package}_FIND_VERSION}\"") + else () + set(version_ok TRUE) + set(version_msg "(found suitable exact version \"${version}\")") + endif () + endif () + else() # minimum version + if (${package}_FIND_VERSION VERSION_GREATER version) + set(version_msg "Found unsuitable version \"${version}\", but required is at least \"${${package}_FIND_VERSION}\"") + else() + set(version_ok TRUE) + set(version_msg "(found suitable version \"${version}\", minimum required is \"${${package}_FIND_VERSION}\")") + endif() + endif() + else () + set(version_ok TRUE) + set(version_msg "(found version \"${version}\")") + endif() + + set (${result} ${version_ok} PARENT_SCOPE) + if (FPCV_RESULT_MESSAGE_VARIABLE) + set (${FPCV_RESULT_MESSAGE_VARIABLE} "${version_msg}" PARENT_SCOPE) + endif() +endfunction() + + +function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG) + + # Set up the arguments for `cmake_parse_arguments`. + set(options CONFIG_MODE HANDLE_COMPONENTS NAME_MISMATCHED HANDLE_VERSION_RANGE) + set(oneValueArgs FAIL_MESSAGE REASON_FAILURE_MESSAGE VERSION_VAR FOUND_VAR) + set(multiValueArgs REQUIRED_VARS) + + # Check whether we are in 'simple' or 'extended' mode: + set(_KEYWORDS_FOR_EXTENDED_MODE ${options} ${oneValueArgs} ${multiValueArgs} ) + list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX) + + unset(FPHSA_NAME_MISMATCHED_override) + if (DEFINED FPHSA_NAME_MISMATCHED) + # If the variable NAME_MISMATCHED variable is set, error if it is passed as + # an argument. The former is for old signatures, the latter is for new + # signatures. + list(FIND ARGN "NAME_MISMATCHED" name_mismatched_idx) + if (NOT name_mismatched_idx EQUAL "-1") + message(FATAL_ERROR + "The `NAME_MISMATCHED` argument may only be specified by the argument or " + "the variable, not both.") + endif () + + # But use the variable if it is not an argument to avoid forcing minimum + # CMake version bumps for calling modules. + set(FPHSA_NAME_MISMATCHED_override "${FPHSA_NAME_MISMATCHED}") + endif () + + if(${INDEX} EQUAL -1) + set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG}) + set(FPHSA_REQUIRED_VARS ${ARGN}) + set(FPHSA_VERSION_VAR) + else() + cmake_parse_arguments(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}" ${_FIRST_ARG} ${ARGN}) + + if(FPHSA_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"") + endif() + + if(NOT FPHSA_FAIL_MESSAGE) + set(FPHSA_FAIL_MESSAGE "DEFAULT_MSG") + endif() + + # In config-mode, we rely on the variable <PackageName>_CONFIG, which is set by find_package() + # when it successfully found the config-file, including version checking: + if(FPHSA_CONFIG_MODE) + list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG) + list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS) + set(FPHSA_VERSION_VAR ${_NAME}_VERSION) + endif() + + if(NOT FPHSA_REQUIRED_VARS AND NOT FPHSA_HANDLE_COMPONENTS) + message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()") + endif() + endif() + + if (DEFINED FPHSA_NAME_MISMATCHED_override) + set(FPHSA_NAME_MISMATCHED "${FPHSA_NAME_MISMATCHED_override}") + endif () + + if (DEFINED CMAKE_FIND_PACKAGE_NAME + AND NOT FPHSA_NAME_MISMATCHED + AND NOT _NAME STREQUAL CMAKE_FIND_PACKAGE_NAME) + message(AUTHOR_WARNING + "The package name passed to `find_package_handle_standard_args` " + "(${_NAME}) does not match the name of the calling package " + "(${CMAKE_FIND_PACKAGE_NAME}). This can lead to problems in calling " + "code that expects `find_package` result variables (e.g., `_FOUND`) " + "to follow a certain pattern.") + endif () + + if (${_NAME}_FIND_VERSION_RANGE AND NOT FPHSA_HANDLE_VERSION_RANGE) + message(AUTHOR_WARNING + "`find_package()` specify a version range but the module ${_NAME} does " + "not support this capability. Only the lower endpoint of the range " + "will be used.") + endif() + + # to propagate package name to FIND_PACKAGE_CHECK_VERSION + set(_CMAKE_FPHSA_PACKAGE_NAME "${_NAME}") + + # now that we collected all arguments, process them + + if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG") + set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}") + endif() + + if (FPHSA_REQUIRED_VARS) + list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR) + endif() + + string(TOUPPER ${_NAME} _NAME_UPPER) + string(TOLOWER ${_NAME} _NAME_LOWER) + + if(FPHSA_FOUND_VAR) + set(_FOUND_VAR_UPPER ${_NAME_UPPER}_FOUND) + set(_FOUND_VAR_MIXED ${_NAME}_FOUND) + if(FPHSA_FOUND_VAR STREQUAL _FOUND_VAR_MIXED OR FPHSA_FOUND_VAR STREQUAL _FOUND_VAR_UPPER) + set(_FOUND_VAR ${FPHSA_FOUND_VAR}) + else() + message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_FOUND_VAR_MIXED}\" and \"${_FOUND_VAR_UPPER}\" are valid names.") + endif() + else() + set(_FOUND_VAR ${_NAME_UPPER}_FOUND) + endif() + + # collect all variables which were not found, so they can be printed, so the + # user knows better what went wrong (#6375) + set(MISSING_VARS "") + set(DETAILS "") + # check if all passed variables are valid + set(FPHSA_FOUND_${_NAME} TRUE) + foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS}) + if(NOT ${_CURRENT_VAR}) + set(FPHSA_FOUND_${_NAME} FALSE) + string(APPEND MISSING_VARS " ${_CURRENT_VAR}") + else() + string(APPEND DETAILS "[${${_CURRENT_VAR}}]") + endif() + endforeach() + if(FPHSA_FOUND_${_NAME}) + set(${_NAME}_FOUND TRUE) + set(${_NAME_UPPER}_FOUND TRUE) + else() + set(${_NAME}_FOUND FALSE) + set(${_NAME_UPPER}_FOUND FALSE) + endif() + + # component handling + unset(FOUND_COMPONENTS_MSG) + unset(MISSING_COMPONENTS_MSG) + + if(FPHSA_HANDLE_COMPONENTS) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(${_NAME}_${comp}_FOUND) + + if(NOT DEFINED FOUND_COMPONENTS_MSG) + set(FOUND_COMPONENTS_MSG "found components:") + endif() + string(APPEND FOUND_COMPONENTS_MSG " ${comp}") + + else() + + if(NOT DEFINED MISSING_COMPONENTS_MSG) + set(MISSING_COMPONENTS_MSG "missing components:") + endif() + string(APPEND MISSING_COMPONENTS_MSG " ${comp}") + + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + string(APPEND MISSING_VARS " ${comp}") + endif() + + endif() + endforeach() + set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}") + string(APPEND DETAILS "[c${COMPONENT_MSG}]") + endif() + + # version handling: + set(VERSION_MSG "") + set(VERSION_OK TRUE) + + # check that the version variable is not empty to avoid emitting a misleading + # message (i.e. `Found unsuitable version ""`) + if (DEFINED ${_NAME}_FIND_VERSION) + if(DEFINED ${FPHSA_VERSION_VAR}) + if(NOT "${${FPHSA_VERSION_VAR}}" STREQUAL "") + set(_FOUND_VERSION ${${FPHSA_VERSION_VAR}}) + if (FPHSA_HANDLE_VERSION_RANGE) + set (FPCV_HANDLE_VERSION_RANGE HANDLE_VERSION_RANGE) + else() + set(FPCV_HANDLE_VERSION_RANGE NO_AUTHOR_WARNING_VERSION_RANGE) + endif() + find_package_check_version ("${_FOUND_VERSION}" VERSION_OK RESULT_MESSAGE_VARIABLE VERSION_MSG + ${FPCV_HANDLE_VERSION_RANGE}) + else() + set(VERSION_OK FALSE) + endif() + endif() + if("${${FPHSA_VERSION_VAR}}" STREQUAL "") + # if the package was not found, but a version was given, add that to the output: + if(${_NAME}_FIND_VERSION_EXACT) + set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")") + elseif (FPHSA_HANDLE_VERSION_RANGE AND ${_NAME}_FIND_VERSION_RANGE) + set(VERSION_MSG "(Required is version range \"${${_NAME}_FIND_VERSION_RANGE}\")") + else() + set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")") + endif() + endif() + else () + # Check with DEFINED as the found version may be 0. + if(DEFINED ${FPHSA_VERSION_VAR}) + set(VERSION_MSG "(found version \"${${FPHSA_VERSION_VAR}}\")") + endif() + endif () + + if(VERSION_OK) + string(APPEND DETAILS "[v${${FPHSA_VERSION_VAR}}(${${_NAME}_FIND_VERSION})]") + else() + set(${_NAME}_FOUND FALSE) + endif() + + + # print the result: + if (${_NAME}_FOUND) + FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}") + else () + + if(FPHSA_CONFIG_MODE) + _FPHSA_HANDLE_FAILURE_CONFIG_MODE() + else() + if(NOT VERSION_OK) + set(RESULT_MSG) + if (_FIRST_REQUIRED_VAR) + string (APPEND RESULT_MSG "found ${${_FIRST_REQUIRED_VAR}}") + endif() + if (COMPONENT_MSG) + if (RESULT_MSG) + string (APPEND RESULT_MSG ", ") + endif() + string (APPEND RESULT_MSG "${FOUND_COMPONENTS_MSG}") + endif() + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (${RESULT_MSG})") + else() + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing:${MISSING_VARS}) ${VERSION_MSG}") + endif() + endif() + + endif () + + set(${_NAME}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE) + set(${_NAME_UPPER}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE) +endfunction() + + +cmake_policy(POP)
\ No newline at end of file diff --git a/cmake/FindPackageMessage.cmake b/cmake/FindPackageMessage.cmake new file mode 100644 index 00000000..e53285be --- /dev/null +++ b/cmake/FindPackageMessage.cmake @@ -0,0 +1,48 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindPackageMessage +------------------ + +.. code-block:: cmake + + find_package_message(<name> "message for user" "find result details") + +This function is intended to be used in FindXXX.cmake modules files. +It will print a message once for each unique find result. This is +useful for telling the user where a package was found. The first +argument specifies the name (XXX) of the package. The second argument +specifies the message to display. The third argument lists details +about the find result so that if they change the message will be +displayed again. The macro also obeys the QUIET argument to the +find_package command. + +Example: + +.. code-block:: cmake + + if(X11_FOUND) + find_package_message(X11 "Found X11: ${X11_X11_LIB}" + "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]") + else() + ... + endif() +#]=======================================================================] + +function(find_package_message pkg msg details) + # Avoid printing a message repeatedly for the same find result. + if(NOT ${pkg}_FIND_QUIETLY) + string(REPLACE "\n" "" details "${details}") + set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg}) + if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}") + # The message has not yet been printed. + message(STATUS "${msg}") + + # Save the find details in the cache to avoid printing the same + # message again. + set("${DETAILS_VAR}" "${details}" + CACHE INTERNAL "Details about finding ${pkg}") + endif() + endif() +endfunction()
\ No newline at end of file diff --git a/cmake/FlagsOverrides.cmake b/cmake/FlagsOverrides.cmake new file mode 100644 index 00000000..0ebbd70a --- /dev/null +++ b/cmake/FlagsOverrides.cmake @@ -0,0 +1,13 @@ +SET (CMAKE_GENERATOR "Ninja") + +SET (CMAKE_C_FLAGS "-Wall -std=c11") +SET (CMAKE_C_FLAGS_DEBUG "-g -fsanitize=address -fsanitize-recover=address") +SET (CMAKE_C_FLAGS_MINSIZERE "-Os -DNDEBUG") +SET (CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG") +SET (CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g") + +SET (CMAKE_CXX_FLAGS "-Wall -std=c++17") +SET (CMAKE_CXX_FLAGS_DEBUG "-g -fsanitize=address -fsanitize-recover=address") +SET (CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG") +SET (CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG") +SET (CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
\ No newline at end of file |