Add files using upload-large-folder tool

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX.txt

@@ -0,0 +1,253 @@
+A short-hand signature is:
+
+.. parsed-literal::
+
+   |FIND_XXX| (<VAR> name1 [path1 path2 ...])
+
+The general signature is:
+
+.. parsed-literal::
+
+   |FIND_XXX| (
+             <VAR>
+             name | |NAMES|
+             [HINTS [path | ENV var]... ]
+             [PATHS [path | ENV var]... ]
+             [REGISTRY_VIEW (64|32|64_32|32_64|HOST|TARGET|BOTH)]
+             [PATH_SUFFIXES suffix1 [suffix2 ...]]
+             [VALIDATOR function]
+             [DOC "cache documentation string"]
+             [NO_CACHE]
+             [REQUIRED]
+             [NO_DEFAULT_PATH]
+             [NO_PACKAGE_ROOT_PATH]
+             [NO_CMAKE_PATH]
+             [NO_CMAKE_ENVIRONMENT_PATH]
+             [NO_SYSTEM_ENVIRONMENT_PATH]
+             [NO_CMAKE_SYSTEM_PATH]
+             [NO_CMAKE_INSTALL_PREFIX]
+             [CMAKE_FIND_ROOT_PATH_BOTH |
+              ONLY_CMAKE_FIND_ROOT_PATH |
+              NO_CMAKE_FIND_ROOT_PATH]
+            )
+
+This command is used to find a |SEARCH_XXX_DESC|.
+A cache entry, or a normal variable if ``NO_CACHE`` is specified,
+named by ``<VAR>`` is created to store the result of this command.
+If the |SEARCH_XXX| is found the result is stored in the variable
+and the search will not be repeated unless the variable is cleared.
+If nothing is found, the result will be ``<VAR>-NOTFOUND``.
+
+Options include:
+
+``NAMES``
+  Specify one or more possible names for the |SEARCH_XXX|.
+
+  When using this to specify names with and without a version
+  suffix, we recommend specifying the unversioned name first
+  so that locally-built packages can be found before those
+  provided by distributions.
+
+``HINTS``, ``PATHS``
+  Specify directories to search in addition to the default locations.
+  The ``ENV var`` sub-option reads paths from a system environment
+  variable.
+
+  .. versionchanged:: 3.24
+    On ``Windows`` platform, it is possible to include registry queries as part
+    of the directories, using a :ref:`dedicated syntax <Find Using Windows Registry>`.
+    Such specifications will be ignored on all other platforms.
+
+``REGISTRY_VIEW``
+  .. versionadded:: 3.24
+
+  .. include:: FIND_XXX_REGISTRY_VIEW.txt
+
+``PATH_SUFFIXES``
+  Specify additional subdirectories to check below each directory
+  location otherwise considered.
+
+``VALIDATOR``
+  .. versionadded:: 3.25
+
+  Specify a :command:`function` to be called for each candidate item found
+  (a :command:`macro` cannot be provided, that will result in an error).
+  Two arguments will be passed to the validator function: the name of a
+  result variable, and the absolute path to the candidate item.  The item
+  will be accepted and the search will end unless the function sets the
+  value in the result variable to false in the calling scope.  The result
+  variable will hold a true value when the validator function is entered.
+
+  .. parsed-literal::
+
+     function(my_check validator_result_var item)
+       if(NOT item MATCHES ...)
+         set(${validator_result_var} FALSE PARENT_SCOPE)
+       endif()
+     endfunction()
+
+     |FIND_XXX| (result NAMES ... VALIDATOR my_check)
+
+  Note that if a cached result is used, the search is skipped and any
+  ``VALIDATOR`` is ignored.  The cached result is not required to pass the
+  validation function.
+
+``DOC``
+  Specify the documentation string for the ``<VAR>`` cache entry.
+
+``NO_CACHE``
+  .. versionadded:: 3.21
+
+  The result of the search will be stored in a normal variable rather than
+  a cache entry.
+
+  .. note::
+
+    If the variable is already set before the call (as a normal or cache
+    variable) then the search will not occur.
+
+  .. warning::
+
+    This option should be used with caution because it can greatly increase
+    the cost of repeated configure steps.
+
+``REQUIRED``
+  .. versionadded:: 3.18
+
+  Stop processing with an error message if nothing is found, otherwise
+  the search will be attempted again the next time |FIND_XXX| is invoked
+  with the same variable.
+
+If ``NO_DEFAULT_PATH`` is specified, then no additional paths are
+added to the search.
+If ``NO_DEFAULT_PATH`` is not specified, the search process is as follows:
+
+.. |FIND_PACKAGE_ROOT_PREFIX_PATH_XXX_SUBDIR| replace::
+   |prefix_XXX_SUBDIR| for each ``<prefix>`` in the
+   :variable:`<PackageName>_ROOT` CMake variable and the
+   :envvar:`<PackageName>_ROOT` environment variable if
+   called from within a find module loaded by
+   :command:`find_package(<PackageName>)`
+
+.. |CMAKE_PREFIX_PATH_XXX_SUBDIR| replace::
+   |prefix_XXX_SUBDIR| for each ``<prefix>`` in :variable:`CMAKE_PREFIX_PATH`
+
+.. |ENV_CMAKE_PREFIX_PATH_XXX_SUBDIR| replace::
+   |prefix_XXX_SUBDIR| for each ``<prefix>`` in :envvar:`CMAKE_PREFIX_PATH`
+
+.. |SYSTEM_ENVIRONMENT_PREFIX_PATH_XXX_SUBDIR| replace::
+   |prefix_XXX_SUBDIR| for each ``<prefix>/[s]bin`` in ``PATH``, and
+   |entry_XXX_SUBDIR| for other entries in ``PATH``
+
+.. |CMAKE_SYSTEM_PREFIX_PATH_XXX_SUBDIR| replace::
+   |prefix_XXX_SUBDIR| for each ``<prefix>`` in
+   :variable:`CMAKE_SYSTEM_PREFIX_PATH`
+
+1. If called from within a find module or any other script loaded by a call to
+   :command:`find_package(<PackageName>)`, search prefixes unique to the
+   current package being found.  See policy :policy:`CMP0074`.
+
+   .. versionadded:: 3.12
+
+   Specifically, search paths specified by the following variables, in order:
+
+   a. :variable:`<PackageName>_ROOT` CMake variable,
+      where ``<PackageName>`` is the case-preserved package name.
+
+   b. :variable:`<PACKAGENAME>_ROOT` CMake variable,
+      where ``<PACKAGENAME>`` is the upper-cased package name.
+      See policy :policy:`CMP0144`.
+
+      .. versionadded:: 3.27
+
+   c. :envvar:`<PackageName>_ROOT` environment variable,
+      where ``<PackageName>`` is the case-preserved package name.
+
+   d. :envvar:`<PACKAGENAME>_ROOT` environment variable,
+      where ``<PACKAGENAME>`` is the upper-cased package name.
+      See policy :policy:`CMP0144`.
+
+      .. versionadded:: 3.27
+
+   The package root variables are maintained as a stack, so if called from
+   nested find modules or config packages, root paths from the parent's find
+   module or config package will be searched after paths from the current
+   module or package.  In other words, the search order would be
+   ``<CurrentPackage>_ROOT``, ``ENV{<CurrentPackage>_ROOT}``,
+   ``<ParentPackage>_ROOT``, ``ENV{<ParentPackage>_ROOT}``, etc.
+   This can be skipped if ``NO_PACKAGE_ROOT_PATH`` is passed or by setting
+   the :variable:`CMAKE_FIND_USE_PACKAGE_ROOT_PATH` to ``FALSE``.
+
+   * |FIND_PACKAGE_ROOT_PREFIX_PATH_XXX|
+
+2. Search paths specified in cmake-specific cache variables.
+   These are intended to be used on the command line with a ``-DVAR=value``.
+   The values are interpreted as :ref:`semicolon-separated lists <CMake Language Lists>`.
+   This can be skipped if ``NO_CMAKE_PATH`` is passed or by setting the
+   :variable:`CMAKE_FIND_USE_CMAKE_PATH` to ``FALSE``.
+
+   * |CMAKE_PREFIX_PATH_XXX|
+   * |CMAKE_XXX_PATH|
+   * |CMAKE_XXX_MAC_PATH|
+
+3. Search paths specified in cmake-specific environment variables.
+   These are intended to be set in the user's shell configuration,
+   and therefore use the host's native path separator
+   (``;`` on Windows and ``:`` on UNIX).
+   This can be skipped if ``NO_CMAKE_ENVIRONMENT_PATH`` is passed or
+   by setting the :variable:`CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH` to ``FALSE``.
+
+   * |ENV_CMAKE_PREFIX_PATH_XXX|
+   * |ENV_CMAKE_XXX_PATH|
+   * |ENV_CMAKE_XXX_MAC_PATH|
+
+4. Search the paths specified by the ``HINTS`` option.
+   These should be paths computed by system introspection, such as a
+   hint provided by the location of another item already found.
+   Hard-coded guesses should be specified with the ``PATHS`` option.
+
+5. Search the standard system environment variables.
+   This can be skipped if ``NO_SYSTEM_ENVIRONMENT_PATH`` is passed or by
+   setting the :variable:`CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH` to ``FALSE``.
+
+   * |SYSTEM_ENVIRONMENT_PATH_XXX|
+
+   |SYSTEM_ENVIRONMENT_PATH_WINDOWS_XXX|
+
+6. Search cmake variables defined in the Platform files
+   for the current system.  The searching of ``CMAKE_INSTALL_PREFIX`` and
+   ``CMAKE_STAGING_PREFIX`` can be
+   skipped if ``NO_CMAKE_INSTALL_PREFIX`` is passed or by setting the
+   :variable:`CMAKE_FIND_USE_INSTALL_PREFIX` to ``FALSE``. All these locations
+   can be skipped if ``NO_CMAKE_SYSTEM_PATH`` is passed or by setting the
+   :variable:`CMAKE_FIND_USE_CMAKE_SYSTEM_PATH` to ``FALSE``.
+
+   * |CMAKE_SYSTEM_PREFIX_PATH_XXX|
+   * |CMAKE_SYSTEM_XXX_PATH|
+   * |CMAKE_SYSTEM_XXX_MAC_PATH|
+
+   The platform paths that these variables contain are locations that
+   typically include installed software. An example being ``/usr/local`` for
+   UNIX based platforms.
+
+7. Search the paths specified by the PATHS option
+   or in the short-hand version of the command.
+   These are typically hard-coded guesses.
+
+The :variable:`CMAKE_IGNORE_PATH`, :variable:`CMAKE_IGNORE_PREFIX_PATH`,
+:variable:`CMAKE_SYSTEM_IGNORE_PATH` and
+:variable:`CMAKE_SYSTEM_IGNORE_PREFIX_PATH` variables can also cause some
+of the above locations to be ignored.
+
+.. versionadded:: 3.16
+  Added ``CMAKE_FIND_USE_<CATEGORY>_PATH`` variables to globally disable
+  various search locations.
+
+.. |FIND_ARGS_XXX| replace:: <VAR> NAMES name
+
+On macOS the :variable:`CMAKE_FIND_FRAMEWORK` and
+:variable:`CMAKE_FIND_APPBUNDLE` variables determine the order of
+preference between Apple-style and unix-style package components.
+
+.. include:: FIND_XXX_ROOT.txt
+.. include:: FIND_XXX_ORDER.txt

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX_ORDER.txt

@@ -0,0 +1,12 @@
+The default search order is designed to be most-specific to
+least-specific for common use cases.
+Projects may override the order by simply calling the command
+multiple times and using the ``NO_*`` options:
+
+.. parsed-literal::
+
+   |FIND_XXX| (|FIND_ARGS_XXX| PATHS paths... NO_DEFAULT_PATH)
+   |FIND_XXX| (|FIND_ARGS_XXX|)
+
+Once one of the calls succeeds the result variable will be set
+and stored in the cache so that no call will search again.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/SUPPORTED_LANGUAGES.txt

@@ -0,0 +1,25 @@
+
+Supported languages are ``C``, ``CXX`` (i.e.  C++), ``CSharp`` (i.e.  C#), ``CUDA``,
+``OBJC`` (i.e. Objective-C), ``OBJCXX`` (i.e. Objective-C++), ``Fortran``, ``HIP``,
+``ISPC``, ``Swift``, ``ASM``, ``ASM_NASM``, ``ASM_MARMASM``, ``ASM_MASM``, and ``ASM-ATT``.
+
+  .. versionadded:: 3.8
+    Added ``CSharp`` and ``CUDA`` support.
+
+  .. versionadded:: 3.15
+    Added ``Swift`` support.
+
+  .. versionadded:: 3.16
+    Added ``OBJC`` and ``OBJCXX`` support.
+
+  .. versionadded:: 3.18
+    Added ``ISPC`` support.
+
+  .. versionadded:: 3.21
+    Added ``HIP`` support.
+
+  .. versionadded:: 3.26
+    Added ``ASM_MARMASM`` support.
+
+If enabling ``ASM``, list it last so that CMake can check whether
+compilers for other languages like ``C`` work for assembly too.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_compile_definitions.rst

@@ -0,0 +1,33 @@
+add_compile_definitions
+-----------------------
+
+.. versionadded:: 3.12
+
+Add preprocessor definitions to the compilation of source files.
+
+.. code-block:: cmake
+
+  add_compile_definitions(<definition> ...)
+
+Adds preprocessor definitions to the compiler command line.
+
+The preprocessor definitions are added to the :prop_dir:`COMPILE_DEFINITIONS`
+directory property for the current ``CMakeLists`` file. They are also added to
+the :prop_tgt:`COMPILE_DEFINITIONS` target property for each target in the
+current ``CMakeLists`` file.
+
+Definitions are specified using the syntax ``VAR`` or ``VAR=value``.
+Function-style definitions are not supported. CMake will automatically
+escape the value correctly for the native build system (note that CMake
+language syntax may require escapes to specify some values).
+
+.. versionadded:: 3.26
+  Any leading ``-D`` on an item will be removed.
+
+.. |command_name| replace:: ``add_compile_definitions``
+.. include:: GENEX_NOTE.txt
+
+See Also
+^^^^^^^^
+
+* The command :command:`target_compile_definitions` adds target-specific definitions.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_custom_command.rst

@@ -0,0 +1,699 @@
+add_custom_command
+------------------
+
+Add a custom build rule to the generated build system.
+
+There are two main signatures for ``add_custom_command``.
+
+.. _`add_custom_command(OUTPUT)`:
+
+Generating Files
+^^^^^^^^^^^^^^^^
+
+The first signature is for adding a custom command to produce an output:
+
+.. code-block:: cmake
+
+  add_custom_command(OUTPUT output1 [output2 ...]
+                     COMMAND command1 [ARGS] [args1...]
+                     [COMMAND command2 [ARGS] [args2...] ...]
+                     [MAIN_DEPENDENCY depend]
+                     [DEPENDS [depends...]]
+                     [BYPRODUCTS [files...]]
+                     [IMPLICIT_DEPENDS <lang1> depend1
+                                      [<lang2> depend2] ...]
+                     [WORKING_DIRECTORY dir]
+                     [COMMENT comment]
+                     [DEPFILE depfile]
+                     [JOB_POOL job_pool]
+                     [JOB_SERVER_AWARE <bool>]
+                     [VERBATIM] [APPEND] [USES_TERMINAL]
+                     [CODEGEN]
+                     [COMMAND_EXPAND_LISTS]
+                     [DEPENDS_EXPLICIT_ONLY])
+
+This defines a command to generate specified ``OUTPUT`` file(s).
+A target created in the same directory (``CMakeLists.txt`` file)
+that specifies any output of the custom command as a source file
+is given a rule to generate the file using the command at build time.
+
+Do not list the output in more than one independent target that
+may build in parallel or the instances of the rule may conflict.
+Instead, use the :command:`add_custom_target` command to drive the
+command and make the other targets depend on that one.  See the
+`Example: Generating Files for Multiple Targets`_ below.
+
+The options are:
+
+``APPEND``
+  Append the ``COMMAND`` and ``DEPENDS`` option values to the custom
+  command for the first output specified.  There must have already
+  been a previous call to this command with the same output.
+
+  If the previous call specified the output via a generator expression,
+  the output specified by the current call must match in at least one
+  configuration after evaluating generator expressions.  In this case,
+  the appended commands and dependencies apply to all configurations.
+
+  The ``COMMENT``, ``MAIN_DEPENDENCY``, and ``WORKING_DIRECTORY``
+  options are currently ignored when ``APPEND`` is given, but may be
+  used in the future.
+
+``BYPRODUCTS``
+  .. versionadded:: 3.2
+
+  Specify the files the command is expected to produce but whose
+  modification time may or may not be newer than the dependencies.
+  If a byproduct name is a relative path it will be interpreted
+  relative to the build tree directory corresponding to the
+  current source directory.
+  Each byproduct file will be marked with the :prop_sf:`GENERATED`
+  source file property automatically.
+
+  *See policy* :policy:`CMP0058` *for the motivation behind this feature.*
+
+  Explicit specification of byproducts is supported by the
+  :generator:`Ninja` generator to tell the ``ninja`` build tool
+  how to regenerate byproducts when they are missing.  It is
+  also useful when other build rules (e.g. custom commands)
+  depend on the byproducts.  Ninja requires a build rule for any
+  generated file on which another rule depends even if there are
+  order-only dependencies to ensure the byproducts will be
+  available before their dependents build.
+
+  The :ref:`Makefile Generators` will remove ``BYPRODUCTS`` and other
+  :prop_sf:`GENERATED` files during ``make clean``.
+
+  This keyword cannot be used with ``APPEND`` (see policy :policy:`CMP0175`).
+  All byproducts must be set in the first call to
+  ``add_custom_command(OUTPUT...)`` for the output files.
+
+  .. versionadded:: 3.20
+    Arguments to ``BYPRODUCTS`` may use a restricted set of
+    :manual:`generator expressions <cmake-generator-expressions(7)>`.
+    :ref:`Target-dependent expressions <Target-Dependent Expressions>`
+    are not permitted.
+
+  .. versionchanged:: 3.28
+    In targets using :ref:`file sets`, custom command byproducts are now
+    considered private unless they are listed in a non-private file set.
+    See policy :policy:`CMP0154`.
+
+``COMMAND``
+  Specify the command-line(s) to execute at build time.
+  At least one ``COMMAND`` would normally be given, but certain patterns
+  may omit it, such as adding commands in separate calls using `APPEND`.
+
+  If more than one ``COMMAND`` is specified, they will be executed in order,
+  but *not* necessarily composed into a stateful shell or batch script.
+  To run a full script, use the :command:`configure_file` command or the
+  :command:`file(GENERATE)` command to create it, and then specify
+  a ``COMMAND`` to launch it.
+
+  The optional ``ARGS`` argument is for backward compatibility and
+  will be ignored.
+
+  If ``COMMAND`` specifies an executable target name (created by the
+  :command:`add_executable` command), it will automatically be replaced
+  by the location of the executable created at build time if either of
+  the following is true:
+
+  * The target is not being cross-compiled (i.e. the
+    :variable:`CMAKE_CROSSCOMPILING` variable is not set to true).
+  * .. versionadded:: 3.6
+      The target is being cross-compiled and an emulator is provided (i.e.
+      its :prop_tgt:`CROSSCOMPILING_EMULATOR` target property is set).
+      In this case, the contents of :prop_tgt:`CROSSCOMPILING_EMULATOR` will be
+      prepended to the command before the location of the target executable.
+
+  If neither of the above conditions are met, it is assumed that the
+  command name is a program to be found on the ``PATH`` at build time.
+
+  Arguments to ``COMMAND`` may use
+  :manual:`generator expressions <cmake-generator-expressions(7)>`.
+  Use the :genex:`TARGET_FILE` generator expression to refer to the location
+  of a target later in the command line (i.e. as a command argument rather
+  than as the command to execute).
+
+  Whenever one of the following target based generator expressions are used as
+  a command to execute or is mentioned in a command argument, a target-level
+  dependency will be added automatically so that the mentioned target will be
+  built before any target using this custom command
+  (see policy :policy:`CMP0112`).
+
+    * ``TARGET_FILE``
+    * ``TARGET_LINKER_FILE``
+    * ``TARGET_SONAME_FILE``
+    * ``TARGET_PDB_FILE``
+
+  This target-level dependency does NOT add a file-level dependency that would
+  cause the custom command to re-run whenever the executable is recompiled.
+  List target names with the ``DEPENDS`` option to add such file-level
+  dependencies.
+
+
+``COMMENT``
+  Display the given message before the commands are executed at
+  build time.  This will be ignored if ``APPEND`` is given, although a future
+  version may use it.
+
+  .. versionadded:: 3.26
+    Arguments to ``COMMENT`` may use
+    :manual:`generator expressions <cmake-generator-expressions(7)>`.
+
+``DEPENDS``
+  Specify files on which the command depends.  Each argument is converted
+  to a dependency as follows:
+
+  1. If the argument is the name of a target (created by the
+     :command:`add_custom_target`, :command:`add_executable`, or
+     :command:`add_library` command) a target-level dependency is
+     created to make sure the target is built before any target
+     using this custom command.  Additionally, if the target is an
+     executable or library, a file-level dependency is created to
+     cause the custom command to re-run whenever the target is
+     recompiled.
+
+  2. If the argument is an absolute path, a file-level dependency
+     is created on that path.
+
+  3. If the argument is the name of a source file that has been
+     added to a target or on which a source file property has been set,
+     a file-level dependency is created on that source file.
+
+  4. If the argument is a relative path and it exists in the current
+     source directory, a file-level dependency is created on that
+     file in the current source directory.
+
+  5. Otherwise, a file-level dependency is created on that path relative
+     to the current binary directory.
+
+  If any dependency is an ``OUTPUT`` of another custom command in the same
+  directory (``CMakeLists.txt`` file), CMake automatically brings the other
+  custom command into the target in which this command is built.
+
+  .. versionadded:: 3.16
+    A target-level dependency is added if any dependency is listed as
+    ``BYPRODUCTS`` of a target or any of its build events in the same
+    directory to ensure the byproducts will be available.
+
+  If ``DEPENDS`` is not specified, the command will run whenever
+  the ``OUTPUT`` is missing; if the command does not actually
+  create the ``OUTPUT``, the rule will always run.
+
+  .. versionadded:: 3.1
+    Arguments to ``DEPENDS`` may use
+    :manual:`generator expressions <cmake-generator-expressions(7)>`.
+
+``COMMAND_EXPAND_LISTS``
+  .. versionadded:: 3.8
+
+  Lists in ``COMMAND`` arguments will be expanded, including those
+  created with
+  :manual:`generator expressions <cmake-generator-expressions(7)>`,
+  allowing ``COMMAND`` arguments such as
+  ``${CC} "-I$<JOIN:$<TARGET_PROPERTY:foo,INCLUDE_DIRECTORIES>,;-I>" foo.cc``
+  to be properly expanded.
+
+  This keyword cannot be used with ``APPEND`` (see policy :policy:`CMP0175`).
+  If the appended commands need this option to be set, it must be set on the
+  first call to ``add_custom_command(OUTPUT...)`` for the output files.
+
+``CODEGEN``
+  .. versionadded:: 3.31
+
+  Adds the custom command to a global ``codegen`` target that can be
+  used to execute the custom command while avoiding the majority of the
+  build graph.
+
+  This option is supported only by :ref:`Ninja Generators` and
+  :ref:`Makefile Generators`, and is ignored by other generators.
+  Furthermore, this option is allowed only if policy :policy:`CMP0171`
+  is set to ``NEW``.
+
+  This keyword cannot be used with ``APPEND`` (see policy :policy:`CMP0175`).
+  It can only be set on the first call to ``add_custom_command(OUTPUT...)``
+  for the output files.
+
+``IMPLICIT_DEPENDS``
+  Request scanning of implicit dependencies of an input file.
+  The language given specifies the programming language whose
+  corresponding dependency scanner should be used.
+  Currently only ``C`` and ``CXX`` language scanners are supported.
+  The language has to be specified for every file in the
+  ``IMPLICIT_DEPENDS`` list.  Dependencies discovered from the
+  scanning are added to those of the custom command at build time.
+  Note that the ``IMPLICIT_DEPENDS`` option is currently supported
+  only for Makefile generators and will be ignored by other generators.
+
+  .. note::
+
+    This option cannot be specified at the same time as ``DEPFILE`` option.
+
+``JOB_POOL``
+  .. versionadded:: 3.15
+
+  Specify a :prop_gbl:`pool <JOB_POOLS>` for the :generator:`Ninja`
+  generator. Incompatible with ``USES_TERMINAL``, which implies
+  the ``console`` pool.
+  Using a pool that is not defined by :prop_gbl:`JOB_POOLS` causes
+  an error by ninja at build time.
+
+  This keyword cannot be used with ``APPEND`` (see policy :policy:`CMP0175`).
+  Job pools can only be specified in the first call to
+  ``add_custom_command(OUTPUT...)`` for the output files.
+
+``JOB_SERVER_AWARE``
+  .. versionadded:: 3.28
+
+  Specify that the command is GNU Make job server aware.
+
+  For the :generator:`Unix Makefiles`, :generator:`MSYS Makefiles`, and
+  :generator:`MinGW Makefiles` generators this will add the ``+`` prefix to the
+  recipe line. See the `GNU Make Documentation`_ for more information.
+
+  This option is silently ignored by other generators.
+
+  This keyword cannot be used with ``APPEND`` (see policy :policy:`CMP0175`).
+  Job server awareness can only be specified in the first call to
+  ``add_custom_command(OUTPUT...)`` for the output files.
+
+.. _`GNU Make Documentation`: https://www.gnu.org/software/make/manual/html_node/MAKE-Variable.html
+
+``MAIN_DEPENDENCY``
+  Specify the primary input source file to the command.  This is
+  treated just like any value given to the ``DEPENDS`` option
+  but also suggests to Visual Studio generators where to hang
+  the custom command. Each source file may have at most one command
+  specifying it as its main dependency. A compile command (i.e. for a
+  library or an executable) counts as an implicit main dependency which
+  gets silently overwritten by a custom command specification.
+
+  This option is currently ignored if ``APPEND`` is given, but a future
+  version may use it.
+
+``OUTPUT``
+  Specify the output files the command is expected to produce.
+  Each output file will be marked with the :prop_sf:`GENERATED`
+  source file property automatically.
+  If the output of the custom command is not actually created
+  as a file on disk it should be marked with the :prop_sf:`SYMBOLIC`
+  source file property.
+
+  If an output file name is a relative path, its absolute path is
+  determined by interpreting it relative to:
+
+  1. the build directory corresponding to the current source directory
+     (:variable:`CMAKE_CURRENT_BINARY_DIR`), or
+
+  2. the current source directory (:variable:`CMAKE_CURRENT_SOURCE_DIR`).
+
+  The path in the build directory is preferred unless the path in the
+  source tree is mentioned as an absolute source file path elsewhere
+  in the current directory.
+
+  The output file path may not contain ``<`` or ``>`` characters.
+
+  .. versionadded:: 3.20
+    Arguments to ``OUTPUT`` may use a restricted set of
+    :manual:`generator expressions <cmake-generator-expressions(7)>`.
+    :ref:`Target-dependent expressions <Target-Dependent Expressions>`
+    are not permitted.
+
+  .. versionchanged:: 3.28
+    In targets using :ref:`file sets`, custom command outputs are now
+    considered private unless they are listed in a non-private file set.
+    See policy :policy:`CMP0154`.
+
+  .. versionchanged:: 3.30
+    The output file path may now use ``#`` characters, except
+    when using the :generator:`Borland Makefiles` generator.
+
+``USES_TERMINAL``
+  .. versionadded:: 3.2
+
+  The command will be given direct access to the terminal if possible.
+  With the :generator:`Ninja` generator, this places the command in
+  the ``console`` :prop_gbl:`pool <JOB_POOLS>`.
+
+  This keyword cannot be used with ``APPEND`` (see policy :policy:`CMP0175`).
+  If the appended commands need access to the terminal, it must be set on
+  the first call to ``add_custom_command(OUTPUT...)`` for the output files.
+
+``VERBATIM``
+  All arguments to the commands will be escaped properly for the
+  build tool so that the invoked command receives each argument
+  unchanged.  Note that one level of escapes is still used by the
+  CMake language processor before add_custom_command even sees the
+  arguments.  Use of ``VERBATIM`` is recommended as it enables
+  correct behavior.  When ``VERBATIM`` is not given the behavior
+  is platform specific because there is no protection of
+  tool-specific special characters.
+
+  This keyword cannot be used with ``APPEND`` (see policy :policy:`CMP0175`).
+  If the appended commands need to be treated as ``VERBATIM``, it must be set
+  on the first call to ``add_custom_command(OUTPUT...)`` for the output files.
+
+``WORKING_DIRECTORY``
+  Execute the command with the given current working directory.
+  If it is a relative path, it will be interpreted relative to the
+  build tree directory corresponding to the current source directory.
+
+  This option is currently ignored if ``APPEND`` is given, but a future
+  version may use it.
+
+  .. versionadded:: 3.13
+    Arguments to ``WORKING_DIRECTORY`` may use
+    :manual:`generator expressions <cmake-generator-expressions(7)>`.
+
+``DEPFILE``
+  .. versionadded:: 3.7
+
+  Specify a depfile which holds dependencies for the custom command. It is
+  usually emitted by the custom command itself.  This keyword may only be used
+  if the generator supports it, as detailed below.
+
+  The expected format, compatible with what is generated by ``gcc`` with the
+  option ``-M``, is independent of the generator or platform.
+
+  The formal syntax, as specified using
+  `BNF <https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form>`_ notation with
+  the regular extensions, is the following:
+
+  .. raw:: latex
+
+    \begin{small}
+
+  .. productionlist:: depfile
+    depfile: `rule`*
+    rule: `targets` (':' (`separator` `dependencies`?)?)? `eol`
+    targets: `target` (`separator` `target`)* `separator`*
+    target: `pathname`
+    dependencies: `dependency` (`separator` `dependency`)* `separator`*
+    dependency: `pathname`
+    separator: (`space` | `line_continue`)+
+    line_continue: '\' `eol`
+    space: ' ' | '\t'
+    pathname: `character`+
+    character: `std_character` | `dollar` | `hash` | `whitespace`
+    std_character: <any character except '$', '#' or ' '>
+    dollar: '$$'
+    hash: '\#'
+    whitespace: '\ '
+    eol: '\r'? '\n'
+
+  .. raw:: latex
+
+    \end{small}
+
+  .. note::
+
+    As part of ``pathname``, any slash and backslash is interpreted as
+    a directory separator.
+
+  .. versionadded:: 3.7
+    The :generator:`Ninja` generator supports ``DEPFILE`` since the keyword
+    was first added.
+
+  .. versionadded:: 3.17
+    Added the :generator:`Ninja Multi-Config` generator, which included
+    support for the ``DEPFILE`` keyword.
+
+  .. versionadded:: 3.20
+    Added support for :ref:`Makefile Generators`.
+
+    .. note::
+
+      ``DEPFILE`` cannot be specified at the same time as the
+      ``IMPLICIT_DEPENDS`` option for :ref:`Makefile Generators`.
+
+  .. versionadded:: 3.21
+    Added support for :ref:`Visual Studio Generators` with VS 2012 and above,
+    and for the :generator:`Xcode` generator.  Support for
+    :manual:`generator expressions <cmake-generator-expressions(7)>` was also
+    added.
+
+  .. versionadded:: 3.29
+    The :ref:`Ninja Generators` will now incorporate the dependencies into its
+    "deps log" database if the file is not listed in ``OUTPUTS`` or
+    ``BYPRODUCTS``.
+
+  Using ``DEPFILE`` with generators other than those listed above is an error.
+
+  If the ``DEPFILE`` argument is relative, it should be relative to
+  :variable:`CMAKE_CURRENT_BINARY_DIR`, and any relative paths inside the
+  ``DEPFILE`` should also be relative to :variable:`CMAKE_CURRENT_BINARY_DIR`.
+  See policy :policy:`CMP0116`, which is always ``NEW`` for
+  :ref:`Makefile Generators`, :ref:`Visual Studio Generators`,
+  and the :generator:`Xcode` generator.
+
+  This keyword cannot be used with ``APPEND`` (see policy :policy:`CMP0175`).
+  Depfiles can only be set on the first call to
+  ``add_custom_command(OUTPUT...)`` for the output files.
+
+``DEPENDS_EXPLICIT_ONLY``
+
+  .. versionadded:: 3.27
+
+  Indicates that the command's ``DEPENDS`` argument represents all files
+  required by the command and implicit dependencies are not required.
+
+  Without this option, if any target uses the output of the custom command,
+  CMake will consider that target's dependencies as implicit dependencies for
+  the custom command in case this custom command requires files implicitly
+  created by those targets.
+
+  This option can be enabled on all custom commands by setting
+  :variable:`CMAKE_ADD_CUSTOM_COMMAND_DEPENDS_EXPLICIT_ONLY` to ``ON``.
+
+  This keyword cannot be used with ``APPEND`` (see policy :policy:`CMP0175`).
+  It can only be set on the first call to ``add_custom_command(OUTPUT...)``
+  for the output files.
+
+  Only the :ref:`Ninja Generators` actually use this information to remove
+  unnecessary implicit dependencies.
+
+  See also the :prop_tgt:`OPTIMIZE_DEPENDENCIES` target property, which may
+  provide another way for reducing the impact of target dependencies in some
+  scenarios.
+
+Examples: Generating Files
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Custom commands may be used to generate source files.
+For example, the code:
+
+.. code-block:: cmake
+
+  add_custom_command(
+    OUTPUT out.c
+    COMMAND someTool -i ${CMAKE_CURRENT_SOURCE_DIR}/in.txt
+                     -o out.c
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/in.txt
+    VERBATIM)
+  add_library(myLib out.c)
+
+adds a custom command to run ``someTool`` to generate ``out.c`` and then
+compile the generated source as part of a library.  The generation rule
+will re-run whenever ``in.txt`` changes.
+
+.. versionadded:: 3.20
+  One may use generator expressions to specify per-configuration outputs.
+  For example, the code:
+
+  .. code-block:: cmake
+
+    add_custom_command(
+      OUTPUT "out-$<CONFIG>.c"
+      COMMAND someTool -i ${CMAKE_CURRENT_SOURCE_DIR}/in.txt
+                       -o "out-$<CONFIG>.c"
+                       -c "$<CONFIG>"
+      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/in.txt
+      VERBATIM)
+    add_library(myLib "out-$<CONFIG>.c")
+
+  adds a custom command to run ``someTool`` to generate ``out-<config>.c``,
+  where ``<config>`` is the build configuration, and then compile the generated
+  source as part of a library.
+
+.. versionadded:: 3.31
+  Use the ``CODEGEN`` option to add a custom command's outputs to the builtin
+  ``codegen`` target.  This is useful to make generated code available for
+   static analysis without building the entire project.  For example:
+
+  .. code-block:: cmake
+
+    add_executable(someTool someTool.c)
+
+    add_custom_command(
+      OUTPUT out.c
+      COMMAND someTool -o out.c
+      CODEGEN)
+
+    add_library(myLib out.c)
+
+  A user may build the ``codegen`` target to generate ``out.c``.
+  ``someTool`` is built as dependency, but ``myLib`` is not built at all.
+
+Example: Generating Files for Multiple Targets
+""""""""""""""""""""""""""""""""""""""""""""""
+
+If multiple independent targets need the same custom command output,
+it must be attached to a single custom target on which they all depend.
+Consider the following example:
+
+.. code-block:: cmake
+
+  add_custom_command(
+    OUTPUT table.csv
+    COMMAND makeTable -i ${CMAKE_CURRENT_SOURCE_DIR}/input.dat
+                      -o table.csv
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/input.dat
+    VERBATIM)
+  add_custom_target(generate_table_csv DEPENDS table.csv)
+
+  add_custom_command(
+    OUTPUT foo.cxx
+    COMMAND genFromTable -i table.csv -case foo -o foo.cxx
+    DEPENDS table.csv           # file-level dependency
+            generate_table_csv  # target-level dependency
+    VERBATIM)
+  add_library(foo foo.cxx)
+
+  add_custom_command(
+    OUTPUT bar.cxx
+    COMMAND genFromTable -i table.csv -case bar -o bar.cxx
+    DEPENDS table.csv           # file-level dependency
+            generate_table_csv  # target-level dependency
+    VERBATIM)
+  add_library(bar bar.cxx)
+
+Output ``foo.cxx`` is needed only by target ``foo`` and output ``bar.cxx``
+is needed only by target ``bar``, but *both* targets need ``table.csv``,
+transitively.  Since ``foo`` and ``bar`` are independent targets that may
+build concurrently, we prevent them from racing to generate ``table.csv``
+by placing its custom command in a separate target, ``generate_table_csv``.
+The custom commands generating ``foo.cxx`` and ``bar.cxx`` each specify a
+target-level dependency on ``generate_table_csv``, so the targets using them,
+``foo`` and ``bar``, will not build until after target ``generate_table_csv``
+is built.
+
+.. _`add_custom_command(TARGET)`:
+
+Build Events
+^^^^^^^^^^^^
+
+The second signature adds a custom command to a target such as a
+library or executable.  This is useful for performing an operation
+before or after building the target.  The command becomes part of the
+target and will only execute when the target itself is built.  If the
+target is already built, the command will not execute.
+
+.. code-block:: cmake
+
+  add_custom_command(TARGET <target>
+                     PRE_BUILD | PRE_LINK | POST_BUILD
+                     COMMAND command1 [ARGS] [args1...]
+                     [COMMAND command2 [ARGS] [args2...] ...]
+                     [BYPRODUCTS [files...]]
+                     [WORKING_DIRECTORY dir]
+                     [COMMENT comment]
+                     [VERBATIM]
+                     [COMMAND_EXPAND_LISTS]
+                     [USES_TERMINAL])
+
+This defines a new command that will be associated with building the
+specified ``<target>``.  The ``<target>`` must be defined in the current
+directory; targets defined in other directories may not be specified.
+
+When the command will happen is determined by which
+of the following is specified:
+
+``PRE_BUILD``
+  This option has unique behavior for the :ref:`Visual Studio Generators`.
+  When using one of the Visual Studio generators, the command will run before
+  any other rules are executed within the target.  With all other generators,
+  this option behaves the same as ``PRE_LINK`` instead.  Because of this,
+  it is recommended to avoid using ``PRE_BUILD`` except when it is known that
+  a Visual Studio generator is being used.
+``PRE_LINK``
+  Run after sources have been compiled but before linking the binary
+  or running the librarian or archiver tool of a static library.
+  This is not defined for targets created by the
+  :command:`add_custom_target` command.
+``POST_BUILD``
+  Run after all other rules within the target have been executed.
+
+Projects should always specify one of the above three keywords when using
+the ``TARGET`` form.  See policy :policy:`CMP0175`.
+
+All other keywords shown in the signature above have the same meaning as they
+do for the :command:`add_custom_command(OUTPUT)` form of the command.
+At least one ``COMMAND`` must be given, see policy :policy:`CMP0175`.
+
+.. note::
+  Because generator expressions can be used in custom commands,
+  it is possible to define ``COMMAND`` lines or whole custom commands
+  which evaluate to empty strings for certain configurations.
+  For :ref:`Visual Studio Generators` these command
+  lines or custom commands will be omitted for the specific
+  configuration and no "empty-string-command" will be added.
+
+  This allows adding individual build events for every configuration.
+
+.. versionadded:: 3.21
+  Support for target-dependent generator expressions.
+
+.. versionadded:: 3.29
+  The ``<target>`` may be an :ref:`ALIAS target <Alias Targets>`.
+
+Examples: Build Events
+^^^^^^^^^^^^^^^^^^^^^^
+
+A ``POST_BUILD`` event may be used to post-process a binary after linking.
+For example, the code:
+
+.. code-block:: cmake
+
+  add_executable(myExe myExe.c)
+  add_custom_command(
+    TARGET myExe POST_BUILD
+    COMMAND someHasher -i "$<TARGET_FILE:myExe>"
+                       -o "$<TARGET_FILE:myExe>.hash"
+    VERBATIM)
+
+will run ``someHasher`` to produce a ``.hash`` file next to the executable
+after linking.
+
+.. versionadded:: 3.20
+  One may use generator expressions to specify per-configuration byproducts.
+  For example, the code:
+
+  .. code-block:: cmake
+
+    add_library(myPlugin MODULE myPlugin.c)
+    add_custom_command(
+      TARGET myPlugin POST_BUILD
+      COMMAND someHasher -i "$<TARGET_FILE:myPlugin>"
+                         --as-code "myPlugin-hash-$<CONFIG>.c"
+      BYPRODUCTS "myPlugin-hash-$<CONFIG>.c"
+      VERBATIM)
+    add_executable(myExe myExe.c "myPlugin-hash-$<CONFIG>.c")
+
+  will run ``someHasher`` after linking ``myPlugin``, e.g. to produce a ``.c``
+  file containing code to check the hash of ``myPlugin`` that the ``myExe``
+  executable can use to verify it before loading.
+
+Ninja Multi-Config
+^^^^^^^^^^^^^^^^^^
+
+.. versionadded:: 3.20
+
+  ``add_custom_command`` supports the :generator:`Ninja Multi-Config`
+  generator's cross-config capabilities. See the generator documentation
+  for more information.
+
+See Also
+^^^^^^^^
+
+* :command:`add_custom_target`

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_definitions.rst

@@ -0,0 +1,38 @@
+add_definitions
+---------------
+
+Add ``-D`` define flags to the compilation of source files.
+
+.. code-block:: cmake
+
+  add_definitions(-DFOO -DBAR ...)
+
+Adds definitions to the compiler command line for targets in the current
+directory, whether added before or after this command is invoked, and for
+the ones in sub-directories added after. This command can be used to add any
+flags, but it is intended to add preprocessor definitions.
+
+.. note::
+
+  This command has been superseded by alternatives:
+
+  * Use :command:`add_compile_definitions` to add preprocessor definitions.
+  * Use :command:`include_directories` to add include directories.
+  * Use :command:`add_compile_options` to add other options.
+
+Flags beginning in ``-D`` or ``/D`` that look like preprocessor definitions are
+automatically added to the :prop_dir:`COMPILE_DEFINITIONS` directory
+property for the current directory.  Definitions with non-trivial values
+may be left in the set of flags instead of being converted for reasons of
+backwards compatibility.  See documentation of the
+:prop_dir:`directory <COMPILE_DEFINITIONS>`,
+:prop_tgt:`target <COMPILE_DEFINITIONS>`,
+:prop_sf:`source file <COMPILE_DEFINITIONS>` ``COMPILE_DEFINITIONS``
+properties for details on adding preprocessor definitions to specific
+scopes and configurations.
+
+See Also
+^^^^^^^^
+
+* The :manual:`cmake-buildsystem(7)` manual for more on defining
+  buildsystem properties.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_executable.rst

@@ -0,0 +1,123 @@
+add_executable
+--------------
+
+.. only:: html
+
+  .. contents::
+
+Add an executable to the project using the specified source files.
+
+Normal Executables
+^^^^^^^^^^^^^^^^^^
+
+.. signature::
+  add_executable(<name> <options>... <sources>...)
+  :target: normal
+
+  Add an executable target called ``<name>`` to be built from the source
+  files listed in the command invocation.
+
+  The options are:
+
+  ``WIN32``
+    Set the :prop_tgt:`WIN32_EXECUTABLE` target property automatically.
+    See documentation of that target property for details.
+
+  ``MACOSX_BUNDLE``
+    Set the :prop_tgt:`MACOSX_BUNDLE` target property automatically.
+    See documentation of that target property for details.
+
+  ``EXCLUDE_FROM_ALL``
+    Set the :prop_tgt:`EXCLUDE_FROM_ALL` target property automatically.
+    See documentation of that target property for details.
+
+The ``<name>`` corresponds to the logical target name and must be globally
+unique within a project.  The actual file name of the executable built is
+constructed based on conventions of the native platform (such as
+``<name>.exe`` or just ``<name>``).
+
+.. versionadded:: 3.1
+  Source arguments to ``add_executable`` may use "generator expressions" with
+  the syntax ``$<...>``.  See the :manual:`cmake-generator-expressions(7)`
+  manual for available expressions.
+
+.. versionadded:: 3.11
+  The source files can be omitted if they are added later using
+  :command:`target_sources`.
+
+By default the executable file will be created in the build tree
+directory corresponding to the source tree directory in which the
+command was invoked.  See documentation of the
+:prop_tgt:`RUNTIME_OUTPUT_DIRECTORY` target property to change this
+location.  See documentation of the :prop_tgt:`OUTPUT_NAME` target property
+to change the ``<name>`` part of the final file name.
+
+See the :manual:`cmake-buildsystem(7)` manual for more on defining
+buildsystem properties.
+
+See also :prop_sf:`HEADER_FILE_ONLY` on what to do if some sources are
+pre-processed, and you want to have the original sources reachable from
+within IDE.
+
+Imported Executables
+^^^^^^^^^^^^^^^^^^^^
+
+.. signature::
+  add_executable(<name> IMPORTED [GLOBAL])
+  :target: IMPORTED
+
+  Add an :ref:`IMPORTED executable target <Imported Targets>` to reference
+  an executable file located outside the project.  The target name may be
+  referenced like any target built within the project, except that by
+  default it is visible only in the directory in which it is created,
+  and below.
+
+  The options are:
+
+  ``GLOBAL``
+    Make the target name globally visible.
+
+No rules are generated to build imported targets, and the :prop_tgt:`IMPORTED`
+target property is ``True``.  Imported executables are useful for convenient
+reference from commands like :command:`add_custom_command`.
+
+Details about the imported executable are specified by setting properties
+whose names begin in ``IMPORTED_``.  The most important such property is
+:prop_tgt:`IMPORTED_LOCATION` (and its per-configuration version
+:prop_tgt:`IMPORTED_LOCATION_<CONFIG>`) which specifies the location of
+the main executable file on disk.  See documentation of the ``IMPORTED_*``
+properties for more information.
+
+Alias Executables
+^^^^^^^^^^^^^^^^^
+
+.. signature::
+  add_executable(<name> ALIAS <target>)
+  :target: ALIAS
+
+  Creates an :ref:`Alias Target <Alias Targets>`, such that ``<name>`` can
+  be used to refer to ``<target>`` in subsequent commands.  The ``<name>``
+  does not appear in the generated buildsystem as a make target.  The
+  ``<target>`` may not be an ``ALIAS``.
+
+.. versionadded:: 3.11
+  An ``ALIAS`` can target a ``GLOBAL`` :ref:`Imported Target <Imported Targets>`
+
+.. versionadded:: 3.18
+  An ``ALIAS`` can target a non-``GLOBAL`` Imported Target. Such alias is
+  scoped to the directory in which it is created and subdirectories.
+  The :prop_tgt:`ALIAS_GLOBAL` target property can be used to check if the
+  alias is global or not.
+
+``ALIAS`` targets can be used as targets to read properties
+from, executables for custom commands and custom targets.  They can also be
+tested for existence with the regular :command:`if(TARGET)` subcommand.
+The ``<name>`` may not be used to modify properties of ``<target>``, that
+is, it may not be used as the operand of :command:`set_property`,
+:command:`set_target_properties`, :command:`target_link_libraries` etc.
+An ``ALIAS`` target may not be installed or exported.
+
+See Also
+^^^^^^^^
+
+* :command:`add_library`

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_link_options.rst

@@ -0,0 +1,44 @@
+add_link_options
+----------------
+
+.. versionadded:: 3.13
+
+Add options to the link step for executable, shared library or module
+library targets in the current directory and below that are added after
+this command is invoked.
+
+.. code-block:: cmake
+
+  add_link_options(<option> ...)
+
+This command can be used to add any link options, but alternative commands
+exist to add libraries (:command:`target_link_libraries` or
+:command:`link_libraries`).  See documentation of the
+:prop_dir:`directory <LINK_OPTIONS>` and
+:prop_tgt:`target <LINK_OPTIONS>` ``LINK_OPTIONS`` properties.
+
+.. note::
+
+  This command cannot be used to add options for static library targets,
+  since they do not use a linker.  To add archiver or MSVC librarian flags,
+  see the :prop_tgt:`STATIC_LIBRARY_OPTIONS` target property.
+
+.. |command_name| replace:: ``add_link_options``
+.. include:: GENEX_NOTE.txt
+
+.. include:: DEVICE_LINK_OPTIONS.txt
+
+.. include:: OPTIONS_SHELL.txt
+
+.. include:: LINK_OPTIONS_LINKER.txt
+
+See Also
+^^^^^^^^
+
+* :command:`link_libraries`
+* :command:`target_link_libraries`
+* :command:`target_link_options`
+
+* :variable:`CMAKE_<LANG>_FLAGS` and :variable:`CMAKE_<LANG>_FLAGS_<CONFIG>`
+  add language-wide flags passed to all invocations of the compiler.
+  This includes invocations that drive compiling and those that drive linking.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/aux_source_directory.rst

@@ -0,0 +1,24 @@
+aux_source_directory
+--------------------
+
+Find all source files in a directory.
+
+.. code-block:: cmake
+
+  aux_source_directory(<dir> <variable>)
+
+Collects the names of all the source files in the specified directory
+and stores the list in the ``<variable>`` provided.  This command is
+intended to be used by projects that use explicit template
+instantiation.  Template instantiation files can be stored in a
+``Templates`` subdirectory and collected automatically using this
+command to avoid manually listing all instantiations.
+
+It is tempting to use this command to avoid writing the list of source
+files for a library or executable target.  While this seems to work,
+there is no way for CMake to generate a build system that knows when a
+new source file has been added.  Normally the generated build system
+knows when it needs to rerun CMake because the ``CMakeLists.txt`` file is
+modified to add a new source.  When the source is just added to the
+directory without modifying this file, one would have to manually
+rerun CMake to generate a build system incorporating the new file.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/break.rst

@@ -0,0 +1,12 @@
+break
+-----
+
+Break from an enclosing foreach or while loop.
+
+.. code-block:: cmake
+
+  break()
+
+Breaks from an enclosing :command:`foreach` or :command:`while` loop.
+
+See also the :command:`continue` command.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/build_command.rst

@@ -0,0 +1,51 @@
+build_command
+-------------
+
+Get a command line to build the current project.
+This is mainly intended for internal use by the :module:`CTest` module.
+
+.. code-block:: cmake
+
+  build_command(<variable>
+                [CONFIGURATION <config>]
+                [PARALLEL_LEVEL <parallel>]
+                [TARGET <target>]
+                [PROJECT_NAME <projname>] # legacy, causes warning
+               )
+
+Sets the given ``<variable>`` to a command-line string of the form::
+
+ <cmake> --build . [--config <config>] [--parallel <parallel>] [--target <target>...] [-- -i]
+
+where ``<cmake>`` is the location of the :manual:`cmake(1)` command-line
+tool, and ``<config>``, ``<parallel>`` and ``<target>`` are the values
+provided to the ``CONFIGURATION``, ``PARALLEL_LEVEL`` and ``TARGET``
+options, if any.  The trailing ``-- -i`` option is added for
+:ref:`Makefile Generators` if policy :policy:`CMP0061` is not set to
+``NEW``.
+
+When invoked, this :option:`cmake --build` command line will launch the
+underlying build system tool.
+
+.. versionadded:: 3.21
+  The ``PARALLEL_LEVEL`` argument can be used to set the
+  :option:`--parallel <cmake--build --parallel>` flag.
+
+.. code-block:: cmake
+
+  build_command(<cachevariable> <makecommand>)
+
+This second signature is deprecated, but still available for backwards
+compatibility.  Use the first signature instead.
+
+It sets the given ``<cachevariable>`` to a command-line string as
+above but without the :option:`--target <cmake--build --target>` option.
+The ``<makecommand>`` is ignored but should be the full path to
+devenv, nmake, make or one of the end user build tools
+for legacy invocations.
+
+.. note::
+ In CMake versions prior to 3.0 this command returned a command
+ line that directly invokes the native build tool for the current
+ generator.  Their implementation of the ``PROJECT_NAME`` option
+ had no useful effects, so CMake now warns on use of the option.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/build_name.rst

@@ -0,0 +1,15 @@
+build_name
+----------
+
+Disallowed since version 3.0.  See CMake Policy :policy:`CMP0036`.
+
+Use ``${CMAKE_SYSTEM}`` and ``${CMAKE_CXX_COMPILER}`` instead.
+
+.. code-block:: cmake
+
+  build_name(variable)
+
+Sets the specified variable to a string representing the platform and
+compiler settings.  These values are now available through the
+:variable:`CMAKE_SYSTEM` and
+:variable:`CMAKE_CXX_COMPILER <CMAKE_<LANG>_COMPILER>` variables.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/cmake_file_api.rst

@@ -0,0 +1,78 @@
+cmake_file_api
+--------------
+
+.. versionadded:: 3.27
+
+Enables interacting with the :manual:`CMake file API <cmake-file-api(7)>`.
+
+.. signature::
+  cmake_file_api(QUERY ...)
+
+  The ``QUERY`` subcommand adds a file API query for the current CMake
+  invocation.
+
+  .. code-block:: cmake
+
+    cmake_file_api(
+      QUERY
+      API_VERSION <version>
+      [CODEMODEL <versions>...]
+      [CACHE <versions>...]
+      [CMAKEFILES <versions>...]
+      [TOOLCHAINS <versions>...]
+    )
+
+  The ``API_VERSION`` must always be given.  Currently, the only supported
+  value for ``<version>`` is 1.  See :ref:`file-api v1` for details of the
+  reply content and location.
+
+  Each of the optional keywords ``CODEMODEL``, ``CACHE``, ``CMAKEFILES`` and
+  ``TOOLCHAINS`` correspond to one of the object kinds that can be requested
+  by the project.  The ``configureLog`` object kind cannot be set with this
+  command, since it must be set before CMake starts reading the top level
+  ``CMakeLists.txt`` file.
+
+  For each of the optional keywords, the ``<versions>`` list must contain one
+  or more version values of the form ``major`` or ``major.minor``, where
+  ``major`` and ``minor`` are integers.  Projects should list the versions they
+  accept in their preferred order, as only the first supported value from the
+  list will be selected.  The command will ignore versions with a ``major``
+  version higher than any major version it supports for that object kind.
+  It will raise an error if it encounters an invalid version number, or if none
+  of the requested versions is supported.
+
+  For each type of object kind requested, a query equivalent to a shared,
+  stateless query will be added internally.  No query file will be created in
+  the file system.  The reply *will* be written to the file system at
+  generation time.
+
+  It is not an error to add a query for the same thing more than once, whether
+  from query files or from multiple calls to ``cmake_file_api(QUERY)``.
+  The final set of queries will be a merged combination of all queries
+  specified on disk and queries submitted by the project.
+
+Example
+^^^^^^^
+
+A project may want to use replies from the file API at build time to implement
+some form of verification task.  Instead of relying on something outside of
+CMake to create a query file, the project can use ``cmake_file_api(QUERY)``
+to request the required information for the current run.  It can then create
+a custom command to run at build time, knowing that the requested information
+should always be available.
+
+.. code-block:: cmake
+
+  cmake_file_api(
+    QUERY
+    API_VERSION 1
+    CODEMODEL 2.3
+    TOOLCHAINS 1
+  )
+
+  add_custom_target(verify_project
+    COMMAND ${CMAKE_COMMAND}
+      -D BUILD_DIR=${CMAKE_BINARY_DIR}
+      -D CONFIG=$<CONFIG>
+      -P ${CMAKE_CURRENT_SOURCE_DIR}/verify_project.cmake
+  )

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/cmake_host_system_information.rst

@@ -0,0 +1,403 @@
+cmake_host_system_information
+-----------------------------
+
+Query various host system information.
+
+Synopsis
+^^^^^^^^
+
+.. parsed-literal::
+
+  `Query host system specific information`_
+    cmake_host_system_information(RESULT <variable> QUERY <key> ...)
+
+  `Query Windows registry`_
+    cmake_host_system_information(RESULT <variable> QUERY WINDOWS_REGISTRY <key> ...)
+
+Query host system specific information
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+  cmake_host_system_information(RESULT <variable> QUERY <key> ...)
+
+Queries system information of the host system on which cmake runs.
+One or more ``<key>`` can be provided to select the information to be
+queried.  The list of queried values is stored in ``<variable>``.
+
+``<key>`` can be one of the following values:
+
+``NUMBER_OF_LOGICAL_CORES``
+  Number of logical cores
+
+``NUMBER_OF_PHYSICAL_CORES``
+  Number of physical cores
+
+``HOSTNAME``
+  Hostname
+
+``FQDN``
+  Fully qualified domain name
+
+``TOTAL_VIRTUAL_MEMORY``
+  Total virtual memory in MiB [#mebibytes]_
+
+``AVAILABLE_VIRTUAL_MEMORY``
+  Available virtual memory in MiB [#mebibytes]_
+
+``TOTAL_PHYSICAL_MEMORY``
+  Total physical memory in MiB [#mebibytes]_
+
+``AVAILABLE_PHYSICAL_MEMORY``
+  Available physical memory in MiB [#mebibytes]_
+
+``IS_64BIT``
+  .. versionadded:: 3.10
+
+  One if processor is 64Bit
+
+``HAS_FPU``
+  .. versionadded:: 3.10
+
+  One if processor has floating point unit
+
+``HAS_MMX``
+  .. versionadded:: 3.10
+
+  One if processor supports MMX instructions
+
+``HAS_MMX_PLUS``
+  .. versionadded:: 3.10
+
+  One if processor supports Ext. MMX instructions
+
+``HAS_SSE``
+  .. versionadded:: 3.10
+
+  One if processor supports SSE instructions
+
+``HAS_SSE2``
+  .. versionadded:: 3.10
+
+  One if processor supports SSE2 instructions
+
+``HAS_SSE_FP``
+  .. versionadded:: 3.10
+
+  One if processor supports SSE FP instructions
+
+``HAS_SSE_MMX``
+  .. versionadded:: 3.10
+
+  One if processor supports SSE MMX instructions
+
+``HAS_AMD_3DNOW``
+  .. versionadded:: 3.10
+
+  One if processor supports 3DNow instructions
+
+``HAS_AMD_3DNOW_PLUS``
+  .. versionadded:: 3.10
+
+  One if processor supports 3DNow+ instructions
+
+``HAS_IA64``
+  .. versionadded:: 3.10
+
+  One if IA64 processor emulating x86
+
+``HAS_SERIAL_NUMBER``
+  .. versionadded:: 3.10
+
+  One if processor has serial number
+
+``PROCESSOR_SERIAL_NUMBER``
+  .. versionadded:: 3.10
+
+  Processor serial number
+
+``PROCESSOR_NAME``
+  .. versionadded:: 3.10
+
+  Human readable processor name
+
+``PROCESSOR_DESCRIPTION``
+  .. versionadded:: 3.10
+
+  Human readable full processor description
+
+``OS_NAME``
+  .. versionadded:: 3.10
+
+  See :variable:`CMAKE_HOST_SYSTEM_NAME`
+
+``OS_RELEASE``
+  .. versionadded:: 3.10
+
+  The OS sub-type e.g. on Windows ``Professional``
+
+``OS_VERSION``
+  .. versionadded:: 3.10
+
+  The OS build ID
+
+``OS_PLATFORM``
+  .. versionadded:: 3.10
+
+  See :variable:`CMAKE_HOST_SYSTEM_PROCESSOR`
+
+``MSYSTEM_PREFIX``
+  .. versionadded:: 3.28
+
+  Available only on Windows hosts.  In a MSYS or MinGW development
+  environment that sets the ``MSYSTEM`` environment variable, this
+  is its installation prefix.  Otherwise, this is the empty string.
+
+``DISTRIB_INFO``
+  .. versionadded:: 3.22
+
+  Read :file:`/etc/os-release` file and define the given ``<variable>``
+  into a list of read variables
+
+``DISTRIB_<name>``
+  .. versionadded:: 3.22
+
+  Get the ``<name>`` variable (see `man 5 os-release`_) if it exists in the
+  :file:`/etc/os-release` file
+
+  Example:
+
+  .. code-block:: cmake
+
+      cmake_host_system_information(RESULT PRETTY_NAME QUERY DISTRIB_PRETTY_NAME)
+      message(STATUS "${PRETTY_NAME}")
+
+      cmake_host_system_information(RESULT DISTRO QUERY DISTRIB_INFO)
+
+      foreach(VAR IN LISTS DISTRO)
+        message(STATUS "${VAR}=`${${VAR}}`")
+      endforeach()
+
+
+  Output::
+
+    -- Ubuntu 20.04.2 LTS
+    -- DISTRO_BUG_REPORT_URL=`https://bugs.launchpad.net/ubuntu/`
+    -- DISTRO_HOME_URL=`https://www.ubuntu.com/`
+    -- DISTRO_ID=`ubuntu`
+    -- DISTRO_ID_LIKE=`debian`
+    -- DISTRO_NAME=`Ubuntu`
+    -- DISTRO_PRETTY_NAME=`Ubuntu 20.04.2 LTS`
+    -- DISTRO_PRIVACY_POLICY_URL=`https://www.ubuntu.com/legal/terms-and-policies/privacy-policy`
+    -- DISTRO_SUPPORT_URL=`https://help.ubuntu.com/`
+    -- DISTRO_UBUNTU_CODENAME=`focal`
+    -- DISTRO_VERSION=`20.04.2 LTS (Focal Fossa)`
+    -- DISTRO_VERSION_CODENAME=`focal`
+    -- DISTRO_VERSION_ID=`20.04`
+
+If :file:`/etc/os-release` file is not found, the command tries to gather OS
+identification via fallback scripts.  The fallback script can use `various
+distribution-specific files`_ to collect OS identification data and map it
+into `man 5 os-release`_ variables.
+
+Fallback Interface Variables
+""""""""""""""""""""""""""""
+
+.. variable:: CMAKE_GET_OS_RELEASE_FALLBACK_SCRIPTS
+
+  In addition to the scripts shipped with CMake, a user may append full
+  paths to his script(s) to the this list.  The script filename has the
+  following format: ``NNN-<name>.cmake``, where ``NNN`` is three digits
+  used to apply collected scripts in a specific order.
+
+.. variable:: CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_<varname>
+
+  Variables collected by the user provided fallback script
+  ought to be assigned to CMake variables using this naming
+  convention.  Example, the ``ID`` variable from the manual becomes
+  ``CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_ID``.
+
+.. variable:: CMAKE_GET_OS_RELEASE_FALLBACK_RESULT
+
+  The fallback script ought to store names of all assigned
+  ``CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_<varname>`` variables in this list.
+
+Example:
+
+.. code-block:: cmake
+
+  # Try to detect some old distribution
+  # See also
+  # - http://linuxmafia.com/faq/Admin/release-files.html
+  #
+  if(NOT EXISTS "${CMAKE_SYSROOT}/etc/foobar-release")
+    return()
+  endif()
+  # Get the first string only
+  file(
+      STRINGS "${CMAKE_SYSROOT}/etc/foobar-release" CMAKE_GET_OS_RELEASE_FALLBACK_CONTENT
+      LIMIT_COUNT 1
+    )
+  #
+  # Example:
+  #
+  #   Foobar distribution release 1.2.3 (server)
+  #
+  if(CMAKE_GET_OS_RELEASE_FALLBACK_CONTENT MATCHES "Foobar distribution release ([0-9\.]+) .*")
+    set(CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_NAME Foobar)
+    set(CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_PRETTY_NAME "${CMAKE_GET_OS_RELEASE_FALLBACK_CONTENT}")
+    set(CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_ID foobar)
+    set(CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_VERSION ${CMAKE_MATCH_1})
+    set(CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_VERSION_ID ${CMAKE_MATCH_1})
+    list(
+        APPEND CMAKE_GET_OS_RELEASE_FALLBACK_RESULT
+        CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_NAME
+        CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_PRETTY_NAME
+        CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_ID
+        CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_VERSION
+        CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_VERSION_ID
+      )
+  endif()
+  unset(CMAKE_GET_OS_RELEASE_FALLBACK_CONTENT)
+
+
+.. rubric:: Footnotes
+
+.. [#mebibytes] One MiB (mebibyte) is equal to 1024x1024 bytes.
+
+.. _man 5 os-release: https://www.freedesktop.org/software/systemd/man/latest/os-release.html
+.. _various distribution-specific files: http://linuxmafia.com/faq/Admin/release-files.html
+
+.. _Query Windows registry:
+
+Query Windows registry
+^^^^^^^^^^^^^^^^^^^^^^
+
+.. versionadded:: 3.24
+
+::
+
+  cmake_host_system_information(RESULT <variable>
+                                QUERY WINDOWS_REGISTRY <key> [VALUE_NAMES|SUBKEYS|VALUE <name>]
+                                [VIEW (64|32|64_32|32_64|HOST|TARGET|BOTH)]
+                                [SEPARATOR <separator>]
+                                [ERROR_VARIABLE <result>])
+
+Performs query operations on local computer registry subkey. Returns a list of
+subkeys or value names that are located under the specified subkey in the
+registry or the data of the specified value name. The result of the queried
+entity is stored in ``<variable>``.
+
+.. note::
+
+  Querying registry for any other platforms than ``Windows``, including
+  ``CYGWIN``, will always returns an empty string and sets an error message in
+  the variable specified with sub-option ``ERROR_VARIABLE``.
+
+``<key>`` specify the full path of a subkey on the local computer. The
+``<key>`` must include a valid root key. Valid root keys for the local computer
+are:
+
+* ``HKLM`` or ``HKEY_LOCAL_MACHINE``
+* ``HKCU`` or ``HKEY_CURRENT_USER``
+* ``HKCR`` or ``HKEY_CLASSES_ROOT``
+* ``HKU`` or ``HKEY_USERS``
+* ``HKCC`` or ``HKEY_CURRENT_CONFIG``
+
+And, optionally, the path to a subkey under the specified root key. The path
+separator can be the slash or the backslash. ``<key>`` is not case sensitive.
+For example:
+
+.. code-block:: cmake
+
+  cmake_host_system_information(RESULT result QUERY WINDOWS_REGISTRY "HKLM")
+  cmake_host_system_information(RESULT result QUERY WINDOWS_REGISTRY "HKLM/SOFTWARE/Kitware")
+  cmake_host_system_information(RESULT result QUERY WINDOWS_REGISTRY "HKCU\\SOFTWARE\\Kitware")
+
+``VALUE_NAMES``
+  Request the list of value names defined under ``<key>``. If a default value
+  is defined, it will be identified with the special name ``(default)``.
+
+``SUBKEYS``
+  Request the list of subkeys defined under ``<key>``.
+
+``VALUE <name>``
+  Request the data stored in value named ``<name>``. If ``VALUE`` is not
+  specified or argument is the special name ``(default)``, the content of the
+  default value, if any, will be returned.
+
+  .. code-block:: cmake
+
+     # query default value for HKLM/SOFTWARE/Kitware key
+     cmake_host_system_information(RESULT result
+                                   QUERY WINDOWS_REGISTRY "HKLM/SOFTWARE/Kitware")
+
+     # query default value for HKLM/SOFTWARE/Kitware key using special value name
+     cmake_host_system_information(RESULT result
+                                   QUERY WINDOWS_REGISTRY "HKLM/SOFTWARE/Kitware"
+                                   VALUE "(default)")
+
+  Supported types are:
+
+  * ``REG_SZ``.
+  * ``REG_EXPAND_SZ``. The returned data is expanded.
+  * ``REG_MULTI_SZ``. The returned is expressed as a CMake list. See also
+    ``SEPARATOR`` sub-option.
+  * ``REG_DWORD``.
+  * ``REG_QWORD``.
+
+  For all other types, an empty string is returned.
+
+``VIEW``
+  Specify which registry views must be queried. When not specified, ``BOTH``
+  view is used.
+
+  ``64``
+    Query the 64bit registry. On ``32bit Windows``, returns always an empty
+    string.
+
+  ``32``
+    Query the 32bit registry.
+
+  ``64_32``
+    For ``VALUE`` sub-option or default value, query the registry using view
+    ``64``, and if the request failed, query the registry using view ``32``.
+    For ``VALUE_NAMES`` and ``SUBKEYS`` sub-options, query both views (``64``
+    and ``32``) and merge the results (sorted and duplicates removed).
+
+  ``32_64``
+    For ``VALUE`` sub-option or default value, query the registry using view
+    ``32``, and if the request failed, query the registry using view ``64``.
+    For ``VALUE_NAMES`` and ``SUBKEYS`` sub-options, query both views (``32``
+    and ``64``) and merge the results (sorted and duplicates removed).
+
+  ``HOST``
+    Query the registry matching the architecture of the host: ``64`` on ``64bit
+    Windows`` and ``32`` on ``32bit Windows``.
+
+  ``TARGET``
+    Query the registry matching the architecture specified by
+    :variable:`CMAKE_SIZEOF_VOID_P` variable. If not defined, fallback to
+    ``HOST`` view.
+
+  ``BOTH``
+    Query both views (``32`` and ``64``). The order depends of the following
+    rules: If :variable:`CMAKE_SIZEOF_VOID_P` variable is defined. Use the
+    following view depending of the content of this variable:
+
+    * ``8``: ``64_32``
+    * ``4``: ``32_64``
+
+    If :variable:`CMAKE_SIZEOF_VOID_P` variable is not defined, rely on
+    architecture of the host:
+
+    * ``64bit``: ``64_32``
+    * ``32bit``: ``32``
+
+``SEPARATOR``
+  Specify the separator character for ``REG_MULTI_SZ`` type. When not
+  specified, the character ``\0`` is used.
+
+``ERROR_VARIABLE <result>``
+  Returns any error raised during query operation. In case of success, the
+  variable holds an empty string.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/cmake_path.rst

@@ -0,0 +1,798 @@
+cmake_path
+----------
+
+.. versionadded:: 3.20
+
+This command is for the manipulation of paths.  Only syntactic aspects of
+paths are handled, there is no interaction of any kind with any underlying
+file system.  The path may represent a non-existing path or even one that
+is not allowed to exist on the current file system or platform.
+For operations that do interact with the filesystem, see the :command:`file`
+command.
+
+.. note::
+
+  The ``cmake_path`` command handles paths in the format of the build system
+  (i.e. the host platform), not the target system.  When cross-compiling,
+  if the path contains elements that are not representable on the host
+  platform (e.g. a drive letter when the host is not Windows), the results
+  will be unpredictable.
+
+Synopsis
+^^^^^^^^
+
+.. parsed-literal::
+
+  `Conventions`_
+
+  `Path Structure And Terminology`_
+
+  `Normalization`_
+
+  `Decomposition`_
+    cmake_path(`GET`_ <path-var> :ref:`ROOT_NAME <GET_ROOT_NAME>` <out-var>)
+    cmake_path(`GET`_ <path-var> :ref:`ROOT_DIRECTORY <GET_ROOT_DIRECTORY>` <out-var>)
+    cmake_path(`GET`_ <path-var> :ref:`ROOT_PATH <GET_ROOT_PATH>` <out-var>)
+    cmake_path(`GET`_ <path-var> :ref:`FILENAME <GET_FILENAME>` <out-var>)
+    cmake_path(`GET`_ <path-var> :ref:`EXTENSION <GET_EXTENSION>` [LAST_ONLY] <out-var>)
+    cmake_path(`GET`_ <path-var> :ref:`STEM <GET_STEM>` [LAST_ONLY] <out-var>)
+    cmake_path(`GET`_ <path-var> :ref:`RELATIVE_PART <GET_RELATIVE_PART>` <out-var>)
+    cmake_path(`GET`_ <path-var> :ref:`PARENT_PATH <GET_PARENT_PATH>` <out-var>)
+
+  `Query`_
+    cmake_path(`HAS_ROOT_NAME`_ <path-var> <out-var>)
+    cmake_path(`HAS_ROOT_DIRECTORY`_ <path-var> <out-var>)
+    cmake_path(`HAS_ROOT_PATH`_ <path-var> <out-var>)
+    cmake_path(`HAS_FILENAME`_ <path-var> <out-var>)
+    cmake_path(`HAS_EXTENSION`_ <path-var> <out-var>)
+    cmake_path(`HAS_STEM`_ <path-var> <out-var>)
+    cmake_path(`HAS_RELATIVE_PART`_ <path-var> <out-var>)
+    cmake_path(`HAS_PARENT_PATH`_ <path-var> <out-var>)
+    cmake_path(`IS_ABSOLUTE`_ <path-var> <out-var>)
+    cmake_path(`IS_RELATIVE`_ <path-var> <out-var>)
+    cmake_path(`IS_PREFIX`_ <path-var> <input> [NORMALIZE] <out-var>)
+    cmake_path(`COMPARE`_ <input1> <OP> <input2> <out-var>)
+
+  `Modification`_
+    cmake_path(:ref:`SET <cmake_path-SET>` <path-var> [NORMALIZE] <input>)
+    cmake_path(`APPEND`_ <path-var> [<input>...] [OUTPUT_VARIABLE <out-var>])
+    cmake_path(`APPEND_STRING`_ <path-var> [<input>...] [OUTPUT_VARIABLE <out-var>])
+    cmake_path(`REMOVE_FILENAME`_ <path-var> [OUTPUT_VARIABLE <out-var>])
+    cmake_path(`REPLACE_FILENAME`_ <path-var> <input> [OUTPUT_VARIABLE <out-var>])
+    cmake_path(`REMOVE_EXTENSION`_ <path-var> [LAST_ONLY] [OUTPUT_VARIABLE <out-var>])
+    cmake_path(`REPLACE_EXTENSION`_ <path-var> [LAST_ONLY] <input> [OUTPUT_VARIABLE <out-var>])
+
+  `Generation`_
+    cmake_path(`NORMAL_PATH`_ <path-var> [OUTPUT_VARIABLE <out-var>])
+    cmake_path(`RELATIVE_PATH`_ <path-var> [BASE_DIRECTORY <input>] [OUTPUT_VARIABLE <out-var>])
+    cmake_path(`ABSOLUTE_PATH`_ <path-var> [BASE_DIRECTORY <input>] [NORMALIZE] [OUTPUT_VARIABLE <out-var>])
+
+  `Native Conversion`_
+    cmake_path(`NATIVE_PATH`_ <path-var> [NORMALIZE] <out-var>)
+    cmake_path(`CONVERT`_ <input> `TO_CMAKE_PATH_LIST`_ <out-var> [NORMALIZE])
+    cmake_path(`CONVERT`_ <input> `TO_NATIVE_PATH_LIST`_ <out-var> [NORMALIZE])
+
+  `Hashing`_
+    cmake_path(`HASH`_ <path-var> <out-var>)
+
+Conventions
+^^^^^^^^^^^
+
+The following conventions are used in this command's documentation:
+
+``<path-var>``
+  Always the name of a variable.  For commands that expect a ``<path-var>``
+  as input, the variable must exist and it is expected to hold a single path.
+
+``<input>``
+  A string literal which may contain a path, path fragment, or multiple paths
+  with a special separator depending on the command.  See the description of
+  each command to see how this is interpreted.
+
+``<input>...``
+  Zero or more string literal arguments.
+
+``<out-var>``
+  The name of a variable into which the result of a command will be written.
+
+
+.. _Path Structure And Terminology:
+
+Path Structure And Terminology
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A path has the following structure (all components are optional, with some
+constraints):
+
+::
+
+  root-name root-directory-separator (item-name directory-separator)* filename
+
+``root-name``
+  Identifies the root on a filesystem with multiple roots (such as ``"C:"``
+  or ``"//myserver"``). It is optional.
+
+``root-directory-separator``
+  A directory separator that, if present, indicates that this path is
+  absolute.  If it is missing and the first element other than the
+  ``root-name`` is an ``item-name``, then the path is relative.
+
+``item-name``
+  A sequence of characters that aren't directory separators.  This name may
+  identify a file, a hard link, a symbolic link, or a directory.  Two special
+  cases are recognized:
+
+    * The item name consisting of a single dot character ``.`` is a
+      directory name that refers to the current directory.
+
+    * The item name consisting of two dot characters ``..`` is a
+      directory name that refers to the parent directory.
+
+  The ``(...)*`` pattern shown above is to indicate that there can be zero
+  or more item names, with multiple items separated by a
+  ``directory-separator``.  The ``()*`` characters are not part of the path.
+
+``directory-separator``
+  The only recognized directory separator is a forward slash character ``/``.
+  If this character is repeated, it is treated as a single directory
+  separator.  In other words, ``/usr///////lib`` is the same as ``/usr/lib``.
+
+.. _FILENAME_DEF:
+.. _EXTENSION_DEF:
+.. _STEM_DEF:
+
+``filename``
+  A path has a ``filename`` if it does not end with a ``directory-separator``.
+  The ``filename`` is effectively the last ``item-name`` of the path, so it
+  can also be a hard link, symbolic link or a directory.
+
+  A ``filename`` can have an *extension*.  By default, the extension is
+  defined as the sub-string beginning at the left-most period (including
+  the period) and until the end of the ``filename``.  In commands that
+  accept a ``LAST_ONLY`` keyword, ``LAST_ONLY`` changes the interpretation
+  to the sub-string beginning at the right-most period.
+
+  The following exceptions apply to the above interpretation:
+
+    * If the first character in the ``filename`` is a period, that period is
+      ignored (i.e. a ``filename`` like ``".profile"`` is treated as having
+      no extension).
+
+    * If the ``filename`` is either ``.`` or ``..``, it has no extension.
+
+  The *stem* is the part of the ``filename`` before the extension.
+
+Some commands refer to a ``root-path``.  This is the concatenation of
+``root-name`` and ``root-directory-separator``, either or both of which can
+be empty.  A ``relative-part`` refers to the full path with any ``root-path``
+removed.
+
+
+Creating A Path Variable
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+While a path can be created with care using an ordinary :command:`set`
+command, it is recommended to use :ref:`cmake_path(SET) <cmake_path-SET>`
+instead, as it automatically converts the path to the required form where
+required.  The :ref:`cmake_path(APPEND) <APPEND>` subcommand may
+be another suitable alternative where a path needs to be constructed by
+joining fragments.  The following example compares the three methods for
+constructing the same path:
+
+.. code-block:: cmake
+
+  set(path1 "${CMAKE_CURRENT_SOURCE_DIR}/data")
+
+  cmake_path(SET path2 "${CMAKE_CURRENT_SOURCE_DIR}/data")
+
+  cmake_path(APPEND path3 "${CMAKE_CURRENT_SOURCE_DIR}" "data")
+
+`Modification`_ and `Generation`_ sub-commands can either store the result
+in-place, or in a separate variable named after an ``OUTPUT_VARIABLE``
+keyword.  All other sub-commands store the result in a mandatory ``<out-var>``
+variable.
+
+.. _Normalization:
+
+Normalization
+^^^^^^^^^^^^^
+
+Some sub-commands support *normalizing* a path.  The algorithm used to
+normalize a path is as follows:
+
+1. If the path is empty, stop (the normalized form of an empty path is
+   also an empty path).
+2. Replace each ``directory-separator``, which may consist of multiple
+   separators, with a single ``/`` (``/a///b  --> /a/b``).
+3. Remove each solitary period (``.``) and any immediately following
+   ``directory-separator`` (``/a/./b/. --> /a/b``).
+4. Remove each ``item-name`` (other than ``..``) that is immediately
+   followed by a ``directory-separator`` and a ``..``, along with any
+   immediately following ``directory-separator`` (``/a/b/../c --> a/c``).
+5. If there is a ``root-directory``, remove any ``..`` and any
+   ``directory-separators`` immediately following them.  The parent of the
+   root directory is treated as still the root directory (``/../a --> /a``).
+6. If the last ``item-name`` is ``..``, remove any trailing
+   ``directory-separator`` (``../ --> ..``).
+7. If the path is empty by this stage, add a ``dot`` (normal form of ``./``
+   is ``.``).
+
+
+.. _Path Decomposition:
+
+Decomposition
+^^^^^^^^^^^^^
+
+.. _GET:
+.. _GET_ROOT_NAME:
+.. _GET_ROOT_DIRECTORY:
+.. _GET_ROOT_PATH:
+.. _GET_FILENAME:
+.. _GET_EXTENSION:
+.. _GET_STEM:
+.. _GET_RELATIVE_PART:
+.. _GET_PARENT_PATH:
+
+The following forms of the ``GET`` subcommand each retrieve a different
+component or group of components from a path.  See
+`Path Structure And Terminology`_ for the meaning of each path component.
+
+.. code-block:: cmake
+
+  cmake_path(GET <path-var> ROOT_NAME <out-var>)
+  cmake_path(GET <path-var> ROOT_DIRECTORY <out-var>)
+  cmake_path(GET <path-var> ROOT_PATH <out-var>)
+  cmake_path(GET <path-var> FILENAME <out-var>)
+  cmake_path(GET <path-var> EXTENSION [LAST_ONLY] <out-var>)
+  cmake_path(GET <path-var> STEM [LAST_ONLY] <out-var>)
+  cmake_path(GET <path-var> RELATIVE_PART <out-var>)
+  cmake_path(GET <path-var> PARENT_PATH <out-var>)
+
+If a requested component is not present in the path, an empty string will be
+stored in ``<out-var>``.  For example, only Windows systems have the concept
+of a ``root-name``, so when the host machine is non-Windows, the ``ROOT_NAME``
+subcommand will always return an empty string.
+
+For ``PARENT_PATH``, if the `HAS_RELATIVE_PART`_ subcommand returns false,
+the result is a copy of ``<path-var>``.  Note that this implies that a root
+directory is considered to have a parent, with that parent being itself.
+Where `HAS_RELATIVE_PART`_ returns true, the result will essentially be
+``<path-var>`` with one less element.
+
+Root examples
+"""""""""""""
+
+.. code-block:: cmake
+
+  set(path "c:/a")
+
+  cmake_path(GET path ROOT_NAME rootName)
+  cmake_path(GET path ROOT_DIRECTORY rootDir)
+  cmake_path(GET path ROOT_PATH rootPath)
+
+  message("Root name is \"${rootName}\"")
+  message("Root directory is \"${rootDir}\"")
+  message("Root path is \"${rootPath}\"")
+
+::
+
+  Root name is "c:"
+  Root directory is "/"
+  Root path is "c:/"
+
+Filename examples
+"""""""""""""""""
+
+.. code-block:: cmake
+
+  set(path "/a/b")
+  cmake_path(GET path FILENAME filename)
+  message("First filename is \"${filename}\"")
+
+  # Trailing slash means filename is empty
+  set(path "/a/b/")
+  cmake_path(GET path FILENAME filename)
+  message("Second filename is \"${filename}\"")
+
+::
+
+  First filename is "b"
+  Second filename is ""
+
+Extension and stem examples
+"""""""""""""""""""""""""""
+
+.. code-block:: cmake
+
+  set(path "name.ext1.ext2")
+
+  cmake_path(GET path EXTENSION fullExt)
+  cmake_path(GET path STEM fullStem)
+  message("Full extension is \"${fullExt}\"")
+  message("Full stem is \"${fullStem}\"")
+
+  # Effect of LAST_ONLY
+  cmake_path(GET path EXTENSION LAST_ONLY lastExt)
+  cmake_path(GET path STEM LAST_ONLY lastStem)
+  message("Last extension is \"${lastExt}\"")
+  message("Last stem is \"${lastStem}\"")
+
+  # Special cases
+  set(dotPath "/a/.")
+  set(dotDotPath "/a/..")
+  set(someMorePath "/a/.some.more")
+  cmake_path(GET dotPath EXTENSION dotExt)
+  cmake_path(GET dotPath STEM dotStem)
+  cmake_path(GET dotDotPath EXTENSION dotDotExt)
+  cmake_path(GET dotDotPath STEM dotDotStem)
+  cmake_path(GET dotMorePath EXTENSION someMoreExt)
+  cmake_path(GET dotMorePath STEM someMoreStem)
+  message("Dot extension is \"${dotExt}\"")
+  message("Dot stem is \"${dotStem}\"")
+  message("Dot-dot extension is \"${dotDotExt}\"")
+  message("Dot-dot stem is \"${dotDotStem}\"")
+  message(".some.more extension is \"${someMoreExt}\"")
+  message(".some.more stem is \"${someMoreStem}\"")
+
+::
+
+  Full extension is ".ext1.ext2"
+  Full stem is "name"
+  Last extension is ".ext2"
+  Last stem is "name.ext1"
+  Dot extension is ""
+  Dot stem is "."
+  Dot-dot extension is ""
+  Dot-dot stem is ".."
+  .some.more extension is ".more"
+  .some.more stem is ".some"
+
+Relative part examples
+""""""""""""""""""""""
+
+.. code-block:: cmake
+
+  set(path "c:/a/b")
+  cmake_path(GET path RELATIVE_PART result)
+  message("Relative part is \"${result}\"")
+
+  set(path "c/d")
+  cmake_path(GET path RELATIVE_PART result)
+  message("Relative part is \"${result}\"")
+
+  set(path "/")
+  cmake_path(GET path RELATIVE_PART result)
+  message("Relative part is \"${result}\"")
+
+::
+
+  Relative part is "a/b"
+  Relative part is "c/d"
+  Relative part is ""
+
+Path traversal examples
+"""""""""""""""""""""""
+
+.. code-block:: cmake
+
+  set(path "c:/a/b")
+  cmake_path(GET path PARENT_PATH result)
+  message("Parent path is \"${result}\"")
+
+  set(path "c:/")
+  cmake_path(GET path PARENT_PATH result)
+  message("Parent path is \"${result}\"")
+
+::
+
+  Parent path is "c:/a"
+  Parent path is "c:/"
+
+
+.. _Path Query:
+
+Query
+^^^^^
+
+Each of the ``GET`` subcommands has a corresponding ``HAS_...``
+subcommand which can be used to discover whether a particular path
+component is present.  See `Path Structure And Terminology`_ for the
+meaning of each path component.
+
+.. _HAS_ROOT_NAME:
+.. _HAS_ROOT_DIRECTORY:
+.. _HAS_ROOT_PATH:
+.. _HAS_FILENAME:
+.. _HAS_EXTENSION:
+.. _HAS_STEM:
+.. _HAS_RELATIVE_PART:
+.. _HAS_PARENT_PATH:
+
+.. code-block:: cmake
+
+  cmake_path(HAS_ROOT_NAME <path-var> <out-var>)
+  cmake_path(HAS_ROOT_DIRECTORY <path-var> <out-var>)
+  cmake_path(HAS_ROOT_PATH <path-var> <out-var>)
+  cmake_path(HAS_FILENAME <path-var> <out-var>)
+  cmake_path(HAS_EXTENSION <path-var> <out-var>)
+  cmake_path(HAS_STEM <path-var> <out-var>)
+  cmake_path(HAS_RELATIVE_PART <path-var> <out-var>)
+  cmake_path(HAS_PARENT_PATH <path-var> <out-var>)
+
+Each of the above follows the predictable pattern of setting ``<out-var>``
+to true if the path has the associated component, or false otherwise.
+Note the following special cases:
+
+* For ``HAS_ROOT_PATH``, a true result will only be returned if at least one
+  of ``root-name`` or ``root-directory`` is non-empty.
+
+* For ``HAS_PARENT_PATH``, the root directory is also considered to have a
+  parent, which will be itself.  The result is true except if the path
+  consists of just a :ref:`filename <FILENAME_DEF>`.
+
+.. _IS_ABSOLUTE:
+
+.. code-block:: cmake
+
+  cmake_path(IS_ABSOLUTE <path-var> <out-var>)
+
+Sets ``<out-var>`` to true if ``<path-var>`` is absolute.  An absolute path
+is a path that unambiguously identifies the location of a file without
+reference to an additional starting location.  On Windows, this means the
+path must have both a ``root-name`` and a ``root-directory-separator`` to be
+considered absolute.  On other platforms, just a ``root-directory-separator``
+is sufficient.  Note that this means on Windows, ``IS_ABSOLUTE`` can be
+false while ``HAS_ROOT_DIRECTORY`` can be true.
+
+.. _IS_RELATIVE:
+
+.. code-block:: cmake
+
+  cmake_path(IS_RELATIVE <path-var> <out-var>)
+
+This will store the opposite of ``IS_ABSOLUTE`` in ``<out-var>``.
+
+.. _IS_PREFIX:
+
+.. code-block:: cmake
+
+  cmake_path(IS_PREFIX <path-var> <input> [NORMALIZE] <out-var>)
+
+Checks if ``<path-var>`` is the prefix of ``<input>``.
+
+When the ``NORMALIZE`` option is specified, ``<path-var>`` and ``<input>``
+are :ref:`normalized <Normalization>` before the check.
+
+.. code-block:: cmake
+
+  set(path "/a/b/c")
+  cmake_path(IS_PREFIX path "/a/b/c/d" result) # result = true
+  cmake_path(IS_PREFIX path "/a/b" result)     # result = false
+  cmake_path(IS_PREFIX path "/x/y/z" result)   # result = false
+
+  set(path "/a/b")
+  cmake_path(IS_PREFIX path "/a/c/../b" NORMALIZE result)   # result = true
+
+.. _Path COMPARE:
+.. _COMPARE:
+
+.. code-block:: cmake
+
+  cmake_path(COMPARE <input1> EQUAL <input2> <out-var>)
+  cmake_path(COMPARE <input1> NOT_EQUAL <input2> <out-var>)
+
+Compares the lexical representations of two paths provided as string literals.
+No normalization is performed on either path, except multiple consecutive
+directory separators are effectively collapsed into a single separator.
+Equality is determined according to the following pseudo-code logic:
+
+::
+
+  if(NOT <input1>.root_name() STREQUAL <input2>.root_name())
+    return FALSE
+
+  if(<input1>.has_root_directory() XOR <input2>.has_root_directory())
+    return FALSE
+
+  Return FALSE if a relative portion of <input1> is not lexicographically
+  equal to the relative portion of <input2>. This comparison is performed path
+  component-wise. If all of the components compare equal, then return TRUE.
+
+.. note::
+  Unlike most other ``cmake_path()`` subcommands, the ``COMPARE`` subcommand
+  takes literal strings as input, not the names of variables.
+
+
+.. _Path Modification:
+
+Modification
+^^^^^^^^^^^^
+
+.. _cmake_path-SET:
+
+.. code-block:: cmake
+
+  cmake_path(SET <path-var> [NORMALIZE] <input>)
+
+Assign the ``<input>`` path to ``<path-var>``.  If ``<input>`` is a native
+path, it is converted into a cmake-style path with forward-slashes
+(``/``). On Windows, the long filename marker is taken into account.
+
+When the ``NORMALIZE`` option is specified, the path is :ref:`normalized
+<Normalization>` after the conversion.
+
+For example:
+
+.. code-block:: cmake
+
+  set(native_path "c:\\a\\b/..\\c")
+  cmake_path(SET path "${native_path}")
+  message("CMake path is \"${path}\"")
+
+  cmake_path(SET path NORMALIZE "${native_path}")
+  message("Normalized CMake path is \"${path}\"")
+
+Output::
+
+  CMake path is "c:/a/b/../c"
+  Normalized CMake path is "c:/a/c"
+
+.. _APPEND:
+
+.. code-block:: cmake
+
+  cmake_path(APPEND <path-var> [<input>...] [OUTPUT_VARIABLE <out-var>])
+
+Append all the ``<input>`` arguments to the ``<path-var>`` using ``/`` as
+the ``directory-separator``.  Depending on the ``<input>``, the previous
+contents of ``<path-var>`` may be discarded.  For each ``<input>`` argument,
+the following algorithm (pseudo-code) applies:
+
+::
+
+  # <path> is the contents of <path-var>
+
+  if(<input>.is_absolute() OR
+     (<input>.has_root_name() AND
+      NOT <input>.root_name() STREQUAL <path>.root_name()))
+    replace <path> with <input>
+    return()
+  endif()
+
+  if(<input>.has_root_directory())
+    remove any root-directory and the entire relative path from <path>
+  elseif(<path>.has_filename() OR
+         (NOT <path-var>.has_root_directory() OR <path>.is_absolute()))
+    append directory-separator to <path>
+  endif()
+
+  append <input> omitting any root-name to <path>
+
+.. _APPEND_STRING:
+
+.. code-block:: cmake
+
+  cmake_path(APPEND_STRING <path-var> [<input>...] [OUTPUT_VARIABLE <out-var>])
+
+Append all the ``<input>`` arguments to the ``<path-var>`` without adding any
+``directory-separator``.
+
+.. _REMOVE_FILENAME:
+
+.. code-block:: cmake
+
+  cmake_path(REMOVE_FILENAME <path-var> [OUTPUT_VARIABLE <out-var>])
+
+Removes the :ref:`filename <FILENAME_DEF>` component (as returned by
+:ref:`GET ... FILENAME <GET_FILENAME>`) from ``<path-var>``.  After removal,
+any trailing ``directory-separator`` is left alone, if present.
+
+If ``OUTPUT_VARIABLE`` is not given, then after this function returns,
+`HAS_FILENAME`_ returns false for ``<path-var>``.
+
+For example:
+
+.. code-block:: cmake
+
+  set(path "/a/b")
+  cmake_path(REMOVE_FILENAME path)
+  message("First path is \"${path}\"")
+
+  # filename is now already empty, the following removes nothing
+  cmake_path(REMOVE_FILENAME path)
+  message("Second path is \"${path}\"")
+
+Output::
+
+  First path is "/a/"
+  Second path is "/a/"
+
+.. _REPLACE_FILENAME:
+
+.. code-block:: cmake
+
+  cmake_path(REPLACE_FILENAME <path-var> <input> [OUTPUT_VARIABLE <out-var>])
+
+Replaces the :ref:`filename <FILENAME_DEF>` component from ``<path-var>``
+with ``<input>``.  If ``<path-var>`` has no filename component (i.e.
+`HAS_FILENAME`_ returns false), the path is unchanged.  The operation is
+equivalent to the following:
+
+.. code-block:: cmake
+
+  cmake_path(HAS_FILENAME path has_filename)
+  if(has_filename)
+    cmake_path(REMOVE_FILENAME path)
+    cmake_path(APPEND path input);
+  endif()
+
+.. _REMOVE_EXTENSION:
+
+.. code-block:: cmake
+
+  cmake_path(REMOVE_EXTENSION <path-var> [LAST_ONLY]
+                                         [OUTPUT_VARIABLE <out-var>])
+
+Removes the :ref:`extension <EXTENSION_DEF>`, if any, from ``<path-var>``.
+
+.. _REPLACE_EXTENSION:
+
+.. code-block:: cmake
+
+  cmake_path(REPLACE_EXTENSION <path-var> [LAST_ONLY] <input>
+                               [OUTPUT_VARIABLE <out-var>])
+
+Replaces the :ref:`extension <EXTENSION_DEF>` with ``<input>``.  Its effect
+is equivalent to the following:
+
+.. code-block:: cmake
+
+  cmake_path(REMOVE_EXTENSION path)
+  if(NOT "input" MATCHES "^\\.")
+    cmake_path(APPEND_STRING path ".")
+  endif()
+  cmake_path(APPEND_STRING path "input")
+
+
+.. _Path Generation:
+
+Generation
+^^^^^^^^^^
+
+.. _NORMAL_PATH:
+
+.. code-block:: cmake
+
+  cmake_path(NORMAL_PATH <path-var> [OUTPUT_VARIABLE <out-var>])
+
+Normalize ``<path-var>`` according the steps described in :ref:`Normalization`.
+
+.. _cmake_path-RELATIVE_PATH:
+.. _RELATIVE_PATH:
+
+.. code-block:: cmake
+
+  cmake_path(RELATIVE_PATH <path-var> [BASE_DIRECTORY <input>]
+                                      [OUTPUT_VARIABLE <out-var>])
+
+Modifies ``<path-var>`` to make it relative to the ``BASE_DIRECTORY`` argument.
+If ``BASE_DIRECTORY`` is not specified, the default base directory will be
+:variable:`CMAKE_CURRENT_SOURCE_DIR`.
+
+For reference, the algorithm used to compute the relative path is the same
+as that used by C++
+`std::filesystem::path::lexically_relative
+<https://en.cppreference.com/w/cpp/filesystem/path/lexically_normal>`_.
+
+.. _ABSOLUTE_PATH:
+
+.. code-block:: cmake
+
+  cmake_path(ABSOLUTE_PATH <path-var> [BASE_DIRECTORY <input>] [NORMALIZE]
+                                      [OUTPUT_VARIABLE <out-var>])
+
+If ``<path-var>`` is a relative path (`IS_RELATIVE`_ is true), it is evaluated
+relative to the given base directory specified by ``BASE_DIRECTORY`` option.
+If ``BASE_DIRECTORY`` is not specified, the default base directory will be
+:variable:`CMAKE_CURRENT_SOURCE_DIR`.
+
+When the ``NORMALIZE`` option is specified, the path is :ref:`normalized
+<Normalization>` after the path computation.
+
+Because ``cmake_path()`` does not access the filesystem, symbolic links are
+not resolved and any leading tilde is not expanded.  To compute a real path
+with symbolic links resolved and leading tildes expanded, use the
+:command:`file(REAL_PATH)` command instead.
+
+Native Conversion
+^^^^^^^^^^^^^^^^^
+
+For commands in this section, *native* refers to the host platform, not the
+target platform when cross-compiling.
+
+.. _cmake_path-NATIVE_PATH:
+.. _NATIVE_PATH:
+
+.. code-block:: cmake
+
+  cmake_path(NATIVE_PATH <path-var> [NORMALIZE] <out-var>)
+
+Converts a cmake-style ``<path-var>`` into a native path with
+platform-specific slashes (``\`` on Windows hosts and ``/`` elsewhere).
+
+When the ``NORMALIZE`` option is specified, the path is :ref:`normalized
+<Normalization>` before the conversion.
+
+.. _CONVERT:
+.. _cmake_path-TO_CMAKE_PATH_LIST:
+.. _TO_CMAKE_PATH_LIST:
+
+.. code-block:: cmake
+
+  cmake_path(CONVERT <input> TO_CMAKE_PATH_LIST <out-var> [NORMALIZE])
+
+Converts a native ``<input>`` path into a cmake-style path with forward
+slashes (``/``).  On Windows hosts, the long filename marker is taken into
+account.  The input can be a single path or a system search path like
+``$ENV{PATH}``.  A search path will be converted to a cmake-style list
+separated by ``;`` characters (on non-Windows platforms, this essentially
+means ``:`` separators are replaced with ``;``).  The result of the
+conversion is stored in the ``<out-var>`` variable.
+
+When the ``NORMALIZE`` option is specified, the path is :ref:`normalized
+<Normalization>` before the conversion.
+
+.. note::
+  Unlike most other ``cmake_path()`` subcommands, the ``CONVERT`` subcommand
+  takes a literal string as input, not the name of a variable.
+
+.. _cmake_path-TO_NATIVE_PATH_LIST:
+.. _TO_NATIVE_PATH_LIST:
+
+.. code-block:: cmake
+
+  cmake_path(CONVERT <input> TO_NATIVE_PATH_LIST <out-var> [NORMALIZE])
+
+Converts a cmake-style ``<input>`` path into a native path with
+platform-specific slashes (``\`` on Windows hosts and ``/`` elsewhere).
+The input can be a single path or a cmake-style list.  A list will be
+converted into a native search path (``;``-separated on Windows,
+``:``-separated on other platforms).  The result of the conversion is
+stored in the ``<out-var>`` variable.
+
+When the ``NORMALIZE`` option is specified, the path is :ref:`normalized
+<Normalization>` before the conversion.
+
+.. note::
+  Unlike most other ``cmake_path()`` subcommands, the ``CONVERT`` subcommand
+  takes a literal string as input, not the name of a variable.
+
+For example:
+
+.. code-block:: cmake
+
+  set(paths "/a/b/c" "/x/y/z")
+  cmake_path(CONVERT "${paths}" TO_NATIVE_PATH_LIST native_paths)
+  message("Native path list is \"${native_paths}\"")
+
+Output on Windows::
+
+  Native path list is "\a\b\c;\x\y\z"
+
+Output on all other platforms::
+
+  Native path list is "/a/b/c:/x/y/z"
+
+Hashing
+^^^^^^^
+
+.. _HASH:
+
+.. code-block:: cmake
+
+    cmake_path(HASH <path-var> <out-var>)
+
+Compute a hash value of ``<path-var>`` such that for two paths ``p1`` and
+``p2`` that compare equal (:ref:`COMPARE ... EQUAL <COMPARE>`), the hash
+value of ``p1`` is equal to the hash value of ``p2``.  The path is always
+:ref:`normalized <Normalization>` before the hash is computed.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/configure_file.rst

@@ -0,0 +1,203 @@
+configure_file
+--------------
+
+.. only:: html
+
+   .. contents::
+
+Copy a file to another location and modify its contents.
+
+.. code-block:: cmake
+
+  configure_file(<input> <output>
+                 [NO_SOURCE_PERMISSIONS | USE_SOURCE_PERMISSIONS |
+                  FILE_PERMISSIONS <permissions>...]
+                 [COPYONLY] [ESCAPE_QUOTES] [@ONLY]
+                 [NEWLINE_STYLE [UNIX|DOS|WIN32|LF|CRLF] ])
+
+Copies an ``<input>`` file to an ``<output>`` file while performing
+`transformations`_ of the input file content.
+
+If the input file is modified the build system will re-run CMake to
+re-configure the file and generate the build system again.
+The generated file is modified and its timestamp updated on subsequent
+cmake runs only if its content is changed.
+
+Options
+^^^^^^^
+
+The options are:
+
+``<input>``
+  Path to the input file.  A relative path is treated with respect to
+  the value of :variable:`CMAKE_CURRENT_SOURCE_DIR`.  The input path
+  must be a file, not a directory.
+
+``<output>``
+  Path to the output file or directory.  A relative path is treated
+  with respect to the value of :variable:`CMAKE_CURRENT_BINARY_DIR`.
+  If the path names an existing directory the output file is placed
+  in that directory with the same file name as the input file.
+  If the path contains non-existent directories, they are created.
+
+``NO_SOURCE_PERMISSIONS``
+  .. versionadded:: 3.19
+
+  Do not transfer the permissions of the input file to the output file.
+  The copied file permissions default to the standard 644 value
+  (-rw-r--r--).
+
+``USE_SOURCE_PERMISSIONS``
+  .. versionadded:: 3.20
+
+  Transfer the permissions of the input file to the output file.
+  This is already the default behavior if none of the three permissions-related
+  keywords are given (``NO_SOURCE_PERMISSIONS``, ``USE_SOURCE_PERMISSIONS``
+  or ``FILE_PERMISSIONS``).  The ``USE_SOURCE_PERMISSIONS`` keyword mostly
+  serves as a way of making the intended behavior clearer at the call site.
+
+``FILE_PERMISSIONS <permissions>...``
+  .. versionadded:: 3.20
+
+  Ignore the input file's permissions and use the specified ``<permissions>``
+  for the output file instead.
+
+``COPYONLY``
+  Copy the file without replacing any variable references or other
+  content.  This option may not be used with ``NEWLINE_STYLE``.
+
+``ESCAPE_QUOTES``
+  Escape any substituted quotes with backslashes (C-style).
+
+``@ONLY``
+  Restrict variable replacement to references of the form ``@VAR@``.
+  This is useful for configuring scripts that use ``${VAR}`` syntax.
+
+``NEWLINE_STYLE <style>``
+  Specify the newline style for the output file.  Specify
+  ``UNIX`` or ``LF`` for ``\n`` newlines, or specify
+  ``DOS``, ``WIN32``, or ``CRLF`` for ``\r\n`` newlines.
+  This option may not be used with ``COPYONLY``.
+
+Transformations
+^^^^^^^^^^^^^^^
+
+:ref:`Variables <CMake Language Variables>` referenced in the input
+file content as ``@VAR@``, ``${VAR}``, ``$CACHE{VAR}``, and
+:ref:`environment variables <CMake Language Environment Variables>`
+referenced as ``$ENV{VAR}``, will each be replaced with the current value
+of the variable, or the empty string if the variable is not defined.
+Furthermore, input lines of the form
+
+.. code-block:: c
+
+  #cmakedefine VAR ...
+
+will be replaced with either
+
+.. code-block:: c
+
+  #define VAR ...
+
+or
+
+.. code-block:: c
+
+  /* #undef VAR */
+
+depending on whether ``VAR`` is set in CMake to any value not considered
+a false constant by the :command:`if` command.  The "..." content on the
+line after the variable name, if any, is processed as above.
+
+Unlike lines of the form ``#cmakedefine VAR ...``, in lines of the form
+``#cmakedefine01 VAR``, ``VAR`` itself will expand to ``VAR 0`` or ``VAR 1``
+rather than being assigned the value ``...``. Therefore, input lines of the form
+
+.. code-block:: c
+
+  #cmakedefine01 VAR
+
+will be replaced with either
+
+.. code-block:: c
+
+  #define VAR 0
+
+or
+
+.. code-block:: c
+
+  #define VAR 1
+
+Input lines of the form ``#cmakedefine01 VAR ...`` will expand
+as ``#cmakedefine01 VAR ... 0`` or ``#cmakedefine01 VAR ... 1``,
+which may lead to undefined behavior.
+
+.. versionadded:: 3.10
+  The result lines (with the exception of the ``#undef`` comments) can be
+  indented using spaces and/or tabs between the ``#`` character
+  and the ``cmakedefine`` or ``cmakedefine01`` words. This whitespace
+  indentation will be preserved in the output lines:
+
+  .. code-block:: c
+
+    #  cmakedefine VAR
+    #  cmakedefine01 VAR
+
+  will be replaced, if ``VAR`` is defined, with
+
+  .. code-block:: c
+
+    #  define VAR
+    #  define VAR 1
+
+Example
+^^^^^^^
+
+Consider a source tree containing a ``foo.h.in`` file:
+
+.. code-block:: c
+
+  #cmakedefine FOO_ENABLE
+  #cmakedefine FOO_STRING "@FOO_STRING@"
+
+An adjacent ``CMakeLists.txt`` may use ``configure_file`` to
+configure the header:
+
+.. code-block:: cmake
+
+  option(FOO_ENABLE "Enable Foo" ON)
+  if(FOO_ENABLE)
+    set(FOO_STRING "foo")
+  endif()
+  configure_file(foo.h.in foo.h @ONLY)
+
+This creates a ``foo.h`` in the build directory corresponding to
+this source directory.  If the ``FOO_ENABLE`` option is on, the
+configured file will contain:
+
+.. code-block:: c
+
+  #define FOO_ENABLE
+  #define FOO_STRING "foo"
+
+Otherwise it will contain:
+
+.. code-block:: c
+
+  /* #undef FOO_ENABLE */
+  /* #undef FOO_STRING */
+
+One may then use the :command:`target_include_directories` command to
+specify the output directory as an include directory:
+
+.. code-block:: cmake
+
+  target_include_directories(<target> [SYSTEM] <INTERFACE|PUBLIC|PRIVATE> "${CMAKE_CURRENT_BINARY_DIR}")
+
+so that sources may include the header as ``#include <foo.h>``.
+
+See Also
+^^^^^^^^
+
+* :command:`file(GENERATE)`

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/ctest_build.rst

@@ -0,0 +1,93 @@
+ctest_build
+-----------
+
+Perform the :ref:`CTest Build Step` as a :ref:`Dashboard Client`.
+
+.. code-block:: cmake
+
+  ctest_build([BUILD <build-dir>] [APPEND]
+              [CONFIGURATION <config>]
+              [PARALLEL_LEVEL <parallel>]
+              [FLAGS <flags>]
+              [PROJECT_NAME <project-name>]
+              [TARGET <target-name>]
+              [NUMBER_ERRORS <num-err-var>]
+              [NUMBER_WARNINGS <num-warn-var>]
+              [RETURN_VALUE <result-var>]
+              [CAPTURE_CMAKE_ERROR <result-var>]
+              )
+
+Build the project and store results in ``Build.xml``
+for submission with the :command:`ctest_submit` command.
+
+The :variable:`CTEST_BUILD_COMMAND` variable may be set to explicitly
+specify the build command line.  Otherwise the build command line is
+computed automatically based on the options given.
+
+The options are:
+
+``BUILD <build-dir>``
+  Specify the top-level build directory.  If not given, the
+  :variable:`CTEST_BINARY_DIRECTORY` variable is used.
+
+``APPEND``
+  Mark ``Build.xml`` for append to results previously submitted to a
+  dashboard server since the last :command:`ctest_start` call.
+  Append semantics are defined by the dashboard server in use.
+  This does *not* cause results to be appended to a ``.xml`` file
+  produced by a previous call to this command.
+
+``CONFIGURATION <config>``
+  Specify the build configuration (e.g. ``Debug``).  If not
+  specified the ``CTEST_BUILD_CONFIGURATION`` variable will be checked.
+  Otherwise the :option:`-C \<cfg\> <ctest -C>` option given to the
+  :manual:`ctest(1)` command will be used, if any.
+
+``PARALLEL_LEVEL <parallel>``
+  .. versionadded:: 3.21
+
+  Specify the parallel level of the underlying build system.  If not
+  specified, the :envvar:`CMAKE_BUILD_PARALLEL_LEVEL` environment
+  variable will be checked.
+
+``FLAGS <flags>``
+  Pass additional arguments to the underlying build command.
+  If not specified the ``CTEST_BUILD_FLAGS`` variable will be checked.
+  This can, e.g., be used to trigger a parallel build using the
+  ``-j`` option of ``make``. See the :module:`ProcessorCount` module
+  for an example.
+
+``PROJECT_NAME <project-name>``
+  Ignored since CMake 3.0.
+
+  .. versionchanged:: 3.14
+    This value is no longer required.
+
+``TARGET <target-name>``
+  Specify the name of a target to build.  If not specified the
+  ``CTEST_BUILD_TARGET`` variable will be checked.  Otherwise the
+  default target will be built.  This is the "all" target
+  (called ``ALL_BUILD`` in :ref:`Visual Studio Generators`).
+
+``NUMBER_ERRORS <num-err-var>``
+  Store the number of build errors detected in the given variable.
+
+``NUMBER_WARNINGS <num-warn-var>``
+  Store the number of build warnings detected in the given variable.
+
+``RETURN_VALUE <result-var>``
+  Store the return value of the native build tool in the given variable.
+
+``CAPTURE_CMAKE_ERROR <result-var>``
+  .. versionadded:: 3.7
+
+  Store in the ``<result-var>`` variable -1 if there are any errors running
+  the command and prevent ctest from returning non-zero if an error occurs.
+
+``QUIET``
+  .. versionadded:: 3.3
+
+  Suppress any CTest-specific non-error output that would have been
+  printed to the console otherwise.  The summary of warnings / errors,
+  as well as the output from the native build tool is unaffected by
+  this option.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/ctest_configure.rst

@@ -0,0 +1,50 @@
+ctest_configure
+---------------
+
+Perform the :ref:`CTest Configure Step` as a :ref:`Dashboard Client`.
+
+.. code-block:: cmake
+
+  ctest_configure([BUILD <build-dir>] [SOURCE <source-dir>] [APPEND]
+                  [OPTIONS <options>] [RETURN_VALUE <result-var>] [QUIET]
+                  [CAPTURE_CMAKE_ERROR <result-var>])
+
+Configure the project build tree and record results in ``Configure.xml``
+for submission with the :command:`ctest_submit` command.
+
+The options are:
+
+``BUILD <build-dir>``
+  Specify the top-level build directory.  If not given, the
+  :variable:`CTEST_BINARY_DIRECTORY` variable is used.
+
+``SOURCE <source-dir>``
+  Specify the source directory.  If not given, the
+  :variable:`CTEST_SOURCE_DIRECTORY` variable is used.
+
+``APPEND``
+  Mark ``Configure.xml`` for append to results previously submitted to a
+  dashboard server since the last :command:`ctest_start` call.
+  Append semantics are defined by the dashboard server in use.
+  This does *not* cause results to be appended to a ``.xml`` file
+  produced by a previous call to this command.
+
+``OPTIONS <options>``
+  Specify command-line arguments to pass to the configuration tool.
+
+``RETURN_VALUE <result-var>``
+  Store in the ``<result-var>`` variable the return value of the native
+  configuration tool.
+
+``CAPTURE_CMAKE_ERROR <result-var>``
+  .. versionadded:: 3.7
+
+  Store in the ``<result-var>`` variable -1 if there are any errors running
+  the command and prevent ctest from returning non-zero if an error occurs.
+
+``QUIET``
+  .. versionadded:: 3.3
+
+  Suppress any CTest-specific non-error messages that would have
+  otherwise been printed to the console.  Output from the underlying
+  configure command is not affected.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/ctest_coverage.rst

@@ -0,0 +1,50 @@
+ctest_coverage
+--------------
+
+Perform the :ref:`CTest Coverage Step` as a :ref:`Dashboard Client`.
+
+.. code-block:: cmake
+
+  ctest_coverage([BUILD <build-dir>] [APPEND]
+                 [LABELS <label>...]
+                 [RETURN_VALUE <result-var>]
+                 [CAPTURE_CMAKE_ERROR <result-var>]
+                 [QUIET]
+                 )
+
+Collect coverage tool results and stores them in ``Coverage.xml``
+for submission with the :command:`ctest_submit` command.
+
+The options are:
+
+``BUILD <build-dir>``
+  Specify the top-level build directory.  If not given, the
+  :variable:`CTEST_BINARY_DIRECTORY` variable is used.
+
+``APPEND``
+  Mark ``Coverage.xml`` for append to results previously submitted to a
+  dashboard server since the last :command:`ctest_start` call.
+  Append semantics are defined by the dashboard server in use.
+  This does *not* cause results to be appended to a ``.xml`` file
+  produced by a previous call to this command.
+
+``LABELS``
+  Filter the coverage report to include only source files labeled
+  with at least one of the labels specified.
+
+``RETURN_VALUE <result-var>``
+  Store in the ``<result-var>`` variable ``0`` if coverage tools
+  ran without error and non-zero otherwise.
+
+``CAPTURE_CMAKE_ERROR <result-var>``
+  .. versionadded:: 3.7
+
+  Store in the ``<result-var>`` variable -1 if there are any errors running
+  the command and prevent ctest from returning non-zero if an error occurs.
+
+``QUIET``
+  .. versionadded:: 3.3
+
+  Suppress any CTest-specific non-error output that would have been
+  printed to the console otherwise.  The summary indicating how many
+  lines of code were covered is unaffected by this option.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/ctest_memcheck.rst

@@ -0,0 +1,45 @@
+ctest_memcheck
+--------------
+
+Perform the :ref:`CTest MemCheck Step` as a :ref:`Dashboard Client`.
+
+.. code-block:: cmake
+
+  ctest_memcheck([BUILD <build-dir>] [APPEND]
+                 [START <start-number>]
+                 [END <end-number>]
+                 [STRIDE <stride-number>]
+                 [EXCLUDE <exclude-regex>]
+                 [INCLUDE <include-regex>]
+                 [EXCLUDE_LABEL <label-exclude-regex>]
+                 [INCLUDE_LABEL <label-include-regex>]
+                 [EXCLUDE_FIXTURE <regex>]
+                 [EXCLUDE_FIXTURE_SETUP <regex>]
+                 [EXCLUDE_FIXTURE_CLEANUP <regex>]
+                 [PARALLEL_LEVEL <level>]
+                 [RESOURCE_SPEC_FILE <file>]
+                 [TEST_LOAD <threshold>]
+                 [SCHEDULE_RANDOM <ON|OFF>]
+                 [STOP_ON_FAILURE]
+                 [STOP_TIME <time-of-day>]
+                 [RETURN_VALUE <result-var>]
+                 [CAPTURE_CMAKE_ERROR <result-var>]
+                 [REPEAT <mode>:<n>]
+                 [OUTPUT_JUNIT <file>]
+                 [DEFECT_COUNT <defect-count-var>]
+                 [QUIET]
+                 )
+
+
+Run tests with a dynamic analysis tool and store results in
+``MemCheck.xml`` for submission with the :command:`ctest_submit`
+command.
+
+Most options are the same as those for the :command:`ctest_test` command.
+
+The options unique to this command are:
+
+``DEFECT_COUNT <defect-count-var>``
+  .. versionadded:: 3.8
+
+  Store in the ``<defect-count-var>`` the number of defects found.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/ctest_read_custom_files.rst

@@ -0,0 +1,14 @@
+ctest_read_custom_files
+-----------------------
+
+read CTestCustom files.
+
+.. code-block:: cmake
+
+  ctest_read_custom_files(<directory>...)
+
+Read all the CTestCustom.ctest or CTestCustom.cmake files from the
+given directory.
+
+By default, invoking :manual:`ctest(1)` without a script will read custom
+files from the binary directory.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/ctest_upload.rst

@@ -0,0 +1,26 @@
+ctest_upload
+------------
+
+Upload files to a dashboard server as a :ref:`Dashboard Client`.
+
+.. code-block:: cmake
+
+  ctest_upload(FILES <file>... [QUIET] [CAPTURE_CMAKE_ERROR <result-var>])
+
+The options are:
+
+``FILES <file>...``
+  Specify a list of files to be sent along with the build results to the
+  dashboard server.
+
+``QUIET``
+  .. versionadded:: 3.3
+
+  Suppress any CTest-specific non-error output that would have been
+  printed to the console otherwise.
+
+``CAPTURE_CMAKE_ERROR <result-var>``
+  .. versionadded:: 3.7
+
+  Store in the ``<result-var>`` variable -1 if there are any errors running
+  the command and prevent ctest from returning non-zero if an error occurs.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/elseif.rst

@@ -0,0 +1,11 @@
+elseif
+------
+
+Starts an elseif portion of an if block.
+
+.. code-block:: cmake
+
+  elseif(<condition>)
+
+See the :command:`if` command, especially for the syntax and logic
+of the ``<condition>``.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/enable_testing.rst

@@ -0,0 +1,20 @@
+enable_testing
+--------------
+
+Enable testing for current directory and below.
+
+.. code-block:: cmake
+
+  enable_testing()
+
+Enables testing for this directory and below.
+
+This command should be in the source directory root
+because ctest expects to find a test file in the build
+directory root.
+
+This command is automatically invoked when the :module:`CTest`
+module is included, except if the ``BUILD_TESTING`` option is
+turned off.
+
+See also the :command:`add_test` command.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/endfunction.rst

@@ -0,0 +1,14 @@
+endfunction
+-----------
+
+Ends a list of commands in a function block.
+
+.. code-block:: cmake
+
+  endfunction([<name>])
+
+See the :command:`function` command.
+
+The optional ``<name>`` argument is supported for backward compatibility
+only. If used it must be a verbatim repeat of the ``<name>`` argument
+of the opening ``function`` command.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/endmacro.rst

@@ -0,0 +1,14 @@
+endmacro
+--------
+
+Ends a list of commands in a macro block.
+
+.. code-block:: cmake
+
+  endmacro([<name>])
+
+See the :command:`macro` command.
+
+The optional ``<name>`` argument is supported for backward compatibility
+only. If used it must be a verbatim repeat of the ``<name>`` argument
+of the opening ``macro`` command.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/file.rst

@@ -0,0 +1,1342 @@
+file
+----
+
+File manipulation command.
+
+This command is dedicated to file and path manipulation requiring access to the
+filesystem.
+
+For other path manipulation, handling only syntactic aspects, have a look at
+:command:`cmake_path` command.
+
+.. note::
+
+  The sub-commands `RELATIVE_PATH`_, `TO_CMAKE_PATH`_ and `TO_NATIVE_PATH`_ has
+  been superseded, respectively, by sub-commands
+  :ref:`RELATIVE_PATH <cmake_path-RELATIVE_PATH>`,
+  :ref:`CONVERT ... TO_CMAKE_PATH_LIST <cmake_path-TO_CMAKE_PATH_LIST>` and
+  :ref:`CONVERT ... TO_NATIVE_PATH_LIST <cmake_path-TO_NATIVE_PATH_LIST>` of
+  :command:`cmake_path` command.
+
+Synopsis
+^^^^^^^^
+
+.. parsed-literal::
+
+  `Reading`_
+    file(`READ`_ <filename> <out-var> [...])
+    file(`STRINGS`_ <filename> <out-var> [...])
+    file(`\<HASH\>`_ <filename> <out-var>)
+    file(`TIMESTAMP`_ <filename> <out-var> [...])
+
+  `Writing`_
+    file({`WRITE`_ | `APPEND`_} <filename> <content>...)
+    file({`TOUCH`_ | `TOUCH_NOCREATE`_} <file>...)
+    file(`GENERATE`_ OUTPUT <output-file> [...])
+    file(`CONFIGURE`_ OUTPUT <output-file> CONTENT <content> [...])
+
+  `Filesystem`_
+    file({`GLOB`_ | `GLOB_RECURSE`_} <out-var> [...] <globbing-expr>...)
+    file(`MAKE_DIRECTORY`_ <directories>...)
+    file({`REMOVE`_ | `REMOVE_RECURSE`_ } <files>...)
+    file(`RENAME`_ <oldname> <newname> [...])
+    file(`COPY_FILE`_ <oldname> <newname> [...])
+    file({`COPY`_ | `INSTALL`_} <file>... DESTINATION <dir> [...])
+    file(`SIZE`_ <filename> <out-var>)
+    file(`READ_SYMLINK`_ <linkname> <out-var>)
+    file(`CREATE_LINK`_ <original> <linkname> [...])
+    file(`CHMOD`_ <files>... <directories>... PERMISSIONS <permissions>... [...])
+    file(`CHMOD_RECURSE`_ <files>... <directories>... PERMISSIONS <permissions>... [...])
+
+  `Path Conversion`_
+    file(`REAL_PATH`_ <path> <out-var> [BASE_DIRECTORY <dir>] [EXPAND_TILDE])
+    file(`RELATIVE_PATH`_ <out-var> <directory> <file>)
+    file({`TO_CMAKE_PATH`_ | `TO_NATIVE_PATH`_} <path> <out-var>)
+
+  `Transfer`_
+    file(`DOWNLOAD`_ <url> [<file>] [...])
+    file(`UPLOAD`_ <file> <url> [...])
+
+  `Locking`_
+    file(`LOCK`_ <path> [...])
+
+  `Archiving`_
+    file(`ARCHIVE_CREATE`_ OUTPUT <archive> PATHS <paths>... [...])
+    file(`ARCHIVE_EXTRACT`_ INPUT <archive> [...])
+
+  `Handling Runtime Binaries`_
+    file(`GET_RUNTIME_DEPENDENCIES`_ [...])
+
+
+Reading
+^^^^^^^
+
+.. signature::
+  file(READ <filename> <variable>
+       [OFFSET <offset>] [LIMIT <max-in>] [HEX])
+
+  Read content from a file called ``<filename>`` and store it in a
+  ``<variable>``.  Optionally start from the given ``<offset>`` and
+  read at most ``<max-in>`` bytes.  The ``HEX`` option causes data to
+  be converted to a hexadecimal representation (useful for binary data).
+  If the ``HEX`` option is specified, letters in the output
+  (``a`` through ``f``) are in lowercase.
+
+.. signature::
+  file(STRINGS <filename> <variable> <options>...)
+
+  Parse a list of ASCII strings from ``<filename>`` and store it in
+  ``<variable>``.  Binary data in the file are ignored.  Carriage return
+  (``\r``, CR) characters are ignored.  The options are:
+
+    ``LENGTH_MAXIMUM <max-len>``
+      Consider only strings of at most a given length.
+
+    ``LENGTH_MINIMUM <min-len>``
+      Consider only strings of at least a given length.
+
+    ``LIMIT_COUNT <max-num>``
+      Limit the number of distinct strings to be extracted.
+
+    ``LIMIT_INPUT <max-in>``
+      Limit the number of input bytes to read from the file.
+
+    ``LIMIT_OUTPUT <max-out>``
+      Limit the number of total bytes to store in the ``<variable>``.
+
+    ``NEWLINE_CONSUME``
+      Treat newline characters (``\n``, LF) as part of string content
+      instead of terminating at them.
+
+    ``NO_HEX_CONVERSION``
+      Intel Hex and Motorola S-record files are automatically converted to
+      binary while reading unless this option is given.
+
+    ``REGEX <regex>``
+      Consider only strings that match the given regular expression,
+      as described under :ref:`string(REGEX) <Regex Specification>`.
+
+      .. versionchanged:: 3.29
+        Capture groups from the last match in the file are stored in
+        :variable:`CMAKE_MATCH_<n>`, similar to
+        :command:`string(REGEX MATCHALL)`.  See policy :policy:`CMP0159`.
+
+    ``ENCODING <encoding-type>``
+      .. versionadded:: 3.1
+
+      Consider strings of a given encoding.  Currently supported encodings are:
+      ``UTF-8``, ``UTF-16LE``, ``UTF-16BE``, ``UTF-32LE``, ``UTF-32BE``.
+      If the ``ENCODING`` option is not provided and the file
+      has a Byte Order Mark, the ``ENCODING`` option will be defaulted
+      to respect the Byte Order Mark.
+
+  .. versionadded:: 3.2
+    Added the ``UTF-16LE``, ``UTF-16BE``, ``UTF-32LE``, ``UTF-32BE`` encodings.
+
+  For example, the code
+
+  .. code-block:: cmake
+
+    file(STRINGS myfile.txt myfile)
+
+  stores a list in the variable ``myfile`` in which each item is a line
+  from the input file.
+
+.. signature::
+  file(<HASH> <filename> <variable>)
+  :target: <HASH>
+
+  Compute a cryptographic hash of the content of ``<filename>`` and
+  store it in a ``<variable>``.  The supported ``<HASH>`` algorithm names
+  are those listed by the :command:`string(<HASH>)` command.
+
+.. signature::
+  file(TIMESTAMP <filename> <variable> [<format>] [UTC])
+
+  Compute a string representation of the modification time of ``<filename>``
+  and store it in ``<variable>``.  Should the command be unable to obtain a
+  timestamp variable will be set to the empty string ("").
+
+  See the :command:`string(TIMESTAMP)` command for documentation of
+  the ``<format>`` and ``UTC`` options.
+
+Writing
+^^^^^^^
+
+.. signature::
+  file(WRITE <filename> <content>...)
+  file(APPEND <filename> <content>...)
+
+  Write ``<content>`` into a file called ``<filename>``.  If the file does
+  not exist, it will be created.  If the file already exists, ``WRITE``
+  mode will overwrite it and ``APPEND`` mode will append to the end.
+  Any directories in the path specified by ``<filename>`` that do not
+  exist will be created.
+
+  If the file is a build input, use the :command:`configure_file` command
+  to update the file only when its content changes.
+
+.. signature::
+  file(TOUCH <files>...)
+  file(TOUCH_NOCREATE <files>...)
+
+  .. versionadded:: 3.12
+
+  Create a file with no content if it does not yet exist. If the file already
+  exists, its access and/or modification will be updated to the time when the
+  function call is executed.
+
+  Use ``TOUCH_NOCREATE`` to touch a file if it exists but not create it.
+  If a file does not exist it will be silently ignored.
+
+  With ``TOUCH`` and ``TOUCH_NOCREATE``, the contents of an existing file
+  will not be modified.
+
+  .. versionchanged:: 3.30
+    ``<files>`` can be an empty list. CMake 3.29 and earlier required
+    at least one file to be given.
+
+.. signature::
+  file(GENERATE [...])
+
+  Generate an output file for each build configuration supported by the current
+  :manual:`CMake Generator <cmake-generators(7)>`.  Evaluate
+  :manual:`generator expressions <cmake-generator-expressions(7)>`
+  from the input content to produce the output content.
+
+  .. code-block:: cmake
+
+    file(GENERATE OUTPUT <output-file>
+         <INPUT <input-file>|CONTENT <content>>
+         [CONDITION <expression>] [TARGET <target>]
+         [NO_SOURCE_PERMISSIONS | USE_SOURCE_PERMISSIONS |
+          FILE_PERMISSIONS <permissions>...]
+         [NEWLINE_STYLE [UNIX|DOS|WIN32|LF|CRLF] ])
+
+  The options are:
+
+    ``CONDITION <condition>``
+      Generate the output file for a particular configuration only if
+      the condition is true.  The condition must be either ``0`` or ``1``
+      after evaluating generator expressions.
+
+    ``CONTENT <content>``
+      Use the content given explicitly as input.
+
+    ``INPUT <input-file>``
+      Use the content from a given file as input.
+
+      .. versionchanged:: 3.10
+        A relative path is treated with respect to the value of
+        :variable:`CMAKE_CURRENT_SOURCE_DIR`.  See policy :policy:`CMP0070`.
+
+    ``OUTPUT <output-file>``
+      Specify the output file name to generate.  Use generator expressions
+      such as :genex:`$<CONFIG>` to specify a configuration-specific
+      output file name.  Multiple configurations may generate the same output
+      file only if the generated content is identical.  Otherwise, the
+      ``<output-file>`` must evaluate to an unique name for each configuration.
+
+      .. versionchanged:: 3.10
+        A relative path (after evaluating generator expressions) is treated
+        with respect to the value of :variable:`CMAKE_CURRENT_BINARY_DIR`.
+        See policy :policy:`CMP0070`.
+
+    ``TARGET <target>``
+      .. versionadded:: 3.19
+
+      Specify which target to use when evaluating generator expressions that
+      require a target for evaluation (e.g.
+      :genex:`$<COMPILE_FEATURES:...>`,
+      :genex:`$<TARGET_PROPERTY:prop>`).
+
+    ``NO_SOURCE_PERMISSIONS``
+      .. versionadded:: 3.20
+
+      The generated file permissions default to the standard 644 value
+      (-rw-r--r--).
+
+    ``USE_SOURCE_PERMISSIONS``
+      .. versionadded:: 3.20
+
+      Transfer the file permissions of the ``INPUT`` file to the generated
+      file. This is already the default behavior if none of the three
+      permissions-related keywords are given (``NO_SOURCE_PERMISSIONS``,
+      ``USE_SOURCE_PERMISSIONS`` or ``FILE_PERMISSIONS``).  The
+      ``USE_SOURCE_PERMISSIONS`` keyword mostly serves as a way of making
+      the intended behavior clearer at the call site. It is an error to
+      specify this option without ``INPUT``.
+
+    ``FILE_PERMISSIONS <permissions>...``
+      .. versionadded:: 3.20
+
+      Use the specified permissions for the generated file.
+
+    ``NEWLINE_STYLE <style>``
+      .. versionadded:: 3.20
+
+      Specify the newline style for the generated file.  Specify
+      ``UNIX`` or ``LF`` for ``\n`` newlines, or specify
+      ``DOS``, ``WIN32``, or ``CRLF`` for ``\r\n`` newlines.
+
+  Exactly one ``CONTENT`` or ``INPUT`` option must be given.  A specific
+  ``OUTPUT`` file may be named by at most one invocation of ``file(GENERATE)``.
+  Generated files are modified and their timestamp updated on subsequent cmake
+  runs only if their content is changed.
+
+  Note also that ``file(GENERATE)`` does not create the output file until the
+  generation phase. The output file will not yet have been written when the
+  ``file(GENERATE)`` command returns, it is written only after processing all
+  of a project's ``CMakeLists.txt`` files.
+
+.. signature::
+  file(CONFIGURE OUTPUT <output-file>
+       CONTENT <content>
+       [ESCAPE_QUOTES] [@ONLY]
+       [NEWLINE_STYLE [UNIX|DOS|WIN32|LF|CRLF] ])
+  :target: CONFIGURE
+
+  .. versionadded:: 3.18
+
+  Generate an output file using the input given by ``CONTENT`` and substitute
+  variable values referenced as ``@VAR@`` or ``${VAR}`` contained therein. The
+  substitution rules behave the same as the :command:`configure_file` command.
+  In order to match :command:`configure_file`'s behavior, generator expressions
+  are not supported for both ``OUTPUT`` and ``CONTENT``, and the output file
+  is only modified and its timestamp updated if the content is changed or the
+  file previously didn't exist.
+
+  The arguments are:
+
+    ``OUTPUT <output-file>``
+      Specify the output file name to generate. A relative path is treated with
+      respect to the value of :variable:`CMAKE_CURRENT_BINARY_DIR`.
+      ``<output-file>`` does not support generator expressions.
+
+    ``CONTENT <content>``
+      Use the content given explicitly as input.
+      ``<content>`` does not support generator expressions.
+
+    ``ESCAPE_QUOTES``
+      Escape any substituted quotes with backslashes (C-style).
+
+    ``@ONLY``
+      Restrict variable replacement to references of the form ``@VAR@``.
+      This is useful for configuring scripts that use ``${VAR}`` syntax.
+
+    ``NEWLINE_STYLE <style>``
+      Specify the newline style for the output file.  Specify
+      ``UNIX`` or ``LF`` for ``\n`` newlines, or specify
+      ``DOS``, ``WIN32``, or ``CRLF`` for ``\r\n`` newlines.
+
+Filesystem
+^^^^^^^^^^
+
+.. signature::
+  file(GLOB <variable>
+       [LIST_DIRECTORIES true|false] [RELATIVE <path>] [CONFIGURE_DEPENDS]
+       <globbing-expressions>...)
+  file(GLOB_RECURSE <variable> [FOLLOW_SYMLINKS]
+       [LIST_DIRECTORIES true|false] [RELATIVE <path>] [CONFIGURE_DEPENDS]
+       <globbing-expressions>...)
+
+  Generate a list of files that match the ``<globbing-expressions>`` and
+  store it into the ``<variable>``.  Globbing expressions are similar to
+  regular expressions, but much simpler.  If ``RELATIVE`` flag is
+  specified, the results will be returned as relative paths to the given
+  path.
+
+  .. versionchanged:: 3.6
+    The results will be ordered lexicographically.
+
+  On Windows and macOS, globbing is case-insensitive even if the underlying
+  filesystem is case-sensitive (both filenames and globbing expressions are
+  converted to lowercase before matching).  On other platforms, globbing is
+  case-sensitive.
+
+  .. versionadded:: 3.3
+    By default ``GLOB`` lists directories. Directories are omitted in the
+    result if ``LIST_DIRECTORIES`` is set to false.
+
+  .. versionadded:: 3.12
+    If the ``CONFIGURE_DEPENDS`` flag is specified, CMake will add logic
+    to the main build system check target to rerun the flagged ``GLOB``
+    commands at build time. If any of the outputs change, CMake will regenerate
+    the build system.
+
+  .. note::
+    We do not recommend using GLOB to collect a list of source files from
+    your source tree.  If no CMakeLists.txt file changes when a source is
+    added or removed then the generated build system cannot know when to
+    ask CMake to regenerate.
+    The ``CONFIGURE_DEPENDS`` flag may not work reliably on all generators, or
+    if a new generator is added in the future that cannot support it, projects
+    using it will be stuck. Even if ``CONFIGURE_DEPENDS`` works reliably, there
+    is still a cost to perform the check on every rebuild.
+
+  Examples of globbing expressions include:
+
+  ============== ======================================================
+  ``*.cxx``      match all files with extension ``cxx``
+  ``*.vt?``      match all files with extension ``vta``, ..., ``vtz``
+  ``f[3-5].txt`` match files ``f3.txt``, ``f4.txt``, ``f5.txt``
+  ============== ======================================================
+
+  The ``GLOB_RECURSE`` mode will traverse all the subdirectories of the
+  matched directory and match the files.  Subdirectories that are symlinks
+  are only traversed if ``FOLLOW_SYMLINKS`` is given or policy
+  :policy:`CMP0009` is not set to ``NEW``.
+
+  .. versionadded:: 3.3
+    By default ``GLOB_RECURSE`` omits directories from result list. Setting
+    ``LIST_DIRECTORIES`` to true adds directories to result list.
+    If ``FOLLOW_SYMLINKS`` is given or policy :policy:`CMP0009` is not set to
+    ``NEW`` then ``LIST_DIRECTORIES`` treats symlinks as directories.
+
+  Examples of recursive globbing include:
+
+  ============== ======================================================
+  ``/dir/*.py``  match all python files in ``/dir`` and subdirectories
+  ============== ======================================================
+
+.. signature::
+  file(MAKE_DIRECTORY <directories>... [RESULT <result>])
+
+  Create the given directories and their parents as needed.
+
+  The options are:
+
+    ``RESULT <result>``
+      .. versionadded:: 3.31
+
+      Set ``<result>`` variable to ``0`` on success or an error message
+      otherwise. If ``RESULT`` is not specified and the operation fails,
+      an error is emitted.
+
+  .. versionchanged:: 3.30
+    ``<directories>`` can be an empty list. CMake 3.29 and earlier required
+    at least one directory to be given.
+
+.. signature::
+  file(REMOVE <files>...)
+  file(REMOVE_RECURSE <files>...)
+
+  Remove the given files.  The ``REMOVE_RECURSE`` mode will remove the given
+  files and directories, including non-empty directories. No error is emitted
+  if a given file does not exist.  Relative input paths are evaluated with
+  respect to the current source directory.
+
+  .. versionchanged:: 3.15
+    Empty input paths are ignored with a warning.  Previous versions of CMake
+    interpreted empty strings as a relative path with respect to the current
+    directory and removed its contents.
+
+.. signature::
+  file(RENAME <oldname> <newname> [RESULT <result>] [NO_REPLACE])
+
+  Move a file or directory within a filesystem from ``<oldname>`` to
+  ``<newname>``, replacing the destination atomically.
+
+  The options are:
+
+    ``RESULT <result>``
+      .. versionadded:: 3.21
+
+      Set ``<result>`` variable to ``0`` on success or an error message
+      otherwise. If ``RESULT`` is not specified and the operation fails,
+      an error is emitted.
+
+    ``NO_REPLACE``
+      .. versionadded:: 3.21
+
+      If the ``<newname>`` path already exists, do not replace it.
+      If ``RESULT <result>`` is used, the result variable will be
+      set to ``NO_REPLACE``.  Otherwise, an error is emitted.
+
+.. signature::
+  file(COPY_FILE <oldname> <newname>
+       [RESULT <result>]
+       [ONLY_IF_DIFFERENT]
+       [INPUT_MAY_BE_RECENT])
+
+  .. versionadded:: 3.21
+
+  Copy a file from ``<oldname>`` to ``<newname>``. Directories are not
+  supported. Symlinks are ignored and ``<oldfile>``'s content is read and
+  written to ``<newname>`` as a new file.
+
+  The options are:
+
+    ``RESULT <result>``
+      Set ``<result>`` variable to ``0`` on success or an error message
+      otherwise.  If ``RESULT`` is not specified and the operation fails,
+      an error is emitted.
+
+    ``ONLY_IF_DIFFERENT``
+      If the ``<newname>`` path already exists, do not replace it if the file's
+      contents are already the same as ``<oldname>`` (this avoids updating
+      ``<newname>``'s timestamp).
+
+    ``INPUT_MAY_BE_RECENT``
+      .. versionadded:: 3.26
+
+      Tell CMake that the input file may have been recently created.  This is
+      meaningful only on Windows, where files may be inaccessible for a short
+      time after they are created.  With this option, if permission is denied,
+      CMake will retry reading the input a few times.
+
+  This sub-command has some similarities to :command:`configure_file`
+  with the ``COPYONLY`` option.  An important difference is that
+  :command:`configure_file` creates a dependency on the source file,
+  so CMake will be re-run if it changes. The ``file(COPY_FILE)``
+  sub-command does not create such a dependency.
+
+  See also the :command:`file(COPY)` sub-command just below which provides
+  further file-copying capabilities.
+
+.. signature::
+  file(COPY [...])
+  file(INSTALL [...])
+
+  The ``COPY`` signature copies files, directories, and symlinks to a
+  destination folder.  Relative input paths are evaluated with respect
+  to the current source directory, and a relative destination is
+  evaluated with respect to the current build directory.  Copying
+  preserves input file timestamps, and optimizes out a file if it exists
+  at the destination with the same timestamp.  Copying preserves input
+  permissions unless explicit permissions or ``NO_SOURCE_PERMISSIONS``
+  are given (default is ``USE_SOURCE_PERMISSIONS``).
+
+  .. code-block:: cmake
+
+    file(<COPY|INSTALL> <files>... DESTINATION <dir>
+         [NO_SOURCE_PERMISSIONS | USE_SOURCE_PERMISSIONS]
+         [FILE_PERMISSIONS <permissions>...]
+         [DIRECTORY_PERMISSIONS <permissions>...]
+         [FOLLOW_SYMLINK_CHAIN]
+         [FILES_MATCHING]
+         [[PATTERN <pattern> | REGEX <regex>]
+          [EXCLUDE] [PERMISSIONS <permissions>...]] [...])
+
+  .. note::
+
+    For a simple file copying operation, the :command:`file(COPY_FILE)`
+    sub-command just above may be easier to use.
+
+  .. versionadded:: 3.15
+    If ``FOLLOW_SYMLINK_CHAIN`` is specified, ``COPY`` will recursively resolve
+    the symlinks at the paths given until a real file is found, and install
+    a corresponding symlink in the destination for each symlink encountered.
+    For each symlink that is installed, the resolution is stripped of the
+    directory, leaving only the filename, meaning that the new symlink points
+    to a file in the same directory as the symlink. This feature is useful on
+    some Unix systems, where libraries are installed as a chain of symlinks
+    with version numbers, with less specific versions pointing to more specific
+    versions. ``FOLLOW_SYMLINK_CHAIN`` will install all of these symlinks and
+    the library itself into the destination directory. For example, if you have
+    the following directory structure:
+
+      * ``/opt/foo/lib/libfoo.so.1.2.3``
+      * ``/opt/foo/lib/libfoo.so.1.2 -> libfoo.so.1.2.3``
+      * ``/opt/foo/lib/libfoo.so.1 -> libfoo.so.1.2``
+      * ``/opt/foo/lib/libfoo.so -> libfoo.so.1``
+
+    and you do:
+
+    .. code-block:: cmake
+
+      file(COPY /opt/foo/lib/libfoo.so DESTINATION lib FOLLOW_SYMLINK_CHAIN)
+
+    This will install all of the symlinks and ``libfoo.so.1.2.3`` itself into
+    ``lib``.
+
+  See the :command:`install(DIRECTORY)` command for documentation of
+  permissions, ``FILES_MATCHING``, ``PATTERN``, ``REGEX``, and
+  ``EXCLUDE`` options.  Copying directories preserves the structure
+  of their content even if options are used to select a subset of
+  files.
+
+  The ``INSTALL`` signature differs slightly from ``COPY``: it prints
+  status messages, and ``NO_SOURCE_PERMISSIONS`` is default. Installation
+  scripts generated by the :command:`install` command use this signature
+  (with some undocumented options for internal use).
+
+  .. versionchanged:: 3.22
+
+    The environment variable :envvar:`CMAKE_INSTALL_MODE` can override the
+    default copying behavior of :command:`file(INSTALL)`.
+
+.. signature::
+  file(SIZE <filename> <variable>)
+
+  .. versionadded:: 3.14
+
+  Determine the file size of the ``<filename>`` and put the result in
+  ``<variable>`` variable. Requires that ``<filename>`` is a valid path
+  pointing to a file and is readable.
+
+.. signature::
+  file(READ_SYMLINK <linkname> <variable>)
+
+  .. versionadded:: 3.14
+
+  Query the symlink ``<linkname>`` and stores the path it points to
+  in the result ``<variable>``.  If ``<linkname>`` does not exist
+  or is not a symlink, CMake issues a fatal error.
+
+  Note that this command returns the raw symlink path and does not resolve
+  a relative path.  The following is an example of how to ensure that an
+  absolute path is obtained:
+
+  .. code-block:: cmake
+
+    set(linkname "/path/to/foo.sym")
+    file(READ_SYMLINK "${linkname}" result)
+    if(NOT IS_ABSOLUTE "${result}")
+      get_filename_component(dir "${linkname}" DIRECTORY)
+      set(result "${dir}/${result}")
+    endif()
+
+.. signature::
+  file(CREATE_LINK <original> <linkname>
+       [RESULT <result>] [COPY_ON_ERROR] [SYMBOLIC])
+
+  .. versionadded:: 3.14
+
+  Create a link ``<linkname>`` that points to ``<original>``.
+  It will be a hard link by default, but providing the ``SYMBOLIC`` option
+  results in a symbolic link instead.  Hard links require that ``original``
+  exists and is a file, not a directory.  If ``<linkname>`` already exists,
+  it will be overwritten.
+
+  The ``<result>`` variable, if specified, receives the status of the
+  operation.  It is set to ``0`` upon success or an error message otherwise.
+  If ``RESULT`` is not specified and the operation fails, a fatal error is
+  emitted.
+
+  Specifying ``COPY_ON_ERROR`` enables copying the file as a fallback if
+  creating the link fails.  It can be useful for handling situations such as
+  ``<original>`` and ``<linkname>`` being on different drives or mount points,
+  which would make them unable to support a hard link.
+
+.. signature::
+  file(CHMOD <files>... <directories>...
+       [PERMISSIONS <permissions>...]
+       [FILE_PERMISSIONS <permissions>...]
+       [DIRECTORY_PERMISSIONS <permissions>...])
+
+  .. versionadded:: 3.19
+
+  Set the permissions for the ``<files>...`` and ``<directories>...``
+  specified. Valid permissions are  ``OWNER_READ``, ``OWNER_WRITE``,
+  ``OWNER_EXECUTE``, ``GROUP_READ``, ``GROUP_WRITE``, ``GROUP_EXECUTE``,
+  ``WORLD_READ``, ``WORLD_WRITE``, ``WORLD_EXECUTE``, ``SETUID``, ``SETGID``.
+
+  Valid combination of keywords are:
+
+    ``PERMISSIONS``
+      All items are changed.
+
+    ``FILE_PERMISSIONS``
+      Only files are changed.
+
+    ``DIRECTORY_PERMISSIONS``
+      Only directories are changed.
+
+    ``PERMISSIONS`` and ``FILE_PERMISSIONS``
+      ``FILE_PERMISSIONS`` overrides ``PERMISSIONS`` for files.
+
+    ``PERMISSIONS`` and ``DIRECTORY_PERMISSIONS``
+      ``DIRECTORY_PERMISSIONS`` overrides ``PERMISSIONS`` for directories.
+
+    ``FILE_PERMISSIONS`` and ``DIRECTORY_PERMISSIONS``
+      Use ``FILE_PERMISSIONS`` for files and ``DIRECTORY_PERMISSIONS`` for
+      directories.
+
+.. signature::
+  file(CHMOD_RECURSE <files>... <directories>...
+       [PERMISSIONS <permissions>...]
+       [FILE_PERMISSIONS <permissions>...]
+       [DIRECTORY_PERMISSIONS <permissions>...])
+
+  .. versionadded:: 3.19
+
+  Same as :cref:`CHMOD`, but change the permissions of files and directories
+  present in the ``<directories>...`` recursively.
+
+
+Path Conversion
+^^^^^^^^^^^^^^^
+
+.. signature::
+  file(REAL_PATH <path> <out-var> [BASE_DIRECTORY <dir>] [EXPAND_TILDE])
+
+  .. versionadded:: 3.19
+
+  Compute the absolute path to an existing file or directory with symlinks
+  resolved.  The options are:
+
+    ``BASE_DIRECTORY <dir>``
+      If the provided ``<path>`` is a relative path, it is evaluated relative
+      to the given base directory ``<dir>``. If no base directory is provided,
+      the default base directory will be :variable:`CMAKE_CURRENT_SOURCE_DIR`.
+
+    ``EXPAND_TILDE``
+      .. versionadded:: 3.21
+
+      If the ``<path>`` is ``~`` or starts with ``~/``, the ``~`` is replaced
+      by the user's home directory.  The path to the home directory is obtained
+      from environment variables.  On Windows, the ``USERPROFILE`` environment
+      variable is used, falling back to the ``HOME`` environment variable
+      if ``USERPROFILE`` is not defined.  On all other platforms, only ``HOME``
+      is used.
+
+  .. versionchanged:: 3.28
+
+    All symlinks are resolved before collapsing ``../`` components.
+    See policy :policy:`CMP0152`.
+
+.. signature::
+  file(RELATIVE_PATH <variable> <directory> <file>)
+
+  Compute the relative path from a ``<directory>`` to a ``<file>`` and
+  store it in the ``<variable>``.
+
+.. signature::
+  file(TO_CMAKE_PATH "<path>" <variable>)
+  file(TO_NATIVE_PATH "<path>" <variable>)
+
+  The ``TO_CMAKE_PATH`` mode converts a native ``<path>`` into a cmake-style
+  path with forward-slashes (``/``).  The input can be a single path or a
+  system search path like ``$ENV{PATH}``.  A search path will be converted
+  to a cmake-style list separated by ``;`` characters.
+
+  The ``TO_NATIVE_PATH`` mode converts a cmake-style ``<path>`` into a native
+  path with platform-specific slashes (``\`` on Windows hosts and ``/``
+  elsewhere).
+
+  Always use double quotes around the ``<path>`` to be sure it is treated
+  as a single argument to this command.
+
+Transfer
+^^^^^^^^
+
+.. signature::
+  file(DOWNLOAD <url> [<file>] <options>...)
+  file(UPLOAD <file> <url> <options>...)
+
+  The ``DOWNLOAD`` subcommand downloads the given ``<url>`` to a local
+  ``<file>``.  The ``UPLOAD`` mode uploads a local ``<file>`` to a given
+  ``<url>``.
+
+  .. versionadded:: 3.19
+    If ``<file>`` is not specified for ``file(DOWNLOAD)``, the file is not
+    saved. This can be useful if you want to know if a file can be downloaded
+    (for example, to check that it exists) without actually saving it anywhere.
+
+  Options to both ``DOWNLOAD`` and ``UPLOAD`` are:
+
+    ``INACTIVITY_TIMEOUT <seconds>``
+      Terminate the operation after a period of inactivity.
+
+    ``LOG <variable>``
+      Store a human-readable log of the operation in a variable.
+
+    ``SHOW_PROGRESS``
+      Print progress information as status messages until the operation is
+      complete.
+
+    ``STATUS <variable>``
+      Store the resulting status of the operation in a variable.
+      The status is a ``;`` separated list of length 2.
+      The first element is the numeric return value for the operation,
+      and the second element is a string value for the error.
+      A ``0`` numeric error means no error in the operation.
+
+    ``TIMEOUT <seconds>``
+      Terminate the operation after a given total time has elapsed.
+
+    ``USERPWD <username>:<password>``
+      .. versionadded:: 3.7
+
+      Set username and password for operation.
+
+    ``HTTPHEADER <HTTP-header>``
+      .. versionadded:: 3.7
+
+      HTTP header for ``DOWNLOAD`` and ``UPLOAD`` operations. ``HTTPHEADER``
+      can be repeated for multiple options:
+
+      .. code-block:: cmake
+
+        file(DOWNLOAD <url>
+             HTTPHEADER "Authorization: Bearer <auth-token>"
+             HTTPHEADER "UserAgent: Mozilla/5.0")
+
+    ``NETRC <level>``
+      .. versionadded:: 3.11
+
+      Specify whether the .netrc file is to be used for operation.  If this
+      option is not specified, the value of the :variable:`CMAKE_NETRC`
+      variable will be used instead.
+
+      Valid levels are:
+
+        ``IGNORED``
+          The .netrc file is ignored.
+          This is the default.
+
+        ``OPTIONAL``
+          The .netrc file is optional, and information in the URL is preferred.
+          The file will be scanned to find which ever information is not
+          specified in the URL.
+
+        ``REQUIRED``
+          The .netrc file is required, and information in the URL is ignored.
+
+    ``NETRC_FILE <file>``
+      .. versionadded:: 3.11
+
+      Specify an alternative .netrc file to the one in your home directory,
+      if the ``NETRC`` level is ``OPTIONAL`` or ``REQUIRED``. If this option
+      is not specified, the value of the :variable:`CMAKE_NETRC_FILE` variable
+      will be used instead.
+
+    ``TLS_VERSION <min>``
+      .. versionadded:: 3.30
+
+      Specify minimum TLS version for ``https://`` URLs.
+      If this option is not specified, the value of the
+      :variable:`CMAKE_TLS_VERSION` variable or :envvar:`CMAKE_TLS_VERSION`
+      environment variable will be used instead.
+      See :variable:`CMAKE_TLS_VERSION` for allowed values.
+
+      .. versionchanged:: 3.31
+        The default is TLS 1.2.
+        Previously, no minimum version was enforced by default.
+
+    ``TLS_VERIFY <ON|OFF>``
+      Specify whether to verify the server certificate for ``https://`` URLs.
+      If this option is not specified, the value of the
+      :variable:`CMAKE_TLS_VERIFY` variable or :envvar:`CMAKE_TLS_VERIFY`
+      environment variable will be used instead.
+      If neither is set, the default is *on*.
+
+      .. versionchanged:: 3.31
+        The default is on.  Previously, the default was off.
+        Users may set the :envvar:`CMAKE_TLS_VERIFY` environment
+        variable to ``0`` to restore the old default.
+
+      .. versionadded:: 3.18
+        Added support to ``file(UPLOAD)``.
+
+    ``TLS_CAINFO <file>``
+      Specify a custom Certificate Authority file for ``https://`` URLs.
+      If this option is not specified, the value of the
+      :variable:`CMAKE_TLS_CAINFO` variable will be used instead.
+
+      .. versionadded:: 3.18
+        Added support to ``file(UPLOAD)``.
+
+  For ``https://`` URLs CMake must be built with SSL/TLS support.
+
+  Additional options to ``DOWNLOAD`` are:
+
+    ``EXPECTED_HASH <algorithm>=<value>``
+      Verify that the downloaded content hash matches the expected value, where
+      ``<algorithm>`` is one of the algorithms supported by :cref:`<HASH>`.
+      If the file already exists and matches the hash, the download is skipped.
+      If the file already exists and does not match the hash, the file is
+      downloaded again. If after download the file does not match the hash, the
+      operation fails with an error. It is an error to specify this option if
+      ``DOWNLOAD`` is not given a ``<file>``.
+
+    ``EXPECTED_MD5 <value>``
+      Historical short-hand for ``EXPECTED_HASH MD5=<value>``. It is an error
+      to specify this if ``DOWNLOAD`` is not given a ``<file>``.
+
+    ``RANGE_START <value>``
+      .. versionadded:: 3.24
+
+      Offset of the start of the range in file in bytes. Could be omitted to
+      download up to the specified ``RANGE_END``.
+
+    ``RANGE_END <value>``
+      .. versionadded:: 3.24
+
+      Offset of the end of the range in file in bytes. Could be omitted to
+      download everything from the specified ``RANGE_START`` to the end of
+      file.
+
+Locking
+^^^^^^^
+
+.. signature::
+  file(LOCK <path> [DIRECTORY] [RELEASE]
+       [GUARD <FUNCTION|FILE|PROCESS>]
+       [RESULT_VARIABLE <variable>]
+       [TIMEOUT <seconds>])
+
+  .. versionadded:: 3.2
+
+  Lock a file specified by ``<path>`` if no ``DIRECTORY`` option present and
+  file ``<path>/cmake.lock`` otherwise.  The file will be locked for the scope
+  defined by the ``GUARD`` option (default value is ``PROCESS``).  The
+  ``RELEASE`` option can be used to unlock the file explicitly.  If the
+  ``TIMEOUT`` option is not specified, CMake will wait until the lock succeeds
+  or until a fatal error occurs.  If ``TIMEOUT`` is set to ``0``, locking will
+  be tried once and the result will be reported immediately.  If ``TIMEOUT``
+  is not ``0``, CMake will try to lock the file for the period specified by
+  the ``TIMEOUT <seconds>`` value.  Any errors will be interpreted as fatal if
+  there is no ``RESULT_VARIABLE`` option.  Otherwise, the result will be stored
+  in ``<variable>`` and will be ``0`` on success or an error message on
+  failure.
+
+  Note that lock is advisory; there is no guarantee that other processes will
+  respect this lock, i.e. lock synchronize two or more CMake instances sharing
+  some modifiable resources. Similar logic applies to the ``DIRECTORY`` option;
+  locking a parent directory doesn't prevent other ``LOCK`` commands from
+  locking any child directory or file.
+
+  Trying to lock the same file twice is not allowed.  Any intermediate
+  directories and the file itself will be created if they not exist.  The
+  ``GUARD`` and ``TIMEOUT`` options are ignored on the ``RELEASE`` operation.
+
+Archiving
+^^^^^^^^^
+
+.. signature::
+  file(ARCHIVE_CREATE OUTPUT <archive>
+    PATHS <paths>...
+    [FORMAT <format>]
+    [COMPRESSION <compression>
+    [COMPRESSION_LEVEL <compression-level>]]
+    [MTIME <mtime>]
+    [WORKING_DIRECTORY <dir>]
+    [VERBOSE])
+  :target: ARCHIVE_CREATE
+  :break: verbatim
+
+  .. versionadded:: 3.18
+
+  Creates the specified ``<archive>`` file with the files and directories
+  listed in ``<paths>``.  Note that ``<paths>`` must list actual files or
+  directories; wildcards are not supported.
+
+  The options are:
+
+  ``FORMAT <format>``
+    Specify the archive format.  Supported values for ``<format>`` are
+    ``7zip``, ``gnutar``, ``pax``, ``paxr``, ``raw`` and ``zip``.
+    If ``FORMAT`` is not given, the default format is ``paxr``.
+
+  ``COMPRESSION <compression>``
+    Some archive formats allow the type of compression to be specified.
+    The ``7zip`` and ``zip`` archive formats already imply a specific type of
+    compression.  The other formats use no compression by default, but can be
+    directed to do so with the ``COMPRESSION`` option.  Valid values for
+    ``<compression>`` are ``None``, ``BZip2``, ``GZip``, ``XZ``, and ``Zstd``.
+
+    .. note::
+      With ``FORMAT`` set to ``raw``, only one file will be compressed
+      with the compression type specified by ``COMPRESSION``.
+
+  ``COMPRESSION_LEVEL <compression-level>``
+    .. versionadded:: 3.19
+
+    The compression level can be specified with the ``COMPRESSION_LEVEL``
+    option.  The ``<compression-level>`` should be between 0-9, with the
+    default being 0.  The ``COMPRESSION`` option must be present when
+    ``COMPRESSION_LEVEL`` is given.
+
+    .. versionadded:: 3.26
+      The ``<compression-level>`` of the ``Zstd`` algorithm can be set
+      between 0-19.
+
+  ``MTIME <mtime>``
+    Specify the modification time recorded in tarball entries.
+
+  ``WORKING_DIRECTORY <dir>``
+    .. versionadded:: 3.31
+
+    Specify the directory in which the archive creation operation will
+    be executed.  Paths in the ``<paths>`` argument can be relative to
+    this directory.  If this option is not provided, the current working
+    directory will be used by default.
+
+  ``VERBOSE``
+    Enable verbose output from the archive operation.
+
+.. signature::
+  file(ARCHIVE_EXTRACT
+    INPUT <archive>
+    [DESTINATION <dir>]
+    [PATTERNS <pattern>...]
+    [LIST_ONLY]
+    [VERBOSE]
+    [TOUCH])
+  :target: ARCHIVE_EXTRACT
+
+  .. versionadded:: 3.18
+
+  Extracts or lists the content of the specified ``<archive>``.
+
+  The options are:
+
+  ``DESTINATION <dir>``
+    Specify the directory under which the content of the archive will be
+    extracted.  If the directory does not exist, it will be created.
+    If ``DESTINATION`` is not given, the current binary directory will
+    be used.
+
+  ``PATTERNS <pattern>...``
+    Extract/list only files and directories that match one of the given
+    patterns.  Wildcards are supported.  If the ``PATTERNS`` option is
+    not given, the entire archive will be listed or extracted.
+
+  ``LIST_ONLY``
+    List the files in the archive rather than extract them.
+
+  ``TOUCH``
+    .. versionadded:: 3.24
+
+    Give extracted files a current local timestamp instead of extracting
+    file timestamps from the archive.
+
+  ``VERBOSE``
+    Enable verbose output from the extraction operation.
+
+  .. note::
+    The working directory for this subcommand is the ``DESTINATION`` directory
+    (provided or computed) except when ``LIST_ONLY`` is specified. Therefore,
+    outside of script mode, it may be best to provide absolute paths to
+    ``INPUT`` archives as they are unlikely to be extracted where a relative
+    path works.
+
+Handling Runtime Binaries
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. signature::
+  file(GET_RUNTIME_DEPENDENCIES [...])
+
+  .. versionadded:: 3.16
+
+  Recursively get the list of libraries depended on by the given files:
+
+  .. code-block:: cmake
+
+    file(GET_RUNTIME_DEPENDENCIES
+      [RESOLVED_DEPENDENCIES_VAR <deps_var>]
+      [UNRESOLVED_DEPENDENCIES_VAR <unresolved_deps_var>]
+      [CONFLICTING_DEPENDENCIES_PREFIX <conflicting_deps_prefix>]
+      [EXECUTABLES <executable_files>...]
+      [LIBRARIES <library_files>...]
+      [MODULES <module_files>...]
+      [DIRECTORIES <directories>...]
+      [BUNDLE_EXECUTABLE <bundle_executable_file>]
+      [PRE_INCLUDE_REGEXES <regexes>...]
+      [PRE_EXCLUDE_REGEXES <regexes>...]
+      [POST_INCLUDE_REGEXES <regexes>...]
+      [POST_EXCLUDE_REGEXES <regexes>...]
+      [POST_INCLUDE_FILES <files>...]
+      [POST_EXCLUDE_FILES <files>...]
+      )
+
+  Please note that this sub-command is not intended to be used in project mode.
+  It is intended for use at install time, either from code generated by the
+  :command:`install(RUNTIME_DEPENDENCY_SET)` command, or from code provided by
+  the project via :command:`install(CODE)` or :command:`install(SCRIPT)`.
+  For example:
+
+  .. code-block:: cmake
+
+    install(CODE [[
+      file(GET_RUNTIME_DEPENDENCIES
+        # ...
+        )
+      ]])
+
+  The arguments are as follows:
+
+    ``RESOLVED_DEPENDENCIES_VAR <deps_var>``
+      Name of the variable in which to store the list of resolved dependencies.
+
+    ``UNRESOLVED_DEPENDENCIES_VAR <unresolved_deps_var>``
+      Name of the variable in which to store the list of unresolved
+      dependencies. If this variable is not specified, and there are any
+      unresolved dependencies, an error is issued.
+
+    ``CONFLICTING_DEPENDENCIES_PREFIX <conflicting_deps_prefix>``
+      Variable prefix in which to store conflicting dependency information.
+      Dependencies are conflicting if two files with the same name are found in
+      two different directories. The list of filenames that conflict are stored
+      in ``<conflicting_deps_prefix>_FILENAMES``. For each filename, the list
+      of paths that were found for that filename are stored in
+      ``<conflicting_deps_prefix>_<filename>``.
+
+    ``EXECUTABLES <executable_files>...``
+      List of executable files to read for dependencies. These are executables
+      that are typically created with :command:`add_executable`, but they do
+      not have to be created by CMake. On Apple platforms, the paths to these
+      files determine the value of ``@executable_path`` when recursively
+      resolving the libraries. Specifying any kind of library (``STATIC``,
+      ``MODULE``, or ``SHARED``) here will result in undefined behavior.
+
+    ``LIBRARIES <library_files>...``
+      List of library files to read for dependencies. These are libraries that
+      are typically created with :command:`add_library(SHARED)`, but they do
+      not have to be created by CMake. Specifying ``STATIC`` libraries,
+      ``MODULE`` libraries, or executables here will result in undefined
+      behavior.
+
+    ``MODULES <module_files>...``
+      List of loadable module files to read for dependencies. These are modules
+      that are typically created with :command:`add_library(MODULE)`, but they
+      do not have to be created by CMake. They are typically used by calling
+      ``dlopen()`` at runtime rather than linked at link time with ``ld -l``.
+      Specifying ``STATIC`` libraries, ``SHARED`` libraries, or executables
+      here will result in undefined behavior.
+
+    ``DIRECTORIES <directories>...``
+      List of additional directories to search for dependencies. On Linux
+      platforms, these directories are searched if the dependency is not found
+      in any of the other usual paths. If it is found in such a directory, a
+      warning is issued, because it means that the file is incomplete (it does
+      not list all of the directories that contain its dependencies).
+      On Windows platforms, these directories are searched if the dependency
+      is not found in any of the other search paths, but no warning is issued,
+      because searching other paths is a normal part of Windows dependency
+      resolution. On Apple platforms, this argument has no effect.
+
+    ``BUNDLE_EXECUTABLE <bundle_executable_file>``
+      Executable to treat as the "bundle executable" when resolving libraries.
+      On Apple platforms, this argument determines the value of
+      ``@executable_path`` when recursively resolving libraries for
+      ``LIBRARIES`` and ``MODULES`` files. It has no effect on ``EXECUTABLES``
+      files. On other platforms, it has no effect. This is typically (but not
+      always) one of the executables in the ``EXECUTABLES`` argument which
+      designates the "main" executable of the package.
+
+  The following arguments specify filters for including or excluding libraries
+  to be resolved. See below for a full description of how they work.
+
+    ``PRE_INCLUDE_REGEXES <regexes>...``
+      List of pre-include regexes through which to filter the names of
+      not-yet-resolved dependencies.
+
+    ``PRE_EXCLUDE_REGEXES <regexes>...``
+      List of pre-exclude regexes through which to filter the names of
+      not-yet-resolved dependencies.
+
+    ``POST_INCLUDE_REGEXES <regexes>...``
+      List of post-include regexes through which to filter the names of
+      resolved dependencies.
+
+    ``POST_EXCLUDE_REGEXES <regexes>...``
+      List of post-exclude regexes through which to filter the names of
+      resolved dependencies.
+
+    ``POST_INCLUDE_FILES <files>...``
+      .. versionadded:: 3.21
+
+      List of post-include filenames through which to filter the names of
+      resolved dependencies. Symlinks are resolved when attempting to match
+      these filenames.
+
+    ``POST_EXCLUDE_FILES <files>...``
+      .. versionadded:: 3.21
+
+      List of post-exclude filenames through which to filter the names of
+      resolved dependencies. Symlinks are resolved when attempting to match
+      these filenames.
+
+  These arguments can be used to exclude unwanted system libraries when
+  resolving the dependencies, or to include libraries from a specific
+  directory. The filtering works as follows:
+
+  1. If the not-yet-resolved dependency matches any of the
+     ``PRE_INCLUDE_REGEXES``, steps 2 and 3 are skipped, and the dependency
+     resolution proceeds to step 4.
+
+  2. If the not-yet-resolved dependency matches any of the
+     ``PRE_EXCLUDE_REGEXES``, dependency resolution stops for that dependency.
+
+  3. Otherwise, dependency resolution proceeds.
+
+  4. ``file(GET_RUNTIME_DEPENDENCIES)`` searches for the dependency according
+     to the linking rules of the platform (see below).
+
+  5. If the dependency is found, and its full path matches one of the
+     ``POST_INCLUDE_REGEXES`` or ``POST_INCLUDE_FILES``, the full path is added
+     to the resolved dependencies, and ``file(GET_RUNTIME_DEPENDENCIES)``
+     recursively resolves that library's own dependencies. Otherwise, resolution
+     proceeds to step 6.
+
+  6. If the dependency is found, but its full path matches one of the
+     ``POST_EXCLUDE_REGEXES`` or ``POST_EXCLUDE_FILES``, it is not added to the
+     resolved dependencies, and dependency resolution stops for that dependency.
+
+  7. If the dependency is found, and its full path does not match either
+     ``POST_INCLUDE_REGEXES``, ``POST_INCLUDE_FILES``, ``POST_EXCLUDE_REGEXES``,
+     or ``POST_EXCLUDE_FILES``, the full path is added to the resolved
+     dependencies, and ``file(GET_RUNTIME_DEPENDENCIES)``  recursively resolves
+     that library's own dependencies.
+
+  Different platforms have different rules for how dependencies are resolved.
+  These specifics are described here.
+
+  On Linux platforms, library resolution works as follows:
+
+  1. If the depending file does not have any ``RUNPATH`` entries, and the
+     library exists in one of the depending file's ``RPATH`` entries, or its
+     parents', in that order, the dependency is resolved to that file.
+  2. Otherwise, if the depending file has any ``RUNPATH`` entries, and the
+     library exists in one of those entries, the dependency is resolved to that
+     file.
+  3. Otherwise, if the library exists in one of the directories listed by
+     ``ldconfig``, the dependency is resolved to that file.
+  4. Otherwise, if the library exists in one of the ``DIRECTORIES`` entries,
+     the dependency is resolved to that file. In this case, a warning is
+     issued, because finding a file in one of the ``DIRECTORIES`` means that
+     the depending file is not complete (it does not list all the directories
+     from which it pulls dependencies).
+
+  5. Otherwise, the dependency is unresolved.
+
+  .. versionchanged:: 3.31
+
+    Resolution of each encountered library file name occurs at most once
+    while processing a given root ELF file (executable or shared object).
+    If a library file name is encountered again in the dependency tree,
+    the original resolution is assumed.  This behavior more closely matches
+    the dynamic loader's behavior on Linux.
+
+  On Windows platforms, library resolution works as follows:
+
+  1. DLL dependency names are converted to lowercase for matching filters.
+     Windows DLL names are case-insensitive, and some linkers mangle the
+     case of the DLL dependency names.  However, this makes it more difficult
+     for ``PRE_INCLUDE_REGEXES``, ``PRE_EXCLUDE_REGEXES``,
+     ``POST_INCLUDE_REGEXES``, and ``POST_EXCLUDE_REGEXES`` to properly
+     filter DLL names - every regex would have to check for both uppercase
+     and lowercase letters.  For example:
+
+     .. code-block:: cmake
+
+       file(GET_RUNTIME_DEPENDENCIES
+         # ...
+         PRE_INCLUDE_REGEXES "^[Mm][Yy][Ll][Ii][Bb][Rr][Aa][Rr][Yy]\\.[Dd][Ll][Ll]$"
+         )
+
+     Converting the DLL name to lowercase allows the regexes to only match
+     lowercase names, thus simplifying the regex. For example:
+
+     .. code-block:: cmake
+
+       file(GET_RUNTIME_DEPENDENCIES
+         # ...
+         PRE_INCLUDE_REGEXES "^mylibrary\\.dll$"
+         )
+
+     This regex will match ``mylibrary.dll`` regardless of how it is cased,
+     either on disk or in the depending file. (For example, it will match
+     ``mylibrary.dll``, ``MyLibrary.dll``, and ``MYLIBRARY.DLL``.)
+
+     .. versionchanged:: 3.27
+
+       The conversion to lowercase only applies while matching filters.
+       Results reported after filtering case-preserve each DLL name as it is
+       found on disk, if resolved, and otherwise as it is referenced by the
+       dependent binary.
+
+       Prior to CMake 3.27, the results were reported with lowercase DLL
+       file names, but the directory portion retained its casing.
+
+  2. (**Not yet implemented**) If the depending file is a Windows Store app,
+     and the dependency is listed as a dependency in the application's package
+     manifest, the dependency is resolved to that file.
+
+  3. Otherwise, if the library exists in the same directory as the depending
+     file, the dependency is resolved to that file.
+
+  4. Otherwise, if the library exists in either the operating system's
+     ``system32`` directory or the ``Windows`` directory, in that order, the
+     dependency is resolved to that file.
+
+  5. Otherwise, if the library exists in one of the directories specified by
+     ``DIRECTORIES``, in the order they are listed, the dependency is resolved
+     to that file. In this case, a warning is not issued, because searching
+     other directories is a normal part of Windows library resolution.
+
+  6. Otherwise, the dependency is unresolved.
+
+  On Apple platforms, library resolution works as follows:
+
+  1. If the dependency starts with ``@executable_path/``, and an
+     ``EXECUTABLES`` argument is in the process of being resolved, and
+     replacing ``@executable_path/`` with the directory of the executable
+     yields an existing file, the dependency is resolved to that file.
+
+  2. Otherwise, if the dependency starts with ``@executable_path/``, and there
+     is a ``BUNDLE_EXECUTABLE`` argument, and replacing ``@executable_path/``
+     with the directory of the bundle executable yields an existing file, the
+     dependency is resolved to that file.
+
+  3. Otherwise, if the dependency starts with ``@loader_path/``, and replacing
+     ``@loader_path/`` with the directory of the depending file yields an
+     existing file, the dependency is resolved to that file.
+
+  4. Otherwise, if the dependency starts with ``@rpath/``, and replacing
+     ``@rpath/`` with one of the ``RPATH`` entries of the depending file
+     yields an existing file, the dependency is resolved to that file.
+     Note that ``RPATH`` entries that start with ``@executable_path/`` or
+     ``@loader_path/`` also have these items replaced with the appropriate
+     path.
+
+  5. Otherwise, if the dependency is an absolute file that exists,
+     the dependency is resolved to that file.
+
+  6. Otherwise, the dependency is unresolved.
+
+  This function accepts several variables that determine which tool is used for
+  dependency resolution:
+
+  .. variable:: CMAKE_GET_RUNTIME_DEPENDENCIES_PLATFORM
+
+    Determines which operating system and executable format the files are built
+    for. This could be one of several values:
+
+    * ``linux+elf``
+    * ``windows+pe``
+    * ``macos+macho``
+
+    If this variable is not specified, it is determined automatically by system
+    introspection.
+
+  .. variable:: CMAKE_GET_RUNTIME_DEPENDENCIES_TOOL
+
+    Determines the tool to use for dependency resolution. It could be one of
+    several values, depending on the value of
+    :variable:`CMAKE_GET_RUNTIME_DEPENDENCIES_PLATFORM`:
+
+    ================================================= =============================================
+       ``CMAKE_GET_RUNTIME_DEPENDENCIES_PLATFORM``       ``CMAKE_GET_RUNTIME_DEPENDENCIES_TOOL``
+    ================================================= =============================================
+    ``linux+elf``                                     ``objdump``
+    ``windows+pe``                                    ``objdump`` or ``dumpbin``
+    ``macos+macho``                                   ``otool``
+    ================================================= =============================================
+
+    If this variable is not specified, it is determined automatically by system
+    introspection.
+
+  .. variable:: CMAKE_GET_RUNTIME_DEPENDENCIES_COMMAND
+
+    Determines the path to the tool to use for dependency resolution. This is
+    the actual path to ``objdump``, ``dumpbin``, or ``otool``.
+
+    If this variable is not specified, it is determined by the value of
+    ``CMAKE_OBJDUMP`` if set, else by system introspection.
+
+    .. versionadded:: 3.18
+      Use ``CMAKE_OBJDUMP`` if set.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/find_library.rst

@@ -0,0 +1,96 @@
+find_library
+------------
+
+.. |FIND_XXX| replace:: find_library
+.. |NAMES| replace:: NAMES name1 [name2 ...] [NAMES_PER_DIR]
+.. |SEARCH_XXX| replace:: library
+.. |SEARCH_XXX_DESC| replace:: library
+.. |prefix_XXX_SUBDIR| replace:: ``<prefix>/lib``
+.. |entry_XXX_SUBDIR| replace:: ``<entry>/lib``
+
+.. |FIND_XXX_REGISTRY_VIEW_DEFAULT| replace:: ``TARGET``
+
+.. |FIND_PACKAGE_ROOT_PREFIX_PATH_XXX| replace::
+   ``<prefix>/lib/<arch>`` if :variable:`CMAKE_LIBRARY_ARCHITECTURE` is set,
+   and |FIND_PACKAGE_ROOT_PREFIX_PATH_XXX_SUBDIR|
+.. |CMAKE_PREFIX_PATH_XXX| replace::
+   ``<prefix>/lib/<arch>`` if :variable:`CMAKE_LIBRARY_ARCHITECTURE` is set,
+   and |CMAKE_PREFIX_PATH_XXX_SUBDIR|
+.. |CMAKE_XXX_PATH| replace:: :variable:`CMAKE_LIBRARY_PATH`
+.. |CMAKE_XXX_MAC_PATH| replace:: :variable:`CMAKE_FRAMEWORK_PATH`
+
+.. |ENV_CMAKE_PREFIX_PATH_XXX| replace::
+   ``<prefix>/lib/<arch>`` if :variable:`CMAKE_LIBRARY_ARCHITECTURE` is set,
+   and |ENV_CMAKE_PREFIX_PATH_XXX_SUBDIR|
+.. |ENV_CMAKE_XXX_PATH| replace:: :envvar:`CMAKE_LIBRARY_PATH`
+.. |ENV_CMAKE_XXX_MAC_PATH| replace:: :envvar:`CMAKE_FRAMEWORK_PATH`
+
+.. |SYSTEM_ENVIRONMENT_PATH_XXX| replace:: The directories in ``LIB``
+   and ``PATH``.
+.. |SYSTEM_ENVIRONMENT_PATH_WINDOWS_XXX| replace::
+   On Windows hosts, CMake 3.3 through 3.27 searched additional paths:
+   ``<prefix>/lib/<arch>`` if :variable:`CMAKE_LIBRARY_ARCHITECTURE`
+   is set, and |SYSTEM_ENVIRONMENT_PREFIX_PATH_XXX_SUBDIR|.
+   This behavior was removed by CMake 3.28.
+
+.. |CMAKE_SYSTEM_PREFIX_PATH_XXX| replace::
+   ``<prefix>/lib/<arch>`` if :variable:`CMAKE_LIBRARY_ARCHITECTURE` is set,
+   and |CMAKE_SYSTEM_PREFIX_PATH_XXX_SUBDIR|
+.. |CMAKE_SYSTEM_XXX_PATH| replace::
+   :variable:`CMAKE_SYSTEM_LIBRARY_PATH`
+.. |CMAKE_SYSTEM_XXX_MAC_PATH| replace::
+   :variable:`CMAKE_SYSTEM_FRAMEWORK_PATH`
+
+.. |CMAKE_FIND_ROOT_PATH_MODE_XXX| replace::
+   :variable:`CMAKE_FIND_ROOT_PATH_MODE_LIBRARY`
+
+.. include:: FIND_XXX.txt
+
+When more than one value is given to the ``NAMES`` option this command by
+default will consider one name at a time and search every directory
+for it.  The ``NAMES_PER_DIR`` option tells this command to consider one
+directory at a time and search for all names in it.
+
+Each library name given to the ``NAMES`` option is first considered
+as a library file name and then considered with platform-specific
+prefixes (e.g. ``lib``) and suffixes (e.g. ``.so``).  Therefore one
+may specify library file names such as ``libfoo.a`` directly.
+This can be used to locate static libraries on UNIX-like systems.
+
+If the library found is a framework, then ``<VAR>`` will be set to the full
+path to the framework ``<fullPath>/A.framework``.  When a full path to a
+framework is used as a library, CMake will use a ``-framework A``, and a
+``-F<fullPath>`` to link the framework to the target.
+
+.. versionadded:: 3.28
+
+  The library found can now be a ``.xcframework`` folder.
+
+If the :variable:`CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX` variable is set all
+search paths will be tested as normal, with the suffix appended, and with
+all matches of ``lib/`` replaced with
+``lib${CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX}/``.  This variable overrides
+the :prop_gbl:`FIND_LIBRARY_USE_LIB32_PATHS`,
+:prop_gbl:`FIND_LIBRARY_USE_LIBX32_PATHS`,
+and :prop_gbl:`FIND_LIBRARY_USE_LIB64_PATHS` global properties.
+
+If the :prop_gbl:`FIND_LIBRARY_USE_LIB32_PATHS` global property is set
+all search paths will be tested as normal, with ``32/`` appended, and
+with all matches of ``lib/`` replaced with ``lib32/``.  This property is
+automatically set for the platforms that are known to need it if at
+least one of the languages supported by the :command:`project` command
+is enabled.
+
+If the :prop_gbl:`FIND_LIBRARY_USE_LIBX32_PATHS` global property is set
+all search paths will be tested as normal, with ``x32/`` appended, and
+with all matches of ``lib/`` replaced with ``libx32/``.  This property is
+automatically set for the platforms that are known to need it if at
+least one of the languages supported by the :command:`project` command
+is enabled.
+
+If the :prop_gbl:`FIND_LIBRARY_USE_LIB64_PATHS` global property is set
+all search paths will be tested as normal, with ``64/`` appended, and
+with all matches of ``lib/`` replaced with ``lib64/``.  This property is
+automatically set for the platforms that are known to need it if at
+least one of the languages supported by the :command:`project` command
+is enabled.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/find_path.rst

@@ -0,0 +1,52 @@
+find_path
+---------
+
+.. |FIND_XXX| replace:: find_path
+.. |NAMES| replace:: NAMES name1 [name2 ...]
+.. |SEARCH_XXX| replace:: file in a directory
+.. |SEARCH_XXX_DESC| replace:: directory containing the named file
+.. |prefix_XXX_SUBDIR| replace:: ``<prefix>/include``
+.. |entry_XXX_SUBDIR| replace:: ``<entry>/include``
+
+.. |FIND_XXX_REGISTRY_VIEW_DEFAULT| replace:: ``TARGET``
+
+.. |FIND_PACKAGE_ROOT_PREFIX_PATH_XXX| replace::
+   ``<prefix>/include/<arch>`` if :variable:`CMAKE_LIBRARY_ARCHITECTURE`
+   is set, and |FIND_PACKAGE_ROOT_PREFIX_PATH_XXX_SUBDIR|
+.. |CMAKE_PREFIX_PATH_XXX| replace::
+   ``<prefix>/include/<arch>`` if :variable:`CMAKE_LIBRARY_ARCHITECTURE`
+   is set, and |CMAKE_PREFIX_PATH_XXX_SUBDIR|
+.. |CMAKE_XXX_PATH| replace:: :variable:`CMAKE_INCLUDE_PATH`
+.. |CMAKE_XXX_MAC_PATH| replace:: :variable:`CMAKE_FRAMEWORK_PATH`
+
+.. |ENV_CMAKE_PREFIX_PATH_XXX| replace::
+   ``<prefix>/include/<arch>`` if :variable:`CMAKE_LIBRARY_ARCHITECTURE` is set,
+   and |ENV_CMAKE_PREFIX_PATH_XXX_SUBDIR|
+.. |ENV_CMAKE_XXX_PATH| replace:: :envvar:`CMAKE_INCLUDE_PATH`
+.. |ENV_CMAKE_XXX_MAC_PATH| replace:: :envvar:`CMAKE_FRAMEWORK_PATH`
+
+.. |SYSTEM_ENVIRONMENT_PATH_XXX| replace:: The directories in ``INCLUDE``
+   and ``PATH``.
+.. |SYSTEM_ENVIRONMENT_PATH_WINDOWS_XXX| replace::
+   On Windows hosts, CMake 3.3 through 3.27 searched additional paths:
+   ``<prefix>/include/<arch>`` if :variable:`CMAKE_LIBRARY_ARCHITECTURE`
+   is set, and |SYSTEM_ENVIRONMENT_PREFIX_PATH_XXX_SUBDIR|.
+   This behavior was removed by CMake 3.28.
+
+.. |CMAKE_SYSTEM_PREFIX_PATH_XXX| replace::
+   ``<prefix>/include/<arch>`` if :variable:`CMAKE_LIBRARY_ARCHITECTURE`
+   is set, and |CMAKE_SYSTEM_PREFIX_PATH_XXX_SUBDIR|
+.. |CMAKE_SYSTEM_XXX_PATH| replace::
+   :variable:`CMAKE_SYSTEM_INCLUDE_PATH`
+.. |CMAKE_SYSTEM_XXX_MAC_PATH| replace::
+   :variable:`CMAKE_SYSTEM_FRAMEWORK_PATH`
+
+.. |CMAKE_FIND_ROOT_PATH_MODE_XXX| replace::
+   :variable:`CMAKE_FIND_ROOT_PATH_MODE_INCLUDE`
+
+.. include:: FIND_XXX.txt
+
+When searching for frameworks, if the file is specified as ``A/b.h``, then
+the framework search will look for ``A.framework/Headers/b.h``.  If that
+is found the path will be set to the path to the framework.  CMake
+will convert this to the correct ``-F`` option to include the file.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/fltk_wrap_ui.rst

@@ -0,0 +1,14 @@
+fltk_wrap_ui
+------------
+
+Create FLTK user interfaces Wrappers.
+
+.. code-block:: cmake
+
+  fltk_wrap_ui(resultingLibraryName source1
+               source2 ... sourceN )
+
+Produce .h and .cxx files for all the .fl and .fld files listed.  The
+resulting .h and .cxx files will be added to a variable named
+``resultingLibraryName_FLTK_UI_SRCS`` which should be added to your
+library.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/get_cmake_property.rst

@@ -0,0 +1,23 @@
+get_cmake_property
+------------------
+
+Get a global property of the CMake instance.
+
+.. code-block:: cmake
+
+  get_cmake_property(<variable> <property>)
+
+Gets a global property from the CMake instance.  The value of
+the ``<property>`` is stored in the specified ``<variable>``.
+If the property is not found, ``<variable>`` will be set to ``NOTFOUND``.
+See the :manual:`cmake-properties(7)` manual for available properties.
+
+In addition to global properties, this command (for historical reasons)
+also supports the :prop_dir:`VARIABLES` and :prop_dir:`MACROS` directory
+properties.  It also supports a special ``COMPONENTS`` global property that
+lists the components given to the :command:`install` command.
+
+See Also
+^^^^^^^^
+
+* the :command:`get_property` command ``GLOBAL`` option

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/install_targets.rst

@@ -0,0 +1,19 @@
+install_targets
+---------------
+
+.. deprecated:: 3.0
+
+  Use the :command:`install(TARGETS)` command instead.
+
+This command has been superseded by the :command:`install` command.  It is
+provided for compatibility with older CMake code.
+
+.. code-block:: cmake
+
+  install_targets(<dir> [RUNTIME_DIRECTORY dir] target target)
+
+Create rules to install the listed targets into the given directory.
+The directory ``<dir>`` is relative to the installation prefix, which is
+stored in the variable :variable:`CMAKE_INSTALL_PREFIX`.  If
+``RUNTIME_DIRECTORY`` is specified, then on systems with special runtime
+files (Windows DLL), the files will be copied to that directory.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/list.rst

@@ -0,0 +1,334 @@
+list
+----
+
+Operations on :ref:`semicolon-separated lists <CMake Language Lists>`.
+
+Synopsis
+^^^^^^^^
+
+.. parsed-literal::
+
+  `Reading`_
+    list(`LENGTH`_ <list> <out-var>)
+    list(`GET`_ <list> <element index> [<index> ...] <out-var>)
+    list(`JOIN`_ <list> <glue> <out-var>)
+    list(`SUBLIST`_ <list> <begin> <length> <out-var>)
+
+  `Search`_
+    list(`FIND`_ <list> <value> <out-var>)
+
+  `Modification`_
+    list(`APPEND`_ <list> [<element>...])
+    list(`FILTER`_ <list> {INCLUDE | EXCLUDE} REGEX <regex>)
+    list(`INSERT`_ <list> <index> [<element>...])
+    list(`POP_BACK`_ <list> [<out-var>...])
+    list(`POP_FRONT`_ <list> [<out-var>...])
+    list(`PREPEND`_ <list> [<element>...])
+    list(`REMOVE_ITEM`_ <list> <value>...)
+    list(`REMOVE_AT`_ <list> <index>...)
+    list(`REMOVE_DUPLICATES`_ <list>)
+    list(`TRANSFORM`_ <list> <ACTION> [...])
+
+  `Ordering`_
+    list(`REVERSE`_ <list>)
+    list(`SORT`_ <list> [...])
+
+Introduction
+^^^^^^^^^^^^
+
+The list subcommands :cref:`APPEND`, :cref:`INSERT`, :cref:`FILTER`,
+:cref:`PREPEND`, :cref:`POP_BACK`, :cref:`POP_FRONT`, :cref:`REMOVE_AT`,
+:cref:`REMOVE_ITEM`, :cref:`REMOVE_DUPLICATES`, :cref:`REVERSE` and
+:cref:`SORT` may create new values for the list within the current CMake
+variable scope.  Similar to the :command:`set` command, the ``list`` command
+creates new variable values in the current scope, even if the list itself is
+actually defined in a parent scope.  To propagate the results of these
+operations upwards, use :command:`set` with ``PARENT_SCOPE``,
+:command:`set` with ``CACHE INTERNAL``, or some other means of value
+propagation.
+
+.. note::
+
+  A list in cmake is a ``;`` separated group of strings.  To create a
+  list, the :command:`set` command can be used.  For example,
+  ``set(var a b c d e)`` creates a list with ``a;b;c;d;e``, and
+  ``set(var "a b c d e")`` creates a string or a list with one item in it.
+  (Note that macro arguments are not variables, and therefore cannot be used
+  in ``LIST`` commands.)
+
+  Individual elements may not contain an unequal number of ``[`` and ``]``
+  characters, and may not end in a backslash (``\``).
+  See :ref:`semicolon-separated lists <CMake Language Lists>` for details.
+
+.. note::
+
+  When specifying index values, if ``<element index>`` is 0 or greater, it
+  is indexed from the beginning of the list, with 0 representing the
+  first list element.  If ``<element index>`` is -1 or lesser, it is indexed
+  from the end of the list, with -1 representing the last list element.
+  Be careful when counting with negative indices: they do not start from
+  0.  -0 is equivalent to 0, the first list element.
+
+Reading
+^^^^^^^
+
+.. signature::
+  list(LENGTH <list> <output variable>)
+
+  Returns the list's length.
+
+.. signature::
+  list(GET <list> <element index> [<element index> ...] <output variable>)
+
+  Returns the list of elements specified by indices from the list.
+
+.. signature:: list(JOIN <list> <glue> <output variable>)
+
+  .. versionadded:: 3.12
+
+  Returns a string joining all list's elements using the glue string.
+  To join multiple strings, which are not part of a list,
+  use :command:`string(JOIN)`.
+
+.. signature::
+  list(SUBLIST <list> <begin> <length> <output variable>)
+
+  .. versionadded:: 3.12
+
+  Returns a sublist of the given list.
+  If ``<length>`` is 0, an empty list will be returned.
+  If ``<length>`` is -1 or the list is smaller than ``<begin>+<length>`` then
+  the remaining elements of the list starting at ``<begin>`` will be returned.
+
+Search
+^^^^^^
+
+.. signature::
+  list(FIND <list> <value> <output variable>)
+
+  Returns the index of the element specified in the list
+  or ``-1`` if it wasn't found.
+
+Modification
+^^^^^^^^^^^^
+
+.. signature::
+  list(APPEND <list> [<element> ...])
+
+  Appends elements to the list. If no variable named ``<list>`` exists in the
+  current scope its value is treated as empty and the elements are appended to
+  that empty list.
+
+.. signature::
+  list(FILTER <list> <INCLUDE|EXCLUDE> REGEX <regular_expression>)
+
+.. versionadded:: 3.6
+
+Includes or removes items from the list that match the mode's pattern.
+In ``REGEX`` mode, items will be matched against the given regular expression.
+
+For more information on regular expressions look under
+:ref:`string(REGEX) <Regex Specification>`.
+
+.. signature::
+  list(INSERT <list> <element_index> <element> [<element> ...])
+
+  Inserts elements to the list to the specified index. It is an
+  error to specify an out-of-range index. Valid indexes are 0 to `N`
+  where `N` is the length of the list, inclusive. An empty list
+  has length 0. If no variable named ``<list>`` exists in the
+  current scope its value is treated as empty and the elements are
+  inserted in that empty list.
+
+.. signature::
+  list(POP_BACK <list> [<out-var>...])
+
+  .. versionadded:: 3.15
+
+  If no variable name is given, removes exactly one element. Otherwise,
+  with `N` variable names provided, assign the last `N` elements' values
+  to the given variables and then remove the last `N` values from
+  ``<list>``.
+
+.. signature::
+  list(POP_FRONT <list> [<out-var>...])
+
+  .. versionadded:: 3.15
+
+  If no variable name is given, removes exactly one element. Otherwise,
+  with `N` variable names provided, assign the first `N` elements' values
+  to the given variables and then remove the first `N` values from
+  ``<list>``.
+
+.. signature::
+  list(PREPEND <list> [<element> ...])
+
+  .. versionadded:: 3.15
+
+  Insert elements to the 0th position in the list. If no variable named
+  ``<list>`` exists in the current scope its value is treated as empty and
+  the elements are prepended to that empty list.
+
+.. signature::
+  list(REMOVE_ITEM <list> <value> [<value> ...])
+
+  Removes all instances of the given items from the list.
+
+.. signature::
+  list(REMOVE_AT <list> <index> [<index> ...])
+
+  Removes items at given indices from the list.
+
+.. signature::
+  list(REMOVE_DUPLICATES <list>)
+
+  Removes duplicated items in the list. The relative order of items
+  is preserved, but if duplicates are encountered,
+  only the first instance is preserved.
+
+.. signature::
+  list(TRANSFORM <list> <ACTION> [<SELECTOR>]
+       [OUTPUT_VARIABLE <output variable>])
+
+  .. versionadded:: 3.12
+
+  Transforms the list by applying an ``<ACTION>`` to all or, by specifying a
+  ``<SELECTOR>``, to the selected elements of the list, storing the result
+  in-place or in the specified output variable.
+
+  .. note::
+
+    The ``TRANSFORM`` sub-command does not change the number of elements in the
+    list. If a ``<SELECTOR>`` is specified, only some elements will be changed,
+    the other ones will remain the same as before the transformation.
+
+  ``<ACTION>`` specifies the action to apply to the elements of the list.
+  The actions have exactly the same semantics as sub-commands of the
+  :command:`string` command.  ``<ACTION>`` must be one of the following:
+
+    :command:`APPEND <string(APPEND)>`, :command:`PREPEND <string(PREPEND)>`
+      Append, prepend specified value to each element of the list.
+
+      .. signature::
+        list(TRANSFORM <list> (APPEND|PREPEND) <value> ...)
+        :target: TRANSFORM_APPEND
+
+    :command:`TOLOWER <string(TOLOWER)>`, :command:`TOUPPER <string(TOUPPER)>`
+      Convert each element of the list to lower, upper characters.
+
+      .. signature::
+        list(TRANSFORM <list> (TOLOWER|TOUPPER) ...)
+        :target: TRANSFORM_TOLOWER
+
+    :command:`STRIP <string(STRIP)>`
+      Remove leading and trailing spaces from each element of the list.
+
+      .. signature::
+        list(TRANSFORM <list> STRIP ...)
+        :target: TRANSFORM_STRIP
+
+    :command:`GENEX_STRIP <string(GENEX_STRIP)>`
+      Strip any
+      :manual:`generator expressions <cmake-generator-expressions(7)>`
+      from each element of the list.
+
+      .. signature::
+        list(TRANSFORM <list> GENEX_STRIP ...)
+        :target: TRANSFORM_GENEX_STRIP
+
+    :command:`REPLACE <string(REGEX REPLACE)>`:
+      Match the regular expression as many times as possible and substitute
+      the replacement expression for the match for each element of the list
+      (same semantic as :command:`string(REGEX REPLACE)`).
+
+      .. signature::
+        list(TRANSFORM <list> REPLACE <regular_expression>
+                                      <replace_expression> ...)
+        :target: TRANSFORM_REPLACE
+
+  ``<SELECTOR>`` determines which elements of the list will be transformed.
+  Only one type of selector can be specified at a time.
+  When given, ``<SELECTOR>`` must be one of the following:
+
+    ``AT``
+      Specify a list of indexes.
+
+      .. code-block:: cmake
+
+        list(TRANSFORM <list> <ACTION> AT <index> [<index> ...] ...)
+
+    ``FOR``
+      Specify a range with, optionally,
+      an increment used to iterate over the range.
+
+      .. code-block:: cmake
+
+        list(TRANSFORM <list> <ACTION> FOR <start> <stop> [<step>] ...)
+
+    ``REGEX``
+      Specify a regular expression.
+      Only elements matching the regular expression will be transformed.
+
+      .. code-block:: cmake
+
+        list(TRANSFORM <list> <ACTION> REGEX <regular_expression> ...)
+
+
+Ordering
+^^^^^^^^
+
+.. signature::
+  list(REVERSE <list>)
+
+  Reverses the contents of the list in-place.
+
+.. signature::
+  list(SORT <list> [COMPARE <compare>] [CASE <case>] [ORDER <order>])
+
+  Sorts the list in-place alphabetically.
+
+  .. versionadded:: 3.13
+    Added the ``COMPARE``, ``CASE``, and ``ORDER`` options.
+
+  .. versionadded:: 3.18
+    Added the ``COMPARE NATURAL`` option.
+
+  Use the ``COMPARE`` keyword to select the comparison method for sorting.
+  The ``<compare>`` option should be one of:
+
+    ``STRING``
+      Sorts a list of strings alphabetically.
+      This is the default behavior if the ``COMPARE`` option is not given.
+
+    ``FILE_BASENAME``
+      Sorts a list of pathnames of files by their basenames.
+
+    ``NATURAL``
+      Sorts a list of strings using natural order
+      (see ``strverscmp(3)`` manual), i.e. such that contiguous digits
+      are compared as whole numbers.
+      For example: the following list `10.0 1.1 2.1 8.0 2.0 3.1`
+      will be sorted as `1.1 2.0 2.1 3.1 8.0 10.0` if the ``NATURAL``
+      comparison is selected where it will be sorted as
+      `1.1 10.0 2.0 2.1 3.1 8.0` with the ``STRING`` comparison.
+
+  Use the ``CASE`` keyword to select a case sensitive or case insensitive
+  sort mode.  The ``<case>`` option should be one of:
+
+    ``SENSITIVE``
+      List items are sorted in a case-sensitive manner.
+      This is the default behavior if the ``CASE`` option is not given.
+
+    ``INSENSITIVE``
+      List items are sorted case insensitively.  The order of
+      items which differ only by upper/lowercase is not specified.
+
+  To control the sort order, the ``ORDER`` keyword can be given.
+  The ``<order>`` option should be one of:
+
+    ``ASCENDING``
+      Sorts the list in ascending order.
+      This is the default behavior when the ``ORDER`` option is not given.
+
+    ``DESCENDING``
+      Sorts the list in descending order.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/return.rst

@@ -0,0 +1,92 @@
+return
+------
+
+Return from a file, directory or function.
+
+.. code-block:: cmake
+
+  return([PROPAGATE <var-name>...])
+
+When this command is encountered in an included file (via :command:`include` or
+:command:`find_package`), it causes processing of the current file to stop
+and control is returned to the including file.  If it is encountered in a
+file which is not included by another file, e.g. a ``CMakeLists.txt``,
+deferred calls scheduled by :command:`cmake_language(DEFER)` are invoked and
+control is returned to the parent directory if there is one.
+
+If ``return()`` is called in a function, control is returned to the caller
+of that function.  Note that a :command:`macro`, unlike a :command:`function`,
+is expanded in place and therefore cannot handle ``return()``.
+
+Policy :policy:`CMP0140` controls the behavior regarding the arguments of the
+command.  All arguments are ignored unless that policy is set to ``NEW``.
+
+``PROPAGATE``
+  .. versionadded:: 3.25
+
+  This option sets or unsets the specified variables in the parent directory or
+  function caller scope. This is equivalent to :command:`set(PARENT_SCOPE)` or
+  :command:`unset(PARENT_SCOPE)` commands, except for the way it interacts
+  with the :command:`block` command, as described below.
+
+  The ``PROPAGATE`` option can be very useful in conjunction with the
+  :command:`block` command.  A ``return`` will propagate the
+  specified variables through any enclosing block scopes created by the
+  :command:`block` commands.  Inside a function, this ensures the variables
+  are propagated to the function's caller, regardless of any blocks within
+  the function.  If not inside a function, it ensures the variables are
+  propagated to the parent file or directory scope. For example:
+
+  .. code-block:: cmake
+    :caption: CMakeLists.txt
+
+    cmake_minimum_required(VERSION 3.25)
+    project(example)
+
+    set(var1 "top-value")
+
+    block(SCOPE_FOR VARIABLES)
+      add_subdirectory(subDir)
+      # var1 has the value "block-nested"
+    endblock()
+
+    # var1 has the value "top-value"
+
+  .. code-block:: cmake
+    :caption: subDir/CMakeLists.txt
+
+    function(multi_scopes result_var1 result_var2)
+      block(SCOPE_FOR VARIABLES)
+        # This would only propagate out of the immediate block, not to
+        # the caller of the function.
+        #set(${result_var1} "new-value" PARENT_SCOPE)
+        #unset(${result_var2} PARENT_SCOPE)
+
+        # This propagates the variables through the enclosing block and
+        # out to the caller of the function.
+        set(${result_var1} "new-value")
+        unset(${result_var2})
+        return(PROPAGATE ${result_var1} ${result_var2})
+      endblock()
+    endfunction()
+
+    set(var1 "some-value")
+    set(var2 "another-value")
+
+    multi_scopes(var1 var2)
+    # Now var1 will hold "new-value" and var2 will be unset
+
+    block(SCOPE_FOR VARIABLES)
+      # This return() will set var1 in the directory scope that included us
+      # via add_subdirectory(). The surrounding block() here does not limit
+      # propagation to the current file, but the block() in the parent
+      # directory scope does prevent propagation going any further.
+      set(var1 "block-nested")
+      return(PROPAGATE var1)
+    endblock()
+
+See Also
+^^^^^^^^
+
+* :command:`block`
+* :command:`function`

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/set_directory_properties.rst

@@ -0,0 +1,23 @@
+set_directory_properties
+------------------------
+
+Set properties of the current directory and subdirectories.
+
+.. code-block:: cmake
+
+  set_directory_properties(PROPERTIES <prop1> <value1> [<prop2> <value2>] ...)
+
+Sets properties of the current directory and its subdirectories in key-value
+pairs.
+
+See also the :command:`set_property(DIRECTORY)` command.
+
+See :ref:`Directory Properties` for the list of properties known to CMake
+and their individual documentation for the behavior of each property.
+
+See Also
+^^^^^^^^
+
+* :command:`define_property`
+* :command:`get_directory_property`
+* the more general :command:`set_property` command

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/set_tests_properties.rst

@@ -0,0 +1,36 @@
+set_tests_properties
+--------------------
+
+Set a property of the tests.
+
+.. code-block:: cmake
+
+  set_tests_properties(<tests>...
+                       [DIRECTORY <dir>]
+                       PROPERTIES <prop1> <value1>
+                       [<prop2> <value2>]...)
+
+Sets a property for the tests.  If the test is not found, CMake
+will report an error.
+
+Test property values may be specified using
+:manual:`generator expressions <cmake-generator-expressions(7)>`
+for tests created by the :command:`add_test(NAME)` signature.
+
+.. versionadded:: 3.28
+  Visibility can be set in other directory scopes using the following option:
+
+  ``DIRECTORY <dir>``
+    The test properties will be set in the ``<dir>`` directory's scope.
+    CMake must already know about this directory, either by having added it
+    through a call to :command:`add_subdirectory` or it being the top level
+    source directory. Relative paths are treated as relative to the current
+    source directory. ``<dir>`` may reference a binary directory.
+
+See Also
+^^^^^^^^
+
+* :command:`add_test`
+* :command:`define_property`
+* the more general :command:`set_property` command
+* :ref:`Test Properties` for the list of properties known to CMake

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/site_name.rst

@@ -0,0 +1,12 @@
+site_name
+---------
+
+Set the given variable to the name of the computer.
+
+.. code-block:: cmake
+
+  site_name(variable)
+
+On UNIX-like platforms, if the variable ``HOSTNAME`` is set, its value
+will be executed as a command expected to print out the host name,
+much like the ``hostname`` command-line tool.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/target_link_libraries.rst

@@ -0,0 +1,432 @@
+target_link_libraries
+---------------------
+
+.. only:: html
+
+   .. contents::
+
+Specify libraries or flags to use when linking a given target and/or
+its dependents.  :ref:`Usage requirements <Target Usage Requirements>`
+from linked library targets will be propagated.  Usage requirements
+of a target's dependencies affect compilation of its own sources.
+
+Overview
+^^^^^^^^
+
+This command has several signatures as detailed in subsections below.
+All of them have the general form
+
+.. code-block:: cmake
+
+  target_link_libraries(<target> ... <item>... ...)
+
+The named ``<target>`` must have been created by a command such as
+:command:`add_executable` or :command:`add_library` and must not be an
+:ref:`ALIAS target <Alias Targets>`.  If policy :policy:`CMP0079` is not
+set to ``NEW`` then the target must have been created in the current
+directory.  Repeated calls for the same ``<target>`` append items in
+the order called.
+
+.. versionadded:: 3.13
+  The ``<target>`` doesn't have to be defined in the same directory as the
+  ``target_link_libraries`` call.
+
+Each ``<item>`` may be:
+
+* **A library target name**: The generated link line will have the
+  full path to the linkable library file associated with the target.
+  The buildsystem will have a dependency to re-link ``<target>`` if
+  the library file changes.
+
+  The named target must be created by :command:`add_library` within
+  the project or as an :ref:`IMPORTED library <Imported Targets>`.
+  If it is created within the project an ordering dependency will
+  automatically be added in the build system to make sure the named
+  library target is up-to-date before the ``<target>`` links.
+
+  If an imported library has the :prop_tgt:`IMPORTED_NO_SONAME`
+  target property set, CMake may ask the linker to search for
+  the library instead of using the full path
+  (e.g. ``/usr/lib/libfoo.so`` becomes ``-lfoo``).
+
+  The full path to the target's artifact will be quoted/escaped for
+  the shell automatically.
+
+* **A full path to a library file**: The generated link line will
+  normally preserve the full path to the file. The buildsystem will
+  have a dependency to re-link ``<target>`` if the library file changes.
+
+  There are some cases where CMake may ask the linker to search for
+  the library (e.g. ``/usr/lib/libfoo.so`` becomes ``-lfoo``), such
+  as when a shared library is detected to have no ``SONAME`` field.
+  See policy :policy:`CMP0060` for discussion of another case.
+
+  If the library file is in a macOS framework, the ``Headers`` directory
+  of the framework will also be processed as a
+  :ref:`usage requirement <Target Usage Requirements>`.  This has the same
+  effect as passing the framework directory as an include directory.
+
+  .. versionadded:: 3.28
+
+    The library file may point to a ``.xcframework`` folder on Apple platforms.
+    If it does, the target will get the selected library's ``Headers``
+    directory as a usage requirement.
+
+  .. versionadded:: 3.8
+    On :ref:`Visual Studio Generators` for VS 2010 and above, library files
+    ending in ``.targets`` will be treated as MSBuild targets files and
+    imported into generated project files.  This is not supported by other
+    generators.
+
+  The full path to the library file will be quoted/escaped for
+  the shell automatically.
+
+* **A plain library name**: The generated link line will ask the linker
+  to search for the library (e.g. ``foo`` becomes ``-lfoo`` or ``foo.lib``).
+
+  The library name/flag is treated as a command-line string fragment and
+  will be used with no extra quoting or escaping.
+
+* **A link flag**: Item names starting with ``-``, but not ``-l`` or
+  ``-framework``, are treated as linker flags.  Note that such flags will
+  be treated like any other library link item for purposes of transitive
+  dependencies, so they are generally safe to specify only as private link
+  items that will not propagate to dependents.
+
+  Link flags specified here are inserted into the link command in the same
+  place as the link libraries. This might not be correct, depending on
+  the linker. Use the :prop_tgt:`LINK_OPTIONS` target property or
+  :command:`target_link_options` command to add link
+  flags explicitly. The flags will then be placed at the toolchain-defined
+  flag position in the link command.
+
+  .. versionadded:: 3.13
+    :prop_tgt:`LINK_OPTIONS` target property and :command:`target_link_options`
+    command.  For earlier versions of CMake, use :prop_tgt:`LINK_FLAGS`
+    property instead.
+
+  The link flag is treated as a command-line string fragment and
+  will be used with no extra quoting or escaping.
+
+* **A generator expression**: A ``$<...>`` :manual:`generator expression
+  <cmake-generator-expressions(7)>` may evaluate to any of the above
+  items or to a :ref:`semicolon-separated list <CMake Language Lists>` of them.
+  If the ``...`` contains any ``;`` characters, e.g. after evaluation
+  of a ``${list}`` variable, be sure to use an explicitly quoted
+  argument ``"$<...>"`` so that this command receives it as a
+  single ``<item>``.
+
+  Additionally, a generator expression may be used as a fragment of
+  any of the above items, e.g. ``foo$<1:_d>``.
+
+  Note that generator expressions will not be used in OLD handling of
+  policy :policy:`CMP0003` or policy :policy:`CMP0004`.
+
+* A ``debug``, ``optimized``, or ``general`` keyword immediately followed
+  by another ``<item>``.  The item following such a keyword will be used
+  only for the corresponding build configuration.  The ``debug`` keyword
+  corresponds to the ``Debug`` configuration (or to configurations named
+  in the :prop_gbl:`DEBUG_CONFIGURATIONS` global property if it is set).
+  The ``optimized`` keyword corresponds to all other configurations.  The
+  ``general`` keyword corresponds to all configurations, and is purely
+  optional.  Higher granularity may be achieved for per-configuration
+  rules by creating and linking to
+  :ref:`IMPORTED library targets <Imported Targets>`.
+  These keywords are interpreted immediately by this command and therefore
+  have no special meaning when produced by a generator expression.
+
+Items containing ``::``, such as ``Foo::Bar``, are assumed to be
+:ref:`IMPORTED <Imported Targets>` or :ref:`ALIAS <Alias Targets>` library
+target names and will cause an error if no such target exists.
+See policy :policy:`CMP0028`.
+
+See the :variable:`CMAKE_LINK_LIBRARIES_STRATEGY` variable and
+corresponding :prop_tgt:`LINK_LIBRARIES_STRATEGY` target property
+for details on how CMake orders direct link dependencies on linker
+command lines.
+
+See the :manual:`cmake-buildsystem(7)` manual for more on defining
+buildsystem properties.
+
+Libraries for a Target and/or its Dependents
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+  target_link_libraries(<target>
+                        <PRIVATE|PUBLIC|INTERFACE> <item>...
+                       [<PRIVATE|PUBLIC|INTERFACE> <item>...]...)
+
+The ``PUBLIC``, ``PRIVATE`` and ``INTERFACE``
+:ref:`scope <Target Command Scope>` keywords can be used to
+specify both the link dependencies and the link interface in one command.
+
+Libraries and targets following ``PUBLIC`` are linked to, and are made
+part of the link interface.  Libraries and targets following ``PRIVATE``
+are linked to, but are not made part of the link interface.  Libraries
+following ``INTERFACE`` are appended to the link interface and are not
+used for linking ``<target>``.
+
+Libraries for both a Target and its Dependents
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+  target_link_libraries(<target> <item>...)
+
+Library dependencies are transitive by default with this signature.
+When this target is linked into another target then the libraries
+linked to this target will appear on the link line for the other
+target too.  This transitive "link interface" is stored in the
+:prop_tgt:`INTERFACE_LINK_LIBRARIES` target property and may be overridden
+by setting the property directly.  When :policy:`CMP0022` is not set to
+``NEW``, transitive linking is built in but may be overridden by the
+:prop_tgt:`LINK_INTERFACE_LIBRARIES` property.  Calls to other signatures
+of this command may set the property making any libraries linked
+exclusively by this signature private.
+
+Libraries for a Target and/or its Dependents (Legacy)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+  target_link_libraries(<target>
+                        <LINK_PRIVATE|LINK_PUBLIC> <lib>...
+                       [<LINK_PRIVATE|LINK_PUBLIC> <lib>...]...)
+
+The ``LINK_PUBLIC`` and ``LINK_PRIVATE`` modes can be used to specify both
+the link dependencies and the link interface in one command.
+
+This signature is for compatibility only.  Prefer the ``PUBLIC`` or
+``PRIVATE`` keywords instead.
+
+Libraries and targets following ``LINK_PUBLIC`` are linked to, and are
+made part of the :prop_tgt:`INTERFACE_LINK_LIBRARIES`.  If policy
+:policy:`CMP0022` is not ``NEW``, they are also made part of the
+:prop_tgt:`LINK_INTERFACE_LIBRARIES`.  Libraries and targets following
+``LINK_PRIVATE`` are linked to, but are not made part of the
+:prop_tgt:`INTERFACE_LINK_LIBRARIES` (or :prop_tgt:`LINK_INTERFACE_LIBRARIES`).
+
+Libraries for Dependents Only (Legacy)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+  target_link_libraries(<target> LINK_INTERFACE_LIBRARIES <item>...)
+
+The ``LINK_INTERFACE_LIBRARIES`` mode appends the libraries to the
+:prop_tgt:`INTERFACE_LINK_LIBRARIES` target property instead of using them
+for linking.  If policy :policy:`CMP0022` is not ``NEW``, then this mode
+also appends libraries to the :prop_tgt:`LINK_INTERFACE_LIBRARIES` and its
+per-configuration equivalent.
+
+This signature is for compatibility only.  Prefer the ``INTERFACE`` mode
+instead.
+
+Libraries specified as ``debug`` are wrapped in a generator expression to
+correspond to debug builds.  If policy :policy:`CMP0022` is
+not ``NEW``, the libraries are also appended to the
+:prop_tgt:`LINK_INTERFACE_LIBRARIES_DEBUG <LINK_INTERFACE_LIBRARIES_<CONFIG>>`
+property (or to the properties corresponding to configurations listed in
+the :prop_gbl:`DEBUG_CONFIGURATIONS` global property if it is set).
+Libraries specified as ``optimized`` are appended to the
+:prop_tgt:`INTERFACE_LINK_LIBRARIES` property.  If policy :policy:`CMP0022`
+is not ``NEW``, they are also appended to the
+:prop_tgt:`LINK_INTERFACE_LIBRARIES` property.  Libraries specified as
+``general`` (or without any keyword) are treated as if specified for both
+``debug`` and ``optimized``.
+
+Linking Object Libraries
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. versionadded:: 3.12
+
+:ref:`Object Libraries` may be used as the ``<target>`` (first) argument
+of ``target_link_libraries`` to specify dependencies of their sources
+on other libraries.  For example, the code
+
+.. code-block:: cmake
+
+  add_library(A SHARED a.c)
+  target_compile_definitions(A PUBLIC A)
+
+  add_library(obj OBJECT obj.c)
+  target_compile_definitions(obj PUBLIC OBJ)
+  target_link_libraries(obj PUBLIC A)
+
+compiles ``obj.c`` with ``-DA -DOBJ`` and establishes usage requirements
+for ``obj`` that propagate to its dependents.
+
+Normal libraries and executables may link to :ref:`Object Libraries`
+to get their objects and usage requirements.  Continuing the above
+example, the code
+
+.. code-block:: cmake
+
+  add_library(B SHARED b.c)
+  target_link_libraries(B PUBLIC obj)
+
+compiles ``b.c`` with ``-DA -DOBJ``, creates shared library ``B``
+with object files from ``b.c`` and ``obj.c``, and links ``B`` to ``A``.
+Furthermore, the code
+
+.. code-block:: cmake
+
+  add_executable(main main.c)
+  target_link_libraries(main B)
+
+compiles ``main.c`` with ``-DA -DOBJ`` and links executable ``main``
+to ``B`` and ``A``.  The object library's usage requirements are
+propagated transitively through ``B``, but its object files are not.
+
+:ref:`Object Libraries` may "link" to other object libraries to get
+usage requirements, but since they do not have a link step nothing
+is done with their object files.  Continuing from the above example,
+the code:
+
+.. code-block:: cmake
+
+  add_library(obj2 OBJECT obj2.c)
+  target_link_libraries(obj2 PUBLIC obj)
+
+  add_executable(main2 main2.c)
+  target_link_libraries(main2 obj2)
+
+compiles ``obj2.c`` with ``-DA -DOBJ``, creates executable ``main2``
+with object files from ``main2.c`` and ``obj2.c``, and links ``main2``
+to ``A``.
+
+In other words, when :ref:`Object Libraries` appear in a target's
+:prop_tgt:`INTERFACE_LINK_LIBRARIES` property they will be
+treated as :ref:`Interface Libraries`, but when they appear in
+a target's :prop_tgt:`LINK_LIBRARIES` property their object files
+will be included in the link too.
+
+.. _`Linking Object Libraries via $<TARGET_OBJECTS>`:
+
+Linking Object Libraries via ``$<TARGET_OBJECTS>``
+""""""""""""""""""""""""""""""""""""""""""""""""""
+
+.. versionadded:: 3.21
+
+The object files associated with an object library may be referenced
+by the :genex:`$<TARGET_OBJECTS>` generator expression.  Such object
+files are placed on the link line *before* all libraries, regardless
+of their relative order.  Additionally, an ordering dependency will be
+added to the build system to make sure the object library is up-to-date
+before the dependent target links.  For example, the code
+
+.. code-block:: cmake
+
+  add_library(obj3 OBJECT obj3.c)
+  target_compile_definitions(obj3 PUBLIC OBJ3)
+
+  add_executable(main3 main3.c)
+  target_link_libraries(main3 PRIVATE a3 $<TARGET_OBJECTS:obj3> b3)
+
+links executable ``main3`` with object files from ``main3.c``
+and ``obj3.c`` followed by the ``a3`` and ``b3`` libraries.
+``main3.c`` is *not* compiled with usage requirements from ``obj3``,
+such as ``-DOBJ3``.
+
+This approach can be used to achieve transitive inclusion of object
+files in link lines as usage requirements.  Continuing the above
+example, the code
+
+.. code-block:: cmake
+
+  add_library(iface_obj3 INTERFACE)
+  target_link_libraries(iface_obj3 INTERFACE obj3 $<TARGET_OBJECTS:obj3>)
+
+creates an interface library ``iface_obj3`` that forwards the ``obj3``
+usage requirements and adds the ``obj3`` object files to dependents'
+link lines.  The code
+
+.. code-block:: cmake
+
+  add_executable(use_obj3 use_obj3.c)
+  target_link_libraries(use_obj3 PRIVATE iface_obj3)
+
+compiles ``use_obj3.c`` with ``-DOBJ3`` and links executable ``use_obj3``
+with object files from ``use_obj3.c`` and ``obj3.c``.
+
+This also works transitively through a static library.  Since a static
+library does not link, it does not consume the object files from
+object libraries referenced this way.  Instead, the object files
+become transitive link dependencies of the static library.
+Continuing the above example, the code
+
+.. code-block:: cmake
+
+  add_library(static3 STATIC static3.c)
+  target_link_libraries(static3 PRIVATE iface_obj3)
+
+  add_executable(use_static3 use_static3.c)
+  target_link_libraries(use_static3 PRIVATE static3)
+
+compiles ``static3.c`` with ``-DOBJ3`` and creates ``libstatic3.a``
+using only its own object file.  ``use_static3.c`` is compiled *without*
+``-DOBJ3`` because the usage requirement is not transitive through
+the private dependency of ``static3``.  However, the link dependencies
+of ``static3`` are propagated, including the ``iface_obj3`` reference
+to ``$<TARGET_OBJECTS:obj3>``.  The ``use_static3`` executable is
+created with object files from ``use_static3.c`` and ``obj3.c``, and
+linked to library ``libstatic3.a``.
+
+When using this approach, it is the project's responsibility to avoid
+linking multiple dependent binaries to ``iface_obj3``, because they will
+all get the ``obj3`` object files on their link lines.
+
+.. note::
+
+  Referencing :genex:`$<TARGET_OBJECTS>` in ``target_link_libraries``
+  calls worked in versions of CMake prior to 3.21 for some cases,
+  but was not fully supported:
+
+  * It did not place the object files before libraries on link lines.
+  * It did not add an ordering dependency on the object library.
+  * It did not work in Xcode with multiple architectures.
+
+Cyclic Dependencies of Static Libraries
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The library dependency graph is normally acyclic (a DAG), but in the case
+of mutually-dependent ``STATIC`` libraries CMake allows the graph to
+contain cycles (strongly connected components).  When another target links
+to one of the libraries, CMake repeats the entire connected component.
+For example, the code
+
+.. code-block:: cmake
+
+  add_library(A STATIC a.c)
+  add_library(B STATIC b.c)
+  target_link_libraries(A B)
+  target_link_libraries(B A)
+  add_executable(main main.c)
+  target_link_libraries(main A)
+
+links ``main`` to ``A B A B``.  While one repetition is usually
+sufficient, pathological object file and symbol arrangements can require
+more.  One may handle such cases by using the
+:prop_tgt:`LINK_INTERFACE_MULTIPLICITY` target property or by manually
+repeating the component in the last ``target_link_libraries`` call.
+However, if two archives are really so interdependent they should probably
+be combined into a single archive, perhaps by using :ref:`Object Libraries`.
+
+Creating Relocatable Packages
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. |INTERFACE_PROPERTY_LINK| replace:: :prop_tgt:`INTERFACE_LINK_LIBRARIES`
+.. include:: /include/INTERFACE_LINK_LIBRARIES_WARNING.txt
+
+See Also
+^^^^^^^^
+
+* :command:`target_compile_definitions`
+* :command:`target_compile_features`
+* :command:`target_compile_options`
+* :command:`target_include_directories`
+* :command:`target_link_directories`
+* :command:`target_link_options`
+* :command:`target_precompile_headers`
+* :command:`target_sources`

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/target_precompile_headers.rst

@@ -0,0 +1,133 @@
+target_precompile_headers
+-------------------------
+
+.. versionadded:: 3.16
+
+Add a list of header files to precompile.
+
+Precompiling header files can speed up compilation by creating a partially
+processed version of some header files, and then using that version during
+compilations rather than repeatedly parsing the original headers.
+
+Main Form
+^^^^^^^^^
+
+.. code-block:: cmake
+
+  target_precompile_headers(<target>
+    <INTERFACE|PUBLIC|PRIVATE> [header1...]
+    [<INTERFACE|PUBLIC|PRIVATE> [header2...] ...])
+
+The command adds header files to the :prop_tgt:`PRECOMPILE_HEADERS` and/or
+:prop_tgt:`INTERFACE_PRECOMPILE_HEADERS` target properties of ``<target>``.
+The named ``<target>`` must have been created by a command such as
+:command:`add_executable` or :command:`add_library` and must not be an
+:ref:`ALIAS target <Alias Targets>`.
+
+The ``INTERFACE``, ``PUBLIC`` and ``PRIVATE`` keywords are required to
+specify the :ref:`scope <Target Command Scope>` of the following arguments.
+``PRIVATE`` and ``PUBLIC`` items will populate the :prop_tgt:`PRECOMPILE_HEADERS`
+property of ``<target>``.  ``PUBLIC`` and ``INTERFACE`` items will populate the
+:prop_tgt:`INTERFACE_PRECOMPILE_HEADERS` property of ``<target>``
+(:ref:`IMPORTED targets <Imported Targets>` only support ``INTERFACE`` items).
+Repeated calls for the same ``<target>`` will append items in the order called.
+
+Projects should generally avoid using ``PUBLIC`` or ``INTERFACE`` for targets
+that will be :command:`exported <install(EXPORT)>`, or they should at least use
+the :genex:`$<BUILD_INTERFACE:...>` generator expression to prevent precompile
+headers from appearing in an installed exported target.  Consumers of a target
+should typically be in control of what precompile headers they use, not have
+precompile headers forced on them by the targets being consumed (since
+precompile headers are not typically usage requirements).  A notable exception
+to this is where an :ref:`interface library <Interface Libraries>` is created
+to define a commonly used set of precompile headers in one place and then other
+targets link to that interface library privately.  In this case, the interface
+library exists specifically to propagate the precompile headers to its
+consumers and the consumer is effectively still in control, since it decides
+whether to link to the interface library or not.
+
+The list of header files is used to generate a header file named
+``cmake_pch.h|xx`` which is used to generate the precompiled header file
+(``.pch``, ``.gch``, ``.pchi``) artifact.  The ``cmake_pch.h|xx`` header
+file will be force included (``-include`` for GCC, ``/FI`` for MSVC) to
+all source files, so sources do not need to have ``#include "pch.h"``.
+
+Header file names specified with angle brackets (e.g. ``<unordered_map>``) or
+explicit double quotes (escaped for the :manual:`cmake-language(7)`,
+e.g. ``[["other_header.h"]]``) will be treated as is, and include directories
+must be available for the compiler to find them.  Other header file names
+(e.g. ``project_header.h``) are interpreted as being relative to the current
+source directory (e.g. :variable:`CMAKE_CURRENT_SOURCE_DIR`) and will be
+included by absolute path.  For example:
+
+.. code-block:: cmake
+
+  target_precompile_headers(myTarget
+    PUBLIC
+      project_header.h
+    PRIVATE
+      [["other_header.h"]]
+      <unordered_map>
+  )
+
+.. |command_name| replace:: ``target_precompile_headers``
+.. |more_see_also| replace:: The :genex:`$<COMPILE_LANGUAGE:...>` generator
+   expression is particularly useful for specifying a language-specific header
+   to precompile for only one language (e.g. ``CXX`` and not ``C``).  In this
+   case, header file names that are not explicitly in double quotes or angle
+   brackets must be specified by absolute path.  Also, when specifying angle
+   brackets inside a generator expression, be sure to encode the closing
+   ``>`` as :genex:`$<ANGLE-R>`.  For example:
+.. include:: GENEX_NOTE.txt
+   :start-line: 1
+
+.. code-block:: cmake
+
+  target_precompile_headers(mylib PRIVATE
+    "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_CURRENT_SOURCE_DIR}/cxx_only.h>"
+    "$<$<COMPILE_LANGUAGE:C>:<stddef.h$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<cstddef$<ANGLE-R>>"
+  )
+
+
+Reusing Precompile Headers
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The command also supports a second signature which can be used to specify that
+one target reuses a precompiled header file artifact from another target
+instead of generating its own:
+
+.. code-block:: cmake
+
+  target_precompile_headers(<target> REUSE_FROM <other_target>)
+
+This form sets the :prop_tgt:`PRECOMPILE_HEADERS_REUSE_FROM` property to
+``<other_target>`` and adds a dependency such that ``<target>`` will depend
+on ``<other_target>``.  CMake will halt with an error if the
+:prop_tgt:`PRECOMPILE_HEADERS` property of ``<target>`` is already set when
+the ``REUSE_FROM`` form is used.
+
+.. note::
+
+  The ``REUSE_FROM`` form requires the same set of compiler options,
+  compiler flags and compiler definitions for both ``<target>`` and
+  ``<other_target>``.  Some compilers (e.g. GCC) may issue a warning if the
+  precompiled header file cannot be used (``-Winvalid-pch``).
+
+See Also
+^^^^^^^^
+
+* To disable precompile headers for specific targets, see the
+  :prop_tgt:`DISABLE_PRECOMPILE_HEADERS` target property.
+
+* To prevent precompile headers from being used when compiling a specific
+  source file, see the :prop_sf:`SKIP_PRECOMPILE_HEADERS` source file property.
+
+* :command:`target_compile_definitions`
+* :command:`target_compile_features`
+* :command:`target_compile_options`
+* :command:`target_include_directories`
+* :command:`target_link_libraries`
+* :command:`target_link_directories`
+* :command:`target_link_options`
+* :command:`target_sources`

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/unset.rst

@@ -0,0 +1,41 @@
+unset
+-----
+
+Unset a variable, cache variable, or environment variable.
+
+Unset Normal Variable or Cache Entry
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+  unset(<variable> [CACHE | PARENT_SCOPE])
+
+Removes a normal variable from the current scope, causing it
+to become undefined.  If ``CACHE`` is present, then a cache variable
+is removed instead of a normal variable.
+
+If ``PARENT_SCOPE`` is present then the variable is removed from the scope
+above the current scope.  See the same option in the :command:`set` command
+for further details.
+
+.. include:: UNSET_NOTE.txt
+
+Unset Environment Variable
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+  unset(ENV{<variable>})
+
+Removes ``<variable>`` from the currently available
+:manual:`Environment Variables <cmake-env-variables(7)>`.
+Subsequent calls of ``$ENV{<variable>}`` will return the empty string.
+
+This command affects only the current CMake process, not the process
+from which CMake was called, nor the system environment at large,
+nor the environment of subsequent build or test processes.
+
+See Also
+^^^^^^^^
+
+* :command:`set`

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/utility_source.rst

@@ -0,0 +1,24 @@
+utility_source
+--------------
+
+Disallowed since version 3.0.  See CMake Policy :policy:`CMP0034`.
+
+Specify the source tree of a third-party utility.
+
+.. code-block:: cmake
+
+  utility_source(cache_entry executable_name
+                 path_to_source [file1 file2 ...])
+
+When a third-party utility's source is included in the distribution,
+this command specifies its location and name.  The cache entry will
+not be set unless the ``path_to_source`` and all listed files exist.  It
+is assumed that the source tree of the utility will have been built
+before it is needed.
+
+When cross compiling CMake will print a warning if a ``utility_source()``
+command is executed, because in many cases it is used to build an
+executable which is executed later on.  This doesn't work when cross
+compiling, since the executable can run only on their target platform.
+So in this case the cache entry has to be adjusted manually so it
+points to an executable which is runnable on the build host.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/variable_watch.rst

@@ -0,0 +1,48 @@
+variable_watch
+--------------
+
+Watch the CMake variable for change.
+
+.. code-block:: cmake
+
+  variable_watch(<variable> [<command>])
+
+If the specified ``<variable>`` changes and no ``<command>`` is given,
+a message will be printed to inform about the change.
+
+If ``<command>`` is given, this command will be executed instead.
+The command will receive the following arguments:
+``COMMAND(<variable> <access> <value> <current_list_file> <stack>)``
+
+``<variable>``
+ Name of the variable being accessed.
+
+``<access>``
+ One of ``READ_ACCESS``, ``UNKNOWN_READ_ACCESS``, ``MODIFIED_ACCESS``,
+ ``UNKNOWN_MODIFIED_ACCESS``, or ``REMOVED_ACCESS``.  The ``UNKNOWN_``
+ values are only used when the variable has never been set.  Once set,
+ they are never used again during the same CMake run, even if the
+ variable is later unset.
+
+``<value>``
+ The value of the variable.  On a modification, this is the new
+ (modified) value of the variable.  On removal, the value is empty.
+
+``<current_list_file>``
+ Full path to the file doing the access.
+
+``<stack>``
+ List of absolute paths of all files currently on the stack of file
+ inclusion, with the bottom-most file first and the currently
+ processed file (that is, ``current_list_file``) last.
+
+Note that for some accesses such as :command:`list(APPEND)`, the watcher
+is executed twice, first with a read access and then with a write one.
+Also note that an :command:`if(DEFINED)` query on the variable does not
+register as an access and the watcher is not executed.
+
+Only non-cache variables can be watched using this command.  Access to
+cache variables is never watched.  However, the existence of a cache
+variable ``var`` causes accesses to the non-cache variable ``var`` to
+not use the ``UNKNOWN_`` prefix, even if a non-cache variable ``var``
+has never existed.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/while.rst

@@ -0,0 +1,33 @@
+while
+-----
+
+Evaluate a group of commands while a condition is true
+
+.. code-block:: cmake
+
+  while(<condition>)
+    <commands>
+  endwhile()
+
+All commands between while and the matching :command:`endwhile` are recorded
+without being invoked.  Once the :command:`endwhile` is evaluated, the
+recorded list of commands is invoked as long as the ``<condition>`` is true.
+
+The ``<condition>`` has the same syntax and is evaluated using the same logic
+as described at length for the :command:`if` command.
+
+The commands :command:`break` and :command:`continue` provide means to
+escape from the normal control flow.
+
+Per legacy, the :command:`endwhile` command admits
+an optional ``<condition>`` argument.
+If used, it must be a verbatim repeat of the argument of the opening
+``while`` command.
+
+See Also
+^^^^^^^^
+
+* :command:`break`
+* :command:`continue`
+* :command:`foreach`
+* :command:`endwhile`

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/ANDROID_NATIVE_LIB_DIRECTORIES.rst

@@ -0,0 +1,18 @@
+ANDROID_NATIVE_LIB_DIRECTORIES
+------------------------------
+
+.. versionadded:: 3.4
+
+Set the Android property that specifies directories to search for the ``.so``
+libraries.
+
+This a string property that contains the directory paths separated
+by semicolons.
+
+This property is initialized by the value of the
+:variable:`CMAKE_ANDROID_NATIVE_LIB_DIRECTORIES` variable if it is set when a
+target is created.
+
+Contents of ``ANDROID_NATIVE_LIB_DIRECTORIES`` may use "generator expressions"
+with the syntax ``$<...>``.  See the :manual:`cmake-generator-expressions(7)`
+manual for available expressions.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/AUTOMOC_EXECUTABLE.rst

@@ -0,0 +1,17 @@
+AUTOMOC_EXECUTABLE
+------------------
+
+.. versionadded:: 3.14
+
+``AUTOMOC_EXECUTABLE`` is file path pointing to the ``moc``
+executable to use for :prop_tgt:`AUTOMOC` enabled files. Setting
+this property will make CMake skip the automatic detection of the
+``moc`` binary as well as the sanity-tests normally run to ensure
+that the binary is available and working as expected.
+
+Usually this property does not need to be set. Only consider this
+property if auto-detection of ``moc`` can not work -- e.g. because
+you are building the ``moc`` binary as part of your project.
+
+See the :manual:`cmake-qt(7)` manual for more information on using CMake
+with Qt.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/BUILD_RPATH.rst

@@ -0,0 +1,36 @@
+BUILD_RPATH
+-----------
+
+.. versionadded:: 3.8
+
+A :ref:`semicolon-separated list <CMake Language Lists>` specifying
+runtime path (``RPATH``) entries to add to binaries linked in the
+build tree (for platforms that support it).  By default, CMake sets
+the runtime path of binaries in the build tree to contain search
+paths it knows are needed to find the shared libraries they link.
+Projects may set ``BUILD_RPATH`` to specify additional search paths.
+
+The build-tree runtime path will *not* be used for binaries in the
+install tree.  It will be replaced with the install-tree runtime path
+during the installation step.  See also the :prop_tgt:`INSTALL_RPATH`
+target property.
+
+This property is initialized by the value of the variable
+:variable:`CMAKE_BUILD_RPATH` if it is set when a target is created.
+
+This property supports
+:manual:`generator expressions <cmake-generator-expressions(7)>`.
+
+Other settings that affect the build-tree runtime path include:
+
+* The :variable:`CMAKE_SKIP_RPATH` variable completely disables runtime
+  paths in both the build tree and install tree.
+
+* The :prop_tgt:`SKIP_BUILD_RPATH` target property disables setting any
+  runtime path in the build tree.
+
+* The :prop_tgt:`BUILD_RPATH_USE_ORIGIN` target property causes the
+  automatically-generated runtime path to use entries relative to ``$ORIGIN``.
+
+* The :prop_tgt:`BUILD_WITH_INSTALL_RPATH` target property causes binaries
+  in the build tree to be built with the install-tree runtime path.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/BUILD_WITH_INSTALL_RPATH.rst

@@ -0,0 +1,15 @@
+BUILD_WITH_INSTALL_RPATH
+------------------------
+
+``BUILD_WITH_INSTALL_RPATH`` is a boolean specifying whether to link the target
+in the build tree with the :prop_tgt:`INSTALL_RPATH`.  This takes precedence
+over :prop_tgt:`SKIP_BUILD_RPATH` and avoids the need for relinking before
+installation.
+
+This property is initialized by the value of the
+:variable:`CMAKE_BUILD_WITH_INSTALL_RPATH` variable if it is set when a target
+is created.
+
+If policy :policy:`CMP0068` is not ``NEW``, this property also controls use of
+:prop_tgt:`INSTALL_NAME_DIR` in the build tree on macOS.  Either way, the
+:prop_tgt:`BUILD_WITH_INSTALL_NAME_DIR` target property takes precedence.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/BUNDLE_EXTENSION.rst

@@ -0,0 +1,8 @@
+BUNDLE_EXTENSION
+----------------
+
+The file extension used to name a :prop_tgt:`BUNDLE`, a :prop_tgt:`FRAMEWORK`,
+or a :prop_tgt:`MACOSX_BUNDLE` target on the macOS and iOS.
+
+The default value is ``bundle``, ``framework``, or ``app`` for the respective
+target types.

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/COMPILE_PDB_NAME.rst

@@ -0,0 +1,13 @@
+COMPILE_PDB_NAME
+----------------
+
+.. versionadded:: 3.1
+
+Output name for the MS debug symbol ``.pdb`` file generated by the
+compiler while building source files.
+
+This property specifies the base name for the debug symbols file.
+If not set, the default is unspecified.
+
+.. |PDB_XXX| replace:: :prop_tgt:`PDB_NAME`
+.. include:: COMPILE_PDB_NOTE.txt

openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/C_EXTENSIONS.rst

@@ -0,0 +1,21 @@
+C_EXTENSIONS
+------------
+
+.. versionadded:: 3.1
+
+Boolean specifying whether compiler specific extensions are requested.
+
+This property specifies whether compiler specific extensions should be
+used.  For some compilers, this results in adding a flag such
+as ``-std=gnu11`` instead of ``-std=c11`` to the compile line.  This
+property is ``ON`` by default. The basic C standard level is
+controlled by the :prop_tgt:`C_STANDARD` target property.
+
+See the :manual:`cmake-compile-features(7)` manual for information on
+compile features and a list of supported compilers.
+
+This property is initialized by the value of
+the :variable:`CMAKE_C_EXTENSIONS` variable if set when a target is created and
+otherwise by the value of
+:variable:`CMAKE_C_EXTENSIONS_DEFAULT <CMAKE_<LANG>_EXTENSIONS_DEFAULT>` (see
+:policy:`CMP0128`).