test build for upstream fix

2 files changed, 1260 insertions, 2 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()
diff --git a/libzip.spec b/libzip.spec
index fefcd17..7bb5fe5 100644
--- a/libzip.spec
+++ b/libzip.spec
@@ -23,7 +23,7 @@ Name:    %{libname}
 Name:    %{libname}%{soname}
 %endif
 Version: 1.7.2
-Release: 1%{?dist}
+Release: 2%{?dist}
 Summary: C library for reading, creating, and modifying zip archives
 
 License: BSD
@@ -32,6 +32,7 @@ Source0: https://libzip.org/download/libzip-%{version}.tar.xz
 
 Patch0:  libzip-gnuinstalldirs.patch
 Patch1:  libzip-privlibs.patch
+Patch2:  https://github.com/nih-at/libzip/commit/992ed23c322c9abb9a108a6d119c09aada50ca9c.patch
 
 BuildRequires:  gcc
 BuildRequires:  zlib-devel >= 1.1.2
@@ -120,7 +121,8 @@ The %{name}-tools package provides command line tools split off %{name}:
 %prep
 %setup -q -n %{libname}-%{version}
 %patch0 -p1 -b .gnuinstalldirs
-%patch1 -p1 -b .privlib
+#patch1 -p1 -b .privlib
+%patch2 -p1 -b .up
 
 # unwanted in package documentation
 rm INSTALL.md
@@ -205,6 +207,9 @@ make check
 
 
 %changelog
+* Mon Jul 13 2020 Remi Collet <remi@remirepo.net> - 1.7.2-2
+- test build for upstream fix
+
 * Mon Jul 13 2020 Remi Collet <remi@remirepo.net> - 1.7.2-1
 - update to 1.7.2
 - fix installation layout using patch from