Copy in and Use the Kitware FindICU.cmake from CMake 3.21

Rather than increase the CMake version requirement to 3.7,
in order to upgrade from our less-than-perfect home-grown
FindICU we copy in the official CMake version and use that.

This seems to fix static linking problems with ICU on Windows.
It may also fix static linking on other platforms.

12 files changed, 1204 insertions, 158 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3568ffc9..151e54ba 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -90,8 +90,12 @@ endif()
 if(POLICY CMP0054)
   cmake_policy(SET CMP0054 NEW)
 endif()
+if(POLICY CMP0074)
+  cmake_policy(SET CMP0074 NEW) #don't warn about ICU_ROOT envvar
+endif()
 
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Kitware/modules")
 
 #Include CMake capabilities
 include(FeatureSummary)
@@ -192,7 +196,10 @@ endif()
 # libicu is highly recommended for RSCALE support
 #  libicu can be found at http://www.icu-project.org
 #  RSCALE info at https://tools.ietf.org/html/rfc7529
-find_package(ICU)
+if(NOT "$ENV{ICU_BASE}" STREQUAL "") #support the old ICU_BASE env
+  set(ICU_ROOT $ENV{ICU_BASE})
+endif()
+find_package(ICU COMPONENTS uc i18n)
 set_package_properties(ICU PROPERTIES
   TYPE RECOMMENDED
   PURPOSE "For RSCALE (RFC7529) support"
@@ -205,14 +212,26 @@ add_feature_info(
 if(ICU_FOUND)
   set(REQUIRES_PRIVATE_ICU "Requires.private: icu-i18n") #for libical.pc
   set(HAVE_LIBICU 1)
-  if(ICU_MAJOR_VERSION VERSION_GREATER 50)
+  if(ICU_VERSION VERSION_GREATER 50)
     set(HAVE_ICU_DANGI TRUE)
   else()
     set(HAVE_ICU_DANGI FALSE)
   endif()
-endif()
-if(ICU_I18N_FOUND)
-  set(HAVE_LIBICU_I18N 1)
+  if(ICU_GENCCODE_EXECUTABLE)
+    get_filename_component(ICU_EXEC ${ICU_GENCCODE_EXECUTABLE} DIRECTORY)
+  elseif(ICU_UCONV_EXECUTABLE)
+    get_filename_component(ICU_EXEC ${ICU_UCONV_EXECUTABLE} DIRECTORY)
+  elseif(ICU_ICUINFO_EXECUTABLE)
+    get_filename_component(ICU_EXEC ${ICU_ICUINFO_EXECUTABLE} DIRECTORY)
+  elseif(ICU_ICU-CONFIG_EXECUTABLE)
+    get_filename_component(ICU_EXEC ${ICU_ICU-CONFIG_EXECUTABLE} DIRECTORY)
+  elseif(ICU_MAKECONV_EXECUTABLE)
+    get_filename_component(ICU_EXEC ${ICU_MAKECONV_EXECUTABLE} DIRECTORY)
+  else()
+    message(FATAL_ERROR
+      "Unable locate the ICU runtime path. Is your ICU installation broken?")
+  endif()
+  set(ICU_BINARY_DIR ${ICU_EXEC} CACHE STRING DOC "Runtime binaries directory for the ICU library")
 endif()
 
 # compile in Berkeley DB support
diff --git a/Install.txt b/Install.txt
index cfbb078c..85f2a4cf 100644
--- a/Install.txt
+++ b/Install.txt
@@ -93,8 +93,8 @@ Homebrew:
   libicu can be found at http://www.icu-project.org
 
   If CMake doesn't locate your libicu installation try setting the
-  ICU_BASE environment variable to the top folder where its installed
-  and run cmake again.
+  ICU_ROOT or ICU_BASE environment variable to the top folder where
+  libicu is installed and run cmake again.
 
 * Berkeley DB storage.
   Optional for the Berkeley Database storage support.
diff --git a/ReleaseNotes.txt b/ReleaseNotes.txt
index e9d639a4..8950aea3 100644
--- a/ReleaseNotes.txt
+++ b/ReleaseNotes.txt
@@ -3,7 +3,7 @@ Release Highlights
 
 Version 3.0.12 (UNRELEASED):
 ---------------------------------
- *
+ * Improved FindICU (copied from official CMake.  see files in cmake/Kitware)
 
 Version 3.0.11 (09 October 2021):
 ---------------------------------
diff --git a/cmake/Kitware/modules/FindICU.cmake b/cmake/Kitware/modules/FindICU.cmake
new file mode 100644
index 00000000..b649f044
--- /dev/null
+++ b/cmake/Kitware/modules/FindICU.cmake
@@ -0,0 +1,438 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying

+# file Copyright.txt or https://cmake.org/licensing for details.

+

+#[=======================================================================[.rst:

+FindICU

+-------

+

+.. versionadded:: 3.7

+

+Find the International Components for Unicode (ICU) libraries and

+programs.

+

+This module supports multiple components.

+Components can include any of: ``data``, ``i18n``, ``io``, ``le``,

+``lx``, ``test``, ``tu`` and ``uc``.

+

+Note that on Windows ``data`` is named ``dt`` and ``i18n`` is named

+``in``; any of the names may be used, and the appropriate

+platform-specific library name will be automatically selected.

+

+.. versionadded:: 3.11

+  Added support for static libraries on Windows.

+

+This module reports information about the ICU installation in

+several variables.  General variables::

+

+  ICU_VERSION - ICU release version

+  ICU_FOUND - true if the main programs and libraries were found

+  ICU_LIBRARIES - component libraries to be linked

+  ICU_INCLUDE_DIRS - the directories containing the ICU headers

+

+Imported targets::

+

+  ICU::<C>

+

+Where ``<C>`` is the name of an ICU component, for example

+``ICU::i18n``; ``<C>`` is lower-case.

+

+ICU programs are reported in::

+

+  ICU_GENCNVAL_EXECUTABLE - path to gencnval executable

+  ICU_ICUINFO_EXECUTABLE - path to icuinfo executable

+  ICU_GENBRK_EXECUTABLE - path to genbrk executable

+  ICU_ICU-CONFIG_EXECUTABLE - path to icu-config executable

+  ICU_GENRB_EXECUTABLE - path to genrb executable

+  ICU_GENDICT_EXECUTABLE - path to gendict executable

+  ICU_DERB_EXECUTABLE - path to derb executable

+  ICU_PKGDATA_EXECUTABLE - path to pkgdata executable

+  ICU_UCONV_EXECUTABLE - path to uconv executable

+  ICU_GENCFU_EXECUTABLE - path to gencfu executable

+  ICU_MAKECONV_EXECUTABLE - path to makeconv executable

+  ICU_GENNORM2_EXECUTABLE - path to gennorm2 executable

+  ICU_GENCCODE_EXECUTABLE - path to genccode executable

+  ICU_GENSPREP_EXECUTABLE - path to gensprep executable

+  ICU_ICUPKG_EXECUTABLE - path to icupkg executable

+  ICU_GENCMN_EXECUTABLE - path to gencmn executable

+

+ICU component libraries are reported in::

+

+  ICU_<C>_FOUND - ON if component was found; ``<C>`` is upper-case.

+  ICU_<C>_LIBRARIES - libraries for component; ``<C>`` is upper-case.

+

+ICU datafiles are reported in::

+

+  ICU_MAKEFILE_INC - Makefile.inc

+  ICU_PKGDATA_INC - pkgdata.inc

+

+This module reads hints about search results from::

+

+  ICU_ROOT - the root of the ICU installation

+

+The environment variable ``ICU_ROOT`` may also be used; the

+ICU_ROOT variable takes precedence.

+

+The following cache variables may also be set::

+

+  ICU_<P>_EXECUTABLE - the path to executable <P>; ``<P>`` is upper-case.

+  ICU_INCLUDE_DIR - the directory containing the ICU headers

+  ICU_<C>_LIBRARY - the library for component <C>; ``<C>`` is upper-case.

+

+.. note::

+

+  In most cases none of the above variables will require setting,

+  unless multiple ICU versions are available and a specific version

+  is required.

+

+Other variables one may set to control this module are::

+

+  ICU_DEBUG - Set to ON to enable debug output from FindICU.

+#]=======================================================================]

+

+# Written by Roger Leigh <rleigh@codelibre.net>

+

+set(icu_programs

+  gencnval

+  icuinfo

+  genbrk

+  icu-config

+  genrb

+  gendict

+  derb

+  pkgdata

+  uconv

+  gencfu

+  makeconv

+  gennorm2

+  genccode

+  gensprep

+  icupkg

+  gencmn)

+

+set(icu_data

+  Makefile.inc

+  pkgdata.inc)

+

+# The ICU checks are contained in a function due to the large number

+# of temporary variables needed.

+function(_ICU_FIND)

+  # Set up search paths, taking compiler into account.  Search ICU_ROOT,

+  # with ICU_ROOT in the environment as a fallback if unset.

+  if(ICU_ROOT)

+    list(APPEND icu_roots "${ICU_ROOT}")

+  else()

+    if(NOT "$ENV{ICU_ROOT}" STREQUAL "")

+      file(TO_CMAKE_PATH "$ENV{ICU_ROOT}" NATIVE_PATH)

+      list(APPEND icu_roots "${NATIVE_PATH}")

+      set(ICU_ROOT "${NATIVE_PATH}"

+          CACHE PATH "Location of the ICU installation" FORCE)

+    endif()

+  endif()

+

+  # Find include directory

+  list(APPEND icu_include_suffixes "include")

+  find_path(ICU_INCLUDE_DIR

+            NAMES "unicode/utypes.h"

+            HINTS ${icu_roots}

+            PATH_SUFFIXES ${icu_include_suffixes}

+            DOC "ICU include directory")

+  set(ICU_INCLUDE_DIR "${ICU_INCLUDE_DIR}" PARENT_SCOPE)

+

+  # Get version

+  if(ICU_INCLUDE_DIR AND EXISTS "${ICU_INCLUDE_DIR}/unicode/uvernum.h")

+    file(STRINGS "${ICU_INCLUDE_DIR}/unicode/uvernum.h" icu_header_str

+      REGEX "^#define[\t ]+U_ICU_VERSION[\t ]+\".*\".*")

+

+    string(REGEX REPLACE "^#define[\t ]+U_ICU_VERSION[\t ]+\"([^ \\n]*)\".*"

+      "\\1" icu_version_string "${icu_header_str}")

+    set(ICU_VERSION "${icu_version_string}")

+    set(ICU_VERSION "${icu_version_string}" PARENT_SCOPE)

+    unset(icu_header_str)

+    unset(icu_version_string)

+  endif()

+

+  if(CMAKE_SIZEOF_VOID_P EQUAL 8)

+    # 64-bit binary directory

+    set(_bin64 "bin64")

+    # 64-bit library directory

+    set(_lib64 "lib64")

+  endif()

+

+

+  # Find all ICU programs

+  list(APPEND icu_binary_suffixes "${_bin64}" "bin" "sbin")

+  foreach(program ${icu_programs})

+    string(TOUPPER "${program}" program_upcase)

+    set(cache_var "ICU_${program_upcase}_EXECUTABLE")

+    set(program_var "ICU_${program_upcase}_EXECUTABLE")

+    find_program("${cache_var}"

+      NAMES "${program}"

+      HINTS ${icu_roots}

+      PATH_SUFFIXES ${icu_binary_suffixes}

+      DOC "ICU ${program} executable"

+      NO_PACKAGE_ROOT_PATH

+      )

+    mark_as_advanced(cache_var)

+    set("${program_var}" "${${cache_var}}" PARENT_SCOPE)

+  endforeach()

+

+  # Find all ICU libraries

+  list(APPEND icu_library_suffixes "${_lib64}" "lib")

+  set(ICU_REQUIRED_LIBS_FOUND ON)

+  set(static_prefix )

+  # static icu libraries compiled with MSVC have the prefix 's'

+  if(MSVC)

+    set(static_prefix "s")

+  endif()

+  foreach(component ${ICU_FIND_COMPONENTS})

+    string(TOUPPER "${component}" component_upcase)

+    set(component_cache "ICU_${component_upcase}_LIBRARY")

+    set(component_cache_release "${component_cache}_RELEASE")

+    set(component_cache_debug "${component_cache}_DEBUG")

+    set(component_found "ICU_${component_upcase}_FOUND")

+    set(component_found_compat "${component_upcase}_FOUND")

+    set(component_libnames "icu${component}")

+    set(component_debug_libnames "icu${component}d")

+

+    # Special case deliberate library naming mismatches between Unix

+    # and Windows builds

+    unset(component_libnames)

+    unset(component_debug_libnames)

+    list(APPEND component_libnames "icu${component}")

+    list(APPEND component_debug_libnames "icu${component}d")

+    if(component STREQUAL "data")

+      list(APPEND component_libnames "icudt")

+      # Note there is no debug variant at present

+      list(APPEND component_debug_libnames "icudtd")

+    endif()

+    if(component STREQUAL "dt")

+      list(APPEND component_libnames "icudata")

+      # Note there is no debug variant at present

+      list(APPEND component_debug_libnames "icudatad")

+    endif()

+    if(component STREQUAL "i18n")

+      list(APPEND component_libnames "icuin")

+      list(APPEND component_debug_libnames "icuind")

+    endif()

+    if(component STREQUAL "in")

+      list(APPEND component_libnames "icui18n")

+      list(APPEND component_debug_libnames "icui18nd")

+    endif()

+

+    if(static_prefix)

+      unset(static_component_libnames)

+      unset(static_component_debug_libnames)

+      foreach(component_libname ${component_libnames})

+        list(APPEND static_component_libnames

+          ${static_prefix}${component_libname})

+      endforeach()

+      foreach(component_libname ${component_debug_libnames})

+        list(APPEND static_component_debug_libnames

+          ${static_prefix}${component_libname})

+      endforeach()

+      list(APPEND component_libnames ${static_component_libnames})

+      list(APPEND component_debug_libnames ${static_component_debug_libnames})

+    endif()

+    find_library("${component_cache_release}"

+      NAMES ${component_libnames}

+      HINTS ${icu_roots}

+      PATH_SUFFIXES ${icu_library_suffixes}

+      DOC "ICU ${component} library (release)"

+      NO_PACKAGE_ROOT_PATH

+      )

+    find_library("${component_cache_debug}"

+      NAMES ${component_debug_libnames}

+      HINTS ${icu_roots}

+      PATH_SUFFIXES ${icu_library_suffixes}

+      DOC "ICU ${component} library (debug)"

+      NO_PACKAGE_ROOT_PATH

+      )

+    include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake)

+    select_library_configurations(ICU_${component_upcase})

+    mark_as_advanced("${component_cache_release}" "${component_cache_debug}")

+    if(${component_cache})

+      set("${component_found}" ON)

+      set("${component_found_compat}" ON)

+      list(APPEND ICU_LIBRARY "${${component_cache}}")

+    endif()

+    mark_as_advanced("${component_found}")

+    mark_as_advanced("${component_found_compat}")

+    set("${component_cache}" "${${component_cache}}" PARENT_SCOPE)

+    set("${component_found}" "${${component_found}}" PARENT_SCOPE)

+    set("${component_found_compat}" "${${component_found_compat}}" PARENT_SCOPE)

+    if(component_found OR component_found_compat)

+      if (ICU_FIND_REQUIRED_${component})

+        list(APPEND ICU_LIBS_FOUND "${component} (required)")

+      else()

+        list(APPEND ICU_LIBS_FOUND "${component} (optional)")

+      endif()

+    else()

+      if (ICU_FIND_REQUIRED_${component})

+        set(ICU_REQUIRED_LIBS_FOUND OFF)

+        list(APPEND ICU_LIBS_NOTFOUND "${component} (required)")

+      else()

+        list(APPEND ICU_LIBS_NOTFOUND "${component} (optional)")

+      endif()

+    endif()

+  endforeach()

+  set(_ICU_REQUIRED_LIBS_FOUND "${ICU_REQUIRED_LIBS_FOUND}" PARENT_SCOPE)

+  set(ICU_LIBRARY "${ICU_LIBRARY}" PARENT_SCOPE)

+

+  # Find all ICU data files

+  if(CMAKE_LIBRARY_ARCHITECTURE)

+    list(APPEND icu_data_suffixes

+      "${_lib64}/${CMAKE_LIBRARY_ARCHITECTURE}/icu/${ICU_VERSION}"

+      "lib/${CMAKE_LIBRARY_ARCHITECTURE}/icu/${ICU_VERSION}"

+      "${_lib64}/${CMAKE_LIBRARY_ARCHITECTURE}/icu"

+      "lib/${CMAKE_LIBRARY_ARCHITECTURE}/icu")

+  endif()

+  list(APPEND icu_data_suffixes

+    "${_lib64}/icu/${ICU_VERSION}"

+    "lib/icu/${ICU_VERSION}"

+    "${_lib64}/icu"

+    "lib/icu")

+  foreach(data ${icu_data})

+    string(TOUPPER "${data}" data_upcase)

+    string(REPLACE "." "_" data_upcase "${data_upcase}")

+    set(cache_var "ICU_${data_upcase}")

+    set(data_var "ICU_${data_upcase}")

+    find_file("${cache_var}"

+      NAMES "${data}"

+      HINTS ${icu_roots}

+      PATH_SUFFIXES ${icu_data_suffixes}

+      DOC "ICU ${data} data file")

+    mark_as_advanced(cache_var)

+    set("${data_var}" "${${cache_var}}" PARENT_SCOPE)

+  endforeach()

+

+  if(NOT ICU_FIND_QUIETLY)

+    if(ICU_LIBS_FOUND)

+      message(STATUS "Found the following ICU libraries:")

+      foreach(found ${ICU_LIBS_FOUND})

+        message(STATUS "  ${found}")

+      endforeach()

+    endif()

+    if(ICU_LIBS_NOTFOUND)

+      message(STATUS "The following ICU libraries were not found:")

+      foreach(notfound ${ICU_LIBS_NOTFOUND})

+        message(STATUS "  ${notfound}")

+      endforeach()

+    endif()

+  endif()

+

+  if(ICU_DEBUG)

+    message(STATUS "--------FindICU.cmake search debug--------")

+    message(STATUS "ICU binary path search order: ${icu_roots}")

+    message(STATUS "ICU include path search order: ${icu_roots}")

+    message(STATUS "ICU library path search order: ${icu_roots}")

+    message(STATUS "----------------")

+  endif()

+endfunction()

+

+_ICU_FIND()

+

+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)

+FIND_PACKAGE_HANDLE_STANDARD_ARGS(ICU

+                                  FOUND_VAR ICU_FOUND

+                                  REQUIRED_VARS ICU_INCLUDE_DIR

+                                                ICU_LIBRARY

+                                                _ICU_REQUIRED_LIBS_FOUND

+                                  VERSION_VAR ICU_VERSION

+                                  FAIL_MESSAGE "Failed to find all ICU components")

+

+unset(_ICU_REQUIRED_LIBS_FOUND)

+

+if(ICU_FOUND)

+  set(ICU_INCLUDE_DIRS "${ICU_INCLUDE_DIR}")

+  set(ICU_LIBRARIES "${ICU_LIBRARY}")

+  foreach(_ICU_component ${ICU_FIND_COMPONENTS})

+    string(TOUPPER "${_ICU_component}" _ICU_component_upcase)

+    set(_ICU_component_cache "ICU_${_ICU_component_upcase}_LIBRARY")

+    set(_ICU_component_cache_release "ICU_${_ICU_component_upcase}_LIBRARY_RELEASE")

+    set(_ICU_component_cache_debug "ICU_${_ICU_component_upcase}_LIBRARY_DEBUG")

+    set(_ICU_component_lib "ICU_${_ICU_component_upcase}_LIBRARIES")

+    set(_ICU_component_found "ICU_${_ICU_component_upcase}_FOUND")

+    set(_ICU_imported_target "ICU::${_ICU_component}")

+    if(${_ICU_component_found})

+      set("${_ICU_component_lib}" "${${_ICU_component_cache}}")

+      if(NOT TARGET ${_ICU_imported_target})

+        add_library(${_ICU_imported_target} UNKNOWN IMPORTED)

+        if(ICU_INCLUDE_DIR)

+          set_target_properties(${_ICU_imported_target} PROPERTIES

+            INTERFACE_INCLUDE_DIRECTORIES "${ICU_INCLUDE_DIR}")

+        endif()

+        if(EXISTS "${${_ICU_component_cache}}")

+          set_target_properties(${_ICU_imported_target} PROPERTIES

+            IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"

+            IMPORTED_LOCATION "${${_ICU_component_cache}}")

+        endif()

+        if(EXISTS "${${_ICU_component_cache_release}}")

+          set_property(TARGET ${_ICU_imported_target} APPEND PROPERTY

+            IMPORTED_CONFIGURATIONS RELEASE)

+          set_target_properties(${_ICU_imported_target} PROPERTIES

+            IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"

+            IMPORTED_LOCATION_RELEASE "${${_ICU_component_cache_release}}")

+        endif()

+        if(EXISTS "${${_ICU_component_cache_debug}}")

+          set_property(TARGET ${_ICU_imported_target} APPEND PROPERTY

+            IMPORTED_CONFIGURATIONS DEBUG)

+          set_target_properties(${_ICU_imported_target} PROPERTIES

+            IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX"

+            IMPORTED_LOCATION_DEBUG "${${_ICU_component_cache_debug}}")

+        endif()

+        if(CMAKE_DL_LIBS AND _ICU_component STREQUAL "uc")

+          set_target_properties(${_ICU_imported_target} PROPERTIES

+            INTERFACE_LINK_LIBRARIES "${CMAKE_DL_LIBS}")

+        endif()

+      endif()

+    endif()

+    unset(_ICU_component_upcase)

+    unset(_ICU_component_cache)

+    unset(_ICU_component_lib)

+    unset(_ICU_component_found)

+    unset(_ICU_imported_target)

+  endforeach()

+endif()

+

+if(ICU_DEBUG)

+  message(STATUS "--------FindICU.cmake results debug--------")

+  message(STATUS "ICU found: ${ICU_FOUND}")

+  message(STATUS "ICU_VERSION number: ${ICU_VERSION}")

+  message(STATUS "ICU_ROOT directory: ${ICU_ROOT}")

+  message(STATUS "ICU_INCLUDE_DIR directory: ${ICU_INCLUDE_DIR}")

+  message(STATUS "ICU_LIBRARIES: ${ICU_LIBRARIES}")

+

+  foreach(program IN LISTS icu_programs)

+    string(TOUPPER "${program}" program_upcase)

+    set(program_lib "ICU_${program_upcase}_EXECUTABLE")

+    message(STATUS "${program} program: ${program_lib}=${${program_lib}}")

+    unset(program_upcase)

+    unset(program_lib)

+  endforeach()

+

+  foreach(data IN LISTS icu_data)

+    string(TOUPPER "${data}" data_upcase)

+    string(REPLACE "." "_" data_upcase "${data_upcase}")

+    set(data_lib "ICU_${data_upcase}")

+    message(STATUS "${data} data: ${data_lib}=${${data_lib}}")

+    unset(data_upcase)

+    unset(data_lib)

+  endforeach()

+

+  foreach(component IN LISTS ICU_FIND_COMPONENTS)

+    string(TOUPPER "${component}" component_upcase)

+    set(component_lib "ICU_${component_upcase}_LIBRARIES")

+    set(component_found "ICU_${component_upcase}_FOUND")

+    set(component_found_compat "${component_upcase}_FOUND")

+    message(STATUS "${component} library found: ${component_found}=${${component_found}}")

+    message(STATUS "${component} library found (compat name): ${component_found_compat}=${${component_found_compat}}")

+    message(STATUS "${component} library: ${component_lib}=${${component_lib}}")

+    unset(component_upcase)

+    unset(component_lib)

+    unset(component_found)

+    unset(component_found_compat)

+  endforeach()

+  message(STATUS "----------------")

+endif()

+

+unset(icu_programs)

diff --git a/cmake/Kitware/modules/FindPackageHandleStandardArgs.cmake b/cmake/Kitware/modules/FindPackageHandleStandardArgs.cmake
new file mode 100644
index 00000000..3a7c0927
--- /dev/null
+++ b/cmake/Kitware/modules/FindPackageHandleStandardArgs.cmake
@@ -0,0 +1,605 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying

+# file Copyright.txt or https://cmake.org/licensing for details.

+

+#[=======================================================================[.rst:

+FindPackageHandleStandardArgs

+-----------------------------

+

+This module provides functions intended to be used in :ref:`Find Modules`

+implementing :command:`find_package(<PackageName>)` calls.

+

+.. command:: find_package_handle_standard_args

+

+  This command handles the ``REQUIRED``, ``QUIET`` and version-related

+  arguments of :command:`find_package`.  It also sets the

+  ``<PackageName>_FOUND`` variable.  The package is considered found if all

+  variables listed contain valid results, e.g. valid filepaths.

+

+  There are two signatures:

+

+  .. code-block:: cmake

+

+    find_package_handle_standard_args(<PackageName>

+      (DEFAULT_MSG|<custom-failure-message>)

+      <required-var>...

+      )

+

+    find_package_handle_standard_args(<PackageName>

+      [FOUND_VAR <result-var>]

+      [REQUIRED_VARS <required-var>...]

+      [VERSION_VAR <version-var>]

+      [HANDLE_VERSION_RANGE]

+      [HANDLE_COMPONENTS]

+      [CONFIG_MODE]

+      [NAME_MISMATCHED]

+      [REASON_FAILURE_MESSAGE <reason-failure-message>]

+      [FAIL_MESSAGE <custom-failure-message>]

+      )

+

+  The ``<PackageName>_FOUND`` variable will be set to ``TRUE`` if all

+  the variables ``<required-var>...`` are valid and any optional

+  constraints are satisfied, and ``FALSE`` otherwise.  A success or

+  failure message may be displayed based on the results and on

+  whether the ``REQUIRED`` and/or ``QUIET`` option was given to

+  the :command:`find_package` call.

+

+  The options are:

+

+  ``(DEFAULT_MSG|<custom-failure-message>)``

+    In the simple signature this specifies the failure message.

+    Use ``DEFAULT_MSG`` to ask for a default message to be computed

+    (recommended).  Not valid in the full signature.

+

+  ``FOUND_VAR <result-var>``

+    .. deprecated:: 3.3

+

+    Specifies either ``<PackageName>_FOUND`` or

+    ``<PACKAGENAME>_FOUND`` as the result variable.  This exists only

+    for compatibility with older versions of CMake and is now ignored.

+    Result variables of both names are always set for compatibility.

+

+  ``REQUIRED_VARS <required-var>...``

+    Specify the variables which are required for this package.

+    These may be named in the generated failure message asking the

+    user to set the missing variable values.  Therefore these should

+    typically be cache entries such as ``FOO_LIBRARY`` and not output

+    variables like ``FOO_LIBRARIES``.

+

+    .. versionchanged:: 3.18

+      If ``HANDLE_COMPONENTS`` is specified, this option can be omitted.

+

+  ``VERSION_VAR <version-var>``

+    Specify the name of a variable that holds the version of the package

+    that has been found.  This version will be checked against the

+    (potentially) specified required version given to the

+    :command:`find_package` call, including its ``EXACT`` option.

+    The default messages include information about the required

+    version and the version which has been actually found, both

+    if the version is ok or not.

+

+  ``HANDLE_VERSION_RANGE``

+    .. versionadded:: 3.19

+

+    Enable handling of a version range, if one is specified. Without this

+    option, a developer warning will be displayed if a version range is

+    specified.

+

+  ``HANDLE_COMPONENTS``

+    Enable handling of package components.  In this case, the command

+    will report which components have been found and which are missing,

+    and the ``<PackageName>_FOUND`` variable will be set to ``FALSE``

+    if any of the required components (i.e. not the ones listed after

+    the ``OPTIONAL_COMPONENTS`` option of :command:`find_package`) are

+    missing.

+

+  ``CONFIG_MODE``

+    Specify that the calling find module is a wrapper around a

+    call to ``find_package(<PackageName> NO_MODULE)``.  This implies

+    a ``VERSION_VAR`` value of ``<PackageName>_VERSION``.  The command

+    will automatically check whether the package configuration file

+    was found.

+

+  ``REASON_FAILURE_MESSAGE <reason-failure-message>``

+    .. versionadded:: 3.16

+

+    Specify a custom message of the reason for the failure which will be

+    appended to the default generated message.

+

+  ``FAIL_MESSAGE <custom-failure-message>``

+    Specify a custom failure message instead of using the default

+    generated message.  Not recommended.

+

+  ``NAME_MISMATCHED``

+    .. versionadded:: 3.17

+

+    Indicate that the ``<PackageName>`` does not match

+    ``${CMAKE_FIND_PACKAGE_NAME}``. This is usually a mistake and raises a

+    warning, but it may be intentional for usage of the command for components

+    of a larger package.

+

+Example for the simple signature:

+

+.. code-block:: cmake

+

+  find_package_handle_standard_args(LibXml2 DEFAULT_MSG

+    LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)

+

+The ``LibXml2`` package is considered to be found if both

+``LIBXML2_LIBRARY`` and ``LIBXML2_INCLUDE_DIR`` are valid.

+Then also ``LibXml2_FOUND`` is set to ``TRUE``.  If it is not found

+and ``REQUIRED`` was used, it fails with a

+:command:`message(FATAL_ERROR)`, independent whether ``QUIET`` was

+used or not.  If it is found, success will be reported, including

+the content of the first ``<required-var>``.  On repeated CMake runs,

+the same message will not be printed again.

+

+.. note::

+

+  If ``<PackageName>`` does not match ``CMAKE_FIND_PACKAGE_NAME`` for the

+  calling module, a warning that there is a mismatch is given. The

+  ``FPHSA_NAME_MISMATCHED`` variable may be set to bypass the warning if using

+  the old signature and the ``NAME_MISMATCHED`` argument using the new

+  signature. To avoid forcing the caller to require newer versions of CMake for

+  usage, the variable's value will be used if defined when the

+  ``NAME_MISMATCHED`` argument is not passed for the new signature (but using

+  both is an error)..

+

+Example for the full signature:

+

+.. code-block:: cmake

+

+  find_package_handle_standard_args(LibArchive

+    REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR

+    VERSION_VAR LibArchive_VERSION)

+

+In this case, the ``LibArchive`` package is considered to be found if

+both ``LibArchive_LIBRARY`` and ``LibArchive_INCLUDE_DIR`` are valid.

+Also the version of ``LibArchive`` will be checked by using the version

+contained in ``LibArchive_VERSION``.  Since no ``FAIL_MESSAGE`` is given,

+the default messages will be printed.

+

+Another example for the full signature:

+

+.. code-block:: cmake

+

+  find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4)

+  find_package_handle_standard_args(Automoc4  CONFIG_MODE)

+

+In this case, a ``FindAutmoc4.cmake`` module wraps a call to

+``find_package(Automoc4 NO_MODULE)`` and adds an additional search

+directory for ``automoc4``.  Then the call to

+``find_package_handle_standard_args`` produces a proper success/failure

+message.

+

+.. command:: find_package_check_version

+

+  .. versionadded:: 3.19

+

+  Helper function which can be used to check if a ``<version>`` is valid

+  against version-related arguments of :command:`find_package`.

+

+  .. code-block:: cmake

+

+    find_package_check_version(<version> <result-var>

+      [HANDLE_VERSION_RANGE]

+      [RESULT_MESSAGE_VARIABLE <message-var>]

+      )

+

+  The ``<result-var>`` will hold a boolean value giving the result of the check.

+

+  The options are:

+

+  ``HANDLE_VERSION_RANGE``

+    Enable handling of a version range, if one is specified. Without this

+    option, a developer warning will be displayed if a version range is

+    specified.

+

+  ``RESULT_MESSAGE_VARIABLE <message-var>``

+    Specify a variable to get back a message describing the result of the check.

+

+Example for the usage:

+

+.. code-block:: cmake

+

+  find_package_check_version(1.2.3 result HANDLE_VERSION_RANGE

+    RESULT_MESSAGE_VARIABLE reason)

+  if (result)

+    message (STATUS "${reason}")

+  else()

+    message (FATAL_ERROR "${reason}")

+  endif()

+#]=======================================================================]

+

+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake)

+

+

+cmake_policy(PUSH)

+# numbers and boolean constants

+cmake_policy (SET CMP0012 NEW)

+# IN_LIST operator

+cmake_policy (SET CMP0057 NEW)

+

+

+# internal helper macro

+macro(_FPHSA_FAILURE_MESSAGE _msg)

+  set (__msg "${_msg}")

+  if (FPHSA_REASON_FAILURE_MESSAGE)

+    string(APPEND __msg "\n    Reason given by package: ${FPHSA_REASON_FAILURE_MESSAGE}\n")

+  endif()

+  if (${_NAME}_FIND_REQUIRED)

+    message(FATAL_ERROR "${__msg}")

+  else ()

+    if (NOT ${_NAME}_FIND_QUIETLY)

+      message(STATUS "${__msg}")

+    endif ()

+  endif ()

+endmacro()

+

+

+# internal helper macro to generate the failure message when used in CONFIG_MODE:

+macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE)

+  # <PackageName>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found:

+  if(${_NAME}_CONFIG)

+    _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing:${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})")

+  else()

+    # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version.

+    # List them all in the error message:

+    if(${_NAME}_CONSIDERED_CONFIGS)

+      set(configsText "")

+      list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount)

+      math(EXPR configsCount "${configsCount} - 1")

+      foreach(currentConfigIndex RANGE ${configsCount})

+        list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename)

+        list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version)

+        string(APPEND configsText "\n    ${filename} (version ${version})")

+      endforeach()

+      if (${_NAME}_NOT_FOUND_MESSAGE)

+        if (FPHSA_REASON_FAILURE_MESSAGE)

+          string(PREPEND FPHSA_REASON_FAILURE_MESSAGE "${${_NAME}_NOT_FOUND_MESSAGE}\n    ")

+        else()

+          set(FPHSA_REASON_FAILURE_MESSAGE "${${_NAME}_NOT_FOUND_MESSAGE}")

+        endif()

+      else()

+        string(APPEND configsText "\n")

+      endif()

+      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:${configsText}")

+

+    else()

+      # Simple case: No Config-file was found at all:

+      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}")

+    endif()

+  endif()

+endmacro()

+

+

+function(FIND_PACKAGE_CHECK_VERSION version result)

+  cmake_parse_arguments (PARSE_ARGV 2 FPCV "HANDLE_VERSION_RANGE;NO_AUTHOR_WARNING_VERSION_RANGE" "RESULT_MESSAGE_VARIABLE" "")

+

+  if (FPCV_UNPARSED_ARGUMENTS)

+    message (FATAL_ERROR "find_package_check_version(): ${FPCV_UNPARSED_ARGUMENTS}: unexpected arguments")

+  endif()

+  if ("RESULT_MESSAGE_VARIABLE" IN_LIST FPCV_KEYWORDS_MISSING_VALUES)

+    message (FATAL_ERROR "find_package_check_version(): RESULT_MESSAGE_VARIABLE expects an argument")

+  endif()

+

+  set (${result} FALSE PARENT_SCOPE)

+  if (FPCV_RESULT_MESSAGE_VARIABLE)

+    unset (${FPCV_RESULT_MESSAGE_VARIABLE} PARENT_SCOPE)

+  endif()

+

+  if (_CMAKE_FPHSA_PACKAGE_NAME)

+    set (package "${_CMAKE_FPHSA_PACKAGE_NAME}")

+  elseif (CMAKE_FIND_PACKAGE_NAME)

+    set (package "${CMAKE_FIND_PACKAGE_NAME}")

+  else()

+    message (FATAL_ERROR "find_package_check_version(): Cannot be used outside a 'Find Module'")

+  endif()

+

+  if (NOT FPCV_NO_AUTHOR_WARNING_VERSION_RANGE

+      AND ${package}_FIND_VERSION_RANGE AND NOT FPCV_HANDLE_VERSION_RANGE)

+    message(AUTHOR_WARNING

+      "`find_package()` specify a version range but the option "

+      "HANDLE_VERSION_RANGE` is not passed to `find_package_check_version()`. "

+      "Only the lower endpoint of the range will be used.")

+  endif()

+

+

+  set (version_ok FALSE)

+  unset (version_msg)

+

+  if (FPCV_HANDLE_VERSION_RANGE AND ${package}_FIND_VERSION_RANGE)

+    if ((${package}_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE"

+          AND version VERSION_GREATER_EQUAL ${package}_FIND_VERSION_MIN)

+        AND ((${package}_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE"

+            AND version VERSION_LESS_EQUAL ${package}_FIND_VERSION_MAX)

+          OR (${package}_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE"

+            AND version VERSION_LESS ${package}_FIND_VERSION_MAX)))

+      set (version_ok TRUE)

+      set(version_msg "(found suitable version \"${version}\", required range is \"${${package}_FIND_VERSION_RANGE}\")")

+    else()

+      set(version_msg "Found unsuitable version \"${version}\", required range is \"${${package}_FIND_VERSION_RANGE}\"")

+    endif()

+  elseif (DEFINED ${package}_FIND_VERSION)

+    if(${package}_FIND_VERSION_EXACT)       # exact version required

+      # count the dots in the version string

+      string(REGEX REPLACE "[^.]" "" version_dots "${version}")

+      # add one dot because there is one dot more than there are components

+      string(LENGTH "${version_dots}." version_dots)

+      if (version_dots GREATER ${package}_FIND_VERSION_COUNT)

+        # Because of the C++ implementation of find_package() ${package}_FIND_VERSION_COUNT

+        # is at most 4 here. Therefore a simple lookup table is used.

+        if (${package}_FIND_VERSION_COUNT EQUAL 1)

+          set(version_regex "[^.]*")

+        elseif (${package}_FIND_VERSION_COUNT EQUAL 2)

+          set(version_regex "[^.]*\\.[^.]*")

+        elseif (${package}_FIND_VERSION_COUNT EQUAL 3)

+          set(version_regex "[^.]*\\.[^.]*\\.[^.]*")

+        else()

+          set(version_regex "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*")

+        endif()

+        string(REGEX REPLACE "^(${version_regex})\\..*" "\\1" version_head "${version}")

+        if (NOT ${package}_FIND_VERSION VERSION_EQUAL version_head)

+          set(version_msg "Found unsuitable version \"${version}\", but required is exact version \"${${package}_FIND_VERSION}\"")

+        else ()

+          set(version_ok TRUE)

+          set(version_msg "(found suitable exact version \"${_FOUND_VERSION}\")")

+        endif ()

+      else ()

+        if (NOT ${package}_FIND_VERSION VERSION_EQUAL version)

+          set(version_msg "Found unsuitable version \"${version}\", but required is exact version \"${${package}_FIND_VERSION}\"")

+        else ()

+          set(version_ok TRUE)

+          set(version_msg "(found suitable exact version \"${version}\")")

+        endif ()

+      endif ()

+    else()     # minimum version

+      if (${package}_FIND_VERSION VERSION_GREATER version)

+        set(version_msg "Found unsuitable version \"${version}\", but required is at least \"${${package}_FIND_VERSION}\"")

+      else()

+        set(version_ok TRUE)

+        set(version_msg "(found suitable version \"${version}\", minimum required is \"${${package}_FIND_VERSION}\")")

+      endif()

+    endif()

+  else ()

+    set(version_ok TRUE)

+    set(version_msg "(found version \"${version}\")")

+  endif()

+

+  set (${result} ${version_ok} PARENT_SCOPE)

+  if (FPCV_RESULT_MESSAGE_VARIABLE)

+    set (${FPCV_RESULT_MESSAGE_VARIABLE} "${version_msg}" PARENT_SCOPE)

+  endif()

+endfunction()

+

+

+function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG)

+

+  # Set up the arguments for `cmake_parse_arguments`.

+  set(options  CONFIG_MODE  HANDLE_COMPONENTS NAME_MISMATCHED HANDLE_VERSION_RANGE)

+  set(oneValueArgs  FAIL_MESSAGE  REASON_FAILURE_MESSAGE VERSION_VAR  FOUND_VAR)

+  set(multiValueArgs REQUIRED_VARS)

+

+  # Check whether we are in 'simple' or 'extended' mode:

+  set(_KEYWORDS_FOR_EXTENDED_MODE  ${options} ${oneValueArgs} ${multiValueArgs} )

+  list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX)

+

+  unset(FPHSA_NAME_MISMATCHED_override)

+  if (DEFINED FPHSA_NAME_MISMATCHED)

+    # If the variable NAME_MISMATCHED variable is set, error if it is passed as

+    # an argument. The former is for old signatures, the latter is for new

+    # signatures.

+    list(FIND ARGN "NAME_MISMATCHED" name_mismatched_idx)

+    if (NOT name_mismatched_idx EQUAL "-1")

+      message(FATAL_ERROR

+        "The `NAME_MISMATCHED` argument may only be specified by the argument or "

+        "the variable, not both.")

+    endif ()

+

+    # But use the variable if it is not an argument to avoid forcing minimum

+    # CMake version bumps for calling modules.

+    set(FPHSA_NAME_MISMATCHED_override "${FPHSA_NAME_MISMATCHED}")

+  endif ()

+

+  if(${INDEX} EQUAL -1)

+    set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG})

+    set(FPHSA_REQUIRED_VARS ${ARGN})

+    set(FPHSA_VERSION_VAR)

+  else()

+    cmake_parse_arguments(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}"  ${_FIRST_ARG} ${ARGN})

+

+    if(FPHSA_UNPARSED_ARGUMENTS)

+      message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"")

+    endif()

+

+    if(NOT FPHSA_FAIL_MESSAGE)

+      set(FPHSA_FAIL_MESSAGE  "DEFAULT_MSG")

+    endif()

+

+    # In config-mode, we rely on the variable <PackageName>_CONFIG, which is set by find_package()

+    # when it successfully found the config-file, including version checking:

+    if(FPHSA_CONFIG_MODE)

+      list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG)

+      list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS)

+      set(FPHSA_VERSION_VAR ${_NAME}_VERSION)

+    endif()

+

+    if(NOT FPHSA_REQUIRED_VARS AND NOT FPHSA_HANDLE_COMPONENTS)

+      message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()")

+    endif()

+  endif()

+

+  if (DEFINED FPHSA_NAME_MISMATCHED_override)

+    set(FPHSA_NAME_MISMATCHED "${FPHSA_NAME_MISMATCHED_override}")

+  endif ()

+

+  if (DEFINED CMAKE_FIND_PACKAGE_NAME

+      AND NOT FPHSA_NAME_MISMATCHED

+      AND NOT _NAME STREQUAL CMAKE_FIND_PACKAGE_NAME)

+    message(AUTHOR_WARNING

+      "The package name passed to `find_package_handle_standard_args` "

+      "(${_NAME}) does not match the name of the calling package "

+      "(${CMAKE_FIND_PACKAGE_NAME}). This can lead to problems in calling "

+      "code that expects `find_package` result variables (e.g., `_FOUND`) "

+      "to follow a certain pattern.")

+  endif ()

+

+  if (${_NAME}_FIND_VERSION_RANGE AND NOT FPHSA_HANDLE_VERSION_RANGE)

+    message(AUTHOR_WARNING

+      "`find_package()` specify a version range but the module ${_NAME} does "

+      "not support this capability. Only the lower endpoint of the range "

+      "will be used.")

+  endif()

+

+  # to propagate package name to FIND_PACKAGE_CHECK_VERSION

+  set(_CMAKE_FPHSA_PACKAGE_NAME "${_NAME}")

+

+  # now that we collected all arguments, process them

+

+  if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG")

+    set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}")

+  endif()

+

+  if (FPHSA_REQUIRED_VARS)

+    list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR)

+  endif()

+

+  string(TOUPPER ${_NAME} _NAME_UPPER)

+  string(TOLOWER ${_NAME} _NAME_LOWER)

+

+  if(FPHSA_FOUND_VAR)

+    set(_FOUND_VAR_UPPER ${_NAME_UPPER}_FOUND)

+    set(_FOUND_VAR_MIXED ${_NAME}_FOUND)

+    if(FPHSA_FOUND_VAR STREQUAL _FOUND_VAR_MIXED  OR  FPHSA_FOUND_VAR STREQUAL _FOUND_VAR_UPPER)

+      set(_FOUND_VAR ${FPHSA_FOUND_VAR})

+    else()

+      message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_FOUND_VAR_MIXED}\" and \"${_FOUND_VAR_UPPER}\" are valid names.")

+    endif()

+  else()

+    set(_FOUND_VAR ${_NAME_UPPER}_FOUND)

+  endif()

+

+  # collect all variables which were not found, so they can be printed, so the

+  # user knows better what went wrong (#6375)

+  set(MISSING_VARS "")

+  set(DETAILS "")

+  # check if all passed variables are valid

+  set(FPHSA_FOUND_${_NAME} TRUE)

+  foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS})

+    if(NOT ${_CURRENT_VAR})

+      set(FPHSA_FOUND_${_NAME} FALSE)

+      string(APPEND MISSING_VARS " ${_CURRENT_VAR}")

+    else()

+      string(APPEND DETAILS "[${${_CURRENT_VAR}}]")

+    endif()

+  endforeach()

+  if(FPHSA_FOUND_${_NAME})

+    set(${_NAME}_FOUND TRUE)

+    set(${_NAME_UPPER}_FOUND TRUE)

+  else()

+    set(${_NAME}_FOUND FALSE)

+    set(${_NAME_UPPER}_FOUND FALSE)

+  endif()

+

+  # component handling

+  unset(FOUND_COMPONENTS_MSG)

+  unset(MISSING_COMPONENTS_MSG)

+

+  if(FPHSA_HANDLE_COMPONENTS)

+    foreach(comp ${${_NAME}_FIND_COMPONENTS})

+      if(${_NAME}_${comp}_FOUND)

+

+        if(NOT DEFINED FOUND_COMPONENTS_MSG)

+          set(FOUND_COMPONENTS_MSG "found components:")

+        endif()

+        string(APPEND FOUND_COMPONENTS_MSG " ${comp}")

+

+      else()

+

+        if(NOT DEFINED MISSING_COMPONENTS_MSG)

+          set(MISSING_COMPONENTS_MSG "missing components:")

+        endif()

+        string(APPEND MISSING_COMPONENTS_MSG " ${comp}")

+

+        if(${_NAME}_FIND_REQUIRED_${comp})

+          set(${_NAME}_FOUND FALSE)

+          string(APPEND MISSING_VARS " ${comp}")

+        endif()

+

+      endif()

+    endforeach()

+    set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}")

+    string(APPEND DETAILS "[c${COMPONENT_MSG}]")

+  endif()

+

+  # version handling:

+  set(VERSION_MSG "")

+  set(VERSION_OK TRUE)

+

+  # check 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 (FPHSA_HANDLE_VERSION_RANGE)

+        set (FPCV_HANDLE_VERSION_RANGE HANDLE_VERSION_RANGE)

+      else()

+        set(FPCV_HANDLE_VERSION_RANGE NO_AUTHOR_WARNING_VERSION_RANGE)

+      endif()

+      find_package_check_version ("${_FOUND_VERSION}" VERSION_OK RESULT_MESSAGE_VARIABLE VERSION_MSG

+        ${FPCV_HANDLE_VERSION_RANGE})

+    else()

+      # if the package was not found, but a version was given, add that to the output:

+      if(${_NAME}_FIND_VERSION_EXACT)

+        set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")")

+      elseif (FPHSA_HANDLE_VERSION_RANGE AND ${_NAME}_FIND_VERSION_RANGE)

+        set(VERSION_MSG "(Required is version range \"${${_NAME}_FIND_VERSION_RANGE}\")")

+      else()

+        set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")")

+      endif()

+    endif()

+  else ()

+    # Check with DEFINED as the found version may be 0.

+    if(DEFINED ${FPHSA_VERSION_VAR})

+      set(VERSION_MSG "(found version \"${${FPHSA_VERSION_VAR}}\")")

+    endif()

+  endif ()

+

+  if(VERSION_OK)

+    string(APPEND DETAILS "[v${${FPHSA_VERSION_VAR}}(${${_NAME}_FIND_VERSION})]")

+  else()

+    set(${_NAME}_FOUND FALSE)

+  endif()

+

+

+  # print the result:

+  if (${_NAME}_FOUND)

+    FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}")

+  else ()

+

+    if(FPHSA_CONFIG_MODE)

+      _FPHSA_HANDLE_FAILURE_CONFIG_MODE()

+    else()

+      if(NOT VERSION_OK)

+        set(RESULT_MSG)

+        if (_FIRST_REQUIRED_VAR)

+          string (APPEND RESULT_MSG "found ${${_FIRST_REQUIRED_VAR}}")

+        endif()

+        if (COMPONENT_MSG)

+          if (RESULT_MSG)

+            string (APPEND RESULT_MSG ", ")

+          endif()

+          string (APPEND RESULT_MSG "${FOUND_COMPONENTS_MSG}")

+        endif()

+        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (${RESULT_MSG})")

+      else()

+        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing:${MISSING_VARS}) ${VERSION_MSG}")

+      endif()

+    endif()

+

+  endif ()

+

+  set(${_NAME}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE)

+  set(${_NAME_UPPER}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE)

+endfunction()

+

+

+cmake_policy(POP)

diff --git a/cmake/Kitware/modules/FindPackageMessage.cmake b/cmake/Kitware/modules/FindPackageMessage.cmake
new file mode 100644
index 00000000..e12e8ed9
--- /dev/null
+++ b/cmake/Kitware/modules/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/Kitware/modules/SelectLibraryConfigurations.cmake b/cmake/Kitware/modules/SelectLibraryConfigurations.cmake
new file mode 100644
index 00000000..50ee9fe7
--- /dev/null
+++ b/cmake/Kitware/modules/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/cmake/modules/FindICU.cmake b/cmake/modules/FindICU.cmake
deleted file mode 100644
index 460db33f..00000000
--- a/cmake/modules/FindICU.cmake
+++ /dev/null
@@ -1,132 +0,0 @@
-# Finds the International Components for Unicode (ICU) Library
-#
-#  ICU_FOUND          - True if ICU found.
-#  ICU_I18N_FOUND     - True if ICU's internationalization library found.
-#  ICU_BINARY_DIR     - Directory with the runtime binaries
-#  ICU_INCLUDE_DIR    - Directory to include to get ICU headers
-#                       Note: always include ICU headers as, e.g.,
-#                       unicode/utypes.h
-#  ICU_LIBRARY        - Library to link against for the common ICU
-#  ICU_I18N_LIBRARY   - Library to link against for ICU internationaliation
-#                       (note: in addition to ICU_LIBRARY)
-#  ICU_VERSION        - ICU version MAJOR.MINOR
-#  ICU_MAJOR_VERSION  - ICU major version
-#  ICO_MINOR_VERSION  - ICU minor version
-#
-
-set_package_properties(ICU PROPERTIES
-  DESCRIPTION "libicu (International Components for Unicode) libraries"
-  URL "http://www.icu-project.org"
-)
-
-if(WIN32)
-  file(TO_CMAKE_PATH "$ENV{PROGRAMFILES}" _program_FILES_DIR)
-endif()
-
-file(TO_NATIVE_PATH "$ENV{ICU_BASE}" icu_root)
-if(DEFINED ICU_BASE)
-  file(TO_NATIVE_PATH "${ICU_BASE}" icu_root)
-else()
-  find_package(PkgConfig QUIET)
-  pkg_check_modules(PC_LibICU QUIET icu-i18n)
-endif()
-
-# Look for the header file.
-find_path(
-  ICU_INCLUDE_DIR
-  NAMES unicode/utypes.h
-  HINTS
-  ${icu_root}/include
-  ${_program_FILES_DIR}/icu/include
-  ${PC_LibICU_INCLUDEDIR}
-  /usr/local/opt/icu4c/include
-  DOC "Include directory for the ICU library"
-)
-mark_as_advanced(ICU_INCLUDE_DIR)
-
-# Look for the library.
-find_library(
-  ICU_LIBRARY
-  NAMES icuuc cygicuuc cygicuuc32
-  HINTS
-  ${icu_root}/lib64/
-  ${icu_root}/lib/
-  ${_program_FILES_DIR}/icu/lib64/
-  ${_program_FILES_DIR}/icu/lib/
-  ${PC_LibICU_LIBDIR}
-  /usr/local/opt/icu4c/lib/
-  DOC "Libraries to link against for the common parts of ICU"
-)
-mark_as_advanced(ICU_LIBRARY)
-
-# Look for the binary path.
-find_program(
-  tmp_DIR
-  NAMES genccode uconv
-  PATHS
-  ${icu_root}/bin64/
-  ${icu_root}/bin/
-  ${_program_FILES_DIR}/icu/bin64/
-  ${_program_FILES_DIR}/icu/bin/
-  /usr/local/opt/icu4c/bin/
-)
-get_filename_component(tmp_DIR ${tmp_DIR} DIRECTORY)
-set(ICU_BINARY_DIR ${tmp_DIR} CACHE DOC STRING "Runtime binaries directory for the ICU library")
-mark_as_advanced(ICU_BINARY_DIR)
-
-# Copy the results to the output variables.
-if(ICU_INCLUDE_DIR AND ICU_LIBRARY)
-  set(ICU_FOUND 1)
-  set(ICU_LIBRARIES ${ICU_LIBRARY})
-  set(ICU_INCLUDE_DIRS ${ICU_INCLUDE_DIR})
-
-  set(ICU_VERSION 0)
-  set(ICU_MAJOR_VERSION 0)
-  set(ICU_MINOR_VERSION 0)
-  file(READ "${ICU_INCLUDE_DIR}/unicode/uvernum.h" _ICU_VERSION_CONENTS)
-  string(REGEX REPLACE ".*#define U_ICU_VERSION_MAJOR_NUM ([0-9]+).*" "\\1" ICU_MAJOR_VERSION "${_ICU_VERSION_CONENTS}")
-  string(REGEX REPLACE ".*#define U_ICU_VERSION_MINOR_NUM ([0-9]+).*" "\\1" ICU_MINOR_VERSION "${_ICU_VERSION_CONENTS}")
-
-  set(ICU_VERSION "${ICU_MAJOR_VERSION}.${ICU_MINOR_VERSION}")
-
-  # Look for the ICU internationalization libraries
-  find_library(
-    ICU_I18N_LIBRARY
-    NAMES icuin icui18n cygicuin cygicuin32
-    HINTS
-    ${icu_root}/lib/
-    ${_program_FILES_DIR}/icu/lib/
-    ${PC_LibICU_LIBDIR}
-    /usr/local/opt/icu4c/lib/
-    DOC "Libraries to link against for ICU internationalization"
-  )
-  mark_as_advanced(ICU_I18N_LIBRARY)
-  if(ICU_I18N_LIBRARY)
-    set(ICU_I18N_FOUND 1)
-    set(ICU_LIBRARIES "${ICU_LIBRARIES} ${ICU_I18N_LIBRARY}")
-  else()
-    set(ICU_I18N_FOUND 0)
-  endif()
-else()
-  set(ICU_FOUND 0)
-  set(ICU_I18N_FOUND 0)
-  set(ICU_INCLUDE_DIRS)
-  set(ICU_LIBRARIES)
-  set(ICU_VERSION)
-  set(ICU_MAJOR_VERSION)
-  set(ICU_MINOR_VERSION)
-endif()
-
-if(ICU_FOUND)
-  if(NOT ICU_FIND_QUIETLY)
-    message(STATUS "Found ICU version ${ICU_VERSION}")
-    message(STATUS "Found ICU header files in ${ICU_INCLUDE_DIRS}")
-    message(STATUS "Found ICU libraries: ${ICU_LIBRARIES}")
-  endif()
-else()
-  if(ICU_FIND_REQUIRED)
-    message(FATAL_ERROR "Could not find ICU")
-  else()
-    message(STATUS "Optional package ICU was not found")
-    endif()
-endif()
diff --git a/config.h.cmake b/config.h.cmake
index c8008692..b7e1d5c9 100644
--- a/config.h.cmake
+++ b/config.h.cmake
@@ -3,9 +3,6 @@
 /* Define if you have the ICU library. */
 #cmakedefine HAVE_LIBICU 1
 
-/* Define if you have the ICU internationalization library. */
-#cmakedefine HAVE_LIBICU_I18N 1
-
 /* Define if you have the Berkeley DB library. */
 #cmakedefine HAVE_BDB 1
 
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 8a18cf97..2ad6e639 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -30,10 +30,7 @@ else()
   )
   target_link_libraries(doesnothing ${CMAKE_THREAD_LIBS_INIT})
   if(ICU_FOUND)
-    target_link_libraries(doesnothing ${ICU_LIBRARY})
-  endif()
-  if(ICU_I18N_FOUND)
-    target_link_libraries(doesnothing ${ICU_I18N_LIBRARY})
+    target_link_libraries(doesnothing ${ICU_LIBRARIES})
   endif()
  if(BDB_FOUND)
     target_link_libraries(doesnothing ${BDB_LIBRARY})
diff --git a/src/libical/CMakeLists.txt b/src/libical/CMakeLists.txt
index fd1a7815..9d8b51ee 100644
--- a/src/libical/CMakeLists.txt
+++ b/src/libical/CMakeLists.txt
@@ -14,7 +14,7 @@ include_directories(
 )
 
 if(ICU_FOUND)
-  include_directories(${ICU_INCLUDE_DIR})
+  include_directories(${ICU_INCLUDE_DIRS})
 endif()
 
 set(PACKAGE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/share/libical")
@@ -268,10 +268,7 @@ endif()
 target_link_libraries(ical ${CMAKE_THREAD_LIBS_INIT})
 
 if(ICU_FOUND)
-  target_link_libraries(ical ${ICU_LIBRARY})
-endif()
-if(ICU_I18N_FOUND)
-  target_link_libraries(ical ${ICU_I18N_LIBRARY})
+  target_link_libraries(ical ${ICU_LIBRARIES})
 endif()
 
 if(WINCE)
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 98ebb929..dc3db6b5 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -8,7 +8,7 @@ include_directories(
 )
 
 if(ICU_FOUND)
-  include_directories(${ICU_INCLUDE_DIR})
+  include_directories(${ICU_INCLUDE_DIRS})
 endif()
 
 if(BDB_FOUND)
@@ -63,10 +63,7 @@ macro(buildme _name _srcs)
 
   target_link_libraries(${_name} ${CMAKE_THREAD_LIBS_INIT})
   if(ICU_FOUND)
-    target_link_libraries(${_name} ${ICU_LIBRARY})
-  endif()
-  if(ICU_I18N_FOUND)
-    target_link_libraries(${_name} ${ICU_I18N_LIBRARY})
+    target_link_libraries(${_name} ${ICU_LIBRARIES})
   endif()
   if(BDB_FOUND)
     target_link_libraries(${_name} ${BDB_LIBRARY})