mirror of
https://github.com/Kitware/CMake.git
synced 2026-01-01 11:22:21 -06:00
a993d12605
- Module documentation synced with other similar find modules. - Added examples section. - Extended components into a separate section. - Components listed with hlist RST directive - Added and updated versions for variables when they got introduced. - Fixed variable name from Ice_ICEBOXXX11_EXECUTABLE to Ice_ICEBOX++11_EXECUTABLE. - Fixed typo in C++ component name: s/IceGrid/IceGrid++11
901 lines
28 KiB
CMake
901 lines
28 KiB
CMake
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
# file LICENSE.rst or https://cmake.org/licensing for details.
|
|
|
|
#[=======================================================================[.rst:
|
|
FindIce
|
|
-------
|
|
|
|
.. versionadded:: 3.1
|
|
|
|
Finds the Internet Communication Engine (Ice) programs, libraries and datafiles.
|
|
Ice is an open-source remote procedure call (RPC) framework developed by ZeroC
|
|
and provides SDKs for various languages to develop network applications.
|
|
|
|
.. versionadded:: 3.4
|
|
Imported targets for components and many new ``*_EXECUTABLE`` variables.
|
|
|
|
.. versionadded:: 3.7
|
|
Debug and Release library variants are found separately.
|
|
|
|
.. versionadded:: 3.10
|
|
Ice 3.7 support, including new components, programs and the Nuget package.
|
|
|
|
Components
|
|
^^^^^^^^^^
|
|
|
|
Ice consists of several libraries and programs (executables). This find module
|
|
supports components, which can be specified using the :command:`find_package`
|
|
command, to select specific Ice libraries for use in a CMake project.
|
|
Executables provided by Ice installation are always searched automatically,
|
|
regardless of the specified components.
|
|
|
|
The list of available components depends on the Ice version in use. To
|
|
successfully find Ice, at least one component must be specified:
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Ice COMPONENTS <components>...)
|
|
|
|
Supported components include:
|
|
|
|
.. hlist::
|
|
|
|
- ``Freeze``
|
|
- ``Glacier2``
|
|
- ``Ice``
|
|
- ``IceBox``
|
|
- ``IceDB``
|
|
- ``IceDiscovery``
|
|
- ``IceGrid``
|
|
- ``IceLocatorDiscovery``
|
|
- ``IcePatch``
|
|
- ``IceSSL``
|
|
- ``IceStorm``
|
|
- ``IceUtil``
|
|
- ``IceXML``
|
|
- ``Slice``
|
|
|
|
Ice 3.7 and later also include C++11-specific components:
|
|
|
|
.. hlist::
|
|
|
|
- ``Glacier2++11``
|
|
- ``Ice++11``
|
|
- ``IceBox++11``
|
|
- ``IceDiscovery++11``
|
|
- ``IceGrid++11``
|
|
- ``IceLocatorDiscovery++11``
|
|
- ``IceSSL++11``
|
|
- ``IceStorm++11``
|
|
|
|
Imported Targets
|
|
^^^^^^^^^^^^^^^^
|
|
|
|
This module provides the following :ref:`Imported Targets`:
|
|
|
|
``Ice::<component>``
|
|
.. versionadded:: 3.4
|
|
|
|
Target encapsulating the usage requirements for the specified Ice component
|
|
(library), available if that component is found. The ``<component>`` should
|
|
be written in the same case, as listed above. For example, use
|
|
``Ice::Glacier2`` for the Ice Glacier2 library, or ``Ice::Ice++11`` for the
|
|
Ice++11 library, etc.
|
|
|
|
Result Variables
|
|
^^^^^^^^^^^^^^^^
|
|
|
|
This module defines the following variables:
|
|
|
|
``Ice_FOUND``
|
|
Boolean indicating whether the main programs, libraries and all requested
|
|
components for using Ice were found.
|
|
|
|
``Ice_VERSION``
|
|
The version of Ice release found.
|
|
|
|
``Ice_INCLUDE_DIRS``
|
|
The include directories containing headers needed to use Ice.
|
|
|
|
``Ice_LIBRARIES``
|
|
Component libraries needed to link against to use Ice.
|
|
|
|
``Ice_SLICE_DIRS``
|
|
The data directories containing interface definitions (``*.ice`` files) for
|
|
Slice (Specification Language for Ice).
|
|
|
|
Ice component libraries are stored in:
|
|
|
|
``Ice_<COMPONENT>_FOUND``
|
|
Boolean indicating whether the specified Ice component is found. The
|
|
``<COMPONENT>`` should be written in uppercase.
|
|
|
|
``Ice_<COMPONENT>_LIBRARIES``
|
|
Libraries provided by the specified Ice component. The ``<COMPONENT>`` should
|
|
be written in uppercase.
|
|
|
|
Slice programs are stored in:
|
|
|
|
``Ice_SLICE2CONFLUENCE_EXECUTABLE``
|
|
.. versionadded:: 3.14
|
|
|
|
The path to the ``slice2confluence`` executable.
|
|
|
|
``Ice_SLICE2CPP_EXECUTABLE``
|
|
The path to the ``slice2cpp`` executable.
|
|
|
|
``Ice_SLICE2CS_EXECUTABLE``
|
|
The path to the ``slice2cs`` executable.
|
|
|
|
``Ice_SLICE2FREEZEJ_EXECUTABLE``
|
|
The path to the ``slice2freezej`` executable.
|
|
|
|
``Ice_SLICE2FREEZE_EXECUTABLE``
|
|
The path to the ``slice2freeze`` executable.
|
|
|
|
``Ice_SLICE2HTML_EXECUTABLE``
|
|
The path to the ``slice2html`` executable.
|
|
|
|
``Ice_SLICE2JAVA_EXECUTABLE``
|
|
The path to the ``slice2java`` executable.
|
|
|
|
``Ice_SLICE2JS_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``slice2js`` executable.
|
|
|
|
``Ice_SLICE2MATLAB_EXECUTABLE``
|
|
.. versionadded:: 3.14
|
|
|
|
The path to the ``slice2matlab`` executable.
|
|
|
|
``Ice_SLICE2OBJC_EXECUTABLE``
|
|
.. versionadded:: 3.10
|
|
|
|
The path to the ``slice2objc`` executable.
|
|
|
|
``Ice_SLICE2PHP_EXECUTABLE``
|
|
The path to the ``slice2php`` executable.
|
|
|
|
``Ice_SLICE2PY_EXECUTABLE``
|
|
The path to the ``slice2py`` executable.
|
|
|
|
``Ice_SLICE2RB_EXECUTABLE``
|
|
The path to the ``slice2rb`` executable.
|
|
|
|
Ice programs are stored in:
|
|
|
|
``Ice_GLACIER2ROUTER_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``glacier2router`` executable.
|
|
|
|
``Ice_ICEBOX_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``icebox`` executable.
|
|
|
|
``Ice_ICEBOX++11_EXECUTABLE``
|
|
.. versionadded:: 3.10
|
|
|
|
The path to the ``icebox++11`` executable.
|
|
|
|
``Ice_ICEBOXADMIN_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``iceboxadmin`` executable.
|
|
|
|
``Ice_ICEBOXD_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``iceboxd`` executable.
|
|
|
|
``Ice_ICEBOXNET_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``iceboxnet`` executable.
|
|
|
|
``Ice_ICEBRIDGE_EXECUTABLE``
|
|
.. versionadded:: 3.10
|
|
|
|
The path to the ``icebridge`` executable.
|
|
|
|
``Ice_ICEGRIDADMIN_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``icegridadmin`` executable.
|
|
|
|
``Ice_ICEGRIDDB_EXECUTABLE``
|
|
.. versionadded:: 3.10
|
|
|
|
The path to the ``icegriddb`` executable.
|
|
|
|
``Ice_ICEGRIDNODE_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``icegridnode`` executable.
|
|
|
|
``Ice_ICEGRIDNODED_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``icegridnoded`` executable.
|
|
|
|
``Ice_ICEGRIDREGISTRY_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``icegridregistry`` executable.
|
|
|
|
``Ice_ICEGRIDREGISTRYD_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``icegridregistryd`` executable.
|
|
|
|
``Ice_ICEPATCH2CALC_EXECUTABLE``
|
|
The path to the ``icepatch2calc`` executable.
|
|
|
|
``Ice_ICEPATCH2CLIENT_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``icepatch2client`` executable.
|
|
|
|
``Ice_ICEPATCH2SERVER_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``icepatch2server`` executable.
|
|
|
|
``Ice_ICESERVICEINSTALL_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``iceserviceinstall`` executable.
|
|
|
|
``Ice_ICESTORMADMIN_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``icestormadmin`` executable.
|
|
|
|
``Ice_ICESTORMDB_EXECUTABLE``
|
|
.. versionadded:: 3.10
|
|
|
|
The path to the ``icestormdb`` executable.
|
|
|
|
``Ice_ICESTORMMIGRATE_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``icestormmigrate`` executable.
|
|
|
|
Ice database programs are stored in the following variables (on Windows, they
|
|
are included with the Ice installation; on other platforms, they are usually
|
|
available through standard Berkeley DB packages):
|
|
|
|
``Ice_DB_ARCHIVE_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_archive`` executable.
|
|
|
|
``Ice_DB_CHECKPOINT_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_checkpoint`` executable.
|
|
|
|
``Ice_DB_DEADLOCK_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_deadlock`` executable.
|
|
|
|
``Ice_DB_DUMP_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_dump`` executable.
|
|
|
|
``Ice_DB_HOTBACKUP_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_hotbackup`` executable.
|
|
|
|
``Ice_DB_LOAD_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_load`` executable.
|
|
|
|
``Ice_DB_LOG_VERIFY_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_log_verify`` executable.
|
|
|
|
``Ice_DB_PRINTLOG_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_printlog`` executable.
|
|
|
|
``Ice_DB_RECOVER_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_recover`` executable.
|
|
|
|
``Ice_DB_STAT_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_stat`` executable.
|
|
|
|
``Ice_DB_TUNER_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_tuner`` executable.
|
|
|
|
``Ice_DB_UPGRADE_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_upgrade`` executable.
|
|
|
|
``Ice_DB_VERIFY_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``db_verify`` executable.
|
|
|
|
``Ice_DUMPDB_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``dumpdb`` executable.
|
|
|
|
``Ice_TRANSFORMDB_EXECUTABLE``
|
|
.. versionadded:: 3.4
|
|
|
|
The path to the ``transformdb`` executable.
|
|
|
|
Cache Variables
|
|
^^^^^^^^^^^^^^^
|
|
|
|
The following cache variables may also be set:
|
|
|
|
``Ice_<PROGRAM>_EXECUTABLE``
|
|
The path to the specified ``<PROGRAM>`` executable; The ``<PROGRAM>`` is the
|
|
uppercase name of the Ice program as listed in above result variables of
|
|
executables.
|
|
|
|
``Ice_INCLUDE_DIR``
|
|
The directory containing Ice headers.
|
|
|
|
``Ice_SLICE_DIR``
|
|
The data directory containing interface definitions for Slice.
|
|
|
|
``Ice_<COMPONENT>_LIBRARY``
|
|
The path to the library for the specified component. The ``<COMPONENT>``
|
|
should be written in uppercase.
|
|
|
|
Hints
|
|
^^^^^
|
|
|
|
This module accepts the following variables:
|
|
|
|
``Ice_HOME``
|
|
Set this CMake variable to the root of the Ice installation in order to
|
|
search for Ice in a custom location.
|
|
|
|
.. note::
|
|
|
|
On Windows, Ice 3.7.0 and later provide libraries via the NuGet
|
|
package manager. Appropriate NuGet packages will be searched for
|
|
using :variable:`CMAKE_PREFIX_PATH`, or alternatively ``Ice_HOME`` may be
|
|
set to the location of a specific NuGet package to restrict the search.
|
|
|
|
``ICE_HOME``
|
|
Environment variable (uppercased) may also be set to the root of the Ice
|
|
installation; The ``Ice_HOME`` CMake variable takes precedence.
|
|
|
|
``Ice_DEBUG``
|
|
Set this variable to boolean true to enable debug output from this module.
|
|
|
|
.. note::
|
|
|
|
In most cases, none of the above variables need to be set unless multiple Ice
|
|
versions are installed and a specific one is required. On Windows, the most
|
|
recent version is typically found using the registry. On Unix-like systems,
|
|
programs, headers, and libraries are usually found in standard locations,
|
|
although ``Ice_SLICE_DIRS`` might not be detected automatically (commonly
|
|
known locations are searched). All other variables default based on the value
|
|
of ``Ice_HOME``, if set.
|
|
|
|
It's also possible to set ``Ice_HOME`` while selectively overriding specific
|
|
locations for individual components; This might be required, for example, in
|
|
newer versions of Visual Studio if the heuristics are not sufficient to
|
|
identify the correct programs and libraries for the specific Visual Studio
|
|
version.
|
|
|
|
Examples
|
|
^^^^^^^^
|
|
|
|
Finding the Ice core library and linking it to a project target:
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Ice COMPONENTS Ice)
|
|
target_link_libraries(project_target PRIVATE Ice::Ice)
|
|
|
|
Finding Ice core library and IceSSL library, and linking them to a project
|
|
target:
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Ice COMPONENTS Ice IceSSL)
|
|
target_link_libraries(project_target PRIVATE Ice::Ice Ice::IceSSL)
|
|
|
|
Finding Ice core library as required component and Ice Freeze library as
|
|
optional:
|
|
|
|
.. code-block:: cmake
|
|
|
|
find_package(Ice COMPONENTS Ice OPTIONAL_COMPONENTS Freeze)
|
|
#]=======================================================================]
|
|
|
|
# Written by Roger Leigh <rleigh@codelibre.net>
|
|
|
|
set(_Ice_db_programs
|
|
db_archive
|
|
db_checkpoint
|
|
db_deadlock
|
|
db_dump
|
|
db_hotbackup
|
|
db_load
|
|
db_log_verify
|
|
db_printlog
|
|
db_recover
|
|
db_stat
|
|
db_tuner
|
|
db_upgrade
|
|
db_verify
|
|
dumpdb
|
|
transformdb)
|
|
|
|
set(_Ice_programs
|
|
glacier2router
|
|
icebox
|
|
icebox++11
|
|
iceboxadmin
|
|
iceboxd
|
|
iceboxnet
|
|
icebridge
|
|
icegridadmin
|
|
icegriddb
|
|
icegridnode
|
|
icegridnoded
|
|
icegridregistry
|
|
icegridregistryd
|
|
icepatch2calc
|
|
icepatch2client
|
|
icepatch2server
|
|
iceserviceinstall
|
|
icestormadmin
|
|
icestormdb
|
|
icestormmigrate)
|
|
|
|
set(_Ice_slice_programs
|
|
slice2confluence
|
|
slice2cpp
|
|
slice2cs
|
|
slice2freezej
|
|
slice2freeze
|
|
slice2html
|
|
slice2java
|
|
slice2js
|
|
slice2matlab
|
|
slice2objc
|
|
slice2php
|
|
slice2py
|
|
slice2rb)
|
|
|
|
|
|
# The Ice checks are contained in a function due to the large number
|
|
# of temporary variables needed.
|
|
function(_Ice_FIND)
|
|
# Released versions of Ice, including generic short forms
|
|
set(ice_versions
|
|
3
|
|
3.7
|
|
3.7.0
|
|
3.6
|
|
3.6.3
|
|
3.6.2
|
|
3.6.1
|
|
3.6.0
|
|
3.5
|
|
3.5.1
|
|
3.5.0
|
|
3.4
|
|
3.4.2
|
|
3.4.1
|
|
3.4.0
|
|
3.3
|
|
3.3.1
|
|
3.3.0)
|
|
|
|
foreach(ver ${ice_versions})
|
|
string(REGEX MATCH "^([0-9]+)\\.([0-9]+)\$" two_digit_version_match "${ver}")
|
|
if(two_digit_version_match)
|
|
string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\$" "\\1\\2" two_digit_version "${ver}")
|
|
list(APPEND ice_suffix_versions "${two_digit_version}")
|
|
endif()
|
|
endforeach()
|
|
|
|
# Set up search paths, taking compiler into account. Search Ice_HOME,
|
|
# with ICE_HOME in the environment as a fallback if unset.
|
|
if(Ice_HOME)
|
|
list(APPEND ice_roots "${Ice_HOME}")
|
|
else()
|
|
if(NOT "$ENV{ICE_HOME}" STREQUAL "")
|
|
file(TO_CMAKE_PATH "$ENV{ICE_HOME}" NATIVE_PATH)
|
|
list(APPEND ice_roots "${NATIVE_PATH}")
|
|
set(Ice_HOME "${NATIVE_PATH}"
|
|
CACHE PATH "Location of the Ice installation" FORCE)
|
|
endif()
|
|
endif()
|
|
|
|
set(_bin "bin/Win32")
|
|
set(_lib "lib/Win32")
|
|
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
|
|
set(_bin "bin/x64")
|
|
set(_lib "lib/x64")
|
|
# 64-bit path suffix
|
|
set(_x64 "/x64")
|
|
# 64-bit library directory
|
|
set(_lib64 "lib64")
|
|
endif()
|
|
|
|
unset(vcvers)
|
|
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_CXX_SIMULATE_ID}" STREQUAL "MSVC")
|
|
if(MSVC_TOOLSET_VERSION GREATER_EQUAL 141)
|
|
set(vcvers "141;140")
|
|
elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 100)
|
|
set(vcvers "${MSVC_TOOLSET_VERSION}")
|
|
elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 90)
|
|
set(vcvers "${MSVC_TOOLSET_VERSION}")
|
|
set(vcyear "2008")
|
|
elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 80)
|
|
set(vcvers "${MSVC_TOOLSET_VERSION}")
|
|
set(vcyear "2005")
|
|
else() # Unknown version
|
|
set(vcvers Unknown)
|
|
endif()
|
|
endif()
|
|
|
|
# For compatibility with ZeroC Windows builds.
|
|
if(vcvers)
|
|
list(APPEND ice_binary_suffixes "build/native/${_bin}/Release" "tools")
|
|
list(APPEND ice_debug_library_suffixes "build/native/${_lib}/Debug")
|
|
list(APPEND ice_release_library_suffixes "build/native/${_lib}/Release")
|
|
foreach(vcver IN LISTS vcvers)
|
|
# Earlier Ice (3.3) builds don't use vcnnn subdirectories, but are harmless to check.
|
|
list(APPEND ice_binary_suffixes "bin/vc${vcver}${_x64}" "bin/vc${vcver}")
|
|
list(APPEND ice_debug_library_suffixes "lib/vc${vcver}${_x64}" "lib/vc${vcver}")
|
|
list(APPEND ice_release_library_suffixes "lib/vc${vcver}${_x64}" "lib/vc${vcver}")
|
|
endforeach()
|
|
endif()
|
|
# Generic 64-bit and 32-bit directories
|
|
list(APPEND ice_binary_suffixes "bin${_x64}" "bin")
|
|
list(APPEND ice_debug_library_suffixes "libx32" "${_lib64}" "lib${_x64}" "lib")
|
|
list(APPEND ice_release_library_suffixes "libx32" "${_lib64}" "lib${_x64}" "lib")
|
|
if(vcvers)
|
|
list(APPEND ice_include_suffixes "build/native/include")
|
|
endif()
|
|
list(APPEND ice_include_suffixes "include")
|
|
list(APPEND ice_slice_suffixes "slice")
|
|
|
|
# On Windows, look in the registry for install locations. Different
|
|
# versions of Ice install support different compiler versions.
|
|
if(vcvers)
|
|
foreach(ice_version ${ice_versions})
|
|
foreach(vcver IN LISTS vcvers)
|
|
list(APPEND ice_nuget_dirs "zeroc.ice.v${vcver}.${ice_version}")
|
|
list(APPEND freeze_nuget_dirs "zeroc.freeze.v${vcver}.${ice_version}")
|
|
endforeach()
|
|
endforeach()
|
|
find_path(Ice_NUGET_DIR
|
|
NAMES "tools/slice2cpp.exe"
|
|
PATH_SUFFIXES ${ice_nuget_dirs}
|
|
DOC "Ice NuGet directory")
|
|
if(Ice_NUGET_DIR)
|
|
list(APPEND ice_roots "${Ice_NUGET_DIR}")
|
|
endif()
|
|
find_path(Freeze_NUGET_DIR
|
|
NAMES "tools/slice2freeze.exe"
|
|
PATH_SUFFIXES ${freeze_nuget_dirs}
|
|
DOC "Freeze NuGet directory")
|
|
if(Freeze_NUGET_DIR)
|
|
list(APPEND ice_roots "${Freeze_NUGET_DIR}")
|
|
endif()
|
|
foreach(ice_version ${ice_versions})
|
|
# Ice 3.3 releases use a Visual Studio year suffix and value is
|
|
# enclosed in double quotes, though only the leading quote is
|
|
# returned by get_filename_component.
|
|
unset(ice_location)
|
|
if(vcyear)
|
|
get_filename_component(ice_location
|
|
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\ZeroC\\Ice ${ice_version} for Visual Studio ${vcyear};InstallDir]"
|
|
PATH)
|
|
if(ice_location AND NOT ("${ice_location}" STREQUAL "/registry" OR "${ice_location}" STREQUAL "/"))
|
|
string(REGEX REPLACE "^\"(.*)\"?$" "\\1" ice_location "${ice_location}")
|
|
get_filename_component(ice_location "${ice_location}" ABSOLUTE)
|
|
else()
|
|
unset(ice_location)
|
|
endif()
|
|
endif()
|
|
# Ice 3.4+ releases don't use a suffix
|
|
if(NOT ice_location OR "${ice_location}" STREQUAL "/registry")
|
|
get_filename_component(ice_location
|
|
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\ZeroC\\Ice ${ice_version};InstallDir]"
|
|
ABSOLUTE)
|
|
endif()
|
|
|
|
if(ice_location AND NOT "${ice_location}" STREQUAL "/registry")
|
|
list(APPEND ice_roots "${ice_location}")
|
|
endif()
|
|
endforeach()
|
|
else()
|
|
foreach(ice_version ${ice_versions})
|
|
# Prefer 64-bit variants if present (and using a 64-bit compiler)
|
|
list(APPEND ice_roots "/opt/Ice-${ice_version}")
|
|
endforeach()
|
|
endif()
|
|
|
|
# Find all Ice programs
|
|
foreach(program ${_Ice_db_programs} ${_Ice_programs} ${_Ice_slice_programs})
|
|
string(TOUPPER "${program}" program_upcase)
|
|
set(cache_var "Ice_${program_upcase}_EXECUTABLE")
|
|
set(program_var "Ice_${program_upcase}_EXECUTABLE")
|
|
find_program("${cache_var}" "${program}"
|
|
HINTS ${ice_roots}
|
|
PATH_SUFFIXES ${ice_binary_suffixes}
|
|
DOC "Ice ${program} executable")
|
|
mark_as_advanced(cache_var)
|
|
set("${program_var}" "${${cache_var}}" PARENT_SCOPE)
|
|
endforeach()
|
|
|
|
# Get version.
|
|
if(Ice_SLICE2CPP_EXECUTABLE)
|
|
# Execute in C locale for safety
|
|
set(_Ice_SAVED_LC_ALL "$ENV{LC_ALL}")
|
|
set(ENV{LC_ALL} C)
|
|
|
|
execute_process(COMMAND ${Ice_SLICE2CPP_EXECUTABLE} --version
|
|
ERROR_VARIABLE Ice_VERSION_SLICE2CPP_FULL
|
|
ERROR_STRIP_TRAILING_WHITESPACE)
|
|
|
|
# restore the previous LC_ALL
|
|
set(ENV{LC_ALL} ${_Ice_SAVED_LC_ALL})
|
|
|
|
# Make short version
|
|
string(REGEX REPLACE "^(.*)\\.[^.]*$" "\\1" Ice_VERSION_SLICE2CPP_SHORT "${Ice_VERSION_SLICE2CPP_FULL}")
|
|
set(Ice_VERSION "${Ice_VERSION_SLICE2CPP_FULL}" PARENT_SCOPE)
|
|
endif()
|
|
|
|
if(NOT Ice_FIND_QUIETLY)
|
|
message(STATUS "Ice version: ${Ice_VERSION_SLICE2CPP_FULL}")
|
|
endif()
|
|
|
|
# Find include directory
|
|
find_path(Ice_INCLUDE_DIR
|
|
NAMES "Ice/Ice.h"
|
|
HINTS ${ice_roots}
|
|
PATH_SUFFIXES ${ice_include_suffixes}
|
|
DOC "Ice include directory")
|
|
set(Ice_INCLUDE_DIR "${Ice_INCLUDE_DIR}" PARENT_SCOPE)
|
|
|
|
find_path(Freeze_INCLUDE_DIR
|
|
NAMES "Freeze/Freeze.h"
|
|
HINTS ${ice_roots}
|
|
PATH_SUFFIXES ${ice_include_suffixes}
|
|
DOC "Freeze include directory")
|
|
set(Freeze_INCLUDE_DIR "${Freeze_INCLUDE_DIR}" PARENT_SCOPE)
|
|
|
|
# In common use on Linux, MacOS X (homebrew) and FreeBSD; prefer
|
|
# version-specific dir
|
|
list(APPEND ice_slice_paths
|
|
/usr/local/share /usr/share)
|
|
list(APPEND ice_slice_suffixes
|
|
"Ice-${Ice_VERSION_SLICE2CPP_FULL}/slice"
|
|
"Ice-${Ice_VERSION_SLICE2CPP_SHORT}/slice"
|
|
"ice/slice"
|
|
Ice)
|
|
|
|
# Find slice directory
|
|
find_path(Ice_SLICE_DIR
|
|
NAMES "Ice/Connection.ice"
|
|
HINTS ${ice_roots}
|
|
${ice_slice_paths}
|
|
PATH_SUFFIXES ${ice_slice_suffixes}
|
|
NO_DEFAULT_PATH
|
|
DOC "Ice slice directory")
|
|
set(Ice_SLICE_DIR "${Ice_SLICE_DIR}" PARENT_SCOPE)
|
|
|
|
# Find all Ice libraries
|
|
set(Ice_REQUIRED_LIBS_FOUND ON)
|
|
foreach(component ${Ice_FIND_COMPONENTS})
|
|
string(TOUPPER "${component}" component_upcase)
|
|
set(component_cache "Ice_${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_library "${component}")
|
|
unset(component_library_release_names)
|
|
unset(component_library_debug_names)
|
|
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_CXX_SIMULATE_ID}" STREQUAL "MSVC")
|
|
string(REGEX MATCH ".+\\+\\+11$" component_library_cpp11 "${component_library}")
|
|
if(component_library_cpp11)
|
|
string(REGEX REPLACE "^(.+)(\\+\\+11)$" "\\1" component_library "${component_library}")
|
|
endif()
|
|
foreach(suffix_ver ${ice_suffix_versions})
|
|
set(_name "${component_library}${suffix_ver}")
|
|
if(component_library_cpp11)
|
|
string(APPEND _name "++11")
|
|
endif()
|
|
list(APPEND component_library_debug_names "${_name}d")
|
|
list(APPEND component_library_release_names "${_name}")
|
|
endforeach()
|
|
set(_name "${component_library}")
|
|
if(component_library_cpp11)
|
|
string(APPEND _name "++11")
|
|
endif()
|
|
list(APPEND component_library_debug_names "${_name}d")
|
|
list(APPEND component_library_release_names "${_name}")
|
|
else()
|
|
list(APPEND component_library_debug_names "${component_library}d")
|
|
list(APPEND component_library_release_names "${component_library}")
|
|
endif()
|
|
find_library("${component_cache_release}" ${component_library_release_names}
|
|
HINTS ${ice_roots}
|
|
PATH_SUFFIXES ${ice_release_library_suffixes}
|
|
DOC "Ice ${component} library (release)")
|
|
find_library("${component_cache_debug}" ${component_library_debug_names}
|
|
HINTS ${ice_roots}
|
|
PATH_SUFFIXES ${ice_debug_library_suffixes}
|
|
DOC "Ice ${component} library (debug)")
|
|
include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake)
|
|
select_library_configurations(Ice_${component_upcase})
|
|
mark_as_advanced("${component_cache_release}" "${component_cache_debug}")
|
|
if(${component_cache})
|
|
set("${component_found}" ON)
|
|
list(APPEND Ice_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 (Ice_FIND_REQUIRED_${component})
|
|
list(APPEND Ice_LIBS_FOUND "${component} (required)")
|
|
else()
|
|
list(APPEND Ice_LIBS_FOUND "${component} (optional)")
|
|
endif()
|
|
else()
|
|
if (Ice_FIND_REQUIRED_${component})
|
|
set(Ice_REQUIRED_LIBS_FOUND OFF)
|
|
list(APPEND Ice_LIBS_NOTFOUND "${component} (required)")
|
|
else()
|
|
list(APPEND Ice_LIBS_NOTFOUND "${component} (optional)")
|
|
endif()
|
|
endif()
|
|
endforeach()
|
|
set(_Ice_REQUIRED_LIBS_FOUND "${Ice_REQUIRED_LIBS_FOUND}" PARENT_SCOPE)
|
|
set(Ice_LIBRARY "${Ice_LIBRARY}" PARENT_SCOPE)
|
|
|
|
if(NOT Ice_FIND_QUIETLY)
|
|
if(Ice_LIBS_FOUND)
|
|
message(STATUS "Found the following Ice libraries:")
|
|
foreach(found ${Ice_LIBS_FOUND})
|
|
message(STATUS " ${found}")
|
|
endforeach()
|
|
endif()
|
|
if(Ice_LIBS_NOTFOUND)
|
|
message(STATUS "The following Ice libraries were not found:")
|
|
foreach(notfound ${Ice_LIBS_NOTFOUND})
|
|
message(STATUS " ${notfound}")
|
|
endforeach()
|
|
endif()
|
|
endif()
|
|
|
|
if(Ice_DEBUG)
|
|
message(STATUS "--------FindIce.cmake search debug--------")
|
|
message(STATUS "ICE binary path search order: ${ice_roots}")
|
|
message(STATUS "ICE binary suffixes: ${ice_binary_suffixes}")
|
|
message(STATUS "ICE include path search order: ${ice_roots}")
|
|
message(STATUS "ICE include suffixes: ${ice_include_suffixes}")
|
|
message(STATUS "ICE slice path search order: ${ice_roots} ${ice_slice_paths}")
|
|
message(STATUS "ICE slice suffixes: ${ice_slice_suffixes}")
|
|
message(STATUS "ICE library path search order: ${ice_roots}")
|
|
message(STATUS "ICE debug library suffixes: ${ice_debug_library_suffixes}")
|
|
message(STATUS "ICE release library suffixes: ${ice_release_library_suffixes}")
|
|
message(STATUS "----------------")
|
|
endif()
|
|
endfunction()
|
|
|
|
_Ice_FIND()
|
|
|
|
include(FindPackageHandleStandardArgs)
|
|
find_package_handle_standard_args(Ice
|
|
REQUIRED_VARS Ice_SLICE2CPP_EXECUTABLE
|
|
Ice_INCLUDE_DIR
|
|
Ice_SLICE_DIR
|
|
Ice_LIBRARY
|
|
_Ice_REQUIRED_LIBS_FOUND
|
|
VERSION_VAR Ice_VERSION
|
|
FAIL_MESSAGE "Failed to find all Ice components")
|
|
|
|
unset(_Ice_REQUIRED_LIBS_FOUND)
|
|
|
|
if(Ice_FOUND)
|
|
set(Ice_INCLUDE_DIRS "${Ice_INCLUDE_DIR}")
|
|
if (Freeze_INCLUDE_DIR)
|
|
list(APPEND Ice_INCLUDE_DIRS "${Freeze_INCLUDE_DIR}")
|
|
endif()
|
|
set(Ice_SLICE_DIRS "${Ice_SLICE_DIR}")
|
|
set(Ice_LIBRARIES "${Ice_LIBRARY}")
|
|
foreach(_Ice_component ${Ice_FIND_COMPONENTS})
|
|
string(TOUPPER "${_Ice_component}" _Ice_component_upcase)
|
|
set(_Ice_component_cache "Ice_${_Ice_component_upcase}_LIBRARY")
|
|
set(_Ice_component_cache_release "Ice_${_Ice_component_upcase}_LIBRARY_RELEASE")
|
|
set(_Ice_component_cache_debug "Ice_${_Ice_component_upcase}_LIBRARY_DEBUG")
|
|
set(_Ice_component_lib "Ice_${_Ice_component_upcase}_LIBRARIES")
|
|
set(_Ice_component_found "${_Ice_component_upcase}_FOUND")
|
|
set(_Ice_imported_target "Ice::${_Ice_component}")
|
|
if(${_Ice_component_found})
|
|
set("${_Ice_component_lib}" "${${_Ice_component_cache}}")
|
|
if(NOT TARGET ${_Ice_imported_target})
|
|
add_library(${_Ice_imported_target} UNKNOWN IMPORTED)
|
|
set_target_properties(${_Ice_imported_target} PROPERTIES
|
|
INTERFACE_INCLUDE_DIRECTORIES "${Ice_INCLUDE_DIRS}")
|
|
if(EXISTS "${${_Ice_component_cache}}")
|
|
set_target_properties(${_Ice_imported_target} PROPERTIES
|
|
IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
|
|
IMPORTED_LOCATION "${${_Ice_component_cache}}")
|
|
endif()
|
|
if(EXISTS "${${_Ice_component_cache_release}}")
|
|
set_property(TARGET ${_Ice_imported_target} APPEND PROPERTY
|
|
IMPORTED_CONFIGURATIONS RELEASE)
|
|
set_target_properties(${_Ice_imported_target} PROPERTIES
|
|
IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
|
|
IMPORTED_LOCATION_RELEASE "${${_Ice_component_cache_release}}")
|
|
endif()
|
|
if(EXISTS "${${_Ice_component_cache_debug}}")
|
|
set_property(TARGET ${_Ice_imported_target} APPEND PROPERTY
|
|
IMPORTED_CONFIGURATIONS DEBUG)
|
|
set_target_properties(${_Ice_imported_target} PROPERTIES
|
|
IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX"
|
|
IMPORTED_LOCATION_DEBUG "${${_Ice_component_cache_debug}}")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
unset(_Ice_component_upcase)
|
|
unset(_Ice_component_cache)
|
|
unset(_Ice_component_lib)
|
|
unset(_Ice_component_found)
|
|
unset(_Ice_imported_target)
|
|
endforeach()
|
|
endif()
|
|
|
|
if(Ice_DEBUG)
|
|
message(STATUS "--------FindIce.cmake results debug--------")
|
|
message(STATUS "Ice_VERSION number: ${Ice_VERSION}")
|
|
message(STATUS "Ice_HOME directory: ${Ice_HOME}")
|
|
message(STATUS "Ice_INCLUDE_DIR directory: ${Ice_INCLUDE_DIR}")
|
|
message(STATUS "Ice_SLICE_DIR directory: ${Ice_SLICE_DIR}")
|
|
message(STATUS "Ice_LIBRARIES: ${Ice_LIBRARIES}")
|
|
message(STATUS "Freeze_INCLUDE_DIR directory: ${Freeze_INCLUDE_DIR}")
|
|
message(STATUS "Ice_INCLUDE_DIRS directory: ${Ice_INCLUDE_DIRS}")
|
|
|
|
foreach(program ${_Ice_db_programs} ${_Ice_programs} ${_Ice_slice_programs})
|
|
string(TOUPPER "${program}" program_upcase)
|
|
message(STATUS "${program} executable: ${Ice_${program_upcase}_EXECUTABLE}")
|
|
endforeach()
|
|
|
|
foreach(component ${Ice_FIND_COMPONENTS})
|
|
string(TOUPPER "${component}" component_upcase)
|
|
set(component_lib "Ice_${component_upcase}_LIBRARIES")
|
|
set(component_found "${component_upcase}_FOUND")
|
|
message(STATUS "${component} library found: ${${component_found}}")
|
|
message(STATUS "${component} library: ${${component_lib}}")
|
|
endforeach()
|
|
message(STATUS "----------------")
|
|
endif()
|
|
|
|
unset(_Ice_db_programs)
|
|
unset(_Ice_programs)
|
|
unset(_Ice_slice_programs)
|