reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-12-15 07:41:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
9e309cd4f0
CMake/Modules/FindICU.cmake

425 lines
15 KiB
CMake
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 19:01:08 +00:00
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
Help: Convert remaining modules to block-style comments
2018-10-22 14:31:08 +00:00
#[=======================================================================[.rst:
FindICU
-------
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.
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``.
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
ICU_<C>_LIBRARIES - libraries for component
ICU datafiles are reported in::
ICU_MAKEFILE_INC - Makefile.inc
ICU_PKGDATA_INC - pkgdata.inc
Note that ``<C>`` is the uppercased name of the component.
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>
ICU_INCLUDE_DIR - the directory containing the ICU headers
ICU_<C>_LIBRARY - the library for component <C>
.. 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.
#]=======================================================================]
FindICU: New module
2016-07-10 17:34:39 +00:00
# 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)
FindICU: Search for packaged data files The files Makefile.inc and pkgdata.inc are installed by ICU to <libdir>/icu and on some distributions to <libdir>/<arch>/icu. These are required by ICU tools like pkgdata, and so are needed by other package build systems at build time, in addition to the libraries and executables already searched for. Search for the files and create cache entries for them, as done for executables.
2017-06-17 22:05:53 +00:00
set(icu_data
Makefile.inc
pkgdata.inc)
FindICU: New module
2016-07-10 17:34:39 +00:00
# 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()
FindICU: Search for packaged data files The files Makefile.inc and pkgdata.inc are installed by ICU to <libdir>/icu and on some distributions to <libdir>/<arch>/icu. These are required by ICU tools like pkgdata, and so are needed by other package build systems at build time, in addition to the libraries and executables already searched for. Search for the files and create cache entries for them, as done for executables.
2017-06-17 22:05:53 +00:00
# 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()
FindICU: New module
2016-07-10 17:34:39 +00:00
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
FindICU: Search in 'sbin' directories for icu tools On Ubuntu, several binaries that FindICU.cmake searches for are installed in 'sbin' instead of 'bin' [1]. [1] https://packages.ubuntu.com/xenial/amd64/icu-devtools/filelist
2017-10-25 20:20:19 +00:00
list(APPEND icu_binary_suffixes "${_bin64}" "bin" "sbin")
FindICU: New module
2016-07-10 17:34:39 +00:00
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}" "${program}"
HINTS ${icu_roots}
PATH_SUFFIXES ${icu_binary_suffixes}
FindICU: Find 64-bit Windows builds under CMP0074 NEW behavior CMP0074 causes FindICU.cmake to always prefer the 32-bit version of ICU programs/libraries on Windows. NO_PACKAGE_ROOT_PATH reverts this behavior. Fixes: #18742
2019-01-24 19:44:18 +00:00
DOC "ICU ${program} executable"
NO_PACKAGE_ROOT_PATH
)
FindICU: New module
2016-07-10 17:34:39 +00:00
mark_as_advanced(cache_var)
set("${program_var}" "${${cache_var}}" PARENT_SCOPE)
endforeach()
# Find all ICU libraries
FindICU: Search for packaged data files The files Makefile.inc and pkgdata.inc are installed by ICU to <libdir>/icu and on some distributions to <libdir>/<arch>/icu. These are required by ICU tools like pkgdata, and so are needed by other package build systems at build time, in addition to the libraries and executables already searched for. Search for the files and create cache entries for them, as done for executables.
2017-06-17 22:05:53 +00:00
list(APPEND icu_library_suffixes "${_lib64}" "lib")
FindICU: New module
2016-07-10 17:34:39 +00:00
set(ICU_REQUIRED_LIBS_FOUND ON)
FindICU: Add support for static libraries on Windows When compiling ICU statically on Windows with Visual Studio, the library file names are prefixed with 's' [1]. [1] http://source.icu-project.org/repos/icu/trunk/icu4c/source/icudefs.mk.in `STATIC_PREFIX_WHEN_USED = s`
2017-10-25 20:21:48 +00:00
set(static_prefix )
# static icu libraries compiled with MSVC have the prefix 's'
if(MSVC)
set(static_prefix "s")
endif()
FindICU: New module
2016-07-10 17:34:39 +00:00
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 "${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()
FindICU: Add support for static libraries on Windows When compiling ICU statically on Windows with Visual Studio, the library file names are prefixed with 's' [1]. [1] http://source.icu-project.org/repos/icu/trunk/icu4c/source/icudefs.mk.in `STATIC_PREFIX_WHEN_USED = s`
2017-10-25 20:21:48 +00:00
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()
FindICU: New module
2016-07-10 17:34:39 +00:00
find_library("${component_cache_release}" ${component_libnames}
HINTS ${icu_roots}
PATH_SUFFIXES ${icu_library_suffixes}
FindICU: Find 64-bit Windows builds under CMP0074 NEW behavior CMP0074 causes FindICU.cmake to always prefer the 32-bit version of ICU programs/libraries on Windows. NO_PACKAGE_ROOT_PATH reverts this behavior. Fixes: #18742
2019-01-24 19:44:18 +00:00
DOC "ICU ${component} library (release)"
NO_PACKAGE_ROOT_PATH
)
FindICU: New module
2016-07-10 17:34:39 +00:00
find_library("${component_cache_debug}" ${component_debug_libnames}
HINTS ${icu_roots}
PATH_SUFFIXES ${icu_library_suffixes}
FindICU: Find 64-bit Windows builds under CMP0074 NEW behavior CMP0074 causes FindICU.cmake to always prefer the 32-bit version of ICU programs/libraries on Windows. NO_PACKAGE_ROOT_PATH reverts this behavior. Fixes: #18742
2019-01-24 19:44:18 +00:00
DOC "ICU ${component} library (debug)"
NO_PACKAGE_ROOT_PATH
)
FindICU: New module
2016-07-10 17:34:39 +00:00
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)
list(APPEND ICU_LIBRARY "${${component_cache}}")
endif()
mark_as_advanced("${component_found}")
set("${component_cache}" "${${component_cache}}" PARENT_SCOPE)
set("${component_found}" "${${component_found}}" PARENT_SCOPE)
if(${component_found})
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)
FindICU: Search for packaged data files The files Makefile.inc and pkgdata.inc are installed by ICU to <libdir>/icu and on some distributions to <libdir>/<arch>/icu. These are required by ICU tools like pkgdata, and so are needed by other package build systems at build time, in addition to the libraries and executables already searched for. Search for the files and create cache entries for them, as done for executables.
2017-06-17 22:05:53 +00:00
# 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}" "${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()
FindICU: New module
2016-07-10 17:34:39 +00:00
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_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()
FindICU: Add libdl to the link libraries for icu-uc
2018-11-08 16:29:27 +00:00
if(CMAKE_DL_LIBS AND _ICU_component STREQUAL "uc")
set_target_properties(${_ICU_imported_target} PROPERTIES
INTERFACE_LINK_LIBRARIES "${CMAKE_DL_LIBS}")
endif()
FindICU: New module
2016-07-10 17:34:39 +00:00
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}}")
unset(program_upcase)
unset(program_lib)
endforeach()
FindICU: Search for packaged data files The files Makefile.inc and pkgdata.inc are installed by ICU to <libdir>/icu and on some distributions to <libdir>/<arch>/icu. These are required by ICU tools like pkgdata, and so are needed by other package build systems at build time, in addition to the libraries and executables already searched for. Search for the files and create cache entries for them, as done for executables.
2017-06-17 22:05:53 +00:00
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}}")
unset(data_upcase)
unset(data_lib)
endforeach()
FindICU: New module
2016-07-10 17:34:39 +00:00
foreach(component IN LISTS ICU_FIND_COMPONENTS)
string(TOUPPER "${component}" component_upcase)
set(component_lib "ICU_${component_upcase}_LIBRARIES")
set(component_found "${component_upcase}_FOUND")
message(STATUS "${component} library found: ${${component_found}}")
message(STATUS "${component} library: ${${component_lib}}")
unset(component_upcase)
unset(component_lib)
unset(component_found)
endforeach()
message(STATUS "----------------")
endif()
unset(icu_programs)
Reference in New Issue Copy Permalink