diff options
Diffstat (limited to '992ed23c322c9abb9a108a6d119c09aada50ca9c.patch')
| -rw-r--r-- | 992ed23c322c9abb9a108a6d119c09aada50ca9c.patch | 1253 |
1 files changed, 1253 insertions, 0 deletions
diff --git a/992ed23c322c9abb9a108a6d119c09aada50ca9c.patch b/992ed23c322c9abb9a108a6d119c09aada50ca9c.patch new file mode 100644 index 0000000..4cebdc6 --- /dev/null +++ b/992ed23c322c9abb9a108a6d119c09aada50ca9c.patch @@ -0,0 +1,1253 @@ +From 992ed23c322c9abb9a108a6d119c09aada50ca9c Mon Sep 17 00:00:00 2001 +From: Thomas Klausner <tk@giga.or.at> +Date: Mon, 13 Jul 2020 12:21:32 +0200 +Subject: [PATCH] Add FindBZip2 and FindLibLZMA files from cmake 3.17 for + backwards compat. + +--- + CMakeLists.txt | 3 + + cmake-compat/CMakePushCheckState.cmake | 91 ++++ + cmake-compat/CheckLibraryExists.cmake | 99 ++++ + cmake-compat/CheckSymbolExists.cmake | 166 +++++++ + cmake-compat/FindBZip2.cmake | 104 ++++ + cmake-compat/FindLibLZMA.cmake | 124 +++++ + .../FindPackageHandleStandardArgs.cmake | 453 ++++++++++++++++++ + cmake-compat/FindPackageMessage.cmake | 48 ++ + .../SelectLibraryConfigurations.cmake | 80 ++++ + 9 files changed, 1168 insertions(+) + create mode 100644 cmake-compat/CMakePushCheckState.cmake + create mode 100644 cmake-compat/CheckLibraryExists.cmake + create mode 100644 cmake-compat/CheckSymbolExists.cmake + create mode 100644 cmake-compat/FindBZip2.cmake + create mode 100644 cmake-compat/FindLibLZMA.cmake + create mode 100644 cmake-compat/FindPackageHandleStandardArgs.cmake + create mode 100644 cmake-compat/FindPackageMessage.cmake + create mode 100644 cmake-compat/SelectLibraryConfigurations.cmake + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 8013d2ea..061ba4df 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -1,6 +1,9 @@ + cmake_minimum_required(VERSION 3.0.2) + + list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake) ++if (${CMAKE_VERSION} VERSION_LESS "3.17.0") ++ list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake-compat) ++endif() + + project(libzip + VERSION 1.7.2 +diff --git a/cmake-compat/CMakePushCheckState.cmake b/cmake-compat/CMakePushCheckState.cmake +new file mode 100644 +index 00000000..3e519ee5 +--- /dev/null ++++ b/cmake-compat/CMakePushCheckState.cmake +@@ -0,0 +1,91 @@ ++# Distributed under the OSI-approved BSD 3-Clause License. See accompanying ++# file Copyright.txt or https://cmake.org/licensing for details. ++ ++#[=======================================================================[.rst: ++CMakePushCheckState ++------------------- ++ ++ ++ ++This module defines three macros: ``CMAKE_PUSH_CHECK_STATE()`` ++``CMAKE_POP_CHECK_STATE()`` and ``CMAKE_RESET_CHECK_STATE()`` These macros can ++be used to save, restore and reset (i.e., clear contents) the state of ++the variables ``CMAKE_REQUIRED_FLAGS``, ``CMAKE_REQUIRED_DEFINITIONS``, ++``CMAKE_REQUIRED_LINK_OPTIONS``, ``CMAKE_REQUIRED_LIBRARIES``, ++``CMAKE_REQUIRED_INCLUDES`` and ``CMAKE_EXTRA_INCLUDE_FILES`` used by the ++various Check-files coming with CMake, like e.g. ``check_function_exists()`` ++etc. ++The variable contents are pushed on a stack, pushing multiple times is ++supported. This is useful e.g. when executing such tests in a Find-module, ++where they have to be set, but after the Find-module has been executed they ++should have the same value as they had before. ++ ++``CMAKE_PUSH_CHECK_STATE()`` macro receives optional argument ``RESET``. ++Whether it's specified, ``CMAKE_PUSH_CHECK_STATE()`` will set all ++``CMAKE_REQUIRED_*`` variables to empty values, same as ++``CMAKE_RESET_CHECK_STATE()`` call will do. ++ ++Usage: ++ ++.. code-block:: cmake ++ ++ cmake_push_check_state(RESET) ++ set(CMAKE_REQUIRED_DEFINITIONS -DSOME_MORE_DEF) ++ check_function_exists(...) ++ cmake_reset_check_state() ++ set(CMAKE_REQUIRED_DEFINITIONS -DANOTHER_DEF) ++ check_function_exists(...) ++ cmake_pop_check_state() ++#]=======================================================================] ++ ++macro(CMAKE_RESET_CHECK_STATE) ++ ++ set(CMAKE_EXTRA_INCLUDE_FILES) ++ set(CMAKE_REQUIRED_INCLUDES) ++ set(CMAKE_REQUIRED_DEFINITIONS) ++ set(CMAKE_REQUIRED_LINK_OPTIONS) ++ set(CMAKE_REQUIRED_LIBRARIES) ++ set(CMAKE_REQUIRED_FLAGS) ++ set(CMAKE_REQUIRED_QUIET) ++ ++endmacro() ++ ++macro(CMAKE_PUSH_CHECK_STATE) ++ ++ if(NOT DEFINED _CMAKE_PUSH_CHECK_STATE_COUNTER) ++ set(_CMAKE_PUSH_CHECK_STATE_COUNTER 0) ++ endif() ++ ++ math(EXPR _CMAKE_PUSH_CHECK_STATE_COUNTER "${_CMAKE_PUSH_CHECK_STATE_COUNTER}+1") ++ ++ set(_CMAKE_EXTRA_INCLUDE_FILES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_EXTRA_INCLUDE_FILES}) ++ set(_CMAKE_REQUIRED_INCLUDES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_INCLUDES}) ++ set(_CMAKE_REQUIRED_DEFINITIONS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_DEFINITIONS}) ++ set(_CMAKE_REQUIRED_LINK_OPTIONS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_LINK_OPTIONS}) ++ set(_CMAKE_REQUIRED_LIBRARIES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_LIBRARIES}) ++ set(_CMAKE_REQUIRED_FLAGS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_FLAGS}) ++ set(_CMAKE_REQUIRED_QUIET_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_QUIET}) ++ ++ if (${ARGC} GREATER 0 AND "${ARGV0}" STREQUAL "RESET") ++ cmake_reset_check_state() ++ endif() ++ ++endmacro() ++ ++macro(CMAKE_POP_CHECK_STATE) ++ ++# don't pop more than we pushed ++ if("${_CMAKE_PUSH_CHECK_STATE_COUNTER}" GREATER "0") ++ ++ set(CMAKE_EXTRA_INCLUDE_FILES ${_CMAKE_EXTRA_INCLUDE_FILES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}}) ++ set(CMAKE_REQUIRED_INCLUDES ${_CMAKE_REQUIRED_INCLUDES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}}) ++ set(CMAKE_REQUIRED_DEFINITIONS ${_CMAKE_REQUIRED_DEFINITIONS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}}) ++ set(CMAKE_REQUIRED_LINK_OPTIONS ${_CMAKE_REQUIRED_LINK_OPTIONS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}}) ++ set(CMAKE_REQUIRED_LIBRARIES ${_CMAKE_REQUIRED_LIBRARIES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}}) ++ set(CMAKE_REQUIRED_FLAGS ${_CMAKE_REQUIRED_FLAGS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}}) ++ set(CMAKE_REQUIRED_QUIET ${_CMAKE_REQUIRED_QUIET_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}}) ++ ++ math(EXPR _CMAKE_PUSH_CHECK_STATE_COUNTER "${_CMAKE_PUSH_CHECK_STATE_COUNTER}-1") ++ endif() ++ ++endmacro() +diff --git a/cmake-compat/CheckLibraryExists.cmake b/cmake-compat/CheckLibraryExists.cmake +new file mode 100644 +index 00000000..6470dfd0 +--- /dev/null ++++ b/cmake-compat/CheckLibraryExists.cmake +@@ -0,0 +1,99 @@ ++# Distributed under the OSI-approved BSD 3-Clause License. See accompanying ++# file Copyright.txt or https://cmake.org/licensing for details. ++ ++#[=======================================================================[.rst: ++CheckLibraryExists ++------------------ ++ ++Check if the function exists. ++ ++.. command:: CHECK_LIBRARY_EXISTS ++ ++ .. code-block:: cmake ++ ++ CHECK_LIBRARY_EXISTS(LIBRARY FUNCTION LOCATION VARIABLE) ++ ++ :: ++ ++ LIBRARY - the name of the library you are looking for ++ FUNCTION - the name of the function ++ LOCATION - location where the library should be found ++ VARIABLE - variable to store the result ++ Will be created as an internal cache variable. ++ ++ ++ ++The following variables may be set before calling this macro to modify ++the way the check is run: ++ ++:: ++ ++ CMAKE_REQUIRED_FLAGS = string of compile command line flags ++ CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) ++ CMAKE_REQUIRED_LINK_OPTIONS = list of options to pass to link command ++ CMAKE_REQUIRED_LIBRARIES = list of libraries to link ++ CMAKE_REQUIRED_QUIET = execute quietly without messages ++#]=======================================================================] ++ ++include_guard(GLOBAL) ++ ++macro(CHECK_LIBRARY_EXISTS LIBRARY FUNCTION LOCATION VARIABLE) ++ if(NOT DEFINED "${VARIABLE}") ++ set(MACRO_CHECK_LIBRARY_EXISTS_DEFINITION ++ "-DCHECK_FUNCTION_EXISTS=${FUNCTION} ${CMAKE_REQUIRED_FLAGS}") ++ if(NOT CMAKE_REQUIRED_QUIET) ++ message(CHECK_START "Looking for ${FUNCTION} in ${LIBRARY}") ++ endif() ++ set(CHECK_LIBRARY_EXISTS_LINK_OPTIONS) ++ if(CMAKE_REQUIRED_LINK_OPTIONS) ++ set(CHECK_LIBRARY_EXISTS_LINK_OPTIONS ++ LINK_OPTIONS ${CMAKE_REQUIRED_LINK_OPTIONS}) ++ endif() ++ set(CHECK_LIBRARY_EXISTS_LIBRARIES ${LIBRARY}) ++ if(CMAKE_REQUIRED_LIBRARIES) ++ set(CHECK_LIBRARY_EXISTS_LIBRARIES ++ ${CHECK_LIBRARY_EXISTS_LIBRARIES} ${CMAKE_REQUIRED_LIBRARIES}) ++ endif() ++ ++ if(CMAKE_C_COMPILER_LOADED) ++ set(_cle_source ${CMAKE_ROOT}/Modules/CheckFunctionExists.c) ++ elseif(CMAKE_CXX_COMPILER_LOADED) ++ set(_cle_source ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckLibraryExists/CheckFunctionExists.cxx) ++ configure_file(${CMAKE_ROOT}/Modules/CheckFunctionExists.c "${_cle_source}" COPYONLY) ++ else() ++ message(FATAL_ERROR "CHECK_FUNCTION_EXISTS needs either C or CXX language enabled") ++ endif() ++ ++ try_compile(${VARIABLE} ++ ${CMAKE_BINARY_DIR} ++ ${_cle_source} ++ COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} ++ ${CHECK_LIBRARY_EXISTS_LINK_OPTIONS} ++ LINK_LIBRARIES ${CHECK_LIBRARY_EXISTS_LIBRARIES} ++ CMAKE_FLAGS ++ -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_LIBRARY_EXISTS_DEFINITION} ++ -DLINK_DIRECTORIES:STRING=${LOCATION} ++ OUTPUT_VARIABLE OUTPUT) ++ unset(_cle_source) ++ ++ if(${VARIABLE}) ++ if(NOT CMAKE_REQUIRED_QUIET) ++ message(CHECK_PASS "found") ++ endif() ++ set(${VARIABLE} 1 CACHE INTERNAL "Have library ${LIBRARY}") ++ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log ++ "Determining if the function ${FUNCTION} exists in the ${LIBRARY} " ++ "passed with the following output:\n" ++ "${OUTPUT}\n\n") ++ else() ++ if(NOT CMAKE_REQUIRED_QUIET) ++ message(CHECK_FAIL "not found") ++ endif() ++ set(${VARIABLE} "" CACHE INTERNAL "Have library ${LIBRARY}") ++ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log ++ "Determining if the function ${FUNCTION} exists in the ${LIBRARY} " ++ "failed with the following output:\n" ++ "${OUTPUT}\n\n") ++ endif() ++ endif() ++endmacro() +diff --git a/cmake-compat/CheckSymbolExists.cmake b/cmake-compat/CheckSymbolExists.cmake +new file mode 100644 +index 00000000..4f202c41 +--- /dev/null ++++ b/cmake-compat/CheckSymbolExists.cmake +@@ -0,0 +1,166 @@ ++# Distributed under the OSI-approved BSD 3-Clause License. See accompanying ++# file Copyright.txt or https://cmake.org/licensing for details. ++ ++#[=======================================================================[.rst: ++CheckSymbolExists ++----------------- ++ ++Provides a macro to check if a symbol exists as a function, variable, ++or macro in ``C``. ++ ++.. command:: check_symbol_exists ++ ++ .. code-block:: cmake ++ ++ check_symbol_exists(<symbol> <files> <variable>) ++ ++ Check that the ``<symbol>`` is available after including given header ++ ``<files>`` and store the result in a ``<variable>``. Specify the list ++ of files in one argument as a semicolon-separated list. ++ ``<variable>`` will be created as an internal cache variable. ++ ++If the header files define the symbol as a macro it is considered ++available and assumed to work. If the header files declare the symbol ++as a function or variable then the symbol must also be available for ++linking (so intrinsics may not be detected). ++If the symbol is a type, enum value, or intrinsic it will not be recognized ++(consider using :module:`CheckTypeSize` or :module:`CheckCSourceCompiles`). ++If the check needs to be done in C++, consider using ++:module:`CheckCXXSymbolExists` instead. ++ ++The following variables may be set before calling this macro to modify ++the way the check is run: ++ ++``CMAKE_REQUIRED_FLAGS`` ++ string of compile command line flags. ++``CMAKE_REQUIRED_DEFINITIONS`` ++ a :ref:`;-list <CMake Language Lists>` of macros to define (-DFOO=bar). ++``CMAKE_REQUIRED_INCLUDES`` ++ a :ref:`;-list <CMake Language Lists>` of header search paths to pass to ++ the compiler. ++``CMAKE_REQUIRED_LINK_OPTIONS`` ++ a :ref:`;-list <CMake Language Lists>` of options to add to the link command. ++``CMAKE_REQUIRED_LIBRARIES`` ++ a :ref:`;-list <CMake Language Lists>` of libraries to add to the link ++ command. See policy :policy:`CMP0075`. ++``CMAKE_REQUIRED_QUIET`` ++ execute quietly without messages. ++ ++For example: ++ ++.. code-block:: cmake ++ ++ include(CheckSymbolExists) ++ ++ # Check for macro SEEK_SET ++ check_symbol_exists(SEEK_SET "stdio.h" HAVE_SEEK_SET) ++ # Check for function fopen ++ check_symbol_exists(fopen "stdio.h" HAVE_FOPEN) ++#]=======================================================================] ++ ++include_guard(GLOBAL) ++ ++cmake_policy(PUSH) ++cmake_policy(SET CMP0054 NEW) # if() quoted variables not dereferenced ++ ++macro(CHECK_SYMBOL_EXISTS SYMBOL FILES VARIABLE) ++ if(CMAKE_C_COMPILER_LOADED) ++ __CHECK_SYMBOL_EXISTS_IMPL("${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.c" "${SYMBOL}" "${FILES}" "${VARIABLE}" ) ++ elseif(CMAKE_CXX_COMPILER_LOADED) ++ __CHECK_SYMBOL_EXISTS_IMPL("${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.cxx" "${SYMBOL}" "${FILES}" "${VARIABLE}" ) ++ else() ++ message(FATAL_ERROR "CHECK_SYMBOL_EXISTS needs either C or CXX language enabled") ++ endif() ++endmacro() ++ ++macro(__CHECK_SYMBOL_EXISTS_IMPL SOURCEFILE SYMBOL FILES VARIABLE) ++ if(NOT DEFINED "${VARIABLE}" OR "x${${VARIABLE}}" STREQUAL "x${VARIABLE}") ++ set(CMAKE_CONFIGURABLE_FILE_CONTENT "/* */\n") ++ set(MACRO_CHECK_SYMBOL_EXISTS_FLAGS ${CMAKE_REQUIRED_FLAGS}) ++ if(CMAKE_REQUIRED_LINK_OPTIONS) ++ set(CHECK_SYMBOL_EXISTS_LINK_OPTIONS ++ LINK_OPTIONS ${CMAKE_REQUIRED_LINK_OPTIONS}) ++ else() ++ set(CHECK_SYMBOL_EXISTS_LINK_OPTIONS) ++ endif() ++ if(CMAKE_REQUIRED_LIBRARIES) ++ set(CHECK_SYMBOL_EXISTS_LIBS ++ LINK_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES}) ++ else() ++ set(CHECK_SYMBOL_EXISTS_LIBS) ++ endif() ++ if(CMAKE_REQUIRED_INCLUDES) ++ set(CMAKE_SYMBOL_EXISTS_INCLUDES ++ "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}") ++ else() ++ set(CMAKE_SYMBOL_EXISTS_INCLUDES) ++ endif() ++ foreach(FILE ${FILES}) ++ string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT ++ "#include <${FILE}>\n") ++ endforeach() ++ string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT " ++int main(int argc, char** argv) ++{ ++ (void)argv;") ++ set(_CSE_CHECK_NON_MACRO "return ((int*)(&${SYMBOL}))[argc];") ++ if("${SYMBOL}" MATCHES "^[a-zA-Z_][a-zA-Z0-9_]*$") ++ # The SYMBOL has a legal macro name. Test whether it exists as a macro. ++ string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT " ++#ifndef ${SYMBOL} ++ ${_CSE_CHECK_NON_MACRO} ++#else ++ (void)argc; ++ return 0; ++#endif") ++ else() ++ # The SYMBOL cannot be a macro (e.g., a template function). ++ string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT " ++ ${_CSE_CHECK_NON_MACRO}") ++ endif() ++ string(APPEND CMAKE_CONFIGURABLE_FILE_CONTENT " ++}") ++ unset(_CSE_CHECK_NON_MACRO) ++ ++ configure_file("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in" ++ "${SOURCEFILE}" @ONLY) ++ ++ if(NOT CMAKE_REQUIRED_QUIET) ++ message(CHECK_START "Looking for ${SYMBOL}") ++ endif() ++ try_compile(${VARIABLE} ++ ${CMAKE_BINARY_DIR} ++ "${SOURCEFILE}" ++ COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} ++ ${CHECK_SYMBOL_EXISTS_LINK_OPTIONS} ++ ${CHECK_SYMBOL_EXISTS_LIBS} ++ CMAKE_FLAGS ++ -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_SYMBOL_EXISTS_FLAGS} ++ "${CMAKE_SYMBOL_EXISTS_INCLUDES}" ++ OUTPUT_VARIABLE OUTPUT) ++ if(${VARIABLE}) ++ if(NOT CMAKE_REQUIRED_QUIET) ++ message(CHECK_PASS "found") ++ endif() ++ set(${VARIABLE} 1 CACHE INTERNAL "Have symbol ${SYMBOL}") ++ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log ++ "Determining if the ${SYMBOL} " ++ "exist passed with the following output:\n" ++ "${OUTPUT}\nFile ${SOURCEFILE}:\n" ++ "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n") ++ else() ++ if(NOT CMAKE_REQUIRED_QUIET) ++ message(CHECK_FAIL "not found") ++ endif() ++ set(${VARIABLE} "" CACHE INTERNAL "Have symbol ${SYMBOL}") ++ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log ++ "Determining if the ${SYMBOL} " ++ "exist failed with the following output:\n" ++ "${OUTPUT}\nFile ${SOURCEFILE}:\n" ++ "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n") ++ endif() ++ unset(CMAKE_CONFIGURABLE_FILE_CONTENT) ++ endif() ++endmacro() ++ ++cmake_policy(POP) +diff --git a/cmake-compat/FindBZip2.cmake b/cmake-compat/FindBZip2.cmake +new file mode 100644 +index 00000000..98ab72cd +--- /dev/null ++++ b/cmake-compat/FindBZip2.cmake +@@ -0,0 +1,104 @@ ++# Distributed under the OSI-approved BSD 3-Clause License. See accompanying ++# file Copyright.txt or https://cmake.org/licensing for details. ++ ++#[=======================================================================[.rst: ++FindBZip2 ++--------- ++ ++Try to find BZip2 ++ ++IMPORTED Targets ++^^^^^^^^^^^^^^^^ ++ ++This module defines :prop_tgt:`IMPORTED` target ``BZip2::BZip2``, if ++BZip2 has been found. ++ ++Result Variables ++^^^^^^^^^^^^^^^^ ++ ++This module defines the following variables: ++ ++``BZIP2_FOUND`` ++ system has BZip2 ++``BZIP2_INCLUDE_DIRS`` ++ the BZip2 include directories ++``BZIP2_LIBRARIES`` ++ Link these to use BZip2 ++``BZIP2_NEED_PREFIX`` ++ this is set if the functions are prefixed with ``BZ2_`` ++``BZIP2_VERSION_STRING`` ++ the version of BZip2 found ++ ++Cache variables ++^^^^^^^^^^^^^^^ ++ ++The following cache variables may also be set: ++ ++``BZIP2_INCLUDE_DIR`` ++ the BZip2 include directory ++#]=======================================================================] ++ ++set(_BZIP2_PATHS PATHS ++ "[HKEY_LOCAL_MACHINE\\SOFTWARE\\GnuWin32\\Bzip2;InstallPath]" ++ ) ++ ++find_path(BZIP2_INCLUDE_DIR bzlib.h ${_BZIP2_PATHS} PATH_SUFFIXES include) ++ ++if (NOT BZIP2_LIBRARIES) ++ find_library(BZIP2_LIBRARY_RELEASE NAMES bz2 bzip2 libbz2 libbzip2 ${_BZIP2_PATHS} PATH_SUFFIXES lib) ++ find_library(BZIP2_LIBRARY_DEBUG NAMES bz2d bzip2d libbz2d libbzip2d ${_BZIP2_PATHS} PATH_SUFFIXES lib) ++ ++ include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake) ++ SELECT_LIBRARY_CONFIGURATIONS(BZIP2) ++else () ++ file(TO_CMAKE_PATH "${BZIP2_LIBRARIES}" BZIP2_LIBRARIES) ++endif () ++ ++if (BZIP2_INCLUDE_DIR AND EXISTS "${BZIP2_INCLUDE_DIR}/bzlib.h") ++ file(STRINGS "${BZIP2_INCLUDE_DIR}/bzlib.h" BZLIB_H REGEX "bzip2/libbzip2 version [0-9]+\\.[^ ]+ of [0-9]+ ") ++ string(REGEX REPLACE ".* bzip2/libbzip2 version ([0-9]+\\.[^ ]+) of [0-9]+ .*" "\\1" BZIP2_VERSION_STRING "${BZLIB_H}") ++endif () ++ ++include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) ++FIND_PACKAGE_HANDLE_STANDARD_ARGS(BZip2 ++ REQUIRED_VARS BZIP2_LIBRARIES BZIP2_INCLUDE_DIR ++ VERSION_VAR BZIP2_VERSION_STRING) ++ ++if (BZIP2_FOUND) ++ set(BZIP2_INCLUDE_DIRS ${BZIP2_INCLUDE_DIR}) ++ include(${CMAKE_CURRENT_LIST_DIR}/CheckSymbolExists.cmake) ++ include(${CMAKE_CURRENT_LIST_DIR}/CMakePushCheckState.cmake) ++ cmake_push_check_state() ++ set(CMAKE_REQUIRED_QUIET ${BZip2_FIND_QUIETLY}) ++ set(CMAKE_REQUIRED_INCLUDES ${BZIP2_INCLUDE_DIR}) ++ set(CMAKE_REQUIRED_LIBRARIES ${BZIP2_LIBRARIES}) ++ CHECK_SYMBOL_EXISTS(BZ2_bzCompressInit "bzlib.h" BZIP2_NEED_PREFIX) ++ cmake_pop_check_state() ++ ++ if(NOT TARGET BZip2::BZip2) ++ add_library(BZip2::BZip2 UNKNOWN IMPORTED) ++ set_target_properties(BZip2::BZip2 PROPERTIES ++ INTERFACE_INCLUDE_DIRECTORIES "${BZIP2_INCLUDE_DIRS}") ++ ++ if(BZIP2_LIBRARY_RELEASE) ++ set_property(TARGET BZip2::BZip2 APPEND PROPERTY ++ IMPORTED_CONFIGURATIONS RELEASE) ++ set_target_properties(BZip2::BZip2 PROPERTIES ++ IMPORTED_LOCATION_RELEASE "${BZIP2_LIBRARY_RELEASE}") ++ endif() ++ ++ if(BZIP2_LIBRARY_DEBUG) ++ set_property(TARGET BZip2::BZip2 APPEND PROPERTY ++ IMPORTED_CONFIGURATIONS DEBUG) ++ set_target_properties(BZip2::BZip2 PROPERTIES ++ IMPORTED_LOCATION_DEBUG "${BZIP2_LIBRARY_DEBUG}") ++ endif() ++ ++ if(NOT BZIP2_LIBRARY_RELEASE AND NOT BZIP2_LIBRARY_DEBUG) ++ set_property(TARGET BZip2::BZip2 APPEND PROPERTY ++ IMPORTED_LOCATION "${BZIP2_LIBRARY}") ++ endif() ++ endif() ++endif () ++ ++mark_as_advanced(BZIP2_INCLUDE_DIR) +diff --git a/cmake-compat/FindLibLZMA.cmake b/cmake-compat/FindLibLZMA.cmake +new file mode 100644 +index 00000000..200d6bf8 +--- /dev/null ++++ b/cmake-compat/FindLibLZMA.cmake +@@ -0,0 +1,124 @@ ++# Distributed under the OSI-approved BSD 3-Clause License. See accompanying ++# file Copyright.txt or https://cmake.org/licensing for details. ++ ++#[=======================================================================[.rst: ++FindLibLZMA ++----------- ++ ++Find LZMA compression algorithm headers and library. ++ ++ ++Imported Targets ++^^^^^^^^^^^^^^^^ ++ ++This module defines :prop_tgt:`IMPORTED` target ``LibLZMA::LibLZMA``, if ++liblzma has been found. ++ ++Result variables ++^^^^^^^^^^^^^^^^ ++ ++This module will set the following variables in your project: ++ ++``LIBLZMA_FOUND`` ++ True if liblzma headers and library were found. ++``LIBLZMA_INCLUDE_DIRS`` ++ Directory where liblzma headers are located. ++``LIBLZMA_LIBRARIES`` ++ Lzma libraries to link against. ++``LIBLZMA_HAS_AUTO_DECODER`` ++ True if lzma_auto_decoder() is found (required). ++``LIBLZMA_HAS_EASY_ENCODER`` ++ True if lzma_easy_encoder() is found (required). ++``LIBLZMA_HAS_LZMA_PRESET`` ++ True if lzma_lzma_preset() is found (required). ++``LIBLZMA_VERSION_MAJOR`` ++ The major version of lzma ++``LIBLZMA_VERSION_MINOR`` ++ The minor version of lzma ++``LIBLZMA_VERSION_PATCH`` ++ The patch version of lzma ++``LIBLZMA_VERSION_STRING`` ++ version number as a string (ex: "5.0.3") ++#]=======================================================================] ++ ++find_path(LIBLZMA_INCLUDE_DIR lzma.h ) ++if(NOT LIBLZMA_LIBRARY) ++ find_library(LIBLZMA_LIBRARY_RELEASE NAMES lzma liblzma PATH_SUFFIXES lib) ++ find_library(LIBLZMA_LIBRARY_DEBUG NAMES lzmad liblzmad PATH_SUFFIXES lib) ++ include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake) ++ select_library_configurations(LIBLZMA) ++else() ++ file(TO_CMAKE_PATH "${LIBLZMA_LIBRARY}" LIBLZMA_LIBRARY) ++endif() ++ ++if(LIBLZMA_INCLUDE_DIR AND EXISTS "${LIBLZMA_INCLUDE_DIR}/lzma/version.h") ++ file(STRINGS "${LIBLZMA_INCLUDE_DIR}/lzma/version.h" LIBLZMA_HEADER_CONTENTS REGEX "#define LZMA_VERSION_[A-Z]+ [0-9]+") ++ ++ string(REGEX REPLACE ".*#define LZMA_VERSION_MAJOR ([0-9]+).*" "\\1" LIBLZMA_VERSION_MAJOR "${LIBLZMA_HEADER_CONTENTS}") ++ string(REGEX REPLACE ".*#define LZMA_VERSION_MINOR ([0-9]+).*" "\\1" LIBLZMA_VERSION_MINOR "${LIBLZMA_HEADER_CONTENTS}") ++ string(REGEX REPLACE ".*#define LZMA_VERSION_PATCH ([0-9]+).*" "\\1" LIBLZMA_VERSION_PATCH "${LIBLZMA_HEADER_CONTENTS}") ++ ++ set(LIBLZMA_VERSION_STRING "${LIBLZMA_VERSION_MAJOR}.${LIBLZMA_VERSION_MINOR}.${LIBLZMA_VERSION_PATCH}") ++ unset(LIBLZMA_HEADER_CONTENTS) ++endif() ++ ++# We're using new code known now as XZ, even library still been called LZMA ++# it can be found in http://tukaani.org/xz/ ++# Avoid using old codebase ++if (LIBLZMA_LIBRARY) ++ include(${CMAKE_CURRENT_LIST_DIR}/CheckLibraryExists.cmake) ++ set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET}) ++ set(CMAKE_REQUIRED_QUIET ${LibLZMA_FIND_QUIETLY}) ++ if(NOT LIBLZMA_LIBRARY_RELEASE AND NOT LIBLZMA_LIBRARY_DEBUG) ++ set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY}) ++ elseif(LIBLZMA_LIBRARY_RELEASE) ++ set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY_RELEASE}) ++ elseif(LIBLZMA_LIBRARY_DEBUG) ++ set(LIBLZMA_LIBRARY_check ${LIBLZMA_LIBRARY_DEBUG}) ++ endif() ++ CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_auto_decoder "" LIBLZMA_HAS_AUTO_DECODER) ++ CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_easy_encoder "" LIBLZMA_HAS_EASY_ENCODER) ++ CHECK_LIBRARY_EXISTS(${LIBLZMA_LIBRARY_check} lzma_lzma_preset "" LIBLZMA_HAS_LZMA_PRESET) ++ unset(LIBLZMA_LIBRARY_check) ++ set(CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVE}) ++endif () ++ ++include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) ++find_package_handle_standard_args(LibLZMA REQUIRED_VARS LIBLZMA_LIBRARY ++ LIBLZMA_INCLUDE_DIR ++ LIBLZMA_HAS_AUTO_DECODER ++ LIBLZMA_HAS_EASY_ENCODER ++ LIBLZMA_HAS_LZMA_PRESET ++ VERSION_VAR LIBLZMA_VERSION_STRING ++ ) ++mark_as_advanced( LIBLZMA_INCLUDE_DIR LIBLZMA_LIBRARY ) ++ ++if (LIBLZMA_FOUND) ++ set(LIBLZMA_LIBRARIES ${LIBLZMA_LIBRARY}) ++ set(LIBLZMA_INCLUDE_DIRS ${LIBLZMA_INCLUDE_DIR}) ++ if(NOT TARGET LibLZMA::LibLZMA) ++ add_library(LibLZMA::LibLZMA UNKNOWN IMPORTED) ++ set_target_properties(LibLZMA::LibLZMA PROPERTIES ++ INTERFACE_INCLUDE_DIRECTORIES ${LIBLZMA_INCLUDE_DIR} ++ IMPORTED_LINK_INTERFACE_LANGUAGES C) ++ ++ if(LIBLZMA_LIBRARY_RELEASE) ++ set_property(TARGET LibLZMA::LibLZMA APPEND PROPERTY ++ IMPORTED_CONFIGURATIONS RELEASE) ++ set_target_properties(LibLZMA::LibLZMA PROPERTIES ++ IMPORTED_LOCATION_RELEASE "${LIBLZMA_LIBRARY_RELEASE}") ++ endif() ++ ++ if(LIBLZMA_LIBRARY_DEBUG) ++ set_property(TARGET LibLZMA::LibLZMA APPEND PROPERTY ++ IMPORTED_CONFIGURATIONS DEBUG) ++ set_target_properties(LibLZMA::LibLZMA PROPERTIES ++ IMPORTED_LOCATION_DEBUG "${LIBLZMA_LIBRARY_DEBUG}") ++ endif() ++ ++ if(NOT LIBLZMA_LIBRARY_RELEASE AND NOT LIBLZMA_LIBRARY_DEBUG) ++ set_target_properties(LibLZMA::LibLZMA PROPERTIES ++ IMPORTED_LOCATION "${LIBLZMA_LIBRARY}") ++ endif() ++ endif() ++endif () +diff --git a/cmake-compat/FindPackageHandleStandardArgs.cmake b/cmake-compat/FindPackageHandleStandardArgs.cmake +new file mode 100644 +index 00000000..a078049e +--- /dev/null ++++ b/cmake-compat/FindPackageHandleStandardArgs.cmake +@@ -0,0 +1,453 @@ ++# 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 a function intended to be used in :ref:`Find Modules` ++implementing :command:`find_package(<PackageName>)` calls. It handles the ++``REQUIRED``, ``QUIET`` and version-related arguments of ``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. ++ ++.. command:: find_package_handle_standard_args ++ ++ There are two signatures:: ++ ++ 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_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>`` ++ Obsolete. 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``. ++ ++ ``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_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>`` ++ 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`` ++ 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. ++#]=======================================================================] ++ ++include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake) ++ ++# 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_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG) ++ ++ # Set up the arguments for `cmake_parse_arguments`. ++ set(options CONFIG_MODE HANDLE_COMPONENTS NAME_MISMATCHED) ++ 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) ++ 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 () ++ ++# 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() ++ ++ list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR) ++ ++ 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 with DEFINED here as the requested or found version may be "0" ++ if (DEFINED ${_NAME}_FIND_VERSION) ++ if(DEFINED ${FPHSA_VERSION_VAR}) ++ set(_FOUND_VERSION ${${FPHSA_VERSION_VAR}}) ++ ++ if(${_NAME}_FIND_VERSION_EXACT) # exact version required ++ # count the dots in the version string ++ string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${_FOUND_VERSION}") ++ # add one dot because there is one dot more than there are components ++ string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS) ++ if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT) ++ # Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT ++ # is at most 4 here. Therefore a simple lookup table is used. ++ if (${_NAME}_FIND_VERSION_COUNT EQUAL 1) ++ set(_VERSION_REGEX "[^.]*") ++ elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2) ++ set(_VERSION_REGEX "[^.]*\\.[^.]*") ++ elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3) ++ set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*") ++ else () ++ set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*") ++ endif () ++ string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${_FOUND_VERSION}") ++ unset(_VERSION_REGEX) ++ if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD) ++ set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"") ++ set(VERSION_OK FALSE) ++ else () ++ set(VERSION_MSG "(found suitable exact version \"${_FOUND_VERSION}\")") ++ endif () ++ unset(_VERSION_HEAD) ++ else () ++ if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _FOUND_VERSION) ++ set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"") ++ set(VERSION_OK FALSE) ++ else () ++ set(VERSION_MSG "(found suitable exact version \"${_FOUND_VERSION}\")") ++ endif () ++ endif () ++ unset(_VERSION_DOTS) ++ ++ else() # minimum version specified: ++ if (${_NAME}_FIND_VERSION VERSION_GREATER _FOUND_VERSION) ++ set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"") ++ set(VERSION_OK FALSE) ++ else () ++ set(VERSION_MSG "(found suitable version \"${_FOUND_VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")") ++ endif () ++ endif() ++ ++ else() ++ ++ # 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}\")") ++ 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) ++ _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})") ++ 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() +diff --git a/cmake-compat/FindPackageMessage.cmake b/cmake-compat/FindPackageMessage.cmake +new file mode 100644 +index 00000000..0628b981 +--- /dev/null ++++ b/cmake-compat/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() +diff --git a/cmake-compat/SelectLibraryConfigurations.cmake b/cmake-compat/SelectLibraryConfigurations.cmake +new file mode 100644 +index 00000000..4c0e9a8c +--- /dev/null ++++ b/cmake-compat/SelectLibraryConfigurations.cmake +@@ -0,0 +1,80 @@ ++# Distributed under the OSI-approved BSD 3-Clause License. See accompanying ++# file Copyright.txt or https://cmake.org/licensing for details. ++ ++#[=======================================================================[.rst: ++SelectLibraryConfigurations ++--------------------------- ++ ++.. code-block:: cmake ++ ++ select_library_configurations(basename) ++ ++This macro takes a library base name as an argument, and will choose ++good values for the variables ++ ++:: ++ ++ basename_LIBRARY ++ basename_LIBRARIES ++ basename_LIBRARY_DEBUG ++ basename_LIBRARY_RELEASE ++ ++depending on what has been found and set. ++ ++If only ``basename_LIBRARY_RELEASE`` is defined, ``basename_LIBRARY`` will ++be set to the release value, and ``basename_LIBRARY_DEBUG`` will be set ++to ``basename_LIBRARY_DEBUG-NOTFOUND``. If only ``basename_LIBRARY_DEBUG`` ++is defined, then ``basename_LIBRARY`` will take the debug value, and ++``basename_LIBRARY_RELEASE`` will be set to ``basename_LIBRARY_RELEASE-NOTFOUND``. ++ ++If the generator supports configuration types, then ``basename_LIBRARY`` ++and ``basename_LIBRARIES`` will be set with debug and optimized flags ++specifying the library to be used for the given configuration. If no ++build type has been set or the generator in use does not support ++configuration types, then ``basename_LIBRARY`` and ``basename_LIBRARIES`` ++will take only the release value, or the debug value if the release one ++is not set. ++#]=======================================================================] ++ ++# This macro was adapted from the FindQt4 CMake module and is maintained by Will ++# Dicharry <wdicharry@stellarscience.com>. ++ ++macro(select_library_configurations basename) ++ if(NOT ${basename}_LIBRARY_RELEASE) ++ set(${basename}_LIBRARY_RELEASE "${basename}_LIBRARY_RELEASE-NOTFOUND" CACHE FILEPATH "Path to a library.") ++ endif() ++ if(NOT ${basename}_LIBRARY_DEBUG) ++ set(${basename}_LIBRARY_DEBUG "${basename}_LIBRARY_DEBUG-NOTFOUND" CACHE FILEPATH "Path to a library.") ++ endif() ++ ++ get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) ++ if( ${basename}_LIBRARY_DEBUG AND ${basename}_LIBRARY_RELEASE AND ++ NOT ${basename}_LIBRARY_DEBUG STREQUAL ${basename}_LIBRARY_RELEASE AND ++ ( _isMultiConfig OR CMAKE_BUILD_TYPE ) ) ++ # if the generator is multi-config or if CMAKE_BUILD_TYPE is set for ++ # single-config generators, set optimized and debug libraries ++ set( ${basename}_LIBRARY "" ) ++ foreach( _libname IN LISTS ${basename}_LIBRARY_RELEASE ) ++ list( APPEND ${basename}_LIBRARY optimized "${_libname}" ) ++ endforeach() ++ foreach( _libname IN LISTS ${basename}_LIBRARY_DEBUG ) ++ list( APPEND ${basename}_LIBRARY debug "${_libname}" ) ++ endforeach() ++ elseif( ${basename}_LIBRARY_RELEASE ) ++ set( ${basename}_LIBRARY ${${basename}_LIBRARY_RELEASE} ) ++ elseif( ${basename}_LIBRARY_DEBUG ) ++ set( ${basename}_LIBRARY ${${basename}_LIBRARY_DEBUG} ) ++ else() ++ set( ${basename}_LIBRARY "${basename}_LIBRARY-NOTFOUND") ++ endif() ++ ++ set( ${basename}_LIBRARIES "${${basename}_LIBRARY}" ) ++ ++ if( ${basename}_LIBRARY ) ++ set( ${basename}_FOUND TRUE ) ++ endif() ++ ++ mark_as_advanced( ${basename}_LIBRARY_RELEASE ++ ${basename}_LIBRARY_DEBUG ++ ) ++endmacro() |