diff --git a/cmake/doc/cmake/html/_sources/command/add_compile_definitions.rst.txt b/cmake/doc/cmake/html/_sources/command/add_compile_definitions.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b2eb2af3b73d059dadd866f635480e901bd70c02
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_compile_definitions.rst.txt
@@ -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( ...)
+
+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.
diff --git a/cmake/doc/cmake/html/_sources/command/add_compile_options.rst.txt b/cmake/doc/cmake/html/_sources/command/add_compile_options.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..869d0c2ceda3e5db3c0a8d99544695801bdc9644
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_compile_options.rst.txt
@@ -0,0 +1,67 @@
+add_compile_options
+-------------------
+
+Add options to the compilation of source files.
+
+.. code-block:: cmake
+
+ add_compile_options( ...)
+
+Adds options to the :prop_dir:`COMPILE_OPTIONS` directory property.
+These options are used when compiling targets from the current
+directory and below.
+
+.. note::
+
+ These options are not used when linking.
+ See the :command:`add_link_options` command for that.
+
+Arguments
+^^^^^^^^^
+
+.. |command_name| replace:: ``add_compile_options``
+.. include:: GENEX_NOTE.txt
+
+.. include:: OPTIONS_SHELL.txt
+
+Example
+^^^^^^^
+
+Since different compilers support different options, a typical use of
+this command is in a compiler-specific conditional clause:
+
+.. code-block:: cmake
+
+ if (MSVC)
+ # warning level 4
+ add_compile_options(/W4)
+ else()
+ # additional warnings
+ add_compile_options(-Wall -Wextra -Wpedantic)
+ endif()
+
+To set per-language options, use the :genex:`$`
+or :genex:`$` generator expressions.
+
+See Also
+^^^^^^^^
+
+* This command can be used to add any options. However, for
+ adding preprocessor definitions and include directories it is recommended
+ to use the more specific commands :command:`add_compile_definitions`
+ and :command:`include_directories`.
+
+* The command :command:`target_compile_options` adds target-specific options.
+
+* This command adds compile options for all languages.
+ Use the :genex:`COMPILE_LANGUAGE` generator expression to specify
+ per-language compile options.
+
+* The source file property :prop_sf:`COMPILE_OPTIONS` adds options to one
+ source file.
+
+* :command:`add_link_options` adds options for linking.
+
+* :variable:`CMAKE__FLAGS` and :variable:`CMAKE__FLAGS_`
+ add language-wide flags passed to all invocations of the compiler.
+ This includes invocations that drive compiling and those that drive linking.
diff --git a/cmake/doc/cmake/html/_sources/command/add_custom_command.rst.txt b/cmake/doc/cmake/html/_sources/command/add_custom_command.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6c2d693f1282ea1a6bbf14f2da182f468f4390a6
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_custom_command.rst.txt
@@ -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 depend1
+ [ depend2] ...]
+ [WORKING_DIRECTORY dir]
+ [COMMENT comment]
+ [DEPFILE depfile]
+ [JOB_POOL job_pool]
+ [JOB_SERVER_AWARE ]
+ [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 `.
+ :ref:`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 `.
+ 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 `.
+
+``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 `.
+
+``COMMAND_EXPAND_LISTS``
+ .. versionadded:: 3.8
+
+ Lists in ``COMMAND`` arguments will be expanded, including those
+ created with
+ :manual:`generator expressions `,
+ allowing ``COMMAND`` arguments such as
+ ``${CC} "-I$,;-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 ` 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 `.
+ :ref:`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 `.
+
+ 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 `.
+
+``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 `_ 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:
+ 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 ` 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-$.c"
+ COMMAND someTool -i ${CMAKE_CURRENT_SOURCE_DIR}/in.txt
+ -o "out-$.c"
+ -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``,
+ where ```` 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
+ 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 ````. The ```` 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 ```` may be an :ref:`ALIAS target `.
+
+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 "$"
+ -o "$.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 "$"
+ --as-code "myPlugin-hash-$.c"
+ BYPRODUCTS "myPlugin-hash-$.c"
+ VERBATIM)
+ add_executable(myExe myExe.c "myPlugin-hash-$.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`
diff --git a/cmake/doc/cmake/html/_sources/command/add_custom_target.rst.txt b/cmake/doc/cmake/html/_sources/command/add_custom_target.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d88e0f0d8351b8ccd03b3702ed8538f1d9e644f9
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_custom_target.rst.txt
@@ -0,0 +1,211 @@
+add_custom_target
+-----------------
+
+Add a target with no output so it will always be built.
+
+.. code-block:: cmake
+
+ add_custom_target(Name [ALL] [command1 [args1...]]
+ [COMMAND command2 [args2...] ...]
+ [DEPENDS depend depend depend ... ]
+ [BYPRODUCTS [files...]]
+ [WORKING_DIRECTORY dir]
+ [COMMENT comment]
+ [JOB_POOL job_pool]
+ [JOB_SERVER_AWARE ]
+ [VERBATIM] [USES_TERMINAL]
+ [COMMAND_EXPAND_LISTS]
+ [SOURCES src1 [src2...]])
+
+Adds a target with the given name that executes the given commands.
+The target has no output file and is *always considered out of date*
+even if the commands try to create a file with the name of the target.
+Use the :command:`add_custom_command` command to generate a file with
+dependencies. By default nothing depends on the custom target. Use
+the :command:`add_dependencies` command to add dependencies to or
+from other targets.
+
+The options are:
+
+``ALL``
+ Indicate that this target should be added to the default build
+ target so that it will be run every time (the command cannot be
+ called ``ALL``).
+
+``BYPRODUCTS``
+ .. versionadded:: 3.2
+
+ Specify the files the command is expected to produce but whose
+ modification time may or may not be updated on subsequent builds.
+ 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``.
+
+ .. versionadded:: 3.20
+ Arguments to ``BYPRODUCTS`` may use a restricted set of
+ :manual:`generator expressions `.
+ :ref:`Target-dependent expressions `
+ are not permitted.
+
+ .. versionchanged:: 3.28
+ In custom targets using :ref:`file sets`, 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.
+ 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.)
+
+ 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 `.
+ 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 this custom target (see policy :policy:`CMP0112`).
+
+ * ``TARGET_FILE``
+ * ``TARGET_LINKER_FILE``
+ * ``TARGET_SONAME_FILE``
+ * ``TARGET_PDB_FILE``
+
+ The command and arguments are optional and if not specified an empty
+ target will be created.
+
+``COMMENT``
+ Display the given message before the commands are executed at
+ build time.
+
+ .. versionadded:: 3.26
+ Arguments to ``COMMENT`` may use
+ :manual:`generator expressions `.
+
+``DEPENDS``
+ Reference files and outputs of custom commands created with
+ :command:`add_custom_command` command calls in the same directory
+ (``CMakeLists.txt`` file). They will be brought up to date when
+ the target is built.
+
+ .. versionchanged:: 3.16
+ A target-level dependency is added if any dependency is a byproduct
+ of a target or any of its build events in the same directory to ensure
+ the byproducts will be available before this target is built.
+
+ Use the :command:`add_dependencies` command to add dependencies
+ on other targets.
+
+``COMMAND_EXPAND_LISTS``
+ .. versionadded:: 3.8
+
+ Lists in ``COMMAND`` arguments will be expanded, including those
+ created with
+ :manual:`generator expressions `,
+ allowing ``COMMAND`` arguments such as
+ ``${CC} "-I$,;-I>" foo.cc``
+ to be properly expanded.
+
+``JOB_POOL``
+ .. versionadded:: 3.15
+
+ Specify a :prop_gbl:`pool ` 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.
+
+``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.
+
+.. _`GNU Make Documentation`: https://www.gnu.org/software/make/manual/html_node/MAKE-Variable.html
+
+``SOURCES``
+ Specify additional source files to be included in the custom target.
+ Specified source files will be added to IDE project files for
+ convenience in editing even if they have no build rules.
+
+``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_target`` 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.
+
+``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 `.
+
+``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.
+
+ .. versionadded:: 3.13
+ Arguments to ``WORKING_DIRECTORY`` may use
+ :manual:`generator expressions `.
+
+Ninja Multi-Config
+^^^^^^^^^^^^^^^^^^
+
+.. versionadded:: 3.20
+
+ ``add_custom_target`` supports the :generator:`Ninja Multi-Config`
+ generator's cross-config capabilities. See the generator documentation
+ for more information.
+
+See Also
+^^^^^^^^
+
+* :command:`add_custom_command`
diff --git a/cmake/doc/cmake/html/_sources/command/add_definitions.rst.txt b/cmake/doc/cmake/html/_sources/command/add_definitions.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5c1f7b43bd620999ead0721b5ede4e602858732b
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_definitions.rst.txt
@@ -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 `,
+:prop_tgt:`target `,
+:prop_sf:`source file ` ``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.
diff --git a/cmake/doc/cmake/html/_sources/command/add_dependencies.rst.txt b/cmake/doc/cmake/html/_sources/command/add_dependencies.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3a51a30b07a946bf0ff0ea5fa3f29178ff207d4a
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_dependencies.rst.txt
@@ -0,0 +1,42 @@
+add_dependencies
+----------------
+
+Add a dependency between top-level targets.
+
+.. code-block:: cmake
+
+ add_dependencies( []...)
+
+Makes a top-level ```` depend on other top-level targets to
+ensure that they build before ```` does. A top-level target
+is one created by one of the :command:`add_executable`,
+:command:`add_library`, or :command:`add_custom_target` commands
+(but not targets generated by CMake like ``install``).
+
+Dependencies added to an :ref:`imported target `
+or an :ref:`interface library ` are followed
+transitively in its place since the target itself does not build.
+
+.. versionadded:: 3.3
+ Allow adding dependencies to interface libraries.
+
+.. versionadded:: 3.8
+ Dependencies will populate the :prop_tgt:`MANUALLY_ADDED_DEPENDENCIES`
+ property of ````.
+
+.. versionchanged:: 3.9
+ The :ref:`Ninja Generators` use weaker ordering than
+ other generators in order to improve available concurrency.
+ They only guarantee that the dependencies' custom commands are
+ finished before sources in ```` start compiling; this
+ ensures generated sources are available.
+
+See Also
+^^^^^^^^
+
+* The ``DEPENDS`` option of :command:`add_custom_target` and
+ :command:`add_custom_command` commands for adding file-level
+ dependencies in custom rules.
+
+* The :prop_sf:`OBJECT_DEPENDS` source file property to add
+ file-level dependencies to object files.
diff --git a/cmake/doc/cmake/html/_sources/command/add_executable.rst.txt b/cmake/doc/cmake/html/_sources/command/add_executable.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b6833b4106bffe78061bfbdc8eb3c5d9eefa103e
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_executable.rst.txt
@@ -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( ... ...)
+ :target: normal
+
+ Add an executable target called ```` 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 ```` 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
+``.exe`` or just ````).
+
+.. 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 ```` 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( IMPORTED [GLOBAL])
+ :target: IMPORTED
+
+ Add an :ref:`IMPORTED executable target ` 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_`) 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( ALIAS )
+ :target: ALIAS
+
+ Creates an :ref:`Alias Target `, such that ```` can
+ be used to refer to ```` in subsequent commands. The ````
+ does not appear in the generated buildsystem as a make target. The
+ ```` may not be an ``ALIAS``.
+
+.. versionadded:: 3.11
+ An ``ALIAS`` can target a ``GLOBAL`` :ref:`Imported Target `
+
+.. 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 ```` may not be used to modify properties of ````, 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`
diff --git a/cmake/doc/cmake/html/_sources/command/add_library.rst.txt b/cmake/doc/cmake/html/_sources/command/add_library.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cab380e6d1233bba0a7045400f1c03e3986579af
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_library.rst.txt
@@ -0,0 +1,302 @@
+add_library
+-----------
+
+.. only:: html
+
+ .. contents::
+
+Add a library to the project using the specified source files.
+
+Normal Libraries
+^^^^^^^^^^^^^^^^
+
+.. signature::
+ add_library( [] [EXCLUDE_FROM_ALL] ...)
+ :target: normal
+
+ Add a library target called ```` to be built from the source files
+ listed in the command invocation.
+
+ The optional ```` specifies the type of library to be created:
+
+ ``STATIC``
+ An archive of object files for use when linking other targets.
+
+ ``SHARED``
+ A dynamic library that may be linked by other targets and loaded
+ at runtime.
+
+ ``MODULE``
+ A plugin that may not be linked by other targets, but may be
+ dynamically loaded at runtime using dlopen-like functionality.
+
+ If no ```` is given the default is ``STATIC`` or ``SHARED``
+ based on the value of the :variable:`BUILD_SHARED_LIBS` variable.
+
+ The options are:
+
+ ``EXCLUDE_FROM_ALL``
+ Set the :prop_tgt:`EXCLUDE_FROM_ALL` target property automatically.
+ See documentation of that target property for details.
+
+The ```` corresponds to the logical target name and must be globally
+unique within a project. The actual file name of the library built is
+constructed based on conventions of the native platform (such as
+``lib.a`` or ``.lib``).
+
+.. versionadded:: 3.1
+ Source arguments to ``add_library`` 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`.
+
+For ``SHARED`` and ``MODULE`` libraries the
+:prop_tgt:`POSITION_INDEPENDENT_CODE` target
+property is set to ``ON`` automatically.
+A ``SHARED`` library may be marked with the :prop_tgt:`FRAMEWORK`
+target property to create an macOS Framework.
+
+.. versionadded:: 3.8
+ A ``STATIC`` library may be marked with the :prop_tgt:`FRAMEWORK`
+ target property to create a static Framework.
+
+If a library does not export any symbols, it must not be declared as a
+``SHARED`` library. For example, a Windows resource DLL or a managed C++/CLI
+DLL that exports no unmanaged symbols would need to be a ``MODULE`` library.
+This is because CMake expects a ``SHARED`` library to always have an
+associated import library on Windows.
+
+By default the library 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:`ARCHIVE_OUTPUT_DIRECTORY`,
+:prop_tgt:`LIBRARY_OUTPUT_DIRECTORY`, and
+:prop_tgt:`RUNTIME_OUTPUT_DIRECTORY` target properties to change this
+location. See documentation of the :prop_tgt:`OUTPUT_NAME` target
+property to change the ```` 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.
+
+.. versionchanged:: 3.30
+
+ On platforms that do not support shared libraries, ``add_library``
+ now fails on calls creating ``SHARED`` libraries instead of
+ automatically converting them to ``STATIC`` libraries as before.
+ See policy :policy:`CMP0164`.
+
+Object Libraries
+^^^^^^^^^^^^^^^^
+
+.. signature::
+ add_library( OBJECT ...)
+ :target: OBJECT
+
+ Add an :ref:`Object Library ` to compile source files
+ without archiving or linking their object files into a library.
+
+Other targets created by ``add_library`` or :command:`add_executable`
+may reference the objects using an expression of the
+form :genex:`$\ ` as a source, where
+``objlib`` is the object library name. For example:
+
+.. code-block:: cmake
+
+ add_library(... $ ...)
+ add_executable(... $ ...)
+
+will include objlib's object files in a library and an executable
+along with those compiled from their own sources. Object libraries
+may contain only sources that compile, header files, and other files
+that would not affect linking of a normal library (e.g. ``.txt``).
+They may contain custom commands generating such sources, but not
+``PRE_BUILD``, ``PRE_LINK``, or ``POST_BUILD`` commands. Some native build
+systems (such as Xcode) may not like targets that have only object files, so
+consider adding at least one real source file to any target that references
+:genex:`$\ `.
+
+.. versionadded:: 3.12
+ Object libraries can be linked to with :command:`target_link_libraries`.
+
+Interface Libraries
+^^^^^^^^^^^^^^^^^^^
+
+.. signature::
+ add_library( INTERFACE)
+ :target: INTERFACE
+
+ Add an :ref:`Interface Library ` target that may
+ specify usage requirements for dependents but does not compile sources
+ and does not produce a library artifact on disk.
+
+ An interface library with no source files is not included as a target
+ in the generated buildsystem. However, it may have
+ properties set on it and it may be installed and exported.
+ Typically, ``INTERFACE_*`` properties are populated on an interface
+ target using the commands:
+
+ * :command:`set_property`,
+ * :command:`target_link_libraries(INTERFACE)`,
+ * :command:`target_link_options(INTERFACE)`,
+ * :command:`target_include_directories(INTERFACE)`,
+ * :command:`target_compile_options(INTERFACE)`,
+ * :command:`target_compile_definitions(INTERFACE)`, and
+ * :command:`target_sources(INTERFACE)`,
+
+ and then it is used as an argument to :command:`target_link_libraries`
+ like any other target.
+
+ .. versionadded:: 3.15
+ An interface library can have :prop_tgt:`PUBLIC_HEADER` and
+ :prop_tgt:`PRIVATE_HEADER` properties. The headers specified by those
+ properties can be installed using the :command:`install(TARGETS)` command.
+
+.. signature::
+ add_library( INTERFACE [EXCLUDE_FROM_ALL] ...)
+ :target: INTERFACE-with-sources
+
+ .. versionadded:: 3.19
+
+ Add an :ref:`Interface Library ` target with
+ source files (in addition to usage requirements and properties as
+ documented by the :command:`above signature `).
+ Source files may be listed directly in the ``add_library`` call
+ or added later by calls to :command:`target_sources` with the
+ ``PRIVATE`` or ``PUBLIC`` keywords.
+
+ If an interface library has source files (i.e. the :prop_tgt:`SOURCES`
+ target property is set), or header sets (i.e. the :prop_tgt:`HEADER_SETS`
+ target property is set), it will appear in the generated buildsystem
+ as a build target much like a target defined by the
+ :command:`add_custom_target` command. It does not compile any sources,
+ but does contain build rules for custom commands created by the
+ :command:`add_custom_command` command.
+
+ The options are:
+
+ ``EXCLUDE_FROM_ALL``
+ Set the :prop_tgt:`EXCLUDE_FROM_ALL` target property automatically.
+ See documentation of that target property for details.
+
+ .. note::
+ In most command signatures where the ``INTERFACE`` keyword appears,
+ the items listed after it only become part of that target's usage
+ requirements and are not part of the target's own settings. However,
+ in this signature of ``add_library``, the ``INTERFACE`` keyword refers
+ to the library type only. Sources listed after it in the ``add_library``
+ call are ``PRIVATE`` to the interface library and do not appear in its
+ :prop_tgt:`INTERFACE_SOURCES` target property.
+
+.. _`add_library imported libraries`:
+
+Imported Libraries
+^^^^^^^^^^^^^^^^^^
+
+.. signature::
+ add_library( IMPORTED [GLOBAL])
+ :target: IMPORTED
+
+ Add an :ref:`IMPORTED library target ` called ````.
+ 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 ```` must be one of:
+
+ ``STATIC``, ``SHARED``, ``MODULE``, ``UNKNOWN``
+ References a library file located outside the project. The
+ :prop_tgt:`IMPORTED_LOCATION` target property (or its per-configuration
+ variant :prop_tgt:`IMPORTED_LOCATION_`) specifies the
+ location of the main library file on disk:
+
+ * For a ``SHARED`` library on most non-Windows platforms, the main library
+ file is the ``.so`` or ``.dylib`` file used by both linkers and dynamic
+ loaders. If the referenced library file has a ``SONAME`` (or on macOS,
+ has a ``LC_ID_DYLIB`` starting in ``@rpath/``), the value of that field
+ should be set in the :prop_tgt:`IMPORTED_SONAME` target property.
+ If the referenced library file does not have a ``SONAME``, but the
+ platform supports it, then the :prop_tgt:`IMPORTED_NO_SONAME` target
+ property should be set.
+
+ * For a ``SHARED`` library on Windows, the :prop_tgt:`IMPORTED_IMPLIB`
+ target property (or its per-configuration variant
+ :prop_tgt:`IMPORTED_IMPLIB_`) specifies the location of the
+ DLL import library file (``.lib`` or ``.dll.a``) on disk, and the
+ ``IMPORTED_LOCATION`` is the location of the ``.dll`` runtime
+ library (and is optional, but needed by the :genex:`TARGET_RUNTIME_DLLS`
+ generator expression).
+
+ Additional usage requirements may be specified in ``INTERFACE_*``
+ properties.
+
+ An ``UNKNOWN`` library type is typically only used in the implementation
+ of :ref:`Find Modules`. It allows the path to an imported library
+ (often found using the :command:`find_library` command) to be used
+ without having to know what type of library it is. This is especially
+ useful on Windows where a static library and a DLL's import library
+ both have the same file extension.
+
+ ``OBJECT``
+ References a set of object files located outside the project.
+ The :prop_tgt:`IMPORTED_OBJECTS` target property (or its per-configuration
+ variant :prop_tgt:`IMPORTED_OBJECTS_`) specifies the locations of
+ object files on disk.
+ Additional usage requirements may be specified in ``INTERFACE_*``
+ properties.
+
+ ``INTERFACE``
+ Does not reference any library or object files on disk, but may
+ specify usage requirements in ``INTERFACE_*`` properties.
+
+ 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 libraries are useful for convenient
+reference from commands like :command:`target_link_libraries`.
+
+Details about the imported library are specified by setting properties whose
+names begin in ``IMPORTED_`` and ``INTERFACE_``. See documentation of
+such properties for more information.
+
+Alias Libraries
+^^^^^^^^^^^^^^^
+
+.. signature::
+ add_library( ALIAS )
+ :target: ALIAS
+
+ Creates an :ref:`Alias Target `, such that ```` can be
+ used to refer to ```` in subsequent commands. The ```` does
+ not appear in the generated buildsystem as a make target. The ````
+ may not be an ``ALIAS``.
+
+.. versionadded:: 3.11
+ An ``ALIAS`` can target a ``GLOBAL`` :ref:`Imported Target `
+
+.. 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 below.
+ 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 linkable targets and as targets to
+read properties from. They can also be tested for existence with the
+regular :command:`if(TARGET)` subcommand. The ```` may not be used
+to modify properties of ````, 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_executable`
diff --git a/cmake/doc/cmake/html/_sources/command/add_link_options.rst.txt b/cmake/doc/cmake/html/_sources/command/add_link_options.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..df727154311107c79ae8dcf9d027922ede027b6d
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_link_options.rst.txt
@@ -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( ...)
+
+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 ` and
+:prop_tgt:`target ` ``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__FLAGS` and :variable:`CMAKE__FLAGS_`
+ add language-wide flags passed to all invocations of the compiler.
+ This includes invocations that drive compiling and those that drive linking.
diff --git a/cmake/doc/cmake/html/_sources/command/add_subdirectory.rst.txt b/cmake/doc/cmake/html/_sources/command/add_subdirectory.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b5fa459667205577632f03712b5fabe3d60bf228
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_subdirectory.rst.txt
@@ -0,0 +1,32 @@
+add_subdirectory
+----------------
+
+Add a subdirectory to the build.
+
+.. code-block:: cmake
+
+ add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL] [SYSTEM])
+
+Adds a subdirectory to the build. The ``source_dir`` specifies the
+directory in which the source ``CMakeLists.txt`` and code files are
+located. If it is a relative path, it will be evaluated with respect
+to the current directory (the typical usage), but it may also be an
+absolute path. The ``binary_dir`` specifies the directory in which to
+place the output files. If it is a relative path, it will be evaluated
+with respect to the current output directory, but it may also be an
+absolute path. If ``binary_dir`` is not specified, the value of
+``source_dir``, before expanding any relative path, will be used (the
+typical usage). The ``CMakeLists.txt`` file in the specified source
+directory will be processed immediately by CMake before processing in
+the current input file continues beyond this command.
+
+If the ``EXCLUDE_FROM_ALL`` argument is provided then the
+:prop_dir:`EXCLUDE_FROM_ALL` property will be set on the added directory.
+This will exclude the directory from a default build. See the directory
+property :prop_dir:`EXCLUDE_FROM_ALL` for full details.
+
+.. versionadded:: 3.25
+ If the ``SYSTEM`` argument is provided, the :prop_dir:`SYSTEM` directory
+ property of the subdirectory will be set to true. This property is
+ used to initialize the :prop_tgt:`SYSTEM` property of each non-imported
+ target created in that subdirectory.
diff --git a/cmake/doc/cmake/html/_sources/command/add_test.rst.txt b/cmake/doc/cmake/html/_sources/command/add_test.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2a3c759d7699e8d05793f416fbaec6cdfb8dc5f6
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/add_test.rst.txt
@@ -0,0 +1,117 @@
+add_test
+--------
+
+Add a test to the project to be run by :manual:`ctest(1)`.
+
+.. code-block:: cmake
+
+ add_test(NAME COMMAND [...]
+ [CONFIGURATIONS ...]
+ [WORKING_DIRECTORY ]
+ [COMMAND_EXPAND_LISTS])
+
+Adds a test called ````. The test name may contain arbitrary
+characters, expressed as a :ref:`Quoted Argument` or :ref:`Bracket Argument`
+if necessary. See policy :policy:`CMP0110`.
+
+CMake only generates tests if the :command:`enable_testing` command has been
+invoked. The :module:`CTest` module invokes ``enable_testing`` automatically
+unless ``BUILD_TESTING`` is set to ``OFF``.
+
+Tests added with the ``add_test(NAME)`` signature support using
+:manual:`generator expressions `
+in test properties set by :command:`set_property(TEST)` or
+:command:`set_tests_properties`. Test properties may only be set in the
+directory the test is created in.
+
+``add_test`` options are:
+
+``COMMAND``
+ Specify the test command-line.
+
+ If ```` specifies an executable target created by
+ :command:`add_executable`:
+
+ * It will automatically be replaced by the location of the executable
+ created at build time.
+
+ * .. versionadded:: 3.3
+
+ The target's :prop_tgt:`CROSSCOMPILING_EMULATOR`, if set, will be
+ used to run the command on the host::
+
+
+
+ .. versionchanged:: 3.29
+
+ The emulator is used only when
+ :variable:`cross-compiling `.
+ See policy :policy:`CMP0158`.
+
+ * .. versionadded:: 3.29
+
+ The target's :prop_tgt:`TEST_LAUNCHER`, if set, will be
+ used to launch the command::
+
+
+
+ If the :prop_tgt:`CROSSCOMPILING_EMULATOR` is also set, both are used::
+
+
+
+ The command may be specified using
+ :manual:`generator expressions `.
+
+``CONFIGURATIONS``
+ Restrict execution of the test only to the named configurations.
+
+``WORKING_DIRECTORY``
+ Set the test property :prop_test:`WORKING_DIRECTORY` in which to execute the
+ test. If not specified, the test will be run in
+ :variable:`CMAKE_CURRENT_BINARY_DIR`. The working directory may be specified
+ using :manual:`generator expressions `.
+
+``COMMAND_EXPAND_LISTS``
+ .. versionadded:: 3.16
+
+ Lists in ``COMMAND`` arguments will be expanded, including those created with
+ :manual:`generator expressions `.
+
+If the test command exits with code ``0`` the test passes. Non-zero exit code
+is a "failed" test. The test property :prop_test:`WILL_FAIL` inverts this
+logic. Note that system-level test failures such as segmentation faults or
+heap errors will still fail the test even if ``WILL_FAIL`` is true. Output
+written to stdout or stderr is captured by :manual:`ctest(1)` and only
+affects the pass/fail status via the :prop_test:`PASS_REGULAR_EXPRESSION`,
+:prop_test:`FAIL_REGULAR_EXPRESSION`, or :prop_test:`SKIP_REGULAR_EXPRESSION`
+test properties.
+
+.. versionadded:: 3.16
+ Added :prop_test:`SKIP_REGULAR_EXPRESSION` property.
+
+Example usage:
+
+.. code-block:: cmake
+
+ add_test(NAME mytest
+ COMMAND testDriver --config $
+ --exe $)
+
+This creates a test ``mytest`` whose command runs a ``testDriver`` tool
+passing the configuration name and the full path to the executable
+file produced by target ``myexe``.
+
+---------------------------------------------------------------------
+
+The command syntax above is recommended over the older, less flexible form:
+
+.. code-block:: cmake
+
+ add_test( [...])
+
+Add a test called ```` with the given command-line.
+
+Unlike the above ``NAME`` signature, target names are not supported
+in the command-line. Furthermore, tests added with this signature do not
+support :manual:`generator expressions `
+in the command-line or test properties.
diff --git a/cmake/doc/cmake/html/_sources/command/aux_source_directory.rst.txt b/cmake/doc/cmake/html/_sources/command/aux_source_directory.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9619f357fa3a3a3dd945cb9561bd167476dad4c5
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/aux_source_directory.rst.txt
@@ -0,0 +1,24 @@
+aux_source_directory
+--------------------
+
+Find all source files in a directory.
+
+.. code-block:: cmake
+
+ aux_source_directory( )
+
+Collects the names of all the source files in the specified directory
+and stores the list in the ```` 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.
diff --git a/cmake/doc/cmake/html/_sources/command/block.rst.txt b/cmake/doc/cmake/html/_sources/command/block.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4c6e1117550010a2493aca3d2a37b745ff67b0db
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/block.rst.txt
@@ -0,0 +1,77 @@
+block
+-----
+
+.. versionadded:: 3.25
+
+Evaluate a group of commands with a dedicated variable and/or policy scope.
+
+.. code-block:: cmake
+
+ block([SCOPE_FOR [POLICIES] [VARIABLES] ] [PROPAGATE ...])
+
+ endblock()
+
+All commands between ``block()`` and the matching :command:`endblock` are
+recorded without being invoked. Once the :command:`endblock` is evaluated, the
+recorded list of commands is invoked inside the requested scopes, then the
+scopes created by the ``block()`` command are removed.
+
+``SCOPE_FOR``
+ Specify which scopes must be created.
+
+ ``POLICIES``
+ Create a new policy scope. This is equivalent to
+ :command:`cmake_policy(PUSH)` with an automatic
+ :command:`cmake_policy(POP)` when leaving the block scope.
+
+ ``VARIABLES``
+ Create a new variable scope.
+
+ If ``SCOPE_FOR`` is not specified, this is equivalent to:
+
+ .. code-block:: cmake
+
+ block(SCOPE_FOR VARIABLES POLICIES)
+
+``PROPAGATE``
+ When a variable scope is created by the :command:`block` command, this
+ option sets or unsets the specified variables in the parent scope. This is
+ equivalent to :command:`set(PARENT_SCOPE)` or :command:`unset(PARENT_SCOPE)`
+ commands.
+
+ .. code-block:: cmake
+
+ set(var1 "INIT1")
+ set(var2 "INIT2")
+
+ block(PROPAGATE var1 var2)
+ set(var1 "VALUE1")
+ unset(var2)
+ endblock()
+
+ # Now var1 holds VALUE1, and var2 is unset
+
+ This option is only allowed when a variable scope is created. An error will
+ be raised in the other cases.
+
+When the ``block()`` is inside a :command:`foreach` or :command:`while`
+command, the :command:`break` and :command:`continue` commands can be used
+inside the block.
+
+.. code-block:: cmake
+
+ while(TRUE)
+ block()
+ ...
+ # the break() command will terminate the while() command
+ break()
+ endblock()
+ endwhile()
+
+
+See Also
+^^^^^^^^
+
+* :command:`endblock`
+* :command:`return`
+* :command:`cmake_policy`
diff --git a/cmake/doc/cmake/html/_sources/command/break.rst.txt b/cmake/doc/cmake/html/_sources/command/break.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4875a2bf2c2a6c4e9b5c2672c33f4eb0a9ab4c43
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/break.rst.txt
@@ -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.
diff --git a/cmake/doc/cmake/html/_sources/command/build_command.rst.txt b/cmake/doc/cmake/html/_sources/command/build_command.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3d86a2e032e46c666390b4e6b3c896e5540a63a4
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/build_command.rst.txt
@@ -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(
+ [CONFIGURATION ]
+ [PARALLEL_LEVEL ]
+ [TARGET ]
+ [PROJECT_NAME ] # legacy, causes warning
+ )
+
+Sets the given ```` to a command-line string of the form::
+
+ --build . [--config ] [--parallel ] [--target ...] [-- -i]
+
+where ```` is the location of the :manual:`cmake(1)` command-line
+tool, and ````, ```` and ```` 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 ` flag.
+
+.. code-block:: cmake
+
+ build_command( )
+
+This second signature is deprecated, but still available for backwards
+compatibility. Use the first signature instead.
+
+It sets the given ```` to a command-line string as
+above but without the :option:`--target ` option.
+The ```` 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.
diff --git a/cmake/doc/cmake/html/_sources/command/build_name.rst.txt b/cmake/doc/cmake/html/_sources/command/build_name.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5acf85830022548281bda3eae7c3e05cbdb287d1
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/build_name.rst.txt
@@ -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 _COMPILER>` variables.
diff --git a/cmake/doc/cmake/html/_sources/command/cmake_file_api.rst.txt b/cmake/doc/cmake/html/_sources/command/cmake_file_api.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e7ee7e7adb2b59b3cb564f8fa9e97a0bec8f6500
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/cmake_file_api.rst.txt
@@ -0,0 +1,78 @@
+cmake_file_api
+--------------
+
+.. versionadded:: 3.27
+
+Enables interacting with the :manual:`CMake file API `.
+
+.. 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
+ [CODEMODEL ...]
+ [CACHE ...]
+ [CMAKEFILES ...]
+ [TOOLCHAINS ...]
+ )
+
+ The ``API_VERSION`` must always be given. Currently, the only supported
+ value for ```` 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 ```` 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=$
+ -P ${CMAKE_CURRENT_SOURCE_DIR}/verify_project.cmake
+ )
diff --git a/cmake/doc/cmake/html/_sources/command/cmake_host_system_information.rst.txt b/cmake/doc/cmake/html/_sources/command/cmake_host_system_information.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0d2f75e12f4f885619e6c3e0c11b9308eed8434e
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/cmake_host_system_information.rst.txt
@@ -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 QUERY ...)
+
+ `Query Windows registry`_
+ cmake_host_system_information(RESULT QUERY WINDOWS_REGISTRY ...)
+
+Query host system specific information
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+ cmake_host_system_information(RESULT QUERY ...)
+
+Queries system information of the host system on which cmake runs.
+One or more ```` can be provided to select the information to be
+queried. The list of queried values is stored in ````.
+
+```` 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 ````
+ into a list of read variables
+
+``DISTRIB_``
+ .. versionadded:: 3.22
+
+ Get the ```` 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-.cmake``, where ``NNN`` is three digits
+ used to apply collected scripts in a specific order.
+
+.. variable:: CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_
+
+ 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_`` 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
+ QUERY WINDOWS_REGISTRY [VALUE_NAMES|SUBKEYS|VALUE ]
+ [VIEW (64|32|64_32|32_64|HOST|TARGET|BOTH)]
+ [SEPARATOR ]
+ [ERROR_VARIABLE ])
+
+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 ````.
+
+.. 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``.
+
+```` specify the full path of a subkey on the local computer. The
+```` 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. ```` 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 ````. If a default value
+ is defined, it will be identified with the special name ``(default)``.
+
+``SUBKEYS``
+ Request the list of subkeys defined under ````.
+
+``VALUE ``
+ Request the data stored in value named ````. 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 ``
+ Returns any error raised during query operation. In case of success, the
+ variable holds an empty string.
diff --git a/cmake/doc/cmake/html/_sources/command/cmake_language.rst.txt b/cmake/doc/cmake/html/_sources/command/cmake_language.rst.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a9c76537338a0d7fd8292b82e3194db43f110871
--- /dev/null
+++ b/cmake/doc/cmake/html/_sources/command/cmake_language.rst.txt
@@ -0,0 +1,536 @@
+cmake_language
+--------------
+
+.. versionadded:: 3.18
+
+Call meta-operations on CMake commands.
+
+Synopsis
+^^^^^^^^
+
+.. parsed-literal::
+
+ cmake_language(`CALL`_ [...])
+ cmake_language(`EVAL`_ CODE ...)
+ cmake_language(`DEFER`_ ... CALL [...])
+ cmake_language(`SET_DEPENDENCY_PROVIDER`_ SUPPORTED_METHODS ...)
+ cmake_language(`GET_MESSAGE_LOG_LEVEL`_ )
+ cmake_language(`EXIT`_ )
+
+Introduction
+^^^^^^^^^^^^
+
+This command will call meta-operations on built-in CMake commands or
+those created via the :command:`macro` or :command:`function` commands.
+
+``cmake_language`` does not introduce a new variable or policy scope.
+
+Calling Commands
+^^^^^^^^^^^^^^^^
+
+.. signature::
+ cmake_language(CALL [...])
+
+ Calls the named ```` with the given arguments (if any).
+ For example, the code:
+
+ .. code-block:: cmake
+
+ set(message_command "message")
+ cmake_language(CALL ${message_command} STATUS "Hello World!")
+
+ is equivalent to
+
+ .. code-block:: cmake
+
+ message(STATUS "Hello World!")
+
+ .. note::
+ To ensure consistency of the code, the following commands are not allowed:
+
+ * ``if`` / ``elseif`` / ``else`` / ``endif``
+ * ``block`` / ``endblock``
+ * ``while`` / ``endwhile``
+ * ``foreach`` / ``endforeach``
+ * ``function`` / ``endfunction``
+ * ``macro`` / ``endmacro``
+
+Evaluating Code
+^^^^^^^^^^^^^^^
+
+.. signature::
+ cmake_language(EVAL CODE ...)
+ :target: EVAL
+
+ Evaluates the ``...`` as CMake code.
+
+ For example, the code:
+
+ .. code-block:: cmake
+
+ set(A TRUE)
+ set(B TRUE)
+ set(C TRUE)
+ set(condition "(A AND B) OR C")
+
+ cmake_language(EVAL CODE "
+ if (${condition})
+ message(STATUS TRUE)
+ else()
+ message(STATUS FALSE)
+ endif()"
+ )
+
+ is equivalent to
+
+ .. code-block:: cmake
+
+ set(A TRUE)
+ set(B TRUE)
+ set(C TRUE)
+ set(condition "(A AND B) OR C")
+
+ file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/eval.cmake "
+ if (${condition})
+ message(STATUS TRUE)
+ else()
+ message(STATUS FALSE)
+ endif()"
+ )
+
+ include(${CMAKE_CURRENT_BINARY_DIR}/eval.cmake)
+
+Deferring Calls
+^^^^^^^^^^^^^^^
+
+.. versionadded:: 3.19
+
+.. signature::
+ cmake_language(DEFER ... CALL [...])
+
+ Schedules a call to the named ```` with the given arguments (if any)
+ to occur at a later time. By default, deferred calls are executed as if
+ written at the end of the current directory's ``CMakeLists.txt`` file,
+ except that they run even after a :command:`return` call. Variable
+ references in arguments are evaluated at the time the deferred call is
+ executed.
+
+ The options are:
+
+ ``DIRECTORY ``
+ Schedule the call for the end of the given directory instead of the
+ current directory. The ```` may reference either a source
+ directory or its corresponding binary directory. Relative paths are
+ treated as relative to the current source directory.
+
+ The given directory must be known to CMake, being either the top-level
+ directory or one added by :command:`add_subdirectory`. Furthermore,
+ the given directory must not yet be finished processing. This means
+ it can be the current directory or one of its ancestors.
+
+ ``ID ``
+ Specify an identification for the deferred call.
+ The ```` may not be empty and may not begin with a capital letter ``A-Z``.
+ The ```` may begin with an underscore (``_``) only if it was generated
+ automatically by an earlier call that used ``ID_VAR`` to get the id.
+
+ ``ID_VAR ``
+ Specify a variable in which to store the identification for the
+ deferred call. If ``ID `` is not given, a new identification
+ will be generated and the generated id will start with an underscore (``_``).
+
+ The currently scheduled list of deferred calls may be retrieved:
+
+ .. code-block:: cmake
+
+ cmake_language(DEFER [DIRECTORY ] GET_CALL_IDS )
+
+ This will store in ```` a :ref:`semicolon-separated list ` of deferred call ids. The ids are for the directory scope in which
+ the calls have been deferred to (i.e. where they will be executed), which can
+ be different to the scope in which they were created. The ``DIRECTORY``
+ option can be used to specify the scope for which to retrieve the call ids.
+ If that option is not given, the call ids for the current directory scope
+ will be returned.
+
+ Details of a specific call may be retrieved from its id:
+
+ .. code-block:: cmake
+
+ cmake_language(DEFER [DIRECTORY