Query Windows Registry¶

Added in version 3.24.

The cmake_host_system_information() command offers the possibility to query the registry on the local computer. See cmake_host_system(QUERY_WINDOWS_REGISTRY) for more information.

Find Using Windows Registry¶

Changed in version 3.24.

Options HINTS and PATHS of find_file(), find_library(), find_path(), find_program(), and find_package() commands offer the possibility, on Windows platform, to query the registry.

The formal syntax, as specified using BNF notation with the regular extensions, for registry query is the following:

registry_query  ::=  '[' sep_definition? root_key


                         ((key_separator sub_key)? (value_separator value_name_)?)? ']'
sep_definition  ::=  '{' value_separator '}'
root_key        ::=  'HKLM' | 'HKEY_LOCAL_MACHINE' | 'HKCU' | 'HKEY_CURRENT_USER' |


                     'HKCR' | 'HKEY_CLASSES_ROOT' | 'HKCC' | 'HKEY_CURRENT_CONFIG' |


                     'HKU' | 'HKEY_USERS'
sub_key         ::=  element (key_separator element)*
key_separator   ::=  '/' | '\\'
value_separator ::=  element | ';'
value_name      ::=  element | '(default)'
element         ::=  character\+
character       ::=  <any character except key_separator and value_separator>

The sep_definition optional item offers the possibility to specify the string used to separate the sub_key from the value_name item. If not specified, the character ; is used. Multiple registry_query items can be specified as part of a path.

# example using default separator
find_file(... PATHS "/root/[HKLM/Stuff;InstallDir]/lib[HKLM\\\\Stuff;Architecture]")
# example using different specified separators
find_library(... HINTS "/root/[{|}HKCU/Stuff|InstallDir]/lib[{@@}HKCU\\\\Stuff@@Architecture]")

If the value_name item is not specified or has the special name (default), the content of the default value, if any, will be returned. The supported types for the value_name are:

When the registry query failed, typically because the key does not exist or the data type is not supported, the string /REGISTRY-NOTFOUND is substituted to the [] query expression.

Standard Variable Names¶

For a FindXxx.cmake module that takes the approach of setting variables (either instead of or in addition to creating imported targets), the following variable names should be used to keep things consistent between Find modules. Note that all variables start with Xxx_, which (unless otherwise noted) must match exactly the name of the FindXxx.cmake file, including upper/lowercase. This prefix on the variable names ensures that they do not conflict with variables of other Find modules. The same pattern should also be followed for any macros, functions and imported targets defined by the Find module.

The following names should not usually be used in CMakeLists.txt files. They are intended for use by Find modules to specify and cache the locations of specific files or directories. Users are typically able to set and edit these variables to control the behavior of Find modules (like entering the path to a library manually):

To prevent users being overwhelmed with settings to configure, try to keep as many options as possible out of the cache, leaving at least one option which can be used to disable use of the module, or locate a not-found library (e.g. Xxx_ROOT_DIR). For the same reason, mark most cache options as advanced. For packages which provide both debug and release binaries, it is common to create cache variables with a _LIBRARY_<CONFIG> suffix, such as Foo_LIBRARY_RELEASE and Foo_LIBRARY_DEBUG. The SelectLibraryConfigurations module can be helpful for such cases.

While these are the standard variable names, you should provide backwards compatibility for any old names that were actually in use. Make sure you comment them as deprecated, so that no-one starts using them.

A Sample Find Module¶

We will describe how to create a simple find module for a library Foo.

The top of the module should begin with a license notice, followed by a blank line, and then followed by a Bracket Comment. The comment should begin with .rst: to indicate that the rest of its content is reStructuredText-format documentation. For example:

# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
#[=======================================================================[.rst:
FindFoo
-------
Finds the Foo library.
Imported Targets
^^^^^^^^^^^^^^^^
This module provides the following imported targets, if found:
``Foo::Foo``


  The Foo library
Result Variables
^^^^^^^^^^^^^^^^
This will define the following variables:
``Foo_FOUND``


  True if the system has the Foo library.
``Foo_VERSION``


  The version of the Foo library which was found.
``Foo_INCLUDE_DIRS``


  Include directories needed to use Foo.
``Foo_LIBRARIES``


  Libraries needed to link to Foo.
Cache Variables
^^^^^^^^^^^^^^^
The following cache variables may also be set:
``Foo_INCLUDE_DIR``


  The directory containing ``foo.h``.
``Foo_LIBRARY``


  The path to the Foo library.
#]=======================================================================]

The module documentation consists of:

If the package provides any macros or functions, they should be listed in an additional section, but can be documented by additional .rst: comment blocks immediately above where those macros or functions are defined.

The find module implementation may begin below the documentation block. Now the actual libraries and so on have to be found. The code here will obviously vary from module to module (dealing with that, after all, is the point of find modules), but there tends to be a common pattern for libraries.

First, we try to use pkg-config to find the library. Note that we cannot rely on this, as it may not be available, but it provides a good starting point.

find_package(PkgConfig)
if(PKG_CONFIG_FOUND)


  pkg_check_modules(PC_Foo QUIET Foo)
endif()

This should define some variables starting PC_Foo_ that contain the information from the Foo.pc file.

Now we need to find the libraries and include files; we use the information from pkg-config to provide hints to CMake about where to look.

find_path(Foo_INCLUDE_DIR


  NAMES foo.h


  PATHS ${PC_Foo_INCLUDE_DIRS}


  PATH_SUFFIXES Foo
)
find_library(Foo_LIBRARY


  NAMES foo


  PATHS ${PC_Foo_LIBRARY_DIRS}
)

Alternatively, if the library is available with multiple configurations, you can use SelectLibraryConfigurations to automatically set the Foo_LIBRARY variable instead:

find_library(Foo_LIBRARY_RELEASE


  NAMES foo


  PATHS ${PC_Foo_LIBRARY_DIRS}/Release
)
find_library(Foo_LIBRARY_DEBUG


  NAMES foo


  PATHS ${PC_Foo_LIBRARY_DIRS}/Debug
)
include(SelectLibraryConfigurations)
select_library_configurations(Foo)

If you have a good way of getting the version (from a header file, for example), you can use that information to set Foo_VERSION (although note that find modules have traditionally used Foo_VERSION_STRING, so you may want to set both). Otherwise, attempt to use the information from pkg-config

set(Foo_VERSION ${PC_Foo_VERSION})

Now we can use FindPackageHandleStandardArgs to do most of the rest of the work for us

include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Foo


  FOUND_VAR Foo_FOUND


  REQUIRED_VARS


    Foo_LIBRARY


    Foo_INCLUDE_DIR


  VERSION_VAR Foo_VERSION
)

This will check that the REQUIRED_VARS contain values (that do not end in -NOTFOUND) and set Foo_FOUND appropriately. It will also cache those values. If Foo_VERSION is set, and a required version was passed to find_package(), it will check the requested version against the one in Foo_VERSION. It will also print messages as appropriate; note that if the package was found, it will print the contents of the first required variable to indicate where it was found.

At this point, we have to provide a way for users of the find module to link to the library or libraries that were found. There are two approaches, as discussed in the Find Modules section above. The traditional variable approach looks like

if(Foo_FOUND)


  set(Foo_LIBRARIES ${Foo_LIBRARY})


  set(Foo_INCLUDE_DIRS ${Foo_INCLUDE_DIR})


  set(Foo_DEFINITIONS ${PC_Foo_CFLAGS_OTHER})
endif()

If more than one library was found, all of them should be included in these variables (see the Standard Variable Names section for more information).

When providing imported targets, these should be namespaced (hence the Foo:: prefix); CMake will recognize that values passed to target_link_libraries() that contain :: in their name are supposed to be imported targets (rather than just library names), and will produce appropriate diagnostic messages if that target does not exist (see policy CMP0028).

if(Foo_FOUND AND NOT TARGET Foo::Foo)


  add_library(Foo::Foo UNKNOWN IMPORTED)


  set_target_properties(Foo::Foo PROPERTIES


    IMPORTED_LOCATION "${Foo_LIBRARY}"


    INTERFACE_COMPILE_OPTIONS "${PC_Foo_CFLAGS_OTHER}"


    INTERFACE_INCLUDE_DIRECTORIES "${Foo_INCLUDE_DIR}"


  )
endif()

One thing to note about this is that the INTERFACE_INCLUDE_DIRECTORIES and similar properties should only contain information about the target itself, and not any of its dependencies. Instead, those dependencies should also be targets, and CMake should be told that they are dependencies of this target. CMake will then combine all the necessary information automatically.

The type of the IMPORTED target created in the add_library() command can always be specified as UNKNOWN type. This simplifies the code in cases where static or shared variants may be found, and CMake will determine the type by inspecting the files.

If the library is available with multiple configurations, the IMPORTED_CONFIGURATIONS target property should also be populated:

if(Foo_FOUND)


  if (NOT TARGET Foo::Foo)


    add_library(Foo::Foo UNKNOWN IMPORTED)


  endif()


  if (Foo_LIBRARY_RELEASE)


    set_property(TARGET Foo::Foo APPEND PROPERTY


      IMPORTED_CONFIGURATIONS RELEASE


    )


    set_target_properties(Foo::Foo PROPERTIES


      IMPORTED_LOCATION_RELEASE "${Foo_LIBRARY_RELEASE}"


    )


  endif()


  if (Foo_LIBRARY_DEBUG)


    set_property(TARGET Foo::Foo APPEND PROPERTY


      IMPORTED_CONFIGURATIONS DEBUG


    )


    set_target_properties(Foo::Foo PROPERTIES


      IMPORTED_LOCATION_DEBUG "${Foo_LIBRARY_DEBUG}"


    )


  endif()


  set_target_properties(Foo::Foo PROPERTIES


    INTERFACE_COMPILE_OPTIONS "${PC_Foo_CFLAGS_OTHER}"


    INTERFACE_INCLUDE_DIRECTORIES "${Foo_INCLUDE_DIR}"


  )
endif()

The RELEASE variant should be listed first in the property so that the variant is chosen if the user uses a configuration which is not an exact match for any listed IMPORTED_CONFIGURATIONS.

Most of the cache variables should be hidden in the ccmake interface unless the user explicitly asks to edit them.

mark_as_advanced(


  Foo_INCLUDE_DIR


  Foo_LIBRARY
)

If this module replaces an older version, you should set compatibility variables to cause the least disruption possible.

# compatibility variables
set(Foo_VERSION_STRING ${Foo_VERSION})