diff --git a/7za/7za b/7za/7za
index ed7d8348..8d85d211 100644
Binary files a/7za/7za and b/7za/7za differ
diff --git a/7za/SOURCE.txt b/7za/SOURCE.txt
new file mode 100644
index 00000000..0c6d8373
--- /dev/null
+++ b/7za/SOURCE.txt
@@ -0,0 +1,98 @@
+#### INFO
+
+https://sourceforge.net/projects/p7zip/
+
+VERSION: https://sourceforge.net/projects/p7zip/files/p7zip/16.02/
+
+#### LICENSE
+
+ 7-Zip
+ ~~~~~
+ License for use and distribution
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ 7-Zip Copyright (C) 1999-2023 Igor Pavlov.
+
+ The licenses for files are:
+
+ 1) 7z.dll:
+ - The "GNU LGPL" as main license for most of the code
+ - The "GNU LGPL" with "unRAR license restriction" for some code
+ - The "BSD 3-clause License" for some code
+ 2) All other files: the "GNU LGPL".
+
+ Redistributions in binary form must reproduce related license information from this file.
+
+ Note:
+ You can use 7-Zip on any computer, including a computer in a commercial
+ organization. You don't need to register or pay for 7-Zip.
+
+
+ GNU LGPL information
+ --------------------
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You can receive a copy of the GNU Lesser General Public License from
+ http://www.gnu.org/
+
+
+
+
+ BSD 3-clause License
+ --------------------
+
+ The "BSD 3-clause License" is used for the code in 7z.dll that implements LZFSE data decompression.
+ That code was derived from the code in the "LZFSE compression library" developed by Apple Inc,
+ that also uses the "BSD 3-clause License":
+
+ ----
+ Copyright (c) 2015-2016, Apple Inc. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer
+ in the documentation and/or other materials provided with the distribution.
+
+ 3. Neither the name of the copyright holder(s) nor the names of any contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ----
+
+
+
+
+ unRAR license restriction
+ -------------------------
+
+ The decompression engine for RAR archives was developed using source
+ code of unRAR program.
+ All copyrights to original unRAR code are owned by Alexander Roshal.
+
+ The license for original unRAR code has the following restriction:
+
+ The unRAR sources cannot be used to re-create the RAR compression algorithm,
+ which is proprietary. Distribution of modified unRAR sources in separate form
+ or as a part of other software is permitted, provided that it is clearly
+ stated in the documentation and source comments that the code may
+ not be used to develop a RAR (WinRAR) compatible archiver.
+
+
+ --
+ Igor Pavlov
diff --git a/cmake/SOURCE.txt b/cmake/SOURCE.txt
new file mode 100644
index 00000000..26b57701
--- /dev/null
+++ b/cmake/SOURCE.txt
@@ -0,0 +1,173 @@
+#### INFO
+
+https://gitlab.kitware.com/cmake/cmake
+
+VERSION: https://github.com/Kitware/CMake/releases/tag/v3.30.2
+
+#### LICENSE
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. [STATIC | SHARED | MODULE]
- [EXCLUDE_FROM_ALL]
- [...])
-
-Adds a library target called ```` to be built from the source files
-listed in the command invocation. 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`.
-
-``STATIC``, ``SHARED``, or ``MODULE`` may be given to specify the type of
-library to be created. ``STATIC`` libraries are archives of object files
-for use when linking other targets. ``SHARED`` libraries are linked
-dynamically and loaded at runtime. ``MODULE`` libraries are plugins that
-are not linked into other targets but may be loaded dynamically at runtime
-using dlopen-like functionality. If no type is given explicitly the
-type is ``STATIC`` or ``SHARED`` based on whether the current value of the
-variable :variable:`BUILD_SHARED_LIBS` is ``ON``. 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.
-
-If ``EXCLUDE_FROM_ALL`` is given the corresponding property will be set on
-the created target. See documentation of the :prop_tgt:`EXCLUDE_FROM_ALL`
-target property for details.
-
-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.
-
-Object Libraries
-^^^^^^^^^^^^^^^^
-
-.. code-block:: cmake
-
- add_library( OBJECT [...])
-
-Creates an :ref:`Object Library `. An object library
-compiles source files but does not archive or link their object files into a
-library. Instead 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
-^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: cmake
-
- add_library( INTERFACE)
-
-Creates an :ref:`Interface Library `.
-An ``INTERFACE`` library target does not compile sources and does
-not produce a library artifact on disk. 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.
-
-An interface library created with the above signature has no source files
-itself and is not included as a target in the generated buildsystem.
-
-.. 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.
-
-.. versionadded:: 3.19
- An interface library target may be created with source files:
-
- .. code-block:: cmake
-
- add_library( INTERFACE [...] [EXCLUDE_FROM_ALL])
-
- 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.
-
-.. 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
-^^^^^^^^^^^^^^^^^^
-
-.. code-block:: cmake
-
- add_library( IMPORTED [GLOBAL])
-
-Creates an :ref:`IMPORTED library target ` called ````.
-No rules are generated to build it, and the :prop_tgt:`IMPORTED` target
-property is ``True``. The target name has scope in the directory in which
-it is created and below, but the ``GLOBAL`` option extends visibility.
-It may be referenced like any target built within the project.
-``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_``.
-
-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.
-
-See documentation of the ``IMPORTED_*`` and ``INTERFACE_*`` properties
-for more information.
-
-Alias Libraries
-^^^^^^^^^^^^^^^
-
-.. code-block:: cmake
-
- add_library( 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/share/cmake-3.27/Help/command/create_test_sourcelist.rst b/cmake/share/cmake-3.27/Help/command/create_test_sourcelist.rst
deleted file mode 100644
index 192406f6..00000000
--- a/cmake/share/cmake-3.27/Help/command/create_test_sourcelist.rst
+++ /dev/null
@@ -1,30 +0,0 @@
-create_test_sourcelist
-----------------------
-
-Create a test driver and source list for building test programs.
-
-.. code-block:: cmake
-
- create_test_sourcelist(sourceListName driverName
- test1 test2 test3
- EXTRA_INCLUDE include.h
- FUNCTION function)
-
-A test driver is a program that links together many small tests into a
-single executable. This is useful when building static executables
-with large libraries to shrink the total required size. The list of
-source files needed to build the test driver will be in
-``sourceListName``. ``driverName`` is the name of the test driver program.
-The rest of the arguments consist of a list of test source files, can
-be semicolon separated. Each test source file should have a function
-in it that is the same name as the file with no extension (foo.cxx
-should have int foo(int, char*[]);) ``driverName`` will be able to call
-each of the tests by name on the command line. If ``EXTRA_INCLUDE`` is
-specified, then the next argument is included into the generated file.
-If ``FUNCTION`` is specified, then the next argument is taken as a
-function name that is passed a pointer to ac and av. This can be used
-to add extra command line processing to each test. The
-``CMAKE_TESTDRIVER_BEFORE_TESTMAIN`` cmake variable can be set to
-have code that will be placed directly before calling the test main function.
-``CMAKE_TESTDRIVER_AFTER_TESTMAIN`` can be set to have code that
-will be placed directly after the call to the test main function.
diff --git a/cmake/share/cmake-3.27/Help/command/enable_language.rst b/cmake/share/cmake-3.27/Help/command/enable_language.rst
deleted file mode 100644
index 87c5f46a..00000000
--- a/cmake/share/cmake-3.27/Help/command/enable_language.rst
+++ /dev/null
@@ -1,24 +0,0 @@
-enable_language
----------------
-
-Enable languages (CXX/C/OBJC/OBJCXX/Fortran/etc)
-
-.. code-block:: cmake
-
- enable_language(... [OPTIONAL])
-
-Enables support for the named languages in CMake. This is the same as
-the :command:`project` command but does not create any of the extra
-variables that are created by the project command.
-
-.. include:: SUPPORTED_LANGUAGES.txt
-
-This command must be called in file scope, not in a function call.
-Furthermore, it must be called in the highest directory common to all
-targets using the named language directly for compiling sources or
-indirectly through link dependencies. It is simplest to enable all
-needed languages in the top-level directory of a project.
-
-The ``OPTIONAL`` keyword is a placeholder for future implementation and
-does not currently work. Instead you can use the :module:`CheckLanguage`
-module to verify support before enabling.
diff --git a/cmake/share/cmake-3.27/Help/command/get_test_property.rst b/cmake/share/cmake-3.27/Help/command/get_test_property.rst
deleted file mode 100644
index c39891d6..00000000
--- a/cmake/share/cmake-3.27/Help/command/get_test_property.rst
+++ /dev/null
@@ -1,26 +0,0 @@
-get_test_property
------------------
-
-Get a property of the test.
-
-.. code-block:: cmake
-
- get_test_property(test property VAR)
-
-Get a property from the test. The value of the property is stored in
-the variable ``VAR``. If the test property is not found, the behavior
-depends on whether it has been defined to be an ``INHERITED`` property
-or not (see :command:`define_property`). Non-inherited properties will
-set ``VAR`` to "NOTFOUND", whereas inherited properties will search the
-relevant parent scope as described for the :command:`define_property`
-command and if still unable to find the property, ``VAR`` will be set to
-an empty string.
-
-For a list of standard properties you can type
-:option:`cmake --help-property-list`.
-
-See Also
-^^^^^^^^
-
-* :command:`define_property`
-* the more general :command:`get_property` command
diff --git a/cmake/share/cmake-3.27/Help/command/install.rst b/cmake/share/cmake-3.27/Help/command/install.rst
deleted file mode 100644
index 296f8380..00000000
--- a/cmake/share/cmake-3.27/Help/command/install.rst
+++ /dev/null
@@ -1,1006 +0,0 @@
-install
--------
-
-Specify rules to run at install time.
-
-Synopsis
-^^^^^^^^
-
-.. parsed-literal::
-
- install(`TARGETS`_ ... [...])
- install(`IMPORTED_RUNTIME_ARTIFACTS`_ ... [...])
- install({`FILES`_ | `PROGRAMS`_} ... [...])
- install(`DIRECTORY`_ ... [...])
- install(`SCRIPT`_ [...])
- install(`CODE`_ [...])
- install(`EXPORT`_ [...])
- install(`RUNTIME_DEPENDENCY_SET`_ [...])
-
-Introduction
-^^^^^^^^^^^^
-
-This command generates installation rules for a project. Install rules
-specified by calls to the ``install()`` command within a source directory
-are executed in order during installation.
-
-.. versionchanged:: 3.14
- Install rules in subdirectories
- added by calls to the :command:`add_subdirectory` command are interleaved
- with those in the parent directory to run in the order declared (see
- policy :policy:`CMP0082`).
-
-.. versionchanged:: 3.22
- The environment variable :envvar:`CMAKE_INSTALL_MODE` can override the
- default copying behavior of ``install()``.
-
-There are multiple signatures for this command. Some of them define
-installation options for files and targets. Options common to
-multiple signatures are covered here but they are valid only for
-signatures that specify them. The common options are:
-
-``DESTINATION``
- Specify the directory on disk to which a file will be installed.
- Arguments can be relative or absolute paths.
-
- If a relative path is given it is interpreted relative to the value
- of the :variable:`CMAKE_INSTALL_PREFIX` variable.
- The prefix can be relocated at install time using the ``DESTDIR``
- mechanism explained in the :variable:`CMAKE_INSTALL_PREFIX` variable
- documentation.
-
- If an absolute path (with a leading slash or drive letter) is given
- it is used verbatim.
-
- As absolute paths are not supported by :manual:`cpack ` installer
- generators, it is preferable to use relative paths throughout.
- In particular, there is no need to make paths absolute by prepending
- :variable:`CMAKE_INSTALL_PREFIX`; this prefix is used by default if
- the DESTINATION is a relative path.
-
-``PERMISSIONS``
- Specify permissions for installed files. Valid permissions are
- ``OWNER_READ``, ``OWNER_WRITE``, ``OWNER_EXECUTE``, ``GROUP_READ``,
- ``GROUP_WRITE``, ``GROUP_EXECUTE``, ``WORLD_READ``, ``WORLD_WRITE``,
- ``WORLD_EXECUTE``, ``SETUID``, and ``SETGID``. Permissions that do
- not make sense on certain platforms are ignored on those platforms.
-
-``CONFIGURATIONS``
- Specify a list of build configurations for which the install rule
- applies (Debug, Release, etc.). Note that the values specified for
- this option only apply to options listed AFTER the ``CONFIGURATIONS``
- option. For example, to set separate install paths for the Debug and
- Release configurations, do the following:
-
- .. code-block:: cmake
-
- install(TARGETS target
- CONFIGURATIONS Debug
- RUNTIME DESTINATION Debug/bin)
- install(TARGETS target
- CONFIGURATIONS Release
- RUNTIME DESTINATION Release/bin)
-
- Note that ``CONFIGURATIONS`` appears BEFORE ``RUNTIME DESTINATION``.
-
-``COMPONENT``
- Specify an installation component name with which the install rule
- is associated, such as ``Runtime`` or ``Development``. During
- component-specific installation only install rules associated with
- the given component name will be executed. During a full installation
- all components are installed unless marked with ``EXCLUDE_FROM_ALL``.
- If ``COMPONENT`` is not provided a default component "Unspecified" is
- created. The default component name may be controlled with the
- :variable:`CMAKE_INSTALL_DEFAULT_COMPONENT_NAME` variable.
-
-``EXCLUDE_FROM_ALL``
- .. versionadded:: 3.6
-
- Specify that the file is excluded from a full installation and only
- installed as part of a component-specific installation
-
-``RENAME``
- Specify a name for an installed file that may be different from the
- original file. Renaming is allowed only when a single file is
- installed by the command.
-
-``OPTIONAL``
- Specify that it is not an error if the file to be installed does
- not exist.
-
-.. versionadded:: 3.1
- Command signatures that install files may print messages during
- installation. Use the :variable:`CMAKE_INSTALL_MESSAGE` variable
- to control which messages are printed.
-
-.. versionadded:: 3.11
- Many of the ``install()`` variants implicitly create the directories
- containing the installed files. If
- :variable:`CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS` is set, these
- directories will be created with the permissions specified. Otherwise,
- they will be created according to the uname rules on Unix-like platforms.
- Windows platforms are unaffected.
-
-Installing Targets
-^^^^^^^^^^^^^^^^^^
-
-.. _`install(TARGETS)`:
-.. _TARGETS:
-
-.. code-block:: cmake
-
- install(TARGETS targets... [EXPORT ]
- [RUNTIME_DEPENDENCIES args...|RUNTIME_DEPENDENCY_SET ]
- [[ARCHIVE|LIBRARY|RUNTIME|OBJECTS|FRAMEWORK|BUNDLE|
- PRIVATE_HEADER|PUBLIC_HEADER|RESOURCE|FILE_SET |CXX_MODULES_BMI]
- [DESTINATION ]
- [PERMISSIONS permissions...]
- [CONFIGURATIONS [Debug|Release|...]]
- [COMPONENT ]
- [NAMELINK_COMPONENT ]
- [OPTIONAL] [EXCLUDE_FROM_ALL]
- [NAMELINK_ONLY|NAMELINK_SKIP]
- ] [...]
- [INCLUDES DESTINATION [ ...]]
- )
-
-The ``TARGETS`` form specifies rules for installing targets from a
-project. There are several kinds of target :ref:`Output Artifacts`
-that may be installed:
-
-``ARCHIVE``
- Target artifacts of this kind include:
-
- * *Static libraries*
- (except on macOS when marked as ``FRAMEWORK``, see below);
- * *DLL import libraries*
- (on all Windows-based systems including Cygwin; they have extension
- ``.lib``, in contrast to the ``.dll`` libraries that go to ``RUNTIME``);
- * On AIX, the *linker import file* created for executables with
- :prop_tgt:`ENABLE_EXPORTS` enabled.
- * On macOS, the *linker import file* created for shared libraries with
- :prop_tgt:`ENABLE_EXPORTS` enabled (except when marked as ``FRAMEWORK``,
- see below).
-
-``LIBRARY``
- Target artifacts of this kind include:
-
- * *Shared libraries*, except
-
- - DLLs (these go to ``RUNTIME``, see below),
- - on macOS when marked as ``FRAMEWORK`` (see below).
-
-``RUNTIME``
- Target artifacts of this kind include:
-
- * *Executables*
- (except on macOS when marked as ``MACOSX_BUNDLE``, see ``BUNDLE`` below);
- * DLLs (on all Windows-based systems including Cygwin; note that the
- accompanying import libraries are of kind ``ARCHIVE``).
-
-``OBJECTS``
- .. versionadded:: 3.9
-
- Object files associated with *object libraries*.
-
-``FRAMEWORK``
- Both static and shared libraries marked with the ``FRAMEWORK``
- property are treated as ``FRAMEWORK`` targets on macOS.
-
-``BUNDLE``
- Executables marked with the :prop_tgt:`MACOSX_BUNDLE` property are treated as
- ``BUNDLE`` targets on macOS.
-
-``PUBLIC_HEADER``
- Any :prop_tgt:`PUBLIC_HEADER` files associated with a library are installed in
- the destination specified by the ``PUBLIC_HEADER`` argument on non-Apple
- platforms. Rules defined by this argument are ignored for :prop_tgt:`FRAMEWORK`
- libraries on Apple platforms because the associated files are installed
- into the appropriate locations inside the framework folder. See
- :prop_tgt:`PUBLIC_HEADER` for details.
-
-``PRIVATE_HEADER``
- Similar to ``PUBLIC_HEADER``, but for ``PRIVATE_HEADER`` files. See
- :prop_tgt:`PRIVATE_HEADER` for details.
-
-``RESOURCE``
- Similar to ``PUBLIC_HEADER`` and ``PRIVATE_HEADER``, but for
- ``RESOURCE`` files. See :prop_tgt:`RESOURCE` for details.
-
-``FILE_SET ``
- .. versionadded:: 3.23
-
- File sets are defined by the :command:`target_sources(FILE_SET)` command.
- If the file set ```` exists and is ``PUBLIC`` or ``INTERFACE``, any
- files in the set are installed under the destination (see below).
- The directory structure relative to the file set's base directories is
- preserved. For example, a file added to the file set as
- ``/blah/include/myproj/here.h`` with a base directory ``/blah/include``
- would be installed to ``myproj/here.h`` below the destination.
-
-``CXX_MODULES_BMI``
-
- .. note ::
-
- Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
-
- Any module files from C++ modules from ``PUBLIC`` sources in a file set of
- type ``CXX_MODULES`` will be installed to the given ``DESTINATION``. All
- modules are placed directly in the destination as no directory structure is
- derived from the names of the modules. An empty ``DESTINATION`` may be used
- to suppress installing these files (for use in generic code).
-
-For each of these arguments given, the arguments following them only apply
-to the target or file type specified in the argument. If none is given, the
-installation properties apply to all target types.
-
-For regular executables, static libraries and shared libraries, the
-``DESTINATION`` argument is not required. For these target types, when
-``DESTINATION`` is omitted, a default destination will be taken from the
-appropriate variable from :module:`GNUInstallDirs`, or set to a built-in
-default value if that variable is not defined. The same is true for file
-sets, and the public and private headers associated with the installed
-targets through the :prop_tgt:`PUBLIC_HEADER` and :prop_tgt:`PRIVATE_HEADER`
-target properties. A destination must always be provided for module libraries,
-Apple bundles and frameworks. A destination can be omitted for interface and
-object libraries, but they are handled differently (see the discussion of this
-topic toward the end of this section).
-
-For shared libraries on DLL platforms, if neither ``RUNTIME`` nor ``ARCHIVE``
-destinations are specified, both the ``RUNTIME`` and ``ARCHIVE`` components are
-installed to their default destinations. If either a ``RUNTIME`` or ``ARCHIVE``
-destination is specified, the component is installed to that destination, and
-the other component is not installed. If both ``RUNTIME`` and ``ARCHIVE``
-destinations are specified, then both components are installed to their
-respective destinations.
-
-The following table shows the target types with their associated variables and
-built-in defaults that apply when no destination is given:
-
-=============================== =============================== ======================
- Target Type GNUInstallDirs Variable Built-In Default
-=============================== =============================== ======================
-``RUNTIME`` ``${CMAKE_INSTALL_BINDIR}`` ``bin``
-``LIBRARY`` ``${CMAKE_INSTALL_LIBDIR}`` ``lib``
-``ARCHIVE`` ``${CMAKE_INSTALL_LIBDIR}`` ``lib``
-``PRIVATE_HEADER`` ``${CMAKE_INSTALL_INCLUDEDIR}`` ``include``
-``PUBLIC_HEADER`` ``${CMAKE_INSTALL_INCLUDEDIR}`` ``include``
-``FILE_SET`` (type ``HEADERS``) ``${CMAKE_INSTALL_INCLUDEDIR}`` ``include``
-=============================== =============================== ======================
-
-Projects wishing to follow the common practice of installing headers into a
-project-specific subdirectory may prefer using file sets with appropriate
-paths and base directories. Otherwise, they must provide a ``DESTINATION``
-instead of being able to rely on the above (see next example below).
-
-To make packages compliant with distribution filesystem layout policies, if
-projects must specify a ``DESTINATION``, it is recommended that they use a
-path that begins with the appropriate :module:`GNUInstallDirs` variable.
-This allows package maintainers to control the install destination by setting
-the appropriate cache variables. The following example shows a static library
-being installed to the default destination provided by
-:module:`GNUInstallDirs`, but with its headers installed to a project-specific
-subdirectory without using file sets:
-
-.. code-block:: cmake
-
- add_library(mylib STATIC ...)
- set_target_properties(mylib PROPERTIES PUBLIC_HEADER mylib.h)
- include(GNUInstallDirs)
- install(TARGETS mylib
- PUBLIC_HEADER
- DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/myproj
- )
-
-In addition to the common options listed above, each target can accept
-the following additional arguments:
-
-``NAMELINK_COMPONENT``
- .. versionadded:: 3.12
-
- On some platforms a versioned shared library has a symbolic link such
- as::
-
- lib.so -> lib.so.1
-
- where ``lib.so.1`` is the soname of the library and ``lib.so``
- is a "namelink" allowing linkers to find the library when given
- ``-l``. The ``NAMELINK_COMPONENT`` option is similar to the
- ``COMPONENT`` option, but it changes the installation component of a shared
- library namelink if one is generated. If not specified, this defaults to the
- value of ``COMPONENT``. It is an error to use this parameter outside of a
- ``LIBRARY`` block.
-
- .. versionchanged:: 3.27
- This parameter is also usable for an ``ARCHIVE`` block to manage
- the linker import file created, on macOS, for shared libraries with
- :prop_tgt:`ENABLE_EXPORTS` enabled.
-
- Consider the following example:
-
- .. code-block:: cmake
-
- install(TARGETS mylib
- LIBRARY
- COMPONENT Libraries
- NAMELINK_COMPONENT Development
- PUBLIC_HEADER
- COMPONENT Development
- )
-
- In this scenario, if you choose to install only the ``Development``
- component, both the headers and namelink will be installed without the
- library. (If you don't also install the ``Libraries`` component, the
- namelink will be a dangling symlink, and projects that link to the library
- will have build errors.) If you install only the ``Libraries`` component,
- only the library will be installed, without the headers and namelink.
-
- This option is typically used for package managers that have separate
- runtime and development packages. For example, on Debian systems, the
- library is expected to be in the runtime package, and the headers and
- namelink are expected to be in the development package.
-
- See the :prop_tgt:`VERSION` and :prop_tgt:`SOVERSION` target properties for
- details on creating versioned shared libraries.
-
-``NAMELINK_ONLY``
- This option causes the installation of only the namelink when a library
- target is installed. On platforms where versioned shared libraries do not
- have namelinks or when a library is not versioned, the ``NAMELINK_ONLY``
- option installs nothing. It is an error to use this parameter outside of a
- ``LIBRARY`` block.
-
- .. versionchanged:: 3.27
- This parameter is also usable for an ``ARCHIVE`` block to manage
- the linker import file created, on macOS, for shared libraries with
- :prop_tgt:`ENABLE_EXPORTS` enabled.
-
- When ``NAMELINK_ONLY`` is given, either ``NAMELINK_COMPONENT`` or
- ``COMPONENT`` may be used to specify the installation component of the
- namelink, but ``COMPONENT`` should generally be preferred.
-
-``NAMELINK_SKIP``
- Similar to ``NAMELINK_ONLY``, but it has the opposite effect: it causes the
- installation of library files other than the namelink when a library target
- is installed. When neither ``NAMELINK_ONLY`` or ``NAMELINK_SKIP`` are given,
- both portions are installed. On platforms where versioned shared libraries
- do not have symlinks or when a library is not versioned, ``NAMELINK_SKIP``
- installs the library. It is an error to use this parameter outside of a
- ``LIBRARY`` block.
-
- .. versionchanged:: 3.27
- This parameter is also usable for an ``ARCHIVE`` block to manage
- the linker import file created, on macOS, for shared libraries with
- :prop_tgt:`ENABLE_EXPORTS` enabled.
-
- If ``NAMELINK_SKIP`` is specified, ``NAMELINK_COMPONENT`` has no effect. It
- is not recommended to use ``NAMELINK_SKIP`` in conjunction with
- ``NAMELINK_COMPONENT``.
-
-The `install(TARGETS)`_ command can also accept the following options at the
-top level:
-
-``EXPORT``
- This option associates the installed target files with an export called
- ````. It must appear before any target options. To actually
- install the export file itself, call `install(EXPORT)`_, documented below.
- See documentation of the :prop_tgt:`EXPORT_NAME` target property to change
- the name of the exported target.
-
- If ``EXPORT`` is used and the targets include ``PUBLIC`` or ``INTERFACE``
- file sets, all of them must be specified with ``FILE_SET`` arguments. All
- ``PUBLIC`` or ``INTERFACE`` file sets associated with a target are included
- in the export.
-
-``INCLUDES DESTINATION``
- This option specifies a list of directories which will be added to the
- :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` target property of the
- ```` when exported by the `install(EXPORT)`_ command. If a
- relative path is specified, it is treated as relative to the
- :genex:`$`.
-
-``RUNTIME_DEPENDENCY_SET``
- .. versionadded:: 3.21
-
- This option causes all runtime dependencies of installed executable, shared
- library, and module targets to be added to the specified runtime dependency
- set. This set can then be installed with an
- `install(RUNTIME_DEPENDENCY_SET)`_ command.
-
- This keyword and the ``RUNTIME_DEPENDENCIES`` keyword are mutually
- exclusive.
-
-``RUNTIME_DEPENDENCIES``
- .. versionadded:: 3.21
-
- This option causes all runtime dependencies of installed executable, shared
- library, and module targets to be installed along with the targets
- themselves. The ``RUNTIME``, ``LIBRARY``, ``FRAMEWORK``, and generic
- arguments are used to determine the properties (``DESTINATION``,
- ``COMPONENT``, etc.) of the installation of these dependencies.
-
- ``RUNTIME_DEPENDENCIES`` is semantically equivalent to the following pair
- of calls:
-
- .. code-block:: cmake
-
- install(TARGETS ... RUNTIME_DEPENDENCY_SET )
- install(RUNTIME_DEPENDENCY_SET args...)
-
- where ```` will be a randomly generated set name.
- The ``args...`` may include any of the following keywords supported by
- the `install(RUNTIME_DEPENDENCY_SET)`_ command:
-
- * ``DIRECTORIES``
- * ``PRE_INCLUDE_REGEXES``
- * ``PRE_EXCLUDE_REGEXES``
- * ``POST_INCLUDE_REGEXES``
- * ``POST_EXCLUDE_REGEXES``
- * ``POST_INCLUDE_FILES``
- * ``POST_EXCLUDE_FILES``
-
- The ``RUNTIME_DEPENDENCIES`` and ``RUNTIME_DEPENDENCY_SET`` keywords are
- mutually exclusive.
-
-One or more groups of properties may be specified in a single call to
-the ``TARGETS`` form of this command. A target may be installed more than
-once to different locations. Consider hypothetical targets ``myExe``,
-``mySharedLib``, and ``myStaticLib``. The code:
-
-.. code-block:: cmake
-
- install(TARGETS myExe mySharedLib myStaticLib
- RUNTIME DESTINATION bin
- LIBRARY DESTINATION lib
- ARCHIVE DESTINATION lib/static)
- install(TARGETS mySharedLib DESTINATION /some/full/path)
-
-will install ``myExe`` to ``/bin`` and ``myStaticLib`` to
-``/lib/static``. On non-DLL platforms ``mySharedLib`` will be
-installed to ``/lib`` and ``/some/full/path``. On DLL platforms
-the ``mySharedLib`` DLL will be installed to ``/bin`` and
-``/some/full/path`` and its import library will be installed to
-``/lib/static`` and ``/some/full/path``.
-
-:ref:`Interface Libraries` may be listed among the targets to install.
-They install no artifacts but will be included in an associated ``EXPORT``.
-If :ref:`Object Libraries` are listed but given no destination for their
-object files, they will be exported as :ref:`Interface Libraries`.
-This is sufficient to satisfy transitive usage requirements of other
-targets that link to the object libraries in their implementation.
-
-Installing a target with the :prop_tgt:`EXCLUDE_FROM_ALL` target property
-set to ``TRUE`` has undefined behavior.
-
-.. versionadded:: 3.3
- An install destination given as a ``DESTINATION`` argument may
- use "generator expressions" with the syntax ``$<...>``. See the
- :manual:`cmake-generator-expressions(7)` manual for available expressions.
-
-.. versionadded:: 3.13
- `install(TARGETS)`_ can install targets that were created in
- other directories. When using such cross-directory install rules, running
- ``make install`` (or similar) from a subdirectory will not guarantee that
- targets from other directories are up-to-date. You can use
- :command:`target_link_libraries` or :command:`add_dependencies`
- to ensure that such out-of-directory targets are built before the
- subdirectory-specific install rules are run.
-
-Installing Imported Runtime Artifacts
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. _`install(IMPORTED_RUNTIME_ARTIFACTS)`:
-.. _IMPORTED_RUNTIME_ARTIFACTS:
-
-.. versionadded:: 3.21
-
-.. code-block:: cmake
-
- install(IMPORTED_RUNTIME_ARTIFACTS targets...
- [RUNTIME_DEPENDENCY_SET ]
- [[LIBRARY|RUNTIME|FRAMEWORK|BUNDLE]
- [DESTINATION ]
- [PERMISSIONS permissions...]
- [CONFIGURATIONS [Debug|Release|...]]
- [COMPONENT ]
- [OPTIONAL] [EXCLUDE_FROM_ALL]
- ] [...]
- )
-
-The ``IMPORTED_RUNTIME_ARTIFACTS`` form specifies rules for installing the
-runtime artifacts of imported targets. Projects may do this if they want to
-bundle outside executables or modules inside their installation. The
-``LIBRARY``, ``RUNTIME``, ``FRAMEWORK``, and ``BUNDLE`` arguments have the
-same semantics that they do in the `TARGETS`_ mode. Only the runtime artifacts
-of imported targets are installed (except in the case of :prop_tgt:`FRAMEWORK`
-libraries, :prop_tgt:`MACOSX_BUNDLE` executables, and :prop_tgt:`BUNDLE`
-CFBundles.) For example, headers and import libraries associated with DLLs are
-not installed. In the case of :prop_tgt:`FRAMEWORK` libraries,
-:prop_tgt:`MACOSX_BUNDLE` executables, and :prop_tgt:`BUNDLE` CFBundles, the
-entire directory is installed.
-
-The ``RUNTIME_DEPENDENCY_SET`` option causes the runtime artifacts of the
-imported executable, shared library, and module library ``targets`` to be
-added to the ```` runtime dependency set. This set can then be
-installed with an `install(RUNTIME_DEPENDENCY_SET)`_ command.
-
-Installing Files
-^^^^^^^^^^^^^^^^
-
-.. _`install(FILES)`:
-.. _`install(PROGRAMS)`:
-.. _FILES:
-.. _PROGRAMS:
-
-.. note::
-
- If installing header files, consider using file sets defined by
- :command:`target_sources(FILE_SET)` instead. File sets associate
- headers with a target and they install as part of the target.
-
-.. code-block:: cmake
-
- install( files...
- TYPE | DESTINATION
- [PERMISSIONS permissions...]
- [CONFIGURATIONS [Debug|Release|...]]
- [COMPONENT ]
- [RENAME ] [OPTIONAL] [EXCLUDE_FROM_ALL])
-
-The ``FILES`` form specifies rules for installing files for a project.
-File names given as relative paths are interpreted with respect to the
-current source directory. Files installed by this form are by default
-given permissions ``OWNER_WRITE``, ``OWNER_READ``, ``GROUP_READ``, and
-``WORLD_READ`` if no ``PERMISSIONS`` argument is given.
-
-The ``PROGRAMS`` form is identical to the ``FILES`` form except that the
-default permissions for the installed file also include ``OWNER_EXECUTE``,
-``GROUP_EXECUTE``, and ``WORLD_EXECUTE``. This form is intended to install
-programs that are not targets, such as shell scripts. Use the ``TARGETS``
-form to install targets built within the project.
-
-The list of ``files...`` given to ``FILES`` or ``PROGRAMS`` may use
-"generator expressions" with the syntax ``$<...>``. See the
-:manual:`cmake-generator-expressions(7)` manual for available expressions.
-However, if any item begins in a generator expression it must evaluate
-to a full path.
-
-Either a ``TYPE`` or a ``DESTINATION`` must be provided, but not both.
-A ``TYPE`` argument specifies the generic file type of the files being
-installed. A destination will then be set automatically by taking the
-corresponding variable from :module:`GNUInstallDirs`, or by using a
-built-in default if that variable is not defined. See the table below for
-the supported file types and their corresponding variables and built-in
-defaults. Projects can provide a ``DESTINATION`` argument instead of a
-file type if they wish to explicitly define the install destination.
-
-======================= ================================== =========================
- ``TYPE`` Argument GNUInstallDirs Variable Built-In Default
-======================= ================================== =========================
-``BIN`` ``${CMAKE_INSTALL_BINDIR}`` ``bin``
-``SBIN`` ``${CMAKE_INSTALL_SBINDIR}`` ``sbin``
-``LIB`` ``${CMAKE_INSTALL_LIBDIR}`` ``lib``
-``INCLUDE`` ``${CMAKE_INSTALL_INCLUDEDIR}`` ``include``
-``SYSCONF`` ``${CMAKE_INSTALL_SYSCONFDIR}`` ``etc``
-``SHAREDSTATE`` ``${CMAKE_INSTALL_SHARESTATEDIR}`` ``com``
-``LOCALSTATE`` ``${CMAKE_INSTALL_LOCALSTATEDIR}`` ``var``
-``RUNSTATE`` ``${CMAKE_INSTALL_RUNSTATEDIR}`` ``/run``
-``DATA`` ``${CMAKE_INSTALL_DATADIR}`` ````
-``INFO`` ``${CMAKE_INSTALL_INFODIR}`` ``/info``
-``LOCALE`` ``${CMAKE_INSTALL_LOCALEDIR}`` ``/locale``
-``MAN`` ``${CMAKE_INSTALL_MANDIR}`` ``/man``
-``DOC`` ``${CMAKE_INSTALL_DOCDIR}`` ``/doc``
-======================= ================================== =========================
-
-Projects wishing to follow the common practice of installing headers into a
-project-specific subdirectory will need to provide a destination rather than
-rely on the above. Using file sets for headers instead of ``install(FILES)``
-would be even better (see :command:`target_sources(FILE_SET)`).
-
-Note that some of the types' built-in defaults use the ``DATAROOT`` directory as
-a prefix. The ``DATAROOT`` prefix is calculated similarly to the types, with
-``CMAKE_INSTALL_DATAROOTDIR`` as the variable and ``share`` as the built-in
-default. You cannot use ``DATAROOT`` as a ``TYPE`` parameter; please use
-``DATA`` instead.
-
-To make packages compliant with distribution filesystem layout policies, if
-projects must specify a ``DESTINATION``, it is recommended that they use a
-path that begins with the appropriate :module:`GNUInstallDirs` variable.
-This allows package maintainers to control the install destination by setting
-the appropriate cache variables. The following example shows how to follow
-this advice while installing an image to a project-specific documentation
-subdirectory:
-
-.. code-block:: cmake
-
- include(GNUInstallDirs)
- install(FILES logo.png
- DESTINATION ${CMAKE_INSTALL_DOCDIR}/myproj
- )
-
-.. versionadded:: 3.4
- An install destination given as a ``DESTINATION`` argument may
- use "generator expressions" with the syntax ``$<...>``. See the
- :manual:`cmake-generator-expressions(7)` manual for available expressions.
-
-.. versionadded:: 3.20
- An install rename given as a ``RENAME`` argument may
- use "generator expressions" with the syntax ``$<...>``. See the
- :manual:`cmake-generator-expressions(7)` manual for available expressions.
-
-Installing Directories
-^^^^^^^^^^^^^^^^^^^^^^
-
-.. _`install(DIRECTORY)`:
-.. _DIRECTORY:
-
-.. note::
-
- To install a directory sub-tree of headers, consider using file sets
- defined by :command:`target_sources(FILE_SET)` instead. File sets not only
- preserve directory structure, they also associate headers with a target
- and install as part of the target.
-
-.. code-block:: cmake
-
- install(DIRECTORY dirs...
- TYPE | DESTINATION
- [FILE_PERMISSIONS permissions...]
- [DIRECTORY_PERMISSIONS permissions...]
- [USE_SOURCE_PERMISSIONS] [OPTIONAL] [MESSAGE_NEVER]
- [CONFIGURATIONS [Debug|Release|...]]
- [COMPONENT ] [EXCLUDE_FROM_ALL]
- [FILES_MATCHING]
- [[PATTERN | REGEX ]
- [EXCLUDE] [PERMISSIONS permissions...]] [...])
-
-The ``DIRECTORY`` form installs contents of one or more directories to a
-given destination. The directory structure is copied verbatim to the
-destination. The last component of each directory name is appended to
-the destination directory but a trailing slash may be used to avoid
-this because it leaves the last component empty. Directory names
-given as relative paths are interpreted with respect to the current
-source directory. If no input directory names are given the
-destination directory will be created but nothing will be installed
-into it. The ``FILE_PERMISSIONS`` and ``DIRECTORY_PERMISSIONS`` options
-specify permissions given to files and directories in the destination.
-If ``USE_SOURCE_PERMISSIONS`` is specified and ``FILE_PERMISSIONS`` is not,
-file permissions will be copied from the source directory structure.
-If no permissions are specified files will be given the default
-permissions specified in the ``FILES`` form of the command, and the
-directories will be given the default permissions specified in the
-``PROGRAMS`` form of the command.
-
-.. versionadded:: 3.1
- The ``MESSAGE_NEVER`` option disables file installation status output.
-
-Installation of directories may be controlled with fine granularity
-using the ``PATTERN`` or ``REGEX`` options. These "match" options specify a
-globbing pattern or regular expression to match directories or files
-encountered within input directories. They may be used to apply
-certain options (see below) to a subset of the files and directories
-encountered. The full path to each input file or directory (with
-forward slashes) is matched against the expression. A ``PATTERN`` will
-match only complete file names: the portion of the full path matching
-the pattern must occur at the end of the file name and be preceded by
-a slash. A ``REGEX`` will match any portion of the full path but it may
-use ``/`` and ``$`` to simulate the ``PATTERN`` behavior. By default all
-files and directories are installed whether or not they are matched.
-The ``FILES_MATCHING`` option may be given before the first match option
-to disable installation of files (but not directories) not matched by
-any expression. For example, the code
-
-.. code-block:: cmake
-
- install(DIRECTORY src/ DESTINATION doc/myproj
- FILES_MATCHING PATTERN "*.png")
-
-will extract and install images from a source tree.
-
-Some options may follow a ``PATTERN`` or ``REGEX`` expression as described
-under :ref:`string(REGEX) ` and are applied
-only to files or directories matching them. The ``EXCLUDE`` option will
-skip the matched file or directory. The ``PERMISSIONS`` option overrides
-the permissions setting for the matched file or directory. For
-example the code
-
-.. code-block:: cmake
-
- install(DIRECTORY icons scripts/ DESTINATION share/myproj
- PATTERN "CVS" EXCLUDE
- PATTERN "scripts/*"
- PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
- GROUP_EXECUTE GROUP_READ)
-
-will install the ``icons`` directory to ``share/myproj/icons`` and the
-``scripts`` directory to ``share/myproj``. The icons will get default
-file permissions, the scripts will be given specific permissions, and any
-``CVS`` directories will be excluded.
-
-Either a ``TYPE`` or a ``DESTINATION`` must be provided, but not both.
-A ``TYPE`` argument specifies the generic file type of the files within the
-listed directories being installed. A destination will then be set
-automatically by taking the corresponding variable from
-:module:`GNUInstallDirs`, or by using a built-in default if that variable
-is not defined. See the table below for the supported file types and their
-corresponding variables and built-in defaults. Projects can provide a
-``DESTINATION`` argument instead of a file type if they wish to explicitly
-define the install destination.
-
-======================= ================================== =========================
- ``TYPE`` Argument GNUInstallDirs Variable Built-In Default
-======================= ================================== =========================
-``BIN`` ``${CMAKE_INSTALL_BINDIR}`` ``bin``
-``SBIN`` ``${CMAKE_INSTALL_SBINDIR}`` ``sbin``
-``LIB`` ``${CMAKE_INSTALL_LIBDIR}`` ``lib``
-``INCLUDE`` ``${CMAKE_INSTALL_INCLUDEDIR}`` ``include``
-``SYSCONF`` ``${CMAKE_INSTALL_SYSCONFDIR}`` ``etc``
-``SHAREDSTATE`` ``${CMAKE_INSTALL_SHARESTATEDIR}`` ``com``
-``LOCALSTATE`` ``${CMAKE_INSTALL_LOCALSTATEDIR}`` ``var``
-``RUNSTATE`` ``${CMAKE_INSTALL_RUNSTATEDIR}`` ``/run``
-``DATA`` ``${CMAKE_INSTALL_DATADIR}`` ````
-``INFO`` ``${CMAKE_INSTALL_INFODIR}`` ``/info``
-``LOCALE`` ``${CMAKE_INSTALL_LOCALEDIR}`` ``/locale``
-``MAN`` ``${CMAKE_INSTALL_MANDIR}`` ``/man``
-``DOC`` ``${CMAKE_INSTALL_DOCDIR}`` ``/doc``
-======================= ================================== =========================
-
-Note that some of the types' built-in defaults use the ``DATAROOT`` directory as
-a prefix. The ``DATAROOT`` prefix is calculated similarly to the types, with
-``CMAKE_INSTALL_DATAROOTDIR`` as the variable and ``share`` as the built-in
-default. You cannot use ``DATAROOT`` as a ``TYPE`` parameter; please use
-``DATA`` instead.
-
-To make packages compliant with distribution filesystem layout policies, if
-projects must specify a ``DESTINATION``, it is recommended that they use a
-path that begins with the appropriate :module:`GNUInstallDirs` variable.
-This allows package maintainers to control the install destination by setting
-the appropriate cache variables.
-
-.. versionadded:: 3.4
- An install destination given as a ``DESTINATION`` argument may
- use "generator expressions" with the syntax ``$<...>``. See the
- :manual:`cmake-generator-expressions(7)` manual for available expressions.
-
-.. versionadded:: 3.5
- The list of ``dirs...`` given to ``DIRECTORY`` may use
- "generator expressions" too.
-
-Custom Installation Logic
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. _`install(CODE)`:
-.. _`install(SCRIPT)`:
-.. _CODE:
-.. _SCRIPT:
-
-.. code-block:: cmake
-
- install([[SCRIPT ] [CODE ]]
- [ALL_COMPONENTS | COMPONENT ]
- [EXCLUDE_FROM_ALL] [...])
-
-The ``SCRIPT`` form will invoke the given CMake script files during
-installation. If the script file name is a relative path it will be
-interpreted with respect to the current source directory. The ``CODE``
-form will invoke the given CMake code during installation. Code is
-specified as a single argument inside a double-quoted string. For
-example, the code
-
-.. code-block:: cmake
-
- install(CODE "MESSAGE(\"Sample install message.\")")
-
-will print a message during installation.
-
-.. versionadded:: 3.21
- When the ``ALL_COMPONENTS`` option is given, the custom installation
- script code will be executed for every component of a component-specific
- installation. This option is mutually exclusive with the ``COMPONENT``
- option.
-
-.. versionadded:: 3.14
- ```` or ```` may use "generator expressions" with the syntax
- ``$<...>`` (in the case of ````, this refers to their use in the file
- name, not the file's contents). See the
- :manual:`cmake-generator-expressions(7)` manual for available expressions.
-
-Installing Exports
-^^^^^^^^^^^^^^^^^^
-
-.. _`install(EXPORT)`:
-.. _EXPORT:
-
-.. code-block:: cmake
-
- install(EXPORT DESTINATION
- [NAMESPACE ] [FILE .cmake]
- [PERMISSIONS permissions...]
- [CONFIGURATIONS [Debug|Release|...]
- [CXX_MODULES_DIRECTORY ]
- [EXPORT_LINK_INTERFACE_LIBRARIES]
- [COMPONENT ]
- [EXCLUDE_FROM_ALL])
- install(EXPORT_ANDROID_MK DESTINATION [...])
-
-The ``EXPORT`` form generates and installs a CMake file containing code to
-import targets from the installation tree into another project.
-Target installations are associated with the export ````
-using the ``EXPORT`` option of the `install(TARGETS)`_ signature
-documented above. The ``NAMESPACE`` option will prepend ```` to
-the target names as they are written to the import file. By default
-the generated file will be called ``.cmake`` but the ``FILE``
-option may be used to specify a different name. The value given to
-the ``FILE`` option must be a file name with the ``.cmake`` extension.
-If a ``CONFIGURATIONS`` option is given then the file will only be installed
-when one of the named configurations is installed. Additionally, the
-generated import file will reference only the matching target
-configurations. See the :variable:`CMAKE_MAP_IMPORTED_CONFIG_`
-variable to map configurations of dependent projects to the installed
-configurations. The ``EXPORT_LINK_INTERFACE_LIBRARIES`` keyword, if
-present, causes the contents of the properties matching
-``(IMPORTED_)?LINK_INTERFACE_LIBRARIES(_)?`` to be exported, when
-policy :policy:`CMP0022` is ``NEW``.
-
-.. note::
- The installed ``.cmake`` file may come with additional
- per-configuration ``-*.cmake`` files to be loaded by
- globbing. Do not use an export name that is the same as the package
- name in combination with installing a ``-config.cmake``
- file or the latter may be incorrectly matched by the glob and loaded.
-
-When a ``COMPONENT`` option is given, the listed ```` implicitly
-depends on all components mentioned in the export set. The exported
-``.cmake`` file will require each of the exported components to be
-present in order for dependent projects to build properly. For example, a
-project may define components ``Runtime`` and ``Development``, with shared
-libraries going into the ``Runtime`` component and static libraries and
-headers going into the ``Development`` component. The export set would also
-typically be part of the ``Development`` component, but it would export
-targets from both the ``Runtime`` and ``Development`` components. Therefore,
-the ``Runtime`` component would need to be installed if the ``Development``
-component was installed, but not vice versa. If the ``Development`` component
-was installed without the ``Runtime`` component, dependent projects that try
-to link against it would have build errors. Package managers, such as APT and
-RPM, typically handle this by listing the ``Runtime`` component as a dependency
-of the ``Development`` component in the package metadata, ensuring that the
-library is always installed if the headers and CMake export file are present.
-
-.. versionadded:: 3.7
- In addition to cmake language files, the ``EXPORT_ANDROID_MK`` mode may be
- used to specify an export to the android ndk build system. This mode
- accepts the same options as the normal export mode. The Android
- NDK supports the use of prebuilt libraries, both static and shared. This
- allows cmake to build the libraries of a project and make them available
- to an ndk build system complete with transitive dependencies, include flags
- and defines required to use the libraries.
-
-``CXX_MODULES_DIRECTORY``
-
- .. note ::
-
- Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
-
- Specify a subdirectory to store C++ module information for targets in the
- export set. This directory will be populated with files which add the
- necessary target property information to the relevant targets. Note that
- without this information, none of the C++ modules which are part of the
- targets in the export set will support being imported in consuming targets.
-
-The ``EXPORT`` form is useful to help outside projects use targets built
-and installed by the current project. For example, the code
-
-.. code-block:: cmake
-
- install(TARGETS myexe EXPORT myproj DESTINATION bin)
- install(EXPORT myproj NAMESPACE mp_ DESTINATION lib/myproj)
- install(EXPORT_ANDROID_MK myproj DESTINATION share/ndk-modules)
-
-will install the executable ``myexe`` to ``/bin`` and code to import
-it in the file ``/lib/myproj/myproj.cmake`` and
-``/share/ndk-modules/Android.mk``. An outside project
-may load this file with the include command and reference the ``myexe``
-executable from the installation tree using the imported target name
-``mp_myexe`` as if the target were built in its own tree.
-
-.. note::
- This command supersedes the :command:`install_targets` command and
- the :prop_tgt:`PRE_INSTALL_SCRIPT` and :prop_tgt:`POST_INSTALL_SCRIPT`
- target properties. It also replaces the ``FILES`` forms of the
- :command:`install_files` and :command:`install_programs` commands.
- The processing order of these install rules relative to
- those generated by :command:`install_targets`,
- :command:`install_files`, and :command:`install_programs` commands
- is not defined.
-
-Installing Runtime Dependencies
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. _`install(RUNTIME_DEPENDENCY_SET)`:
-.. _RUNTIME_DEPENDENCY_SET:
-
-.. versionadded:: 3.21
-
-.. code-block:: cmake
-
- install(RUNTIME_DEPENDENCY_SET
- [[LIBRARY|RUNTIME|FRAMEWORK]
- [DESTINATION ]
- [PERMISSIONS permissions...]
- [CONFIGURATIONS [Debug|Release|...]]
- [COMPONENT ]
- [NAMELINK_COMPONENT ]
- [OPTIONAL] [EXCLUDE_FROM_ALL]
- ] [...]
- [PRE_INCLUDE_REGEXES regexes...]
- [PRE_EXCLUDE_REGEXES regexes...]
- [POST_INCLUDE_REGEXES regexes...]
- [POST_EXCLUDE_REGEXES regexes...]
- [POST_INCLUDE_FILES files...]
- [POST_EXCLUDE_FILES files...]
- [DIRECTORIES directories...]
- )
-
-Installs a runtime dependency set previously created by one or more
-`install(TARGETS)`_ or `install(IMPORTED_RUNTIME_ARTIFACTS)`_ commands. The
-dependencies of targets belonging to a runtime dependency set are installed in
-the ``RUNTIME`` destination and component on DLL platforms, and in the
-``LIBRARY`` destination and component on non-DLL platforms. macOS frameworks
-are installed in the ``FRAMEWORK`` destination and component.
-Targets built within the build tree will never be installed as runtime
-dependencies, nor will their own dependencies, unless the targets themselves
-are installed with `install(TARGETS)`_.
-
-The generated install script calls :command:`file(GET_RUNTIME_DEPENDENCIES)`
-on the build-tree files to calculate the runtime dependencies. The build-tree
-executable files are passed as the ``EXECUTABLES`` argument, the build-tree
-shared libraries as the ``LIBRARIES`` argument, and the build-tree modules as
-the ``MODULES`` argument. On macOS, if one of the executables is a
-:prop_tgt:`MACOSX_BUNDLE`, that executable is passed as the
-``BUNDLE_EXECUTABLE`` argument. At most one such bundle executable may be in
-the runtime dependency set on macOS. The :prop_tgt:`MACOSX_BUNDLE` property
-has no effect on other platforms. Note that
-:command:`file(GET_RUNTIME_DEPENDENCIES)` only supports collecting the runtime
-dependencies for Windows, Linux and macOS platforms, so
-``install(RUNTIME_DEPENDENCY_SET)`` has the same limitation.
-
-The following sub-arguments are forwarded through as the corresponding
-arguments to :command:`file(GET_RUNTIME_DEPENDENCIES)` (for those that provide
-a non-empty list of directories, regular expressions or files). They all
-support :manual:`generator expressions `.
-
-* ``DIRECTORIES ``
-* ``PRE_INCLUDE_REGEXES ``
-* ``PRE_EXCLUDE_REGEXES ``
-* ``POST_INCLUDE_REGEXES ``
-* ``POST_EXCLUDE_REGEXES ``
-* ``POST_INCLUDE_FILES ``
-* ``POST_EXCLUDE_FILES ``
-
-Generated Installation Script
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. note::
-
- Use of this feature is not recommended. Please consider using the
- :option:`cmake --install` instead.
-
-The ``install()`` command generates a file, ``cmake_install.cmake``, inside
-the build directory, which is used internally by the generated install target
-and by CPack. You can also invoke this script manually with
-:option:`cmake -P`. This script accepts several variables:
-
-``COMPONENT``
- Set this variable to install only a single CPack component as opposed to all
- of them. For example, if you only want to install the ``Development``
- component, run ``cmake -DCOMPONENT=Development -P cmake_install.cmake``.
-
-``BUILD_TYPE``
- Set this variable to change the build type if you are using a multi-config
- generator. For example, to install with the ``Debug`` configuration, run
- ``cmake -DBUILD_TYPE=Debug -P cmake_install.cmake``.
-
-``DESTDIR``
- This is an environment variable rather than a CMake variable. It allows you
- to change the installation prefix on UNIX systems. See :envvar:`DESTDIR` for
- details.
diff --git a/cmake/share/cmake-3.27/Help/command/set_tests_properties.rst b/cmake/share/cmake-3.27/Help/command/set_tests_properties.rst
deleted file mode 100644
index 63ab60c4..00000000
--- a/cmake/share/cmake-3.27/Help/command/set_tests_properties.rst
+++ /dev/null
@@ -1,23 +0,0 @@
-set_tests_properties
---------------------
-
-Set a property of the tests.
-
-.. code-block:: cmake
-
- set_tests_properties(test1 [test2...] PROPERTIES prop1 value1 prop2 value2)
-
-Sets a property for the tests. If the test is not found, CMake
-will report an error.
-
-Test property values may be specified using
-:manual:`generator expressions `
-for tests created by the :command:`add_test(NAME)` signature.
-
-See Also
-^^^^^^^^
-
-* :command:`add_test`
-* :command:`define_property`
-* the more general :command:`set_property` command
-* :ref:`Target Properties` for the list of properties known to CMake
diff --git a/cmake/share/cmake-3.27/Help/envvar/CTEST_PARALLEL_LEVEL.rst b/cmake/share/cmake-3.27/Help/envvar/CTEST_PARALLEL_LEVEL.rst
deleted file mode 100644
index 3d9da133..00000000
--- a/cmake/share/cmake-3.27/Help/envvar/CTEST_PARALLEL_LEVEL.rst
+++ /dev/null
@@ -1,7 +0,0 @@
-CTEST_PARALLEL_LEVEL
---------------------
-
-.. include:: ENV_VAR.txt
-
-Specify the number of tests for CTest to run in parallel. See :manual:`ctest(1)`
-for more information on parallel test execution.
diff --git a/cmake/share/cmake-3.27/Help/generator/Visual Studio 11 2012.rst b/cmake/share/cmake-3.27/Help/generator/Visual Studio 11 2012.rst
deleted file mode 100644
index e53af83b..00000000
--- a/cmake/share/cmake-3.27/Help/generator/Visual Studio 11 2012.rst
+++ /dev/null
@@ -1,57 +0,0 @@
-Visual Studio 11 2012
----------------------
-
-Deprecated. Generates Visual Studio 11 (VS 2012) project files.
-
-.. note::
- This generator is deprecated and will be removed in a future version
- of CMake. It will still be possible to build with VS 11 2012 tools
- using the :generator:`Visual Studio 12 2013` (or above) generator
- with :variable:`CMAKE_GENERATOR_TOOLSET` set to ``v110``, or by
- using the :generator:`NMake Makefiles` generator.
-
-For compatibility with CMake versions prior to 3.0, one may specify this
-generator using the name "Visual Studio 11" without the year component.
-
-Project Types
-^^^^^^^^^^^^^
-
-Only Visual C++ and C# projects may be generated (and Fortran with
-Intel compiler integration). Other types of projects (JavaScript,
-Database, Website, etc.) are not supported.
-
-Platform Selection
-^^^^^^^^^^^^^^^^^^
-
-The default target platform name (architecture) is ``Win32``.
-
-.. versionadded:: 3.1
- The :variable:`CMAKE_GENERATOR_PLATFORM` variable may be set, perhaps
- via the :option:`cmake -A` option, to specify a target platform
- name (architecture). For example:
-
- * ``cmake -G "Visual Studio 11 2012" -A Win32``
- * ``cmake -G "Visual Studio 11 2012" -A x64``
- * ``cmake -G "Visual Studio 11 2012" -A ARM``
- * ``cmake -G "Visual Studio 11 2012" -A ``
- (Specify a target platform matching a Windows CE SDK name.)
-
-For compatibility with CMake versions prior to 3.1, one may specify
-a target platform name optionally at the end of the generator name.
-This is supported only for:
-
-``Visual Studio 11 2012 Win64``
- Specify target platform ``x64``.
-
-``Visual Studio 11 2012 ARM``
- Specify target platform ``ARM``.
-
-``Visual Studio 11 2012 ``
- Specify target platform matching a Windows CE SDK name.
-
-Toolset Selection
-^^^^^^^^^^^^^^^^^
-
-The ``v110`` toolset that comes with Visual Studio 11 2012 is selected by
-default. The :variable:`CMAKE_GENERATOR_TOOLSET` option may be set, perhaps
-via the :option:`cmake -T` option, to specify another toolset.
diff --git a/cmake/share/cmake-3.27/Help/generator/Visual Studio 9 2008.rst b/cmake/share/cmake-3.27/Help/generator/Visual Studio 9 2008.rst
deleted file mode 100644
index be0620fd..00000000
--- a/cmake/share/cmake-3.27/Help/generator/Visual Studio 9 2008.rst
+++ /dev/null
@@ -1,41 +0,0 @@
-Visual Studio 9 2008
---------------------
-
-Deprecated. Generates Visual Studio 9 2008 project files.
-
-.. note::
- This generator is deprecated and will be removed in a future version
- of CMake. It will still be possible to build with VS 9 2008 tools
- using the :generator:`Visual Studio 12 2013` generator (or above,
- and with VS 10 2010 also installed) with
- :variable:`CMAKE_GENERATOR_TOOLSET` set to ``v90``,
- or by using the :generator:`NMake Makefiles` generator.
-
-Platform Selection
-^^^^^^^^^^^^^^^^^^
-
-The default target platform name (architecture) is ``Win32``.
-
-.. versionadded:: 3.1
- The :variable:`CMAKE_GENERATOR_PLATFORM` variable may be set, perhaps
- via the :option:`cmake -A` option, to specify a target platform
- name (architecture). For example:
-
- * ``cmake -G "Visual Studio 9 2008" -A Win32``
- * ``cmake -G "Visual Studio 9 2008" -A x64``
- * ``cmake -G "Visual Studio 9 2008" -A Itanium``
- * ``cmake -G "Visual Studio 9 2008" -A ``
- (Specify a target platform matching a Windows CE SDK name.)
-
-For compatibility with CMake versions prior to 3.1, one may specify
-a target platform name optionally at the end of the generator name.
-This is supported only for:
-
-``Visual Studio 9 2008 Win64``
- Specify target platform ``x64``.
-
-``Visual Studio 9 2008 IA64``
- Specify target platform ``Itanium``.
-
-``Visual Studio 9 2008 ``
- Specify target platform matching a Windows CE SDK name.
diff --git a/cmake/share/cmake-3.27/Help/policy/CMP0099.rst b/cmake/share/cmake-3.27/Help/policy/CMP0099.rst
deleted file mode 100644
index f4d60b05..00000000
--- a/cmake/share/cmake-3.27/Help/policy/CMP0099.rst
+++ /dev/null
@@ -1,26 +0,0 @@
-CMP0099
--------
-
-.. versionadded:: 3.17
-
-Target link properties :prop_tgt:`INTERFACE_LINK_OPTIONS`,
-:prop_tgt:`INTERFACE_LINK_DIRECTORIES` and :prop_tgt:`INTERFACE_LINK_DEPENDS`
-are now transitive over private dependencies of static libraries.
-
-In CMake 3.16 and below the interface link properties attached to libraries
-are not propagated for private dependencies of static libraries.
-Only the libraries themselves are propagated to link the dependent binary.
-CMake 3.17 and later prefer to propagate all interface link properties.
-This policy provides compatibility for projects that have not been updated
-to expect the new behavior.
-
-The ``OLD`` behavior for this policy is to not propagate interface link
-properties. The ``NEW`` behavior of this policy is to propagate interface link
-properties.
-
-This policy was introduced in CMake version 3.17. Use the
-:command:`cmake_policy` command to set it to ``OLD`` or ``NEW`` explicitly.
-Unlike many policies, CMake version |release| does *not* warn
-when this policy is not set and simply uses ``OLD`` behavior.
-
-.. include:: DEPRECATED.txt
diff --git a/cmake/share/cmake-3.27/Help/policy/CMP0118.rst b/cmake/share/cmake-3.27/Help/policy/CMP0118.rst
deleted file mode 100644
index 4b298eb5..00000000
--- a/cmake/share/cmake-3.27/Help/policy/CMP0118.rst
+++ /dev/null
@@ -1,25 +0,0 @@
-CMP0118
--------
-
-.. versionadded:: 3.20
-
-The :prop_sf:`GENERATED` source file property is now visible in all directories.
-
-Whether or not a source file is generated is an all-or-nothing global
-property of the source. Consequently, the associated ``GENERATED``
-property is now visible from any directory scope, not only from the scope
-for which it was set.
-
-Additionally, the ``GENERATED`` property may now be set only to boolean
-values, and may not be turned off once turned on.
-
-The ``OLD`` behavior of this policy is to only allow ``GENERATED`` to be
-visible from the directory scope for which it was set. The ``NEW``
-behavior on the other hand allows it to be visible from any scope.
-
-This policy was introduced in CMake version 3.20. Use the
-:command:`cmake_policy` command to set it to ``OLD`` or ``NEW`` explicitly.
-Unlike many policies, CMake version |release| does *not* warn
-when this policy is not set and simply uses ``OLD`` behavior with regard
-to visibility of the ``GENERATED`` property. However, CMake does warn
-about setting the ``GENERATED`` property to a non-boolean value.
diff --git a/cmake/share/cmake-3.27/Help/policy/CMP0135.rst b/cmake/share/cmake-3.27/Help/policy/CMP0135.rst
deleted file mode 100644
index 266ed442..00000000
--- a/cmake/share/cmake-3.27/Help/policy/CMP0135.rst
+++ /dev/null
@@ -1,29 +0,0 @@
-CMP0135
--------
-
-.. versionadded:: 3.24
-
-When using the ``URL`` download method with the :command:`ExternalProject_Add`
-command, CMake 3.23 and below sets the timestamps of the extracted contents
-to the same as the timestamps in the archive. When the ``URL`` changes, the
-new archive is downloaded and extracted, but the timestamps of the extracted
-contents might not be newer than the previous contents. Anything that depends
-on the extracted contents might not be rebuilt, even though the contents may
-change.
-
-CMake 3.24 and above prefers to set the timestamps of all extracted contents
-to the time of the extraction. This ensures that anything that depends on the
-extracted contents will be rebuilt whenever the ``URL`` changes.
-
-The ``DOWNLOAD_EXTRACT_TIMESTAMP`` option to the
-:command:`ExternalProject_Add` command can be used to explicitly specify how
-timestamps should be handled. When ``DOWNLOAD_EXTRACT_TIMESTAMP`` is not
-given, this policy controls the default behavior. The ``OLD`` behavior for
-this policy is to restore the timestamps from the archive. The ``NEW``
-behavior sets the timestamps of extracted contents to the time of extraction.
-
-This policy was introduced in CMake version 3.24. CMake version |release|
-warns when the policy is not set and uses ``OLD`` behavior. Use the
-:command:`cmake_policy` command to set it to ``OLD`` or ``NEW`` explicitly.
-
-.. include:: DEPRECATED.txt
diff --git a/cmake/share/cmake-3.27/Help/policy/DISALLOWED_COMMAND.txt b/cmake/share/cmake-3.27/Help/policy/DISALLOWED_COMMAND.txt
deleted file mode 100644
index da547813..00000000
--- a/cmake/share/cmake-3.27/Help/policy/DISALLOWED_COMMAND.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-CMake >= |disallowed_version| prefer that this command never be called.
-The ``OLD`` behavior for this policy is to allow the command to be called.
-The ``NEW`` behavior for this policy is to issue a ``FATAL_ERROR`` when the
-command is called.
-
-This policy was introduced in CMake version |disallowed_version|.
-CMake version |release| warns when the policy is not set and uses
-``OLD`` behavior. Use the :command:`cmake_policy` command to set it to ``OLD`` or
-``NEW`` explicitly.
diff --git a/cmake/share/cmake-3.27/Help/prop_dir/EXCLUDE_FROM_ALL.rst b/cmake/share/cmake-3.27/Help/prop_dir/EXCLUDE_FROM_ALL.rst
deleted file mode 100644
index 119f3efe..00000000
--- a/cmake/share/cmake-3.27/Help/prop_dir/EXCLUDE_FROM_ALL.rst
+++ /dev/null
@@ -1,13 +0,0 @@
-EXCLUDE_FROM_ALL
-----------------
-
-Set this directory property to a true value on a subdirectory to exclude
-its targets from the "all" target of its ancestors. If excluded, running
-e.g. ``make`` in the parent directory will not build targets the
-subdirectory by default. This does not affect the "all" target of the
-subdirectory itself. Running e.g. ``make`` inside the subdirectory will
-still build its targets.
-
-If the :prop_tgt:`EXCLUDE_FROM_ALL` target property is set on a target
-then its value determines whether the target is included in the "all"
-target of this directory and its ancestors.
diff --git a/cmake/share/cmake-3.27/Help/prop_test/FAIL_REGULAR_EXPRESSION.rst b/cmake/share/cmake-3.27/Help/prop_test/FAIL_REGULAR_EXPRESSION.rst
deleted file mode 100644
index 4a93bafa..00000000
--- a/cmake/share/cmake-3.27/Help/prop_test/FAIL_REGULAR_EXPRESSION.rst
+++ /dev/null
@@ -1,19 +0,0 @@
-FAIL_REGULAR_EXPRESSION
------------------------
-
-If the output matches this regular expression the test will fail,
-regardless of the process exit code.
-
-If set, if the output matches one of specified regular expressions,
-the test will fail. Example:
-
-.. code-block:: cmake
-
- set_tests_properties(mytest PROPERTIES
- FAIL_REGULAR_EXPRESSION "[^a-z]Error;ERROR;Failed"
- )
-
-``FAIL_REGULAR_EXPRESSION`` expects a list of regular expressions.
-
-See also the :prop_test:`PASS_REGULAR_EXPRESSION` and
-:prop_test:`SKIP_REGULAR_EXPRESSION` test properties.
diff --git a/cmake/share/cmake-3.27/Help/prop_test/PASS_REGULAR_EXPRESSION.rst b/cmake/share/cmake-3.27/Help/prop_test/PASS_REGULAR_EXPRESSION.rst
deleted file mode 100644
index f5ade110..00000000
--- a/cmake/share/cmake-3.27/Help/prop_test/PASS_REGULAR_EXPRESSION.rst
+++ /dev/null
@@ -1,20 +0,0 @@
-PASS_REGULAR_EXPRESSION
------------------------
-
-The output must match this regular expression for the test to pass.
-The process exit code is ignored.
-
-If set, the test output will be checked against the specified regular
-expressions and at least one of the regular expressions has to match,
-otherwise the test will fail. Example:
-
-.. code-block:: cmake
-
- set_tests_properties(mytest PROPERTIES
- PASS_REGULAR_EXPRESSION "TestPassed;All ok"
- )
-
-``PASS_REGULAR_EXPRESSION`` expects a list of regular expressions.
-
-See also the :prop_test:`FAIL_REGULAR_EXPRESSION` and
-:prop_test:`SKIP_REGULAR_EXPRESSION` test properties.
diff --git a/cmake/share/cmake-3.27/Help/prop_test/SKIP_REGULAR_EXPRESSION.rst b/cmake/share/cmake-3.27/Help/prop_test/SKIP_REGULAR_EXPRESSION.rst
deleted file mode 100644
index d69cf4f9..00000000
--- a/cmake/share/cmake-3.27/Help/prop_test/SKIP_REGULAR_EXPRESSION.rst
+++ /dev/null
@@ -1,21 +0,0 @@
-SKIP_REGULAR_EXPRESSION
------------------------
-
-.. versionadded:: 3.16
-
-If the output matches this regular expression the test will be marked as skipped.
-
-If set, if the output matches one of specified regular expressions,
-the test will be marked as skipped. Example:
-
-.. code-block:: cmake
-
- set_property(TEST mytest PROPERTY
- SKIP_REGULAR_EXPRESSION "[^a-z]Skip" "SKIP" "Skipped"
- )
-
-``SKIP_REGULAR_EXPRESSION`` expects a list of regular expressions.
-
-See also the :prop_test:`SKIP_RETURN_CODE`,
-:prop_test:`PASS_REGULAR_EXPRESSION`, and :prop_test:`FAIL_REGULAR_EXPRESSION`
-test properties.
diff --git a/cmake/share/cmake-3.27/Help/prop_test/SKIP_RETURN_CODE.rst b/cmake/share/cmake-3.27/Help/prop_test/SKIP_RETURN_CODE.rst
deleted file mode 100644
index dae26233..00000000
--- a/cmake/share/cmake-3.27/Help/prop_test/SKIP_RETURN_CODE.rst
+++ /dev/null
@@ -1,12 +0,0 @@
-SKIP_RETURN_CODE
-----------------
-
-Return code to mark a test as skipped.
-
-Sometimes only a test itself can determine if all requirements for the
-test are met. If such a situation should not be considered a hard failure
-a return code of the process can be specified that will mark the test as
-``Not Run`` if it is encountered. Valid values are in the range of
-0 to 255, inclusive.
-
-See also the :prop_test:`SKIP_REGULAR_EXPRESSION` property.
diff --git a/cmake/share/cmake-3.27/Help/prop_test/WILL_FAIL.rst b/cmake/share/cmake-3.27/Help/prop_test/WILL_FAIL.rst
deleted file mode 100644
index 5ec47fdb..00000000
--- a/cmake/share/cmake-3.27/Help/prop_test/WILL_FAIL.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-WILL_FAIL
----------
-
-If set to true, this will invert the pass/fail flag of the test.
-
-This property can be used for tests that are expected to fail and return a
-non-zero return code. Note that system-level test failures such as segmentation
-faults or heap errors will still fail the test even if ``WILL_FALL`` is true.
diff --git a/cmake/share/cmake-3.27/Help/prop_tgt/AUTOGEN_ORIGIN_DEPENDS.rst b/cmake/share/cmake-3.27/Help/prop_tgt/AUTOGEN_ORIGIN_DEPENDS.rst
deleted file mode 100644
index 964030a4..00000000
--- a/cmake/share/cmake-3.27/Help/prop_tgt/AUTOGEN_ORIGIN_DEPENDS.rst
+++ /dev/null
@@ -1,40 +0,0 @@
-AUTOGEN_ORIGIN_DEPENDS
-----------------------
-
-.. versionadded:: 3.14
-
-Switch for forwarding origin target dependencies to the corresponding
-``_autogen`` target.
-
-Targets which have their :prop_tgt:`AUTOMOC` or :prop_tgt:`AUTOUIC` property
-``ON`` have a corresponding ``_autogen`` target which generates
-``moc`` and ``uic`` files. As this ``_autogen`` target is created at
-generate-time, it is not possible to define dependencies of it using
-e.g. :command:`add_dependencies`. Instead the
-``AUTOGEN_ORIGIN_DEPENDS`` target property decides whether the origin
-target dependencies should be forwarded to the ``_autogen`` target or not.
-
-By default ``AUTOGEN_ORIGIN_DEPENDS`` is initialized from
-:variable:`CMAKE_AUTOGEN_ORIGIN_DEPENDS` which is ``ON`` by default.
-
-In total the dependencies of the ``_autogen`` target are composed from
-
-- forwarded origin target dependencies
- (enabled by default via ``AUTOGEN_ORIGIN_DEPENDS``)
-- additional user defined dependencies from :prop_tgt:`AUTOGEN_TARGET_DEPENDS`
-
-See the :manual:`cmake-qt(7)` manual for more information on using CMake
-with Qt.
-
-Note
-^^^^
-
-Disabling ``AUTOGEN_ORIGIN_DEPENDS`` is useful to avoid building of
-origin target dependencies when building the ``_autogen`` target only.
-This is especially interesting when a
-:variable:`global autogen target ` is enabled.
-
-When the ``_autogen`` target doesn't require all the origin target's
-dependencies, and ``AUTOGEN_ORIGIN_DEPENDS`` is disabled, it might be
-necessary to extend :prop_tgt:`AUTOGEN_TARGET_DEPENDS` to add missing
-dependencies.
diff --git a/cmake/share/cmake-3.27/Help/prop_tgt/AUTOGEN_TARGET_DEPENDS.rst b/cmake/share/cmake-3.27/Help/prop_tgt/AUTOGEN_TARGET_DEPENDS.rst
deleted file mode 100644
index 7a86a56c..00000000
--- a/cmake/share/cmake-3.27/Help/prop_tgt/AUTOGEN_TARGET_DEPENDS.rst
+++ /dev/null
@@ -1,36 +0,0 @@
-AUTOGEN_TARGET_DEPENDS
-----------------------
-
-Additional target dependencies of the corresponding ``_autogen`` target.
-
-Targets which have their :prop_tgt:`AUTOMOC` or :prop_tgt:`AUTOUIC` property
-``ON`` have a corresponding ``_autogen`` target which generates
-``moc`` and ``uic`` files. As this ``_autogen`` target is created at
-generate-time, it is not possible to define dependencies of it using
-e.g. :command:`add_dependencies`. Instead the
-``AUTOGEN_TARGET_DEPENDS`` target property can be set to a
-:ref:`;-list ` of additional dependencies for the
-``_autogen`` target. Dependencies can be target names or file names.
-
-In total the dependencies of the ``_autogen`` target are composed from
-
-- forwarded origin target dependencies
- (enabled by default via :prop_tgt:`AUTOGEN_ORIGIN_DEPENDS`)
-- additional user defined dependencies from ``AUTOGEN_TARGET_DEPENDS``
-
-See the :manual:`cmake-qt(7)` manual for more information on using CMake
-with Qt.
-
-Use cases
-^^^^^^^^^
-
-If :prop_tgt:`AUTOMOC` or :prop_tgt:`AUTOUIC` depends on a file that is either
-
-- a :prop_sf:`GENERATED` non C++ file (e.g. a :prop_sf:`GENERATED` ``.json``
- or ``.ui`` file) or
-- a :prop_sf:`GENERATED` C++ file that isn't recognized by :prop_tgt:`AUTOMOC`
- and :prop_tgt:`AUTOUIC` because it's skipped by :prop_sf:`SKIP_AUTOMOC`,
- :prop_sf:`SKIP_AUTOUIC`, :prop_sf:`SKIP_AUTOGEN` or :policy:`CMP0071` or
-- a file that isn't in the origin target's sources
-
-it must be added to ``AUTOGEN_TARGET_DEPENDS``.
diff --git a/cmake/share/cmake-3.27/Help/prop_tgt/IMPORTED_IMPLIB.rst b/cmake/share/cmake-3.27/Help/prop_tgt/IMPORTED_IMPLIB.rst
deleted file mode 100644
index 94920bb1..00000000
--- a/cmake/share/cmake-3.27/Help/prop_tgt/IMPORTED_IMPLIB.rst
+++ /dev/null
@@ -1,24 +0,0 @@
-IMPORTED_IMPLIB
----------------
-
-Full path to the import library for an ``IMPORTED`` target.
-
-This property may be set:
-
-* On DLL platforms, to the location of the ``.lib`` part of the DLL.
-* On AIX, to an import file (e.g. ``.imp``) created for executables that export
- symbols (see the :prop_tgt:`ENABLE_EXPORTS` target property).
-* On macOS, to an import file (e.g. ``.tbd``) created for shared libraries (see
- the :prop_tgt:`ENABLE_EXPORTS` target property). For frameworks this is the
- location of the ``.tbd`` file symlink just inside the framework folder.
-
-The ``IMPORTED_IMPLIB`` target property may be overridden for a
-given configuration ```` by the configuration-specific
-:prop_tgt:`IMPORTED_IMPLIB_` target property. Furthermore,
-the :prop_tgt:`MAP_IMPORTED_CONFIG_` target property may be
-used to map between a project's configurations and those of an imported
-target. If none of these is set then the name of any other configuration
-listed in the :prop_tgt:`IMPORTED_CONFIGURATIONS` target property may be
-selected and its :prop_tgt:`IMPORTED_IMPLIB_` value used.
-
-This property is ignored for non-imported targets.
diff --git a/cmake/share/cmake-3.27/Help/prop_tgt/IOS_INSTALL_COMBINED.rst b/cmake/share/cmake-3.27/Help/prop_tgt/IOS_INSTALL_COMBINED.rst
deleted file mode 100644
index ae4d8830..00000000
--- a/cmake/share/cmake-3.27/Help/prop_tgt/IOS_INSTALL_COMBINED.rst
+++ /dev/null
@@ -1,19 +0,0 @@
-IOS_INSTALL_COMBINED
---------------------
-
-.. versionadded:: 3.5
-
-Build a combined (device and simulator) target when installing.
-
-When this property is set to set to false (which is the default) then it will
-either be built with the device SDK or the simulator SDK depending on the SDK
-set. But if this property is set to true then the target will at install time
-also be built for the corresponding SDK and combined into one library.
-
-.. note::
-
- If a selected architecture is available for both: device SDK and simulator
- SDK it will be built for the SDK selected by :variable:`CMAKE_OSX_SYSROOT`
- and removed from the corresponding SDK.
-
-This feature requires at least Xcode version 6.
diff --git a/cmake/share/cmake-3.27/Help/prop_tgt/Swift_LANGUAGE_VERSION.rst b/cmake/share/cmake-3.27/Help/prop_tgt/Swift_LANGUAGE_VERSION.rst
deleted file mode 100644
index 9e5ddfd7..00000000
--- a/cmake/share/cmake-3.27/Help/prop_tgt/Swift_LANGUAGE_VERSION.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-Swift_LANGUAGE_VERSION
-----------------------
-
-.. versionadded:: 3.16
-
-This property sets the language version for the Swift sources in the target. If
-one is not specified, it will default to ```` if
-specified, otherwise it is the latest version supported by the compiler.
diff --git a/cmake/share/cmake-3.27/Help/prop_tgt/VS_KEYWORD.rst b/cmake/share/cmake-3.27/Help/prop_tgt/VS_KEYWORD.rst
deleted file mode 100644
index a02c50ce..00000000
--- a/cmake/share/cmake-3.27/Help/prop_tgt/VS_KEYWORD.rst
+++ /dev/null
@@ -1,10 +0,0 @@
-VS_KEYWORD
-----------
-
-Visual Studio project keyword for VS 9 (2008) and older.
-
-Can be set to change the visual studio keyword, for example Qt
-integration works better if this is set to Qt4VSv1.0.
-
-Use the :prop_tgt:`VS_GLOBAL_KEYWORD` target property to set the
-keyword for Visual Studio 11 (2012) and newer.
diff --git a/cmake/share/cmake-3.27/Help/variable/BUILD_SHARED_LIBS.rst b/cmake/share/cmake-3.27/Help/variable/BUILD_SHARED_LIBS.rst
deleted file mode 100644
index 0d02d9d3..00000000
--- a/cmake/share/cmake-3.27/Help/variable/BUILD_SHARED_LIBS.rst
+++ /dev/null
@@ -1,10 +0,0 @@
-BUILD_SHARED_LIBS
------------------
-
-Global flag to cause :command:`add_library` to create shared libraries if on.
-
-If present and true, this will cause all libraries to be built shared
-unless the library was explicitly added as a static library. This
-variable is often added to projects as an :command:`option` so that each user
-of a project can decide if they want to build the project using shared or
-static libraries.
diff --git a/cmake/share/cmake-3.27/Help/variable/CMAKE_CUDA_HOST_COMPILER.rst b/cmake/share/cmake-3.27/Help/variable/CMAKE_CUDA_HOST_COMPILER.rst
deleted file mode 100644
index 9a9ca7f0..00000000
--- a/cmake/share/cmake-3.27/Help/variable/CMAKE_CUDA_HOST_COMPILER.rst
+++ /dev/null
@@ -1,29 +0,0 @@
-CMAKE_CUDA_HOST_COMPILER
-------------------------
-
-.. versionadded:: 3.10
-
-When :variable:`CMAKE_CUDA_COMPILER_ID _COMPILER_ID>` is
-``NVIDIA``, ``CMAKE_CUDA_HOST_COMPILER`` selects the compiler executable to use
-when compiling host code for ``CUDA`` language files.
-This maps to the ``nvcc -ccbin`` option.
-
-The ``CMAKE_CUDA_HOST_COMPILER`` variable may be set explicitly before CUDA is
-first enabled by a :command:`project` or :command:`enable_language` command.
-This can be done via ``-DCMAKE_CUDA_HOST_COMPILER=...`` on the command line
-or in a :ref:`toolchain file `. Or, one may set
-the :envvar:`CUDAHOSTCXX` environment variable to provide a default value.
-
-Once the CUDA language is enabled, the ``CMAKE_CUDA_HOST_COMPILER`` variable
-is read-only and changes to it are undefined behavior.
-
-.. note::
-
- Since ``CMAKE_CUDA_HOST_COMPILER`` is meaningful only when the
- :variable:`CMAKE_CUDA_COMPILER_ID _COMPILER_ID>` is ``NVIDIA``,
- it does not make sense to set ``CMAKE_CUDA_HOST_COMPILER`` without also
- setting ``CMAKE_CUDA_COMPILER`` to NVCC.
-
-.. note::
-
- Ignored when using :ref:`Visual Studio Generators`.
diff --git a/cmake/share/cmake-3.27/Help/variable/CMAKE_FIND_LIBRARY_SUFFIXES.rst b/cmake/share/cmake-3.27/Help/variable/CMAKE_FIND_LIBRARY_SUFFIXES.rst
deleted file mode 100644
index b65cf286..00000000
--- a/cmake/share/cmake-3.27/Help/variable/CMAKE_FIND_LIBRARY_SUFFIXES.rst
+++ /dev/null
@@ -1,12 +0,0 @@
-CMAKE_FIND_LIBRARY_SUFFIXES
----------------------------
-
-Suffixes to append when looking for libraries.
-
-This specifies what suffixes to add to library names when the
-:command:`find_library` command looks for libraries. On Windows systems this
-is typically ``.lib`` and, depending on the compiler, ``.dll.a``, ``.a``
-(e.g. GCC and Clang), so when it tries to find the ``foo`` library, it will
-look for ``[]foo.lib`` and/or ``[]foo[.dll].a``, depending on
-the compiler used and the ```` specified in the
-:variable:`CMAKE_FIND_LIBRARY_PREFIXES`.
diff --git a/cmake/share/cmake-3.27/Help/variable/CMAKE_HIP_ARCHITECTURES.rst b/cmake/share/cmake-3.27/Help/variable/CMAKE_HIP_ARCHITECTURES.rst
deleted file mode 100644
index ce65706d..00000000
--- a/cmake/share/cmake-3.27/Help/variable/CMAKE_HIP_ARCHITECTURES.rst
+++ /dev/null
@@ -1,12 +0,0 @@
-CMAKE_HIP_ARCHITECTURES
------------------------
-
-.. versionadded:: 3.21
-
-Default value for :prop_tgt:`HIP_ARCHITECTURES` property of targets.
-
-This is initialized to the architectures reported by ``rocm_agent_enumerator``,
-if available, and otherwise to the default chosen by the compiler.
-
-This variable is used to initialize the :prop_tgt:`HIP_ARCHITECTURES` property
-on all targets. See the target property for additional information.
diff --git a/cmake/share/cmake-3.27/Help/variable/CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT.rst b/cmake/share/cmake-3.27/Help/variable/CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT.rst
deleted file mode 100644
index 0bf22237..00000000
--- a/cmake/share/cmake-3.27/Help/variable/CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT.rst
+++ /dev/null
@@ -1,16 +0,0 @@
-CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT
--------------------------------------------
-
-.. versionadded:: 3.7.1
-
-CMake sets this variable to a ``TRUE`` value when the
-:variable:`CMAKE_INSTALL_PREFIX` has just been initialized to
-its default value, typically on the first run of CMake within
-a new build tree. This can be used by project code to change
-the default without overriding a user-provided value:
-
-.. code-block:: cmake
-
- if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
- set(CMAKE_INSTALL_PREFIX "/my/default" CACHE PATH "..." FORCE)
- endif()
diff --git a/cmake/share/cmake-3.27/Help/variable/CMAKE_MODULE_PATH.rst b/cmake/share/cmake-3.27/Help/variable/CMAKE_MODULE_PATH.rst
deleted file mode 100644
index 015c4711..00000000
--- a/cmake/share/cmake-3.27/Help/variable/CMAKE_MODULE_PATH.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-CMAKE_MODULE_PATH
------------------
-
-:ref:`Semicolon-separated list ` of directories,
-represented using forward slashes, specifying a search path for CMake modules
-to be loaded by the :command:`include` or :command:`find_package` commands
-before checking the default modules that come with CMake. By default it is
-empty. It is intended to be set by the project.
diff --git a/cmake/share/cmake-3.27/Help/variable/CMAKE_REQUIRE_FIND_PACKAGE_PackageName.rst b/cmake/share/cmake-3.27/Help/variable/CMAKE_REQUIRE_FIND_PACKAGE_PackageName.rst
deleted file mode 100644
index 872f2c6f..00000000
--- a/cmake/share/cmake-3.27/Help/variable/CMAKE_REQUIRE_FIND_PACKAGE_PackageName.rst
+++ /dev/null
@@ -1,14 +0,0 @@
-CMAKE_REQUIRE_FIND_PACKAGE_
-----------------------------------------
-
-.. versionadded:: 3.22
-
-Variable for making :command:`find_package` call ``REQUIRED``.
-
-Every non-``REQUIRED`` :command:`find_package` call in a project can be
-turned into ``REQUIRED`` by setting the variable
-``CMAKE_REQUIRE_FIND_PACKAGE_`` to ``TRUE``.
-This can be used to assert assumptions about build environment and to
-ensure the build will fail early if they do not hold.
-
-See also the :variable:`CMAKE_DISABLE_FIND_PACKAGE_` variable.
diff --git a/cmake/share/cmake-3.27/Help/variable/CMAKE_SYSTEM_NAME.rst b/cmake/share/cmake-3.27/Help/variable/CMAKE_SYSTEM_NAME.rst
deleted file mode 100644
index 3c54fdf0..00000000
--- a/cmake/share/cmake-3.27/Help/variable/CMAKE_SYSTEM_NAME.rst
+++ /dev/null
@@ -1,23 +0,0 @@
-CMAKE_SYSTEM_NAME
------------------
-
-The name of the operating system for which CMake is to build.
-See the :variable:`CMAKE_SYSTEM_VERSION` variable for the OS version.
-
-Note that ``CMAKE_SYSTEM_NAME`` is not set to anything by default when running
-in script mode, since it's not building anything.
-
-System Name for Host Builds
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-``CMAKE_SYSTEM_NAME`` is by default set to the same value as the
-:variable:`CMAKE_HOST_SYSTEM_NAME` variable so that the build
-targets the host system.
-
-System Name for Cross Compiling
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-``CMAKE_SYSTEM_NAME`` may be set explicitly when first configuring a new build
-tree in order to enable :ref:`cross compiling `.
-In this case the :variable:`CMAKE_SYSTEM_VERSION` variable must also be
-set explicitly.
diff --git a/cmake/share/cmake-3.27/Modules/CMakeCUDACompilerABI.cu b/cmake/share/cmake-3.27/Modules/CMakeCUDACompilerABI.cu
deleted file mode 100644
index fd022c48..00000000
--- a/cmake/share/cmake-3.27/Modules/CMakeCUDACompilerABI.cu
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef __CUDACC__
-# error "A C or C++ compiler has been selected for CUDA"
-#endif
-
-#include
-
-#include
-
-#include "CMakeCompilerABI.h"
-
-int main(int argc, char* argv[])
-{
- int require = 0;
- require += info_sizeof_dptr[argc];
- require += info_byte_order_big_endian[argc];
- require += info_byte_order_little_endian[argc];
-#if defined(ABI_ID)
- require += info_abi[argc];
-#endif
- static_cast(argv);
-
- int count = 0;
- if (cudaGetDeviceCount(&count) != cudaSuccess || count == 0) {
- std::fprintf(stderr, "No CUDA devices found.\n");
- return -1;
- }
-
- int found = 0;
- const char* sep = "";
- for (int device = 0; device < count; ++device) {
- cudaDeviceProp prop;
- if (cudaGetDeviceProperties(&prop, device) == cudaSuccess) {
- std::printf("%s%d%d", sep, prop.major, prop.minor);
- sep = ";";
- found = 1;
- }
- }
-
- if (!found) {
- std::fprintf(stderr, "No CUDA architecture detected from any devices.\n");
- // Convince the compiler that the non-zero return value depends
- // on the info strings so they are not optimized out.
- return require ? -1 : 1;
- }
-
- return 0;
-}
diff --git a/cmake/share/cmake-3.27/Modules/CMakeCommonLanguageInclude.cmake b/cmake/share/cmake-3.27/Modules/CMakeCommonLanguageInclude.cmake
deleted file mode 100644
index 5eb10882..00000000
--- a/cmake/share/cmake-3.27/Modules/CMakeCommonLanguageInclude.cmake
+++ /dev/null
@@ -1,23 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-
-# this file has flags that are shared across languages and sets
-# cache values that can be initialized in the platform-compiler.cmake file
-# it may be included by more than one language.
-
-string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " $ENV{LDFLAGS}")
-string(APPEND CMAKE_SHARED_LINKER_FLAGS_INIT " $ENV{LDFLAGS}")
-string(APPEND CMAKE_MODULE_LINKER_FLAGS_INIT " $ENV{LDFLAGS}")
-
-cmake_initialize_per_config_variable(CMAKE_EXE_LINKER_FLAGS "Flags used by the linker")
-cmake_initialize_per_config_variable(CMAKE_SHARED_LINKER_FLAGS "Flags used by the linker during the creation of shared libraries")
-cmake_initialize_per_config_variable(CMAKE_MODULE_LINKER_FLAGS "Flags used by the linker during the creation of modules")
-cmake_initialize_per_config_variable(CMAKE_STATIC_LINKER_FLAGS "Flags used by the linker during the creation of static libraries")
-
-# Alias the build tool variable for backward compatibility.
-set(CMAKE_BUILD_TOOL ${CMAKE_MAKE_PROGRAM})
-
-mark_as_advanced(
-CMAKE_VERBOSE_MAKEFILE
-)
diff --git a/cmake/share/cmake-3.27/Modules/CMakeDetermineCUDACompiler.cmake b/cmake/share/cmake-3.27/Modules/CMakeDetermineCUDACompiler.cmake
deleted file mode 100644
index 34bd4a84..00000000
--- a/cmake/share/cmake-3.27/Modules/CMakeDetermineCUDACompiler.cmake
+++ /dev/null
@@ -1,624 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
-include(${CMAKE_ROOT}/Modules/CMakeParseImplicitLinkInfo.cmake)
-
-if( NOT ( ("${CMAKE_GENERATOR}" MATCHES "Make") OR
- ("${CMAKE_GENERATOR}" MATCHES "Ninja") OR
- ("${CMAKE_GENERATOR}" MATCHES "Visual Studio (1|[9][0-9])") ) )
- message(FATAL_ERROR "CUDA language not currently supported by \"${CMAKE_GENERATOR}\" generator")
-endif()
-
-if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
- if(DEFINED ENV{CUDAHOSTCXX} OR DEFINED CMAKE_CUDA_HOST_COMPILER)
- message(WARNING "Visual Studio does not support specifying CUDAHOSTCXX or CMAKE_CUDA_HOST_COMPILER. Using the C++ compiler provided by Visual Studio.")
- endif()
-else()
- if(NOT CMAKE_CUDA_COMPILER)
- set(CMAKE_CUDA_COMPILER_INIT NOTFOUND)
-
- # prefer the environment variable CUDACXX
- if(NOT $ENV{CUDACXX} STREQUAL "")
- get_filename_component(CMAKE_CUDA_COMPILER_INIT $ENV{CUDACXX} PROGRAM PROGRAM_ARGS CMAKE_CUDA_FLAGS_ENV_INIT)
- if(CMAKE_CUDA_FLAGS_ENV_INIT)
- set(CMAKE_CUDA_COMPILER_ARG1 "${CMAKE_CUDA_FLAGS_ENV_INIT}" CACHE STRING "Arguments to CUDA compiler")
- endif()
- if(NOT EXISTS ${CMAKE_CUDA_COMPILER_INIT})
- message(FATAL_ERROR "Could not find compiler set in environment variable CUDACXX:\n$ENV{CUDACXX}.\n${CMAKE_CUDA_COMPILER_INIT}")
- endif()
- endif()
-
- # finally list compilers to try
- if(NOT CMAKE_CUDA_COMPILER_INIT)
- set(CMAKE_CUDA_COMPILER_LIST nvcc)
- endif()
-
- set(_CMAKE_CUDA_COMPILER_PATHS "$ENV{CUDA_PATH}/bin")
- _cmake_find_compiler(CUDA)
- unset(_CMAKE_CUDA_COMPILER_PATHS)
- else()
- _cmake_find_compiler_path(CUDA)
- endif()
-
- mark_as_advanced(CMAKE_CUDA_COMPILER)
-
- #Allow the user to specify a host compiler except for Visual Studio
- if(NOT $ENV{CUDAHOSTCXX} STREQUAL "")
- get_filename_component(CMAKE_CUDA_HOST_COMPILER $ENV{CUDAHOSTCXX} PROGRAM)
- if(NOT EXISTS ${CMAKE_CUDA_HOST_COMPILER})
- message(FATAL_ERROR "Could not find compiler set in environment variable CUDAHOSTCXX:\n$ENV{CUDAHOSTCXX}.\n${CMAKE_CUDA_HOST_COMPILER}")
- endif()
- endif()
-endif()
-
-if(NOT "$ENV{CUDAARCHS}" STREQUAL "")
- set(CMAKE_CUDA_ARCHITECTURES "$ENV{CUDAARCHS}" CACHE STRING "CUDA architectures")
-endif()
-
-# Build a small source file to identify the compiler.
-if(NOT CMAKE_CUDA_COMPILER_ID_RUN)
- set(CMAKE_CUDA_COMPILER_ID_RUN 1)
-
- include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
-
- if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
- # We will not know CMAKE_CUDA_COMPILER until the main compiler id step
- # below extracts it, but we do know that the compiler id will be NVIDIA.
- set(CMAKE_CUDA_COMPILER_ID "NVIDIA")
- else()
- # We determine the vendor to help with find the toolkit and use the right flags for detection right away.
- # The main compiler identification is still needed below to extract other information.
- list(APPEND CMAKE_CUDA_COMPILER_ID_VENDORS NVIDIA Clang)
- set(CMAKE_CUDA_COMPILER_ID_VENDOR_REGEX_NVIDIA "nvcc: NVIDIA \\(R\\) Cuda compiler driver")
- set(CMAKE_CUDA_COMPILER_ID_VENDOR_REGEX_Clang "(clang version)")
- CMAKE_DETERMINE_COMPILER_ID_VENDOR(CUDA "--version")
-
- if(CMAKE_CUDA_COMPILER_ID STREQUAL "Clang" AND WIN32)
- message(FATAL_ERROR "Clang with CUDA is not yet supported on Windows. See CMake issue #20776.")
- endif()
-
- # Find the CUDA toolkit. We store the CMAKE_CUDA_COMPILER_TOOLKIT_ROOT, CMAKE_CUDA_COMPILER_TOOLKIT_VERSION and
- # CMAKE_CUDA_COMPILER_LIBRARY_ROOT in CMakeCUDACompiler.cmake so FindCUDAToolkit can avoid searching on future
- # runs and the toolkit is the same.
- # This is very similar to FindCUDAToolkit, but somewhat simplified since we can issue fatal errors
- # if we fail and we don't need to account for searching the libraries.
-
- # For NVCC we can easily deduce the SDK binary directory from the compiler path.
- if(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
- set(_CUDA_NVCC_EXECUTABLE "${CMAKE_CUDA_COMPILER}")
- else()
- # Search using CUDAToolkit_ROOT and then CUDA_PATH for equivalence with FindCUDAToolkit.
- # In FindCUDAToolkit CUDAToolkit_ROOT is searched automatically due to being in a find_package().
- # First we search candidate non-default paths to give them priority.
- find_program(_CUDA_NVCC_EXECUTABLE
- NAMES nvcc nvcc.exe
- PATHS ${CUDAToolkit_ROOT}
- ENV CUDAToolkit_ROOT
- ENV CUDA_PATH
- PATH_SUFFIXES bin
- NO_DEFAULT_PATH
- )
-
- # If we didn't find NVCC, then try the default paths.
- find_program(_CUDA_NVCC_EXECUTABLE
- NAMES nvcc nvcc.exe
- PATH_SUFFIXES bin
- )
-
- # If the user specified CUDAToolkit_ROOT but nvcc could not be found, this is an error.
- if(NOT _CUDA_NVCC_EXECUTABLE AND (DEFINED CUDAToolkit_ROOT OR DEFINED ENV{CUDAToolkit_ROOT}))
- set(fail_base "Could not find nvcc executable in path specified by")
-
- if(DEFINED CUDAToolkit_ROOT)
- message(FATAL_ERROR "${fail_base} CUDAToolkit_ROOT=${CUDAToolkit_ROOT}")
- elseif(DEFINED ENV{CUDAToolkit_ROOT})
- message(FATAL_ERROR "${fail_base} environment variable CUDAToolkit_ROOT=$ENV{CUDAToolkit_ROOT}")
- endif()
- endif()
-
- # CUDAToolkit_ROOT cmake/env variable not specified, try platform defaults.
- #
- # - Linux: /usr/local/cuda-X.Y
- # - macOS: /Developer/NVIDIA/CUDA-X.Y
- # - Windows: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\vX.Y
- #
- # We will also search the default symlink location /usr/local/cuda first since
- # if CUDAToolkit_ROOT is not specified, it is assumed that the symlinked
- # directory is the desired location.
- if(NOT _CUDA_NVCC_EXECUTABLE)
- if(UNIX)
- if(NOT APPLE)
- set(platform_base "/usr/local/cuda-")
- else()
- set(platform_base "/Developer/NVIDIA/CUDA-")
- endif()
- else()
- set(platform_base "C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v")
- endif()
-
- # Build out a descending list of possible cuda installations, e.g.
- file(GLOB possible_paths "${platform_base}*")
- # Iterate the glob results and create a descending list.
- set(versions)
- foreach(p ${possible_paths})
- # Extract version number from end of string
- string(REGEX MATCH "[0-9][0-9]?\\.[0-9]$" p_version ${p})
- if(IS_DIRECTORY ${p} AND p_version)
- list(APPEND versions ${p_version})
- endif()
- endforeach()
-
- # Sort numerically in descending order, so we try the newest versions first.
- list(SORT versions COMPARE NATURAL ORDER DESCENDING)
-
- # With a descending list of versions, populate possible paths to search.
- set(search_paths)
- foreach(v ${versions})
- list(APPEND search_paths "${platform_base}${v}")
- endforeach()
-
- # Force the global default /usr/local/cuda to the front on Unix.
- if(UNIX)
- list(INSERT search_paths 0 "/usr/local/cuda")
- endif()
-
- # Now search for nvcc again using the platform default search paths.
- find_program(_CUDA_NVCC_EXECUTABLE
- NAMES nvcc nvcc.exe
- PATHS ${search_paths}
- PATH_SUFFIXES bin
- )
-
- # We are done with these variables now, cleanup.
- unset(platform_base)
- unset(possible_paths)
- unset(versions)
- unset(search_paths)
-
- if(NOT _CUDA_NVCC_EXECUTABLE)
- message(FATAL_ERROR "Failed to find nvcc.\nCompiler ${CMAKE_CUDA_COMPILER_ID} requires the CUDA toolkit. Please set the CUDAToolkit_ROOT variable.")
- endif()
- endif()
- endif()
-
- # Given that NVCC can be provided by multiple different sources (NVIDIA HPC SDK, CUDA Toolkit, distro)
- # each of which has a different layout, we need to extract the CUDA toolkit root from the compiler
- # itself, allowing us to support numerous different scattered toolkit layouts
- execute_process(COMMAND ${_CUDA_NVCC_EXECUTABLE} "-v" "__cmake_determine_cuda"
- OUTPUT_VARIABLE _CUDA_NVCC_OUT ERROR_VARIABLE _CUDA_NVCC_OUT)
- if(_CUDA_NVCC_OUT MATCHES "\\#\\$ TOP=([^\r\n]*)")
- get_filename_component(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "${CMAKE_MATCH_1}" ABSOLUTE)
- else()
- get_filename_component(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "${_CUDA_NVCC_EXECUTABLE}" DIRECTORY)
- get_filename_component(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}" DIRECTORY)
- endif()
-
- if(_CUDA_NVCC_OUT MATCHES "\\#\\$ NVVMIR_LIBRARY_DIR=([^\r\n]*)")
- get_filename_component(_CUDA_NVVMIR_LIBRARY_DIR "${CMAKE_MATCH_1}" ABSOLUTE)
-
- #We require the path to end in `/nvvm/libdevice'
- if(_CUDA_NVVMIR_LIBRARY_DIR MATCHES "nvvm/libdevice$")
- get_filename_component(_CUDA_NVVMIR_LIBRARY_DIR "${_CUDA_NVVMIR_LIBRARY_DIR}/../.." ABSOLUTE)
- set(CMAKE_CUDA_COMPILER_LIBRARY_ROOT_FROM_NVVMIR_LIBRARY_DIR "${_CUDA_NVVMIR_LIBRARY_DIR}")
- endif()
-
- unset(_CUDA_NVVMIR_LIBRARY_DIR)
- unset(_cuda_nvvmir_dir_name)
- endif()
- unset(_CUDA_NVCC_OUT)
-
- set(CMAKE_CUDA_DEVICE_LINKER "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}/bin/nvlink${CMAKE_EXECUTABLE_SUFFIX}")
- set(CMAKE_CUDA_FATBINARY "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}/bin/fatbinary${CMAKE_EXECUTABLE_SUFFIX}")
-
- # In a non-scattered installation the following are equivalent to CMAKE_CUDA_COMPILER_TOOLKIT_ROOT.
- # We first check for a non-scattered installation to prefer it over a scattered installation.
-
- # CMAKE_CUDA_COMPILER_LIBRARY_ROOT contains the device library.
- if(DEFINED CMAKE_CUDA_COMPILER_LIBRARY_ROOT_FROM_NVVMIR_LIBRARY_DIR)
- set(CMAKE_CUDA_COMPILER_LIBRARY_ROOT "${CMAKE_CUDA_COMPILER_LIBRARY_ROOT_FROM_NVVMIR_LIBRARY_DIR}")
- elseif(EXISTS "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}/nvvm/libdevice")
- set(CMAKE_CUDA_COMPILER_LIBRARY_ROOT "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}")
- elseif(CMAKE_SYSROOT_LINK AND EXISTS "${CMAKE_SYSROOT_LINK}/usr/lib/cuda/nvvm/libdevice")
- set(CMAKE_CUDA_COMPILER_LIBRARY_ROOT "${CMAKE_SYSROOT_LINK}/usr/lib/cuda")
- elseif(EXISTS "${CMAKE_SYSROOT}/usr/lib/cuda/nvvm/libdevice")
- set(CMAKE_CUDA_COMPILER_LIBRARY_ROOT "${CMAKE_SYSROOT}/usr/lib/cuda")
- else()
- message(FATAL_ERROR "Couldn't find CUDA library root.")
- endif()
- unset(CMAKE_CUDA_COMPILER_LIBRARY_ROOT_FROM_NVVMIR_LIBRARY_DIR)
-
- # CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT contains the linking stubs necessary for device linking and other low-level library files.
- if(CMAKE_SYSROOT_LINK AND EXISTS "${CMAKE_SYSROOT_LINK}/usr/lib/nvidia-cuda-toolkit/bin/crt/link.stub")
- set(CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT "${CMAKE_SYSROOT_LINK}/usr/lib/nvidia-cuda-toolkit")
- elseif(EXISTS "${CMAKE_SYSROOT}/usr/lib/nvidia-cuda-toolkit/bin/crt/link.stub")
- set(CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT "${CMAKE_SYSROOT}/usr/lib/nvidia-cuda-toolkit")
- else()
- set(CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}")
- endif()
- endif()
-
- # For regular nvcc we the toolkit version is the same as the compiler version and we can parse it from the vendor test output.
- # For Clang we need to invoke nvcc to get version output.
- if(NOT CMAKE_GENERATOR MATCHES "Visual Studio")
- if(CMAKE_CUDA_COMPILER_ID STREQUAL "Clang")
- execute_process(COMMAND ${_CUDA_NVCC_EXECUTABLE} "--version" OUTPUT_VARIABLE CMAKE_CUDA_COMPILER_ID_OUTPUT)
- endif()
-
- if(CMAKE_CUDA_COMPILER_ID_OUTPUT MATCHES [=[V([0-9]+\.[0-9]+\.[0-9]+)]=])
- set(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION "${CMAKE_MATCH_1}")
- endif()
- endif()
-
- set(CMAKE_CUDA_COMPILER_ID_FLAGS_ALWAYS "-v")
-
- if(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
- set(nvcc_test_flags "--keep --keep-dir tmp")
- if(CMAKE_CUDA_HOST_COMPILER)
- string(APPEND nvcc_test_flags " -ccbin=\"${CMAKE_CUDA_HOST_COMPILER}\"")
- endif()
- # If we have extracted the vendor as NVIDIA we should require detection to
- # work. If we don't, users will get confusing errors later about failure
- # to detect a default value for CMAKE_CUDA_ARCHITECTURES
- set(CMAKE_CUDA_COMPILER_ID_REQUIRE_SUCCESS ON)
- elseif(CMAKE_CUDA_COMPILER_ID STREQUAL "Clang")
- set(clang_test_flags "--cuda-path=\"${CMAKE_CUDA_COMPILER_LIBRARY_ROOT}\"")
- if(CMAKE_CROSSCOMPILING)
- # Need to pass the host target and include directories if we're crosscompiling.
- string(APPEND clang_test_flags " --sysroot=\"${CMAKE_SYSROOT}\" --target=${CMAKE_CUDA_COMPILER_TARGET}")
- endif()
- endif()
-
- # Rest of the code treats an empty value as equivalent to "use the defaults".
- # Error out early to prevent confusing errors as a result of this.
- # Note that this also catches invalid non-numerical values such as "a".
- if(DEFINED CMAKE_CUDA_ARCHITECTURES)
- if(CMAKE_CUDA_ARCHITECTURES STREQUAL "")
- message(FATAL_ERROR "CMAKE_CUDA_ARCHITECTURES must be non-empty if set.")
- elseif(CMAKE_CUDA_ARCHITECTURES AND NOT CMAKE_CUDA_ARCHITECTURES MATCHES "^([0-9]+a?(-real|-virtual)?(;[0-9]+a?(-real|-virtual)?|;)*|all|all-major|native)$")
- message(FATAL_ERROR
- "CMAKE_CUDA_ARCHITECTURES:\n"
- " ${CMAKE_CUDA_ARCHITECTURES}\n"
- "is not one of the following:\n"
- " * a semicolon-separated list of integers, each optionally\n"
- " followed by '-real' or '-virtual'\n"
- " * a special value: all, all-major, native\n"
- )
- endif()
- endif()
-
- if(CMAKE_CUDA_COMPILER_ID STREQUAL "Clang")
- # Clang doesn't automatically select an architecture supported by the SDK.
- # Try in reverse order of deprecation with the most recent at front (i.e. the most likely to work for new setups).
- foreach(arch "52" "30" "20")
- list(APPEND CMAKE_CUDA_COMPILER_ID_TEST_FLAGS_FIRST "${clang_test_flags} --cuda-gpu-arch=sm_${arch}")
- endforeach()
- elseif(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
- list(APPEND CMAKE_CUDA_COMPILER_ID_TEST_FLAGS_FIRST "${nvcc_test_flags}")
- endif()
-
- # We perform compiler identification for a second time to extract implicit linking info and host compiler for NVCC.
- # We need to unset the compiler ID otherwise CMAKE_DETERMINE_COMPILER_ID() doesn't work.
- set(CMAKE_CUDA_COMPILER_ID)
- set(CMAKE_CUDA_PLATFORM_ID)
- file(READ ${CMAKE_ROOT}/Modules/CMakePlatformId.h.in
- CMAKE_CUDA_COMPILER_ID_PLATFORM_CONTENT)
-
- CMAKE_DETERMINE_COMPILER_ID(CUDA CUDAFLAGS CMakeCUDACompilerId.cu)
-
- if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
- # Now that we have the path to nvcc, we can compute the toolkit root.
- get_filename_component(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "${CMAKE_CUDA_COMPILER}" DIRECTORY)
- get_filename_component(CMAKE_CUDA_COMPILER_TOOLKIT_ROOT "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}" DIRECTORY)
- set(CMAKE_CUDA_COMPILER_LIBRARY_ROOT "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}")
-
- # The compiler comes with the toolkit, so the versions are the same.
- set(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION ${CMAKE_CUDA_COMPILER_VERSION})
- endif()
-
- include(${CMAKE_ROOT}/Modules/CUDA/architectures.cmake)
-
- _cmake_find_compiler_sysroot(CUDA)
-endif()
-
-set(_CMAKE_PROCESSING_LANGUAGE "CUDA")
-include(CMakeFindBinUtils)
-include(Compiler/${CMAKE_CUDA_COMPILER_ID}-FindBinUtils OPTIONAL)
-unset(_CMAKE_PROCESSING_LANGUAGE)
-
-if(MSVC_CUDA_ARCHITECTURE_ID)
- set(SET_MSVC_CUDA_ARCHITECTURE_ID
- "set(MSVC_CUDA_ARCHITECTURE_ID ${MSVC_CUDA_ARCHITECTURE_ID})")
-endif()
-
-if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
- set(CMAKE_CUDA_HOST_LINK_LAUNCHER "${CMAKE_LINKER}")
- set(CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES "")
- set(CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES "")
- set(CMAKE_CUDA_HOST_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
-
- # We do not currently detect CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES but we
- # do need to detect CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT from the compiler by
- # looking at which cudart library exists in the implicit link libraries passed
- # to the host linker.
- if(CMAKE_CUDA_COMPILER_PRODUCED_OUTPUT MATCHES "link\\.exe [^\n]*cudart_static\\.lib")
- set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT "STATIC")
- elseif(CMAKE_CUDA_COMPILER_PRODUCED_OUTPUT MATCHES "link\\.exe [^\n]*cudart\\.lib")
- set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT "SHARED")
- else()
- set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT "NONE")
- endif()
- set(_SET_CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT
- "set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT \"${CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT}\")")
-elseif(CMAKE_CUDA_COMPILER_ID STREQUAL "Clang")
- string(REGEX MATCHALL "-target-cpu sm_([0-9]+)" target_cpus "${CMAKE_CUDA_COMPILER_PRODUCED_OUTPUT}")
-
- foreach(cpu ${target_cpus})
- string(REGEX MATCH "-target-cpu sm_([0-9]+)" dont_care "${cpu}")
- list(APPEND architectures_detected "${CMAKE_MATCH_1}")
- endforeach()
-
- # Find target directory when crosscompiling.
- if(CMAKE_CROSSCOMPILING)
- if(CMAKE_SYSTEM_PROCESSOR STREQUAL "armv7-a")
- # Support for NVPACK
- set(_CUDA_TARGET_NAME "armv7-linux-androideabi")
- elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm")
- set(_CUDA_TARGET_NAME "armv7-linux-gnueabihf")
- elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
- if(ANDROID_ARCH_NAME STREQUAL "arm64")
- set(_CUDA_TARGET_NAME "aarch64-linux-androideabi")
- else()
- set(_CUDA_TARGET_NAME "aarch64-linux")
- endif()
- elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
- set(_CUDA_TARGET_NAME "x86_64-linux")
- endif()
-
- if(EXISTS "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}/targets/${_CUDA_TARGET_NAME}")
- set(_CUDA_TARGET_DIR "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}/targets/${_CUDA_TARGET_NAME}")
- endif()
- endif()
-
- # If not already set we can simply use the toolkit root or it's a scattered installation.
- if(NOT _CUDA_TARGET_DIR)
- set(_CUDA_TARGET_DIR "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}")
- endif()
-
- # We can't use find_library() yet at this point, so try a few guesses.
- if(EXISTS "${_CUDA_TARGET_DIR}/lib64")
- set(_CUDA_LIBRARY_DIR "${_CUDA_TARGET_DIR}/lib64")
- elseif(EXISTS "${_CUDA_TARGET_DIR}/lib/x64")
- set(_CUDA_LIBRARY_DIR "${_CUDA_TARGET_DIR}/lib/x64")
- elseif(EXISTS "${_CUDA_TARGET_DIR}/lib")
- set(_CUDA_LIBRARY_DIR "${_CUDA_TARGET_DIR}/lib")
- else()
- message(FATAL_ERROR "Unable to find _CUDA_LIBRARY_DIR based on _CUDA_TARGET_DIR=${_CUDA_TARGET_DIR}")
- endif()
-
- # _CUDA_TARGET_DIR always points to the directory containing the include directory.
- # On a scattered installation /usr, on a non-scattered something like /usr/local/cuda or /usr/local/cuda-10.2/targets/aarch64-linux.
- if(EXISTS "${_CUDA_TARGET_DIR}/include/cuda_runtime.h")
- set(_CUDA_INCLUDE_DIR "${_CUDA_TARGET_DIR}/include")
- else()
- message(FATAL_ERROR "Unable to find cuda_runtime.h in \"${_CUDA_TARGET_DIR}/include\" for _CUDA_INCLUDE_DIR.")
- endif()
-
- # Clang does not add any CUDA SDK libraries or directories when invoking the host linker.
- # Add the CUDA toolkit library directory ourselves so that linking works.
- # The CUDA runtime libraries are handled elsewhere by CMAKE_CUDA_RUNTIME_LIBRARY.
- set(CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES "${_CUDA_INCLUDE_DIR}")
- set(CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES "${_CUDA_LIBRARY_DIR}")
- set(CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES "")
- set(CMAKE_CUDA_HOST_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
-elseif(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
- set(_nvcc_log "")
- string(REPLACE "\r" "" _nvcc_output_orig "${CMAKE_CUDA_COMPILER_PRODUCED_OUTPUT}")
- if(_nvcc_output_orig MATCHES "#\\\$ +PATH= *([^\n]*)\n")
- set(_nvcc_path "${CMAKE_MATCH_1}")
- string(APPEND _nvcc_log " found 'PATH=' string: [${_nvcc_path}]\n")
- string(REPLACE ":" ";" _nvcc_path "${_nvcc_path}")
- else()
- set(_nvcc_path "")
- string(REPLACE "\n" "\n " _nvcc_output_log "\n${_nvcc_output_orig}")
- string(APPEND _nvcc_log " no 'PATH=' string found in nvcc output:${_nvcc_output_log}\n")
- endif()
- if(_nvcc_output_orig MATCHES "#\\\$ +LIBRARIES= *([^\n]*)\n")
- set(_nvcc_libraries "${CMAKE_MATCH_1}")
- string(APPEND _nvcc_log " found 'LIBRARIES=' string: [${_nvcc_libraries}]\n")
- else()
- set(_nvcc_libraries "")
- string(REPLACE "\n" "\n " _nvcc_output_log "\n${_nvcc_output_orig}")
- string(APPEND _nvcc_log " no 'LIBRARIES=' string found in nvcc output:${_nvcc_output_log}\n")
- endif()
-
- set(_nvcc_link_line "")
- if(_nvcc_libraries)
- # Remove variable assignments.
- string(REGEX REPLACE "#\\\$ *[^= ]+=[^\n]*\n" "" _nvcc_output "${_nvcc_output_orig}")
- # Encode [] characters that break list expansion.
- string(REPLACE "[" "{==={" _nvcc_output "${_nvcc_output}")
- string(REPLACE "]" "}===}" _nvcc_output "${_nvcc_output}")
- # Split lines.
- string(REGEX REPLACE "\n+(#\\\$ )?" ";" _nvcc_output "${_nvcc_output}")
- foreach(line IN LISTS _nvcc_output)
- set(_nvcc_output_line "${line}")
- string(REPLACE "{==={" "[" _nvcc_output_line "${_nvcc_output_line}")
- string(REPLACE "}===}" "]" _nvcc_output_line "${_nvcc_output_line}")
- string(APPEND _nvcc_log " considering line: [${_nvcc_output_line}]\n")
- if("${_nvcc_output_line}" MATCHES "^ *nvlink")
- string(APPEND _nvcc_log " ignoring nvlink line\n")
- elseif(_nvcc_libraries)
- if("${_nvcc_output_line}" MATCHES "(@\"?((tmp/)?a\\.exe\\.res)\"?)")
- set(_nvcc_link_res_arg "${CMAKE_MATCH_1}")
- set(_nvcc_link_res_file "${CMAKE_MATCH_2}")
- set(_nvcc_link_res "${CMAKE_PLATFORM_INFO_DIR}/CompilerIdCUDA/${_nvcc_link_res_file}")
- if(EXISTS "${_nvcc_link_res}")
- file(READ "${_nvcc_link_res}" _nvcc_link_res_content)
- string(REPLACE "${_nvcc_link_res_arg}" "${_nvcc_link_res_content}" _nvcc_output_line "${_nvcc_output_line}")
- endif()
- endif()
- string(FIND "${_nvcc_output_line}" "${_nvcc_libraries}" _nvcc_libraries_pos)
- if(NOT _nvcc_libraries_pos EQUAL -1)
- set(_nvcc_link_line "${_nvcc_output_line}")
- string(APPEND _nvcc_log " extracted link line: [${_nvcc_link_line}]\n")
- endif()
- endif()
- endforeach()
- endif()
-
- if(_nvcc_link_line)
- if("x${CMAKE_CUDA_SIMULATE_ID}" STREQUAL "xMSVC")
- set(CMAKE_CUDA_HOST_LINK_LAUNCHER "${CMAKE_LINKER}")
- else()
- #extract the compiler that is being used for linking
- separate_arguments(_nvcc_link_line_args UNIX_COMMAND "${_nvcc_link_line}")
- list(GET _nvcc_link_line_args 0 _nvcc_host_link_launcher)
- if(IS_ABSOLUTE "${_nvcc_host_link_launcher}")
- string(APPEND _nvcc_log " extracted link launcher absolute path: [${_nvcc_host_link_launcher}]\n")
- set(CMAKE_CUDA_HOST_LINK_LAUNCHER "${_nvcc_host_link_launcher}")
- else()
- string(APPEND _nvcc_log " extracted link launcher name: [${_nvcc_host_link_launcher}]\n")
- find_program(_nvcc_find_host_link_launcher
- NAMES ${_nvcc_host_link_launcher}
- PATHS ${_nvcc_path} NO_DEFAULT_PATH)
- find_program(_nvcc_find_host_link_launcher
- NAMES ${_nvcc_host_link_launcher})
- if(_nvcc_find_host_link_launcher)
- string(APPEND _nvcc_log " found link launcher absolute path: [${_nvcc_find_host_link_launcher}]\n")
- set(CMAKE_CUDA_HOST_LINK_LAUNCHER "${_nvcc_find_host_link_launcher}")
- else()
- string(APPEND _nvcc_log " could not find link launcher absolute path\n")
- set(CMAKE_CUDA_HOST_LINK_LAUNCHER "${_nvcc_host_link_launcher}")
- endif()
- unset(_nvcc_find_host_link_launcher CACHE)
- endif()
- endif()
-
- #prefix the line with cuda-fake-ld so that implicit link info believes it is
- #a link line
- set(_nvcc_link_line "cuda-fake-ld ${_nvcc_link_line}")
- CMAKE_PARSE_IMPLICIT_LINK_INFO("${_nvcc_link_line}"
- CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES
- CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES
- CMAKE_CUDA_HOST_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES
- log
- "${CMAKE_CUDA_IMPLICIT_OBJECT_REGEX}"
- LANGUAGE CUDA)
-
- # Detect CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT from the compiler by looking at which
- # cudart library exists in the implicit link libraries passed to the host linker.
- # This is required when a project sets the cuda runtime library as part of the
- # initial flags.
- if(";${CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES};" MATCHES [[;cudart_static(\.lib)?;]])
- set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT "STATIC")
- elseif(";${CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES};" MATCHES [[;cudart(\.lib)?;]])
- set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT "SHARED")
- else()
- set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT "NONE")
- endif()
- set(_SET_CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT
- "set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT \"${CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT}\")")
-
- message(CONFIGURE_LOG
- "Parsed CUDA nvcc implicit link information:\n${_nvcc_log}\n${log}\n\n")
- else()
- message(CONFIGURE_LOG
- "Failed to parse CUDA nvcc implicit link information:\n${_nvcc_log}\n\n")
- message(FATAL_ERROR "Failed to extract nvcc implicit link line.")
- endif()
-endif()
-
-# CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES is detected above as the list of
-# libraries that the CUDA compiler implicitly passes to the host linker.
-# CMake invokes the host linker directly and so needs to pass these libraries.
-# We filter out those that should not be passed unconditionally both here
-# and from CMAKE_CUDA_IMPLICIT_LINK_LIBRARIES in CMakeTestCUDACompiler.
-set(CMAKE_CUDA_IMPLICIT_LINK_LIBRARIES_EXCLUDE
- # The CUDA runtime libraries are controlled by CMAKE_CUDA_RUNTIME_LIBRARY.
- cudart cudart.lib
- cudart_static cudart_static.lib
- cudadevrt cudadevrt.lib
-
- # Dependencies of the CUDA static runtime library on Linux hosts.
- rt
- pthread
- dl
- )
-list(REMOVE_ITEM CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES ${CMAKE_CUDA_IMPLICIT_LINK_LIBRARIES_EXCLUDE})
-
-if(CMAKE_CUDA_COMPILER_SYSROOT)
- string(CONCAT _SET_CMAKE_CUDA_COMPILER_SYSROOT
- "set(CMAKE_CUDA_COMPILER_SYSROOT \"${CMAKE_CUDA_COMPILER_SYSROOT}\")\n"
- "set(CMAKE_COMPILER_SYSROOT \"${CMAKE_CUDA_COMPILER_SYSROOT}\")")
-else()
- set(_SET_CMAKE_CUDA_COMPILER_SYSROOT "")
-endif()
-
-# Determine CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES
-if(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
- set(CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES)
- string(REPLACE "\r" "" _nvcc_output_orig "${CMAKE_CUDA_COMPILER_PRODUCED_OUTPUT}")
- if(_nvcc_output_orig MATCHES "#\\\$ +INCLUDES= *([^\n]*)\n")
- set(_nvcc_includes "${CMAKE_MATCH_1}")
- string(APPEND _nvcc_log " found 'INCLUDES=' string: [${_nvcc_includes}]\n")
- else()
- set(_nvcc_includes "")
- string(REPLACE "\n" "\n " _nvcc_output_log "\n${_nvcc_output_orig}")
- string(APPEND _nvcc_log " no 'INCLUDES=' string found in nvcc output:${_nvcc_output_log}\n")
- endif()
- if(_nvcc_includes)
- # across all operating system each include directory is prefixed with -I
- separate_arguments(_nvcc_output NATIVE_COMMAND "${_nvcc_includes}")
- foreach(line IN LISTS _nvcc_output)
- string(REGEX REPLACE "^-I" "" line "${line}")
- get_filename_component(line "${line}" ABSOLUTE)
- list(APPEND CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES "${line}")
- endforeach()
-
- message(CONFIGURE_LOG
- "Parsed CUDA nvcc include information:\n${_nvcc_log}\n${log}\n\n")
- else()
- message(CONFIGURE_LOG
- "Failed to detect CUDA nvcc include information:\n${_nvcc_log}\n\n")
- endif()
-
- string(REGEX MATCHALL "-arch compute_([0-9]+)" target_cpus "${CMAKE_CUDA_COMPILER_PRODUCED_OUTPUT}")
-
- foreach(cpu ${target_cpus})
- string(REGEX MATCH "-arch compute_([0-9]+)" dont_care "${cpu}")
- list(APPEND architectures_detected "${CMAKE_MATCH_1}")
- endforeach()
-endif()
-
-# If the user didn't set the architectures, then set them to a default.
-# If the user did, then make sure those architectures worked.
-if("${CMAKE_CUDA_ARCHITECTURES}" STREQUAL "")
- cmake_policy(GET CMP0104 _CUDA_CMP0104)
-
- if(NOT CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA" OR _CUDA_CMP0104 STREQUAL "NEW")
- set(CMAKE_CUDA_ARCHITECTURES "${architectures_detected}" CACHE STRING "CUDA architectures")
-
- if(NOT CMAKE_CUDA_ARCHITECTURES)
- message(FATAL_ERROR "Failed to detect a default CUDA architecture.\n\nCompiler output:\n${CMAKE_CUDA_COMPILER_PRODUCED_OUTPUT}")
- endif()
- endif()
-endif()
-
-# configure all variables set in this file
-configure_file(${CMAKE_ROOT}/Modules/CMakeCUDACompiler.cmake.in
- ${CMAKE_PLATFORM_INFO_DIR}/CMakeCUDACompiler.cmake
- @ONLY
-)
-
-# Don't leak variables unnecessarily to user code.
-unset(_CUDA_INCLUDE_DIR CACHE)
-unset(_CUDA_NVCC_EXECUTABLE CACHE)
-unset(_CUDA_LIBRARY_DIR)
-unset(_CUDA_TARGET_DIR)
-unset(_CUDA_TARGET_NAME)
-
-unset(architectures_detected)
-
-set(CMAKE_CUDA_COMPILER_ENV_VAR "CUDACXX")
-set(CMAKE_CUDA_HOST_COMPILER_ENV_VAR "CUDAHOSTCXX")
diff --git a/cmake/share/cmake-3.27/Modules/CMakeDetermineHIPCompiler.cmake b/cmake/share/cmake-3.27/Modules/CMakeDetermineHIPCompiler.cmake
deleted file mode 100644
index ee9f95e8..00000000
--- a/cmake/share/cmake-3.27/Modules/CMakeDetermineHIPCompiler.cmake
+++ /dev/null
@@ -1,234 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
-include(${CMAKE_ROOT}/Modules/CMakeParseImplicitLinkInfo.cmake)
-include(${CMAKE_ROOT}/Modules/CMakeParseLibraryArchitecture.cmake)
-
-if( NOT ( ("${CMAKE_GENERATOR}" MATCHES "Make") OR
- ("${CMAKE_GENERATOR}" MATCHES "Ninja") ) )
- message(FATAL_ERROR "HIP language not currently supported by \"${CMAKE_GENERATOR}\" generator")
-endif()
-
-
-if(NOT CMAKE_HIP_COMPILER)
- set(CMAKE_HIP_COMPILER_INIT NOTFOUND)
-
- # prefer the environment variable HIPCXX
- if(NOT $ENV{HIPCXX} STREQUAL "")
- if("$ENV{HIPCXX}" MATCHES "hipcc")
- message(FATAL_ERROR
- "The HIPCXX environment variable is set to the hipcc wrapper:\n"
- " $ENV{HIPCXX}\n"
- "This is not supported. Use Clang directly, or let CMake pick a default."
- )
- endif()
- get_filename_component(CMAKE_HIP_COMPILER_INIT $ENV{HIPCXX} PROGRAM PROGRAM_ARGS CMAKE_HIP_FLAGS_ENV_INIT)
- if(CMAKE_HIP_FLAGS_ENV_INIT)
- set(CMAKE_HIP_COMPILER_ARG1 "${CMAKE_HIP_FLAGS_ENV_INIT}" CACHE STRING "Arguments to CXX compiler")
- endif()
- if(NOT EXISTS ${CMAKE_HIP_COMPILER_INIT})
- message(FATAL_ERROR "Could not find compiler set in environment variable HIPCXX:\n$ENV{HIPCXX}.\n${CMAKE_HIP_COMPILER_INIT}")
- endif()
- endif()
-
- # finally list compilers to try
- if(NOT CMAKE_HIP_COMPILER_INIT)
- set(CMAKE_HIP_COMPILER_LIST clang++)
-
- # Look for the Clang coming with ROCm to support HIP.
- execute_process(COMMAND hipconfig --hipclangpath
- OUTPUT_VARIABLE _CMAKE_HIPCONFIG_CLANGPATH
- RESULT_VARIABLE _CMAKE_HIPCONFIG_RESULT
- )
- if(_CMAKE_HIPCONFIG_RESULT EQUAL 0 AND EXISTS "${_CMAKE_HIPCONFIG_CLANGPATH}")
- set(CMAKE_HIP_COMPILER_HINTS "${_CMAKE_HIPCONFIG_CLANGPATH}")
- endif()
- endif()
-
- _cmake_find_compiler(HIP)
-elseif(CMAKE_HIP_COMPILER MATCHES "hipcc")
- message(FATAL_ERROR
- "CMAKE_HIP_COMPILER is set to the hipcc wrapper:\n"
- " ${CMAKE_HIP_COMPILER}\n"
- "This is not supported. Use Clang directly, or let CMake pick a default."
- )
-else()
- _cmake_find_compiler_path(HIP)
-endif()
-
-mark_as_advanced(CMAKE_HIP_COMPILER)
-
-# Build a small source file to identify the compiler.
-if(NOT CMAKE_HIP_COMPILER_ID_RUN)
- set(CMAKE_HIP_COMPILER_ID_RUN 1)
-
- # Try to identify the compiler.
- set(CMAKE_HIP_COMPILER_ID)
- set(CMAKE_HIP_PLATFORM_ID)
- file(READ ${CMAKE_ROOT}/Modules/CMakePlatformId.h.in
- CMAKE_HIP_COMPILER_ID_PLATFORM_CONTENT)
-
- list(APPEND CMAKE_HIP_COMPILER_ID_TEST_FLAGS_FIRST "-v")
-
- include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
- CMAKE_DETERMINE_COMPILER_ID(HIP HIPFLAGS CMakeHIPCompilerId.hip)
-
- _cmake_find_compiler_sysroot(HIP)
-endif()
-
-if(NOT CMAKE_HIP_COMPILER_ROCM_ROOT AND CMAKE_HIP_COMPILER_ID STREQUAL "Clang")
- execute_process(COMMAND "${CMAKE_HIP_COMPILER}" -v -print-targets
- OUTPUT_STRIP_TRAILING_WHITESPACE
- RESULT_VARIABLE _CMAKE_HIP_COMPILER_RESULT
- OUTPUT_VARIABLE _CMAKE_HIP_COMPILER_STDOUT
- ERROR_VARIABLE _CMAKE_HIP_COMPILER_STDERR
- )
-
- if(_CMAKE_HIP_COMPILER_RESULT EQUAL 0 AND _CMAKE_HIP_COMPILER_STDERR MATCHES "Found HIP installation: *([^,]*)[,\n]")
- set(CMAKE_HIP_COMPILER_ROCM_ROOT "${CMAKE_MATCH_1}")
- file(TO_CMAKE_PATH "${CMAKE_HIP_COMPILER_ROCM_ROOT}" CMAKE_HIP_COMPILER_ROCM_ROOT)
- endif()
-endif()
-if(NOT CMAKE_HIP_COMPILER_ROCM_ROOT)
- execute_process(
- COMMAND hipconfig --rocmpath
- OUTPUT_VARIABLE _CMAKE_HIPCONFIG_ROCMPATH
- RESULT_VARIABLE _CMAKE_HIPCONFIG_RESULT
- )
- if(_CMAKE_HIPCONFIG_RESULT EQUAL 0 AND EXISTS "${_CMAKE_HIPCONFIG_ROCMPATH}")
- set(CMAKE_HIP_COMPILER_ROCM_ROOT "${_CMAKE_HIPCONFIG_ROCMPATH}")
- endif()
-endif()
-if(NOT CMAKE_HIP_COMPILER_ROCM_ROOT)
- message(FATAL_ERROR "Failed to find ROCm root directory.")
-endif()
-
-# Normally implicit link information is not detected until
-cmake_parse_implicit_link_info("${CMAKE_HIP_COMPILER_PRODUCED_OUTPUT}"
- _CMAKE_HIP_COMPILER_ID_IMPLICIT_LIBS
- _CMAKE_HIP_COMPILER_ID_IMPLICIT_DIRS
- _CMAKE_HIP_COMPILER_ID_IMPLICIT_FWKS
- _CMAKE_HIP_COMPILER_ID_IMPLICIT_LOG
- "" LANGUAGE HIP)
-message(CONFIGURE_LOG
- "Parsed HIP implicit link information from compiler id output:\n${_CMAKE_HIP_COMPILER_ID_IMPLICIT_LOG}\n\n")
-cmake_parse_library_architecture(HIP "${_CMAKE_HIP_COMPILER_ID_IMPLICIT_DIRS}" "" CMAKE_HIP_LIBRARY_ARCHITECTURE)
-if(CMAKE_HIP_LIBRARY_ARCHITECTURE)
- message(CONFIGURE_LOG
- "Parsed HIP library architecture from compiler id output: ${CMAKE_HIP_LIBRARY_ARCHITECTURE}\n")
-endif()
-unset(_CMAKE_HIP_COMPILER_ID_IMPLICIT_LIBS)
-unset(_CMAKE_HIP_COMPILER_ID_IMPLICIT_DIRS)
-unset(_CMAKE_HIP_COMPILER_ID_IMPLICIT_FWKS)
-unset(_CMAKE_HIP_COMPILER_ID_IMPLICIT_LOG)
-
-if(NOT CMAKE_HIP_COMPILER_ROCM_LIB)
- set(_CMAKE_HIP_COMPILER_ROCM_LIB_DIRS
- "${CMAKE_HIP_COMPILER_ROCM_ROOT}/lib"
- "${CMAKE_HIP_COMPILER_ROCM_ROOT}/lib64"
- )
- if(CMAKE_HIP_LIBRARY_ARCHITECTURE)
- list(APPEND _CMAKE_HIP_COMPILER_ROCM_LIB_DIRS "${CMAKE_HIP_COMPILER_ROCM_ROOT}/lib/${CMAKE_HIP_LIBRARY_ARCHITECTURE}")
- endif()
- foreach(dir IN LISTS _CMAKE_HIP_COMPILER_ROCM_LIB_DIRS)
- if(EXISTS "${dir}/cmake/hip-lang/hip-lang-config.cmake")
- set(CMAKE_HIP_COMPILER_ROCM_LIB "${dir}")
- break()
- endif()
- endforeach()
- if(NOT CMAKE_HIP_COMPILER_ROCM_LIB)
- list(TRANSFORM _CMAKE_HIP_COMPILER_ROCM_LIB_DIRS APPEND "/cmake/hip-lang/hip-lang-config.cmake")
- string(REPLACE ";" "\n " _CMAKE_HIP_COMPILER_ROCM_LIB_DIRS "${_CMAKE_HIP_COMPILER_ROCM_LIB_DIRS}")
- message(FATAL_ERROR
- "The ROCm root directory:\n"
- " ${CMAKE_HIP_COMPILER_ROCM_ROOT}\n"
- "does not contain the HIP runtime CMake package, expected at one of:\n"
- " ${_CMAKE_HIP_COMPILER_ROCM_LIB_DIRS}\n"
- )
- endif()
- unset(_CMAKE_HIP_COMPILER_ROCM_LIB_DIRS)
-endif()
-if(CMAKE_HIP_COMPILER_ROCM_LIB MATCHES "/lib64$" AND NOT DEFINED CMAKE_SIZEOF_VOID_P)
- # We have not yet determined the target ABI but we need 'find_package' to
- # search lib64 directories to find hip-lang CMake package dependencies.
- # This will be replaced by ABI detection later.
- set(CMAKE_HIP_SIZEOF_DATA_PTR 8)
-endif()
-
-if (NOT _CMAKE_TOOLCHAIN_LOCATION)
- get_filename_component(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_HIP_COMPILER}" PATH)
-endif ()
-
-set(_CMAKE_PROCESSING_LANGUAGE "HIP")
-include(CMakeFindBinUtils)
-include(Compiler/${CMAKE_HIP_COMPILER_ID}-FindBinUtils OPTIONAL)
-unset(_CMAKE_PROCESSING_LANGUAGE)
-
-if(CMAKE_HIP_COMPILER_SYSROOT)
- string(CONCAT _SET_CMAKE_HIP_COMPILER_SYSROOT
- "set(CMAKE_HIP_COMPILER_SYSROOT \"${CMAKE_HIP_COMPILER_SYSROOT}\")\n"
- "set(CMAKE_COMPILER_SYSROOT \"${CMAKE_HIP_COMPILER_SYSROOT}\")")
-else()
- set(_SET_CMAKE_HIP_COMPILER_SYSROOT "")
-endif()
-
-if(CMAKE_HIP_COMPILER_ARCHITECTURE_ID)
- set(_SET_CMAKE_HIP_COMPILER_ARCHITECTURE_ID
- "set(CMAKE_HIP_COMPILER_ARCHITECTURE_ID ${CMAKE_HIP_COMPILER_ARCHITECTURE_ID})")
-else()
- set(_SET_CMAKE_HIP_COMPILER_ARCHITECTURE_ID "")
-endif()
-
-if(MSVC_HIP_ARCHITECTURE_ID)
- set(SET_MSVC_HIP_ARCHITECTURE_ID
- "set(MSVC_HIP_ARCHITECTURE_ID ${MSVC_HIP_ARCHITECTURE_ID})")
-endif()
-
-if(NOT DEFINED CMAKE_HIP_ARCHITECTURES)
- # Use 'rocm_agent_enumerator' to get the current GPU architecture.
- set(_CMAKE_HIP_ARCHITECTURES)
- find_program(_CMAKE_HIP_ROCM_AGENT_ENUMERATOR
- NAMES rocm_agent_enumerator
- HINTS "${CMAKE_HIP_COMPILER_ROCM_ROOT}/bin"
- NO_CACHE)
- if(_CMAKE_HIP_ROCM_AGENT_ENUMERATOR)
- execute_process(COMMAND "${_CMAKE_HIP_ROCM_AGENT_ENUMERATOR}" -t GPU
- RESULT_VARIABLE _CMAKE_ROCM_AGENT_ENUMERATOR_RESULT
- OUTPUT_VARIABLE _CMAKE_ROCM_AGENT_ENUMERATOR_STDOUT
- ERROR_VARIABLE _CMAKE_ROCM_AGENT_ENUMERATOR_STDERR
- )
- if(_CMAKE_ROCM_AGENT_ENUMERATOR_RESULT EQUAL 0)
- separate_arguments(_hip_archs NATIVE_COMMAND "${_CMAKE_ROCM_AGENT_ENUMERATOR_STDOUT}")
- foreach(_hip_arch ${_hip_archs})
- if(_hip_arch STREQUAL "gfx000")
- continue()
- endif()
- string(FIND ${_hip_arch} ":" pos)
- if(NOT pos STREQUAL "-1")
- string(SUBSTRING ${_hip_arch} 0 ${pos} _hip_arch)
- endif()
- list(APPEND _CMAKE_HIP_ARCHITECTURES "${_hip_arch}")
- endforeach()
- endif()
- unset(_CMAKE_ROCM_AGENT_ENUMERATOR_RESULT)
- unset(_CMAKE_ROCM_AGENT_ENUMERATOR_STDOUT)
- unset(_CMAKE_ROCM_AGENT_ENUMERATOR_STDERR)
- endif()
- unset(_CMAKE_HIP_ROCM_AGENT_ENUMERATOR)
- if(_CMAKE_HIP_ARCHITECTURES)
- set(CMAKE_HIP_ARCHITECTURES "${_CMAKE_HIP_ARCHITECTURES}" CACHE STRING "HIP architectures")
- elseif(CMAKE_HIP_COMPILER_PRODUCED_OUTPUT MATCHES " -target-cpu ([a-z0-9]+) ")
- set(CMAKE_HIP_ARCHITECTURES "${CMAKE_MATCH_1}" CACHE STRING "HIP architectures")
- else()
- message(FATAL_ERROR "Failed to find a default HIP architecture.")
- endif()
- unset(_CMAKE_HIP_ARCHITECTURES)
-endif()
-
-# configure variables set in this file for fast reload later on
-configure_file(${CMAKE_ROOT}/Modules/CMakeHIPCompiler.cmake.in
- ${CMAKE_PLATFORM_INFO_DIR}/CMakeHIPCompiler.cmake
- @ONLY
- )
-set(CMAKE_HIP_COMPILER_ENV_VAR "HIPCXX")
diff --git a/cmake/share/cmake-3.27/Modules/CMakeHIPCompilerABI.hip b/cmake/share/cmake-3.27/Modules/CMakeHIPCompilerABI.hip
deleted file mode 100644
index d10f862f..00000000
--- a/cmake/share/cmake-3.27/Modules/CMakeHIPCompilerABI.hip
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef __HIP__
-# error "A C or C++ compiler has been selected for HIP"
-#endif
-
-#include "CMakeCompilerABI.h"
-
-int main(int argc, char* argv[])
-{
- int require = 0;
- require += info_sizeof_dptr[argc];
-#if defined(ABI_ID)
- require += info_abi[argc];
-#endif
- (void)argv;
- return require;
-}
diff --git a/cmake/share/cmake-3.27/Modules/CMakePackageConfigHelpers.cmake b/cmake/share/cmake-3.27/Modules/CMakePackageConfigHelpers.cmake
deleted file mode 100644
index fa8db11d..00000000
--- a/cmake/share/cmake-3.27/Modules/CMakePackageConfigHelpers.cmake
+++ /dev/null
@@ -1,346 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-CMakePackageConfigHelpers
--------------------------
-
-Helpers functions for creating config files that can be included by other
-projects to find and use a package.
-
-Adds the :command:`configure_package_config_file()` and
-:command:`write_basic_package_version_file()` commands.
-
-Generating a Package Configuration File
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. command:: configure_package_config_file
-
- Create a config file for a project::
-
- configure_package_config_file(
- INSTALL_DESTINATION
- [PATH_VARS ... ]
- [NO_SET_AND_CHECK_MACRO]
- [NO_CHECK_REQUIRED_COMPONENTS_MACRO]
- [INSTALL_PREFIX ]
- )
-
-``configure_package_config_file()`` should be used instead of the plain
-:command:`configure_file()` command when creating the ``Config.cmake``
-or ``-config.cmake`` file for installing a project or library.
-It helps making the resulting package relocatable by avoiding hardcoded paths
-in the installed ``Config.cmake`` file.
-
-In a ``FooConfig.cmake`` file there may be code like this to make the install
-destinations know to the using project:
-
-.. code-block:: cmake
-
- set(FOO_INCLUDE_DIR "@CMAKE_INSTALL_FULL_INCLUDEDIR@" )
- set(FOO_DATA_DIR "@CMAKE_INSTALL_PREFIX@/@RELATIVE_DATA_INSTALL_DIR@" )
- set(FOO_ICONS_DIR "@CMAKE_INSTALL_PREFIX@/share/icons" )
- #...logic to determine installedPrefix from the own location...
- set(FOO_CONFIG_DIR "${installedPrefix}/@CONFIG_INSTALL_DIR@" )
-
-All 4 options shown above are not sufficient, since the first 3 hardcode the
-absolute directory locations, and the 4th case works only if the logic to
-determine the ``installedPrefix`` is correct, and if ``CONFIG_INSTALL_DIR``
-contains a relative path, which in general cannot be guaranteed. This has the
-effect that the resulting ``FooConfig.cmake`` file would work poorly under
-Windows and OSX, where users are used to choose the install location of a
-binary package at install time, independent from how
-:variable:`CMAKE_INSTALL_PREFIX` was set at build/cmake time.
-
-Using ``configure_package_config_file`` helps. If used correctly, it makes
-the resulting ``FooConfig.cmake`` file relocatable. Usage:
-
-1. write a ``FooConfig.cmake.in`` file as you are used to
-2. insert a line containing only the string ``@PACKAGE_INIT@``
-3. instead of ``set(FOO_DIR "@SOME_INSTALL_DIR@")``, use
- ``set(FOO_DIR "@PACKAGE_SOME_INSTALL_DIR@")`` (this must be after the
- ``@PACKAGE_INIT@`` line)
-4. instead of using the normal :command:`configure_file()`, use
- ``configure_package_config_file()``
-
-
-
-The ```` arguments are the input and output file, the
-same way as in :command:`configure_file()`.
-
-The ```` given to ``INSTALL_DESTINATION`` must be the destination where
-the ``FooConfig.cmake`` file will be installed to. This path can either be
-absolute, or relative to the ``INSTALL_PREFIX`` path.
-
-The variables ```` to ```` given as ``PATH_VARS`` are the
-variables which contain install destinations. For each of them the macro will
-create a helper variable ``PACKAGE_``. These helper variables must be
-used in the ``FooConfig.cmake.in`` file for setting the installed location.
-They are calculated by ``configure_package_config_file`` so that they are
-always relative to the installed location of the package. This works both for
-relative and also for absolute locations. For absolute locations it works
-only if the absolute location is a subdirectory of ``INSTALL_PREFIX``.
-
-.. versionadded:: 3.1
- If the ``INSTALL_PREFIX`` argument is passed, this is used as base path to
- calculate all the relative paths. The ```` argument must be an absolute
- path. If this argument is not passed, the :variable:`CMAKE_INSTALL_PREFIX`
- variable will be used instead. The default value is good when generating a
- FooConfig.cmake file to use your package from the install tree. When
- generating a FooConfig.cmake file to use your package from the build tree this
- option should be used.
-
-By default ``configure_package_config_file`` also generates two helper macros,
-``set_and_check()`` and ``check_required_components()`` into the
-``FooConfig.cmake`` file.
-
-``set_and_check()`` should be used instead of the normal ``set()`` command for
-setting directories and file locations. Additionally to setting the variable
-it also checks that the referenced file or directory actually exists and fails
-with a ``FATAL_ERROR`` otherwise. This makes sure that the created
-``FooConfig.cmake`` file does not contain wrong references.
-When using the ``NO_SET_AND_CHECK_MACRO``, this macro is not generated
-into the ``FooConfig.cmake`` file.
-
-``check_required_components()`` should be called at the end of
-the ``FooConfig.cmake`` file. This macro checks whether all requested,
-non-optional components have been found, and if this is not the case, sets
-the ``Foo_FOUND`` variable to ``FALSE``, so that the package is considered to
-be not found. It does that by testing the ``Foo__FOUND``
-variables for all requested required components. This macro should be
-called even if the package doesn't provide any components to make sure
-users are not specifying components erroneously. When using the
-``NO_CHECK_REQUIRED_COMPONENTS_MACRO`` option, this macro is not generated
-into the ``FooConfig.cmake`` file.
-
-For an example see below the documentation for
-:command:`write_basic_package_version_file()`.
-
-Generating a Package Version File
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. command:: write_basic_package_version_file
-
- Create a version file for a project::
-
- write_basic_package_version_file(
- [VERSION ]
- COMPATIBILITY
- [ARCH_INDEPENDENT] )
-
-
-Writes a file for use as ``ConfigVersion.cmake`` file to
-````. See the documentation of :command:`find_package()` for
-details on this.
-
-```` is the output filename, it should be in the build tree.
-```` is the version number of the project to be installed.
-
-If no ``VERSION`` is given, the :variable:`PROJECT_VERSION` variable is used.
-If this hasn't been set, it errors out.
-
-The ``COMPATIBILITY`` mode ``AnyNewerVersion`` means that the installed
-package version will be considered compatible if it is newer or exactly the
-same as the requested version. This mode should be used for packages which
-are fully backward compatible, also across major versions.
-If ``SameMajorVersion`` is used instead, then the behavior differs from
-``AnyNewerVersion`` in that the major version number must be the same as
-requested, e.g. version 2.0 will not be considered compatible if 1.0 is
-requested. This mode should be used for packages which guarantee backward
-compatibility within the same major version.
-If ``SameMinorVersion`` is used, the behavior is the same as
-``SameMajorVersion``, but both major and minor version must be the same as
-requested, e.g version 0.2 will not be compatible if 0.1 is requested.
-If ``ExactVersion`` is used, then the package is only considered compatible if
-the requested version matches exactly its own version number (not considering
-the tweak version). For example, version 1.2.3 of a package is only
-considered compatible to requested version 1.2.3. This mode is for packages
-without compatibility guarantees.
-If your project has more elaborated version matching rules, you will need to
-write your own custom ``ConfigVersion.cmake`` file instead of using this
-macro.
-
-.. versionadded:: 3.11
- The ``SameMinorVersion`` compatibility mode.
-
-.. versionadded:: 3.14
- If ``ARCH_INDEPENDENT`` is given, the installed package version will be
- considered compatible even if it was built for a different architecture than
- the requested architecture. Otherwise, an architecture check will be performed,
- and the package will be considered compatible only if the architecture matches
- exactly. For example, if the package is built for a 32-bit architecture, the
- package is only considered compatible if it is used on a 32-bit architecture,
- unless ``ARCH_INDEPENDENT`` is given, in which case the package is considered
- compatible on any architecture.
-
-.. note:: ``ARCH_INDEPENDENT`` is intended for header-only libraries or similar
- packages with no binaries.
-
-.. versionadded:: 3.19
- The version file generated by ``AnyNewerVersion``, ``SameMajorVersion`` and
- ``SameMinorVersion`` arguments of ``COMPATIBILITY`` handle the version range
- if any is specified (see :command:`find_package` command for the details).
- ``ExactVersion`` mode is incompatible with version ranges and will display an
- author warning if one is specified.
-
-Internally, this macro executes :command:`configure_file()` to create the
-resulting version file. Depending on the ``COMPATIBILITY``, the corresponding
-``BasicConfigVersion-.cmake.in`` file is used.
-Please note that these files are internal to CMake and you should not call
-:command:`configure_file()` on them yourself, but they can be used as starting
-point to create more sophisticated custom ``ConfigVersion.cmake`` files.
-
-Example Generating Package Files
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Example using both :command:`configure_package_config_file` and
-``write_basic_package_version_file()``:
-
-``CMakeLists.txt``:
-
-.. code-block:: cmake
-
- include(GNUInstallDirs)
- set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR}/Foo
- CACHE PATH "Location of header files" )
- set(SYSCONFIG_INSTALL_DIR ${CMAKE_INSTALL_SYSCONFDIR}/foo
- CACHE PATH "Location of configuration files" )
- #...
- include(CMakePackageConfigHelpers)
- configure_package_config_file(FooConfig.cmake.in
- ${CMAKE_CURRENT_BINARY_DIR}/FooConfig.cmake
- INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Foo
- PATH_VARS INCLUDE_INSTALL_DIR SYSCONFIG_INSTALL_DIR)
- write_basic_package_version_file(
- ${CMAKE_CURRENT_BINARY_DIR}/FooConfigVersion.cmake
- VERSION 1.2.3
- COMPATIBILITY SameMajorVersion )
- install(FILES ${CMAKE_CURRENT_BINARY_DIR}/FooConfig.cmake
- ${CMAKE_CURRENT_BINARY_DIR}/FooConfigVersion.cmake
- DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Foo )
-
-``FooConfig.cmake.in``:
-
-::
-
- set(FOO_VERSION x.y.z)
- ...
- @PACKAGE_INIT@
- ...
- set_and_check(FOO_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
- set_and_check(FOO_SYSCONFIG_DIR "@PACKAGE_SYSCONFIG_INSTALL_DIR@")
-
- check_required_components(Foo)
-#]=======================================================================]
-
-include(WriteBasicConfigVersionFile)
-
-macro(WRITE_BASIC_PACKAGE_VERSION_FILE)
- write_basic_config_version_file(${ARGN})
-endmacro()
-
-function(CONFIGURE_PACKAGE_CONFIG_FILE _inputFile _outputFile)
- set(options NO_SET_AND_CHECK_MACRO NO_CHECK_REQUIRED_COMPONENTS_MACRO)
- set(oneValueArgs INSTALL_DESTINATION INSTALL_PREFIX)
- set(multiValueArgs PATH_VARS )
-
- cmake_parse_arguments(CCF "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
- if(CCF_UNPARSED_ARGUMENTS)
- message(FATAL_ERROR "Unknown keywords given to CONFIGURE_PACKAGE_CONFIG_FILE(): \"${CCF_UNPARSED_ARGUMENTS}\"")
- endif()
-
- if(NOT CCF_INSTALL_DESTINATION)
- message(FATAL_ERROR "No INSTALL_DESTINATION given to CONFIGURE_PACKAGE_CONFIG_FILE()")
- endif()
-
- if(DEFINED CCF_INSTALL_PREFIX)
- if(IS_ABSOLUTE "${CCF_INSTALL_PREFIX}")
- set(installPrefix "${CCF_INSTALL_PREFIX}")
- else()
- message(FATAL_ERROR "INSTALL_PREFIX must be an absolute path")
- endif()
- elseif(IS_ABSOLUTE "${CMAKE_INSTALL_PREFIX}")
- set(installPrefix "${CMAKE_INSTALL_PREFIX}")
- else()
- get_filename_component(installPrefix "${CMAKE_INSTALL_PREFIX}" ABSOLUTE)
- endif()
-
- if(IS_ABSOLUTE "${CCF_INSTALL_DESTINATION}")
- set(absInstallDir "${CCF_INSTALL_DESTINATION}")
- else()
- set(absInstallDir "${installPrefix}/${CCF_INSTALL_DESTINATION}")
- endif()
-
- file(RELATIVE_PATH PACKAGE_RELATIVE_PATH "${absInstallDir}" "${installPrefix}" )
-
- foreach(var ${CCF_PATH_VARS})
- if(NOT DEFINED ${var})
- message(FATAL_ERROR "Variable ${var} does not exist")
- else()
- if(IS_ABSOLUTE "${${var}}")
- string(REPLACE "${installPrefix}" "\${PACKAGE_PREFIX_DIR}"
- PACKAGE_${var} "${${var}}")
- else()
- set(PACKAGE_${var} "\${PACKAGE_PREFIX_DIR}/${${var}}")
- endif()
- endif()
- endforeach()
-
- get_filename_component(inputFileName "${_inputFile}" NAME)
-
- set(PACKAGE_INIT "
-####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
-####### Any changes to this file will be overwritten by the next CMake run ####
-####### The input file was ${inputFileName} ########
-
-get_filename_component(PACKAGE_PREFIX_DIR \"\${CMAKE_CURRENT_LIST_DIR}/${PACKAGE_RELATIVE_PATH}\" ABSOLUTE)
-")
-
- if("${absInstallDir}" MATCHES "^(/usr)?/lib(64)?/.+")
- # Handle "/usr move" symlinks created by some Linux distros.
- string(APPEND PACKAGE_INIT "
-# Use original install prefix when loaded through a \"/usr move\"
-# cross-prefix symbolic link such as /lib -> /usr/lib.
-get_filename_component(_realCurr \"\${CMAKE_CURRENT_LIST_DIR}\" REALPATH)
-get_filename_component(_realOrig \"${absInstallDir}\" REALPATH)
-if(_realCurr STREQUAL _realOrig)
- set(PACKAGE_PREFIX_DIR \"${installPrefix}\")
-endif()
-unset(_realOrig)
-unset(_realCurr)
-")
- endif()
-
- if(NOT CCF_NO_SET_AND_CHECK_MACRO)
- string(APPEND PACKAGE_INIT "
-macro(set_and_check _var _file)
- set(\${_var} \"\${_file}\")
- if(NOT EXISTS \"\${_file}\")
- message(FATAL_ERROR \"File or directory \${_file} referenced by variable \${_var} does not exist !\")
- endif()
-endmacro()
-")
- endif()
-
-
- if(NOT CCF_NO_CHECK_REQUIRED_COMPONENTS_MACRO)
- string(APPEND PACKAGE_INIT "
-macro(check_required_components _NAME)
- foreach(comp \${\${_NAME}_FIND_COMPONENTS})
- if(NOT \${_NAME}_\${comp}_FOUND)
- if(\${_NAME}_FIND_REQUIRED_\${comp})
- set(\${_NAME}_FOUND FALSE)
- endif()
- endif()
- endforeach()
-endmacro()
-")
- endif()
-
- string(APPEND PACKAGE_INIT "
-####################################################################################")
-
- configure_file("${_inputFile}" "${_outputFile}" @ONLY)
-
-endfunction()
diff --git a/cmake/share/cmake-3.27/Modules/CMakeSwiftInformation.cmake b/cmake/share/cmake-3.27/Modules/CMakeSwiftInformation.cmake
deleted file mode 100644
index c5d525e6..00000000
--- a/cmake/share/cmake-3.27/Modules/CMakeSwiftInformation.cmake
+++ /dev/null
@@ -1,137 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-if(UNIX)
- set(CMAKE_Swift_OUTPUT_EXTENSION .o)
-else()
- set(CMAKE_Swift_OUTPUT_EXTENSION .obj)
-endif()
-
-# Load compiler-specific information.
-if(CMAKE_Swift_COMPILER_ID)
- include(Compiler/${CMAKE_Swift_COMPILER_ID}-Swift OPTIONAL)
-
- if(CMAKE_SYSTEM_PROCESSOR)
- include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_Swift_COMPILER_ID}-Swift-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
- endif()
- include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_Swift_COMPILER_ID}-Swift OPTIONAL)
-endif()
-
-set(CMAKE_INCLUDE_FLAG_Swift "-I ")
-
-# FIXME: Move compiler- and platform-specific flags to the above-included modules.
-if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" OR CMAKE_SYSTEM_NAME STREQUAL "iOS"
- OR CMAKE_SYSTEM_NAME STREQUAL "tvOS" OR CMAKE_SYSTEM_NAME STREQUAL "watchOS")
- set(CMAKE_SHARED_LIBRARY_SONAME_Swift_FLAG "-Xlinker -install_name -Xlinker ")
-elseif(NOT CMAKE_SYSTEM_NAME STREQUAL Windows)
- set(CMAKE_SHARED_LIBRARY_SONAME_Swift_FLAG "-Xlinker -soname -Xlinker ")
-endif()
-if(NOT CMAKE_SYSTEM_NAME STREQUAL Windows)
- set(CMAKE_EXECUTABLE_RUNTIME_Swift_FLAG "-Xlinker -rpath -Xlinker ")
- set(CMAKE_SHARED_LIBRARY_RUNTIME_Swift_FLAG "-Xlinker -rpath -Xlinker ")
- if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" OR CMAKE_SYSTEM_NAME STREQUAL "iOS"
- OR CMAKE_SYSTEM_NAME STREQUAL "tvOS" OR CMAKE_SYSTEM_NAME STREQUAL "watchOS")
- set(CMAKE_EXECUTABLE_RUNTIME_Swift_FLAG_SEP "")
- set(CMAKE_SHARED_LIBRARY_RUNTIME_Swift_FLAG_SEP "")
- else()
- set(CMAKE_EXECUTABLE_RUNTIME_Swift_FLAG_SEP ":")
- set(CMAKE_SHARED_LIBRARY_RUNTIME_Swift_FLAG_SEP ":")
- endif()
-endif()
-
-set(CMAKE_Swift_COMPILE_OPTIONS_TARGET "-target ")
-set(CMAKE_Swift_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN "-tools-directory ")
-# NOTE(compnerd) the `-sdk` support is not yet ready in the compiler; when that
-# is fully working, we should be able to enable this.
-# set(CMAKE_Swift_COMPILE_OPTIONS_SYSROOT "-sdk ")
-# NOTE(compnerd) do not setup `-frontend` as we use the compiler as the driver
-# during the link phase and use that to drive the compilation
-set(CMAKE_Swift_COMPILER_ARG1 "")
-set(CMAKE_Swift_DEFINE_FLAG -D)
-set(CMAKE_Swift_FRAMEWORK_SEARCH_FLAG "-F ")
-set(CMAKE_Swift_LIBRARY_PATH_FLAG "-L ")
-set(CMAKE_Swift_LIBRARY_PATH_TERMINATOR "")
-set(CMAKE_Swift_LINK_LIBRARY_FLAG "-l")
-set(CMAKE_Swift_LINKER_WRAPPER_FLAG "-Xlinker" " ")
-set(CMAKE_Swift_RESPONSE_FILE_LINK_FLAG @)
-
-set(CMAKE_Swift_LINKER_PREFERENCE 50)
-set(CMAKE_Swift_LINKER_PREFERENCE_PROPAGATES 1)
-
-# NOTE(compnerd) use the short form for convenience and ease of search. They
-# are treated equivalent to their long form names as well as custom Swift
-# specific names.
-set(CMAKE_Swift_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreaded -libc MT)
-set(CMAKE_Swift_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL -libc MD)
-set(CMAKE_Swift_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug -libc MTd)
-set(CMAKE_Swift_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL -libc MDd)
-
-if(CMAKE_GENERATOR STREQUAL "Xcode")
- # Xcode has a separate Xcode project option (SWIFT_COMPILATION_MODE) used to set
- # whether compiling with whole-module optimizations or incrementally. Setting
- # these options here will have no effect when compiling with the built-in driver,
- # and will explode violently, leaving build products in the source directory, when
- # using the old swift driver.
- set(CMAKE_Swift_FLAGS_DEBUG_INIT "-Onone -g ${CMAKE_Swift_FLAGS_DEBUG_LINKER_FLAGS}")
- set(CMAKE_Swift_FLAGS_RELEASE_INIT "-O")
- set(CMAKE_Swift_FLAGS_RELWITHDEBINFO_INIT "-O -g ${CMAKE_Swift_FLAGS_RELWITHDEBINFO_LINKER_FLAGS}")
- set(CMAKE_Swift_FLAGS_MINSIZEREL_INIT "-Osize")
-else()
- set(CMAKE_Swift_FLAGS_DEBUG_INIT "-Onone -g -incremental")
- set(CMAKE_Swift_FLAGS_RELEASE_INIT "-O")
- set(CMAKE_Swift_FLAGS_RELWITHDEBINFO_INIT "-O -g")
- set(CMAKE_Swift_FLAGS_MINSIZEREL_INIT "-Osize")
-
- # Enable Whole Module Optimization by default unless the old
- # C++ driver is being used, which behaves differently under WMO.
- if(NOT CMAKE_Swift_COMPILER_USE_OLD_DRIVER)
- string(APPEND CMAKE_Swift_FLAGS_RELEASE_INIT " -wmo")
- string(APPEND CMAKE_Swift_FLAGS_RELWITHDEBINFO_INIT " -wmo")
- string(APPEND CMAKE_Swift_FLAGS_MINSIZEREL_INIT " -wmo")
- endif()
-endif()
-
-if(CMAKE_EXECUTABLE_FORMAT STREQUAL "ELF")
- if(NOT DEFINED CMAKE_Swift_LINK_WHAT_YOU_USE_FLAG)
- set(CMAKE_Swift_LINK_WHAT_YOU_USE_FLAG "LINKER:--no-as-needed")
- endif()
- if(NOT DEFINED CMAKE_LINK_WHAT_YOU_USE_CHECK)
- set(CMAKE_LINK_WHAT_YOU_USE_CHECK ldd -u -r)
- endif()
-endif()
-
-cmake_initialize_per_config_variable(CMAKE_Swift_FLAGS "Swift Compiler Flags")
-
-# NOTE(compnerd) we do not have an object compile rule since we build the objects as part of the link step
-if(NOT CMAKE_Swift_COMPILE_OBJECT)
- set(CMAKE_Swift_COMPILE_OBJECT ":")
-endif()
-
-if(NOT CMAKE_Swift_NUM_THREADS MATCHES "^[0-9]+$")
- cmake_host_system_information(RESULT CMAKE_Swift_NUM_THREADS QUERY NUMBER_OF_LOGICAL_CORES)
-endif()
-
-if(NOT CMAKE_Swift_CREATE_SHARED_LIBRARY)
- set(CMAKE_Swift_CREATE_SHARED_LIBRARY " -j ${CMAKE_Swift_NUM_THREADS} -num-threads ${CMAKE_Swift_NUM_THREADS} -emit-library -o -module-name -module-link-name -emit-module -emit-module-path -emit-dependencies ${CMAKE_Swift_IMPLIB_LINKER_FLAGS} ")
-endif()
-
-if(NOT CMAKE_Swift_CREATE_SHARED_MODULE)
- set(CMAKE_Swift_CREATE_SHARED_MODULE ${CMAKE_Swift_CREATE_SHARED_LIBRARY})
-endif()
-
-if(NOT CMAKE_Swift_LINK_EXECUTABLE)
- set(CMAKE_Swift_LINK_EXECUTABLE " -j ${CMAKE_Swift_NUM_THREADS} -num-threads ${CMAKE_Swift_NUM_THREADS} -emit-executable -o -emit-dependencies ")
-endif()
-
-if(NOT CMAKE_Swift_LINK_EXECUTABLE_WITH_EXPORTS)
- set(CMAKE_Swift_LINK_EXECUTABLE_WITH_EXPORTS "${CMAKE_Swift_LINK_EXECUTABLE} -emit-module -emit-module-path ${CMAKE_Swift_IMPLIB_LINKER_FLAGS}")
-endif()
-
-if(NOT CMAKE_Swift_CREATE_STATIC_LIBRARY)
- set(CMAKE_Swift_CREATE_STATIC_LIBRARY " -j ${CMAKE_Swift_NUM_THREADS} -num-threads ${CMAKE_Swift_NUM_THREADS} -emit-library -static -o -module-name -module-link-name -emit-module -emit-module-path -emit-dependencies ")
-
- set(CMAKE_Swift_ARCHIVE_CREATE " crs ")
- set(CMAKE_Swift_ARCHIVE_FINISH "")
-endif()
-
-set(CMAKE_Swift_INFORMATION_LOADED 1)
diff --git a/cmake/share/cmake-3.27/Modules/CUDA/architectures.cmake b/cmake/share/cmake-3.27/Modules/CUDA/architectures.cmake
deleted file mode 100644
index 91126fa9..00000000
--- a/cmake/share/cmake-3.27/Modules/CUDA/architectures.cmake
+++ /dev/null
@@ -1,69 +0,0 @@
-# See supported GPUs on Wikipedia
-# https://en.wikipedia.org/wiki/CUDA#GPUs_supported
-
-# Initial set based on CUDA 7.0.
-set(CMAKE_CUDA_ARCHITECTURES_ALL 20 21 30 35 37 50 52 53)
-set(CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR 20 30 35 50)
-
-if(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION VERSION_GREATER_EQUAL 8.0)
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL 60 61 62)
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR 60)
-endif()
-
-if(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION VERSION_GREATER_EQUAL 9.0)
- if(NOT CMAKE_CUDA_COMPILER_ID STREQUAL "Clang" OR CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL 70 72)
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR 70)
- endif()
-
- list(REMOVE_ITEM CMAKE_CUDA_ARCHITECTURES_ALL 20 21)
- list(REMOVE_ITEM CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR 20)
-endif()
-
-if(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION VERSION_GREATER_EQUAL 10.0
- AND (NOT CMAKE_CUDA_COMPILER_ID STREQUAL "Clang" OR CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 8.0))
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL 75)
-endif()
-
-if(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION VERSION_GREATER_EQUAL 11.0)
- if(NOT CMAKE_CUDA_COMPILER_ID STREQUAL "Clang" OR CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0)
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL 80)
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR 80)
- endif()
-
- list(REMOVE_ITEM CMAKE_CUDA_ARCHITECTURES_ALL 30)
- list(REMOVE_ITEM CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR 30)
-endif()
-
-if(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION VERSION_GREATER_EQUAL 11.1
- AND (NOT CMAKE_CUDA_COMPILER_ID STREQUAL "Clang" OR CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 13.0))
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL 86)
-endif()
-
-if(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION VERSION_GREATER_EQUAL 11.4
- AND (NOT CMAKE_CUDA_COMPILER_ID STREQUAL "Clang"))
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL 87)
-endif()
-
-if(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION VERSION_GREATER_EQUAL 11.8
- AND (NOT CMAKE_CUDA_COMPILER_ID STREQUAL "Clang"))
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL 89 90)
- list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR 90)
-endif()
-
-if(CMAKE_CUDA_COMPILER_TOOLKIT_VERSION VERSION_GREATER_EQUAL 12.0
- AND (NOT CMAKE_CUDA_COMPILER_ID STREQUAL "Clang"))
- list(REMOVE_ITEM CMAKE_CUDA_ARCHITECTURES_ALL 35 37)
- list(REMOVE_ITEM CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR 35)
-endif()
-
-# only generate jit code for the newest arch for all/all-major
-list(POP_BACK CMAKE_CUDA_ARCHITECTURES_ALL _latest_arch)
-list(TRANSFORM CMAKE_CUDA_ARCHITECTURES_ALL APPEND "-real")
-list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL ${_latest_arch})
-
-list(POP_BACK CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR _latest_arch)
-list(TRANSFORM CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR APPEND "-real")
-list(APPEND CMAKE_CUDA_ARCHITECTURES_ALL_MAJOR ${_latest_arch})
-
-unset(_latest_arch)
diff --git a/cmake/share/cmake-3.27/Modules/CheckIPOSupported/main.c b/cmake/share/cmake-3.27/Modules/CheckIPOSupported/main.c
deleted file mode 100644
index e71d02a4..00000000
--- a/cmake/share/cmake-3.27/Modules/CheckIPOSupported/main.c
+++ /dev/null
@@ -1,6 +0,0 @@
-int foo();
-
-int main()
-{
- return foo();
-}
diff --git a/cmake/share/cmake-3.27/Modules/CheckLibraryExists.lists.in b/cmake/share/cmake-3.27/Modules/CheckLibraryExists.lists.in
deleted file mode 100644
index 9ae04171..00000000
--- a/cmake/share/cmake-3.27/Modules/CheckLibraryExists.lists.in
+++ /dev/null
@@ -1,8 +0,0 @@
-PROJECT(CHECK_LIBRARY_EXISTS)
-
-
-ADD_DEFINITIONS(-DCHECK_FUNCTION_EXISTS=${CHECK_LIBRARY_EXISTS_FUNCTION})
-LINK_DIRECTORIES(${CHECK_LIBRARY_EXISTS_LOCATION})
-ADD_EXECUTABLE(CheckLibraryExists ${CHECK_LIBRARY_EXISTS_SOURCE})
-TARGET_LINK_LIBRARIES(CheckLibraryExists ${CHECK_LIBRARY_EXISTS_LIBRARY})
-
diff --git a/cmake/share/cmake-3.27/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake b/cmake/share/cmake-3.27/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake
deleted file mode 100644
index 58a66715..00000000
--- a/cmake/share/cmake-3.27/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake
+++ /dev/null
@@ -1,7 +0,0 @@
-
-set(_compiler_id_pp_test "defined(__COMO__)")
-
-set(_compiler_id_version_compute "
- /* __COMO_VERSION__ = VRR */
-# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__COMO_VERSION__ / 100)
-# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__COMO_VERSION__ % 100)")
diff --git a/cmake/share/cmake-3.27/Modules/Compiler/GNU-C.cmake b/cmake/share/cmake-3.27/Modules/Compiler/GNU-C.cmake
deleted file mode 100644
index f6e29737..00000000
--- a/cmake/share/cmake-3.27/Modules/Compiler/GNU-C.cmake
+++ /dev/null
@@ -1,49 +0,0 @@
-include(Compiler/GNU)
-__compiler_gnu(C)
-
-
-if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
- AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
- AND CMAKE_DEPFILE_FLAGS_C)
- # dependencies are computed by the compiler itself
- set(CMAKE_C_DEPFILE_FORMAT gcc)
- set(CMAKE_C_DEPENDS_USE_COMPILER TRUE)
-endif()
-
-set(CMAKE_C_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c)
-
-if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.5)
- set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90")
- set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90")
-elseif (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.4)
- set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c89")
- set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu89")
-endif()
-
-if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.4)
- set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
- set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99")
- set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99")
- set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
-endif()
-
-if (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.7)
- set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")
- set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")
- set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)
-elseif (NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.6)
- set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c1x")
- set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu1x")
-endif()
-
-if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)
- set(CMAKE_C17_STANDARD_COMPILE_OPTION "-std=c17")
- set(CMAKE_C17_EXTENSION_COMPILE_OPTION "-std=gnu17")
-endif()
-
-if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 9.1)
- set(CMAKE_C23_STANDARD_COMPILE_OPTION "-std=c2x")
- set(CMAKE_C23_EXTENSION_COMPILE_OPTION "-std=gnu2x")
-endif()
-
-__compiler_check_default_language_standard(C 3.4 90 5.0 11 8.1 17)
diff --git a/cmake/share/cmake-3.27/Modules/Compiler/GNU-CXX.cmake b/cmake/share/cmake-3.27/Modules/Compiler/GNU-CXX.cmake
deleted file mode 100644
index e296c377..00000000
--- a/cmake/share/cmake-3.27/Modules/Compiler/GNU-CXX.cmake
+++ /dev/null
@@ -1,74 +0,0 @@
-include(Compiler/GNU)
-__compiler_gnu(CXX)
-
-
-if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
- AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
- AND CMAKE_DEPFILE_FLAGS_CXX)
- # dependencies are computed by the compiler itself
- set(CMAKE_CXX_DEPFILE_FORMAT gcc)
- set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
-endif()
-
-set(CMAKE_CXX_COMPILE_OPTIONS_EXPLICIT_LANGUAGE -x c++)
-
-if (WIN32)
- if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
- set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fno-keep-inline-dllexport")
- endif()
-else()
- if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.0)
- set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
- endif()
-endif()
-
-if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
- set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98")
- set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
-endif()
-
-if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7)
- set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
- set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11")
- set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
-elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.4)
- # 4.3 supports 0x variants
- set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++0x")
- set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++0x")
-endif()
-
-if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8.1)
- set(CMAKE_CXX11_STANDARD__HAS_FULL_SUPPORT ON)
-endif()
-
-if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
- set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14")
- set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
-elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
- set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++1y")
- set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++1y")
-endif()
-
-if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
- set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
-endif()
-
-if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
- set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17")
- set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
-elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
- set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++1z")
- set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
-endif()
-
-if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 11.1)
- set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++20")
- set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++20")
- set(CMAKE_CXX23_STANDARD_COMPILE_OPTION "-std=c++23")
- set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-std=gnu++23")
-elseif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.0)
- set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
- set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
-endif()
-
-__compiler_check_default_language_standard(CXX 3.4 98 6.0 14 11.1 17)
diff --git a/cmake/share/cmake-3.27/Modules/Compiler/NVIDIA-CUDA.cmake b/cmake/share/cmake-3.27/Modules/Compiler/NVIDIA-CUDA.cmake
deleted file mode 100644
index 00c6c916..00000000
--- a/cmake/share/cmake-3.27/Modules/Compiler/NVIDIA-CUDA.cmake
+++ /dev/null
@@ -1,175 +0,0 @@
-include(Compiler/CMakeCommonCompilerMacros)
-
-set(CMAKE_CUDA_COMPILER_HAS_DEVICE_LINK_PHASE True)
-set(CMAKE_CUDA_VERBOSE_FLAG "-v")
-set(CMAKE_CUDA_VERBOSE_COMPILE_FLAG "-Xcompiler=-v")
-
-set(_CMAKE_COMPILE_AS_CUDA_FLAG "-x cu")
-set(_CMAKE_CUDA_WHOLE_FLAG "-c")
-set(_CMAKE_CUDA_RDC_FLAG "-rdc=true")
-set(_CMAKE_CUDA_PTX_FLAG "-ptx")
-set(_CMAKE_CUDA_CUBIN_FLAG "-cubin")
-set(_CMAKE_CUDA_FATBIN_FLAG "-fatbin")
-if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL "11.7.0")
- set(_CMAKE_CUDA_OPTIX_FLAG "-optix-ir")
-endif()
-
-if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 10.2.89)
- # The -forward-unknown-to-host-compiler flag was only
- # added to nvcc in 10.2 so before that we had no good
- # way to invoke the CUDA compiler and propagate unknown
- # flags such as -pthread to the host compiler
- set(_CMAKE_CUDA_EXTRA_FLAGS "-forward-unknown-to-host-compiler")
-else()
- set(_CMAKE_CUDA_EXTRA_FLAGS "")
-endif()
-
-if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL "8.0.0")
- set(_CMAKE_CUDA_EXTRA_DEVICE_LINK_FLAGS "-Wno-deprecated-gpu-targets")
-else()
- set(_CMAKE_CUDA_EXTRA_DEVICE_LINK_FLAGS "")
-endif()
-
-if(CMAKE_CUDA_HOST_COMPILER AND NOT CMAKE_GENERATOR MATCHES "Visual Studio")
- string(APPEND _CMAKE_CUDA_EXTRA_FLAGS " -ccbin=")
-endif()
-
-if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 10.2.89)
- # Starting in 10.2, nvcc supported treating all warnings as errors
- set(CMAKE_CUDA_COMPILE_OPTIONS_WARNING_AS_ERROR "-Werror" "all-warnings")
-endif()
-
-if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 10.2.89)
- # The -MD flag was only added to nvcc in 10.2 so
- # before that we had to invoke the compiler twice
- # to get header dependency information
- set(CMAKE_DEPFILE_FLAGS_CUDA "-MD -MT -MF ")
-else()
- set(CMAKE_CUDA_DEPENDS_EXTRA_COMMANDS " ${_CMAKE_CUDA_EXTRA_FLAGS} ${_CMAKE_COMPILE_AS_CUDA_FLAG} -M -MT -o ")
-endif()
-set(CMAKE_CUDA_DEPFILE_FORMAT gcc)
-if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
- AND CMAKE_GENERATOR MATCHES "Makefiles|WMake")
- set(CMAKE_CUDA_DEPENDS_USE_COMPILER TRUE)
-endif()
-
-if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 11.2)
- set(_CMAKE_CUDA_IPO_SUPPORTED_BY_CMAKE YES)
- set(_CMAKE_CUDA_IPO_MAY_BE_SUPPORTED_BY_COMPILER YES)
-
- set(CMAKE_CUDA_DEVICE_LINK_OPTIONS_IPO " -dlto")
-endif()
-
-if(NOT "x${CMAKE_CUDA_SIMULATE_ID}" STREQUAL "xMSVC")
- set(CMAKE_CUDA_COMPILE_OPTIONS_PIE -Xcompiler=-fPIE)
- set(CMAKE_CUDA_COMPILE_OPTIONS_PIC -Xcompiler=-fPIC)
- set(CMAKE_CUDA_COMPILE_OPTIONS_VISIBILITY -Xcompiler=-fvisibility=)
- # CMAKE_SHARED_LIBRARY_CUDA_FLAGS is sent to the host linker so we
- # don't need to forward it through nvcc.
- set(CMAKE_SHARED_LIBRARY_CUDA_FLAGS -fPIC)
- string(APPEND CMAKE_CUDA_FLAGS_INIT " ")
- string(APPEND CMAKE_CUDA_FLAGS_DEBUG_INIT " -g")
- string(APPEND CMAKE_CUDA_FLAGS_RELEASE_INIT " -O3 -DNDEBUG")
- string(APPEND CMAKE_CUDA_FLAGS_MINSIZEREL_INIT " -O1 -DNDEBUG")
- string(APPEND CMAKE_CUDA_FLAGS_RELWITHDEBINFO_INIT " -O2 -g -DNDEBUG")
-endif()
-
-set(CMAKE_SHARED_LIBRARY_CREATE_CUDA_FLAGS -shared)
-set(CMAKE_INCLUDE_SYSTEM_FLAG_CUDA "-isystem ")
-
-if (CMAKE_CUDA_SIMULATE_ID STREQUAL "GNU")
- set(CMAKE_CUDA_LINKER_WRAPPER_FLAG "-Wl,")
- set(CMAKE_CUDA_LINKER_WRAPPER_FLAG_SEP ",")
-elseif(CMAKE_CUDA_SIMULATE_ID STREQUAL "Clang")
- set(CMAKE_CUDA_LINKER_WRAPPER_FLAG "-Xlinker" " ")
- set(CMAKE_CUDA_LINKER_WRAPPER_FLAG_SEP)
-endif()
-
-set(CMAKE_CUDA_DEVICE_COMPILER_WRAPPER_FLAG "-Xcompiler=")
-set(CMAKE_CUDA_DEVICE_COMPILER_WRAPPER_FLAG_SEP ",")
-set(CMAKE_CUDA_DEVICE_LINKER_WRAPPER_FLAG "-Xlinker=")
-set(CMAKE_CUDA_DEVICE_LINKER_WRAPPER_FLAG_SEP ",")
-
-set(CMAKE_CUDA_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC "cudadevrt;cudart_static")
-set(CMAKE_CUDA_RUNTIME_LIBRARY_LINK_OPTIONS_SHARED "cudadevrt;cudart")
-set(CMAKE_CUDA_RUNTIME_LIBRARY_LINK_OPTIONS_NONE "")
-
-if(UNIX AND NOT (CMAKE_SYSTEM_NAME STREQUAL "QNX"))
- list(APPEND CMAKE_CUDA_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC "rt" "pthread" "dl")
-endif()
-
-if("x${CMAKE_CUDA_SIMULATE_ID}" STREQUAL "xMSVC")
- # MSVC requires c++14 as the minimum level
- set(CMAKE_CUDA03_STANDARD_COMPILE_OPTION "")
- set(CMAKE_CUDA03_EXTENSION_COMPILE_OPTION "")
-
- # MSVC requires c++14 as the minimum level
- set(CMAKE_CUDA11_STANDARD_COMPILE_OPTION "")
- set(CMAKE_CUDA11_EXTENSION_COMPILE_OPTION "")
-
- if (NOT CMAKE_CUDA_COMPILER_VERSION VERSION_LESS 9.0)
- if(CMAKE_CUDA_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.10.25017)
- set(CMAKE_CUDA14_STANDARD_COMPILE_OPTION "-std=c++14")
- set(CMAKE_CUDA14_EXTENSION_COMPILE_OPTION "-std=c++14")
- else()
- set(CMAKE_CUDA14_STANDARD_COMPILE_OPTION "")
- set(CMAKE_CUDA14_EXTENSION_COMPILE_OPTION "")
- endif()
- endif()
-
- if (NOT CMAKE_CUDA_COMPILER_VERSION VERSION_LESS 11.0)
- if(CMAKE_CUDA_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.11.25505)
- set(CMAKE_CUDA17_STANDARD_COMPILE_OPTION "-std=c++17")
- set(CMAKE_CUDA17_EXTENSION_COMPILE_OPTION "-std=c++17")
- endif()
- endif()
-
- if (NOT CMAKE_CUDA_COMPILER_VERSION VERSION_LESS 12.0)
- if(CMAKE_CUDA_SIMULATE_VERSION VERSION_GREATER_EQUAL 19.11.25505)
- set(CMAKE_CUDA20_STANDARD_COMPILE_OPTION "-std=c++20")
- set(CMAKE_CUDA20_EXTENSION_COMPILE_OPTION "-std=c++20")
- endif()
- endif()
-
-else()
- set(CMAKE_CUDA03_STANDARD_COMPILE_OPTION "")
- set(CMAKE_CUDA03_EXTENSION_COMPILE_OPTION "")
-
- set(CMAKE_CUDA11_STANDARD_COMPILE_OPTION "-std=c++11")
- set(CMAKE_CUDA11_EXTENSION_COMPILE_OPTION "-std=c++11")
-
- if (NOT CMAKE_CUDA_COMPILER_VERSION VERSION_LESS 9.0)
- set(CMAKE_CUDA03_STANDARD_COMPILE_OPTION "-std=c++03")
- set(CMAKE_CUDA03_EXTENSION_COMPILE_OPTION "-std=c++03")
- set(CMAKE_CUDA14_STANDARD_COMPILE_OPTION "-std=c++14")
- set(CMAKE_CUDA14_EXTENSION_COMPILE_OPTION "-std=c++14")
- endif()
-
- if (NOT CMAKE_CUDA_COMPILER_VERSION VERSION_LESS 11.0)
- set(CMAKE_CUDA17_STANDARD_COMPILE_OPTION "-std=c++17")
- set(CMAKE_CUDA17_EXTENSION_COMPILE_OPTION "-std=c++17")
- endif()
-
- if (NOT CMAKE_CUDA_COMPILER_VERSION VERSION_LESS 12.0)
- set(CMAKE_CUDA20_STANDARD_COMPILE_OPTION "-std=c++20")
- set(CMAKE_CUDA20_EXTENSION_COMPILE_OPTION "-std=c++20")
- endif()
-
-endif()
-
-if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL "9.0")
- set(CMAKE_CUDA_RESPONSE_FILE_DEVICE_LINK_FLAG "--options-file ")
- set(CMAKE_CUDA_RESPONSE_FILE_FLAG "--options-file ")
-endif()
-
-if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL "11.0")
- set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_INCLUDES 1)
- set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_LIBRARIES 1)
- set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_OBJECTS 1)
-else()
- set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_INCLUDES 0)
- set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_LIBRARIES 0)
- set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_OBJECTS 0)
-endif()
-
-__compiler_check_default_language_standard(CUDA 6.0 03)
diff --git a/cmake/share/cmake-3.27/Modules/ExternalProject.cmake b/cmake/share/cmake-3.27/Modules/ExternalProject.cmake
deleted file mode 100644
index a741e409..00000000
--- a/cmake/share/cmake-3.27/Modules/ExternalProject.cmake
+++ /dev/null
@@ -1,4358 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-include_guard(GLOBAL)
-
-#[=======================================================================[.rst:
-ExternalProject
----------------
-
-.. only:: html
-
- .. contents::
-
-Commands
-^^^^^^^^
-
-External Project Definition
-"""""""""""""""""""""""""""
-
-.. command:: ExternalProject_Add
-
- The ``ExternalProject_Add()`` function creates a custom target to drive
- download, update/patch, configure, build, install and test steps of an
- external project:
-
- .. code-block:: cmake
-
- ExternalProject_Add( [...])
-
- The individual steps within the process can be driven independently if
- required (e.g. for CDash submission) and extra custom steps can be defined,
- along with the ability to control the step dependencies. The directory
- structure used for the management of the external project can also be
- customized. The function supports a large number of options which can be used
- to tailor the external project behavior.
-
- **Directory Options:**
- Most of the time, the default directory layout is sufficient. It is largely
- an implementation detail that the main project usually doesn't need to
- change. In some circumstances, however, control over the directory layout
- can be useful or necessary. The directory options are potentially more
- useful from the point of view that the main build can use the
- :command:`ExternalProject_Get_Property` command to retrieve their values,
- thereby allowing the main project to refer to build artifacts of the
- external project.
-
- ``PREFIX ``
- Root directory for the external project. Unless otherwise noted below,
- all other directories associated with the external project will be
- created under here.
-
- ``TMP_DIR ``
- Directory in which to store temporary files.
-
- ``STAMP_DIR ``
- Directory in which to store the timestamps of each step. Log files from
- individual steps are also created in here unless overridden by LOG_DIR
- (see *Logging Options* below).
-
- ``LOG_DIR ``
- .. versionadded:: 3.14
-
- Directory in which to store the logs of each step.
-
- ``DOWNLOAD_DIR ``
- Directory in which to store downloaded files before unpacking them. This
- directory is only used by the URL download method, all other download
- methods use ``SOURCE_DIR`` directly instead.
-
- ``SOURCE_DIR ``
- Source directory into which downloaded contents will be unpacked, or for
- non-URL download methods, the directory in which the repository should be
- checked out, cloned, etc. If no download method is specified, this must
- point to an existing directory where the external project has already
- been unpacked or cloned/checked out.
-
- .. note::
- If a download method is specified, any existing contents of the source
- directory may be deleted. Only the URL download method checks whether
- this directory is either missing or empty before initiating the
- download, stopping with an error if it is not empty. All other
- download methods silently discard any previous contents of the source
- directory.
-
- ``BINARY_DIR ``
- Specify the build directory location. This option is ignored if
- ``BUILD_IN_SOURCE`` is enabled.
-
- ``INSTALL_DIR ``
- Installation prefix to be placed in the ```` placeholder.
- This does not actually configure the external project to install to
- the given prefix. That must be done by passing appropriate arguments
- to the external project configuration step, e.g. using ````.
-
- If any of the above ``..._DIR`` options are not specified, their defaults
- are computed as follows. If the ``PREFIX`` option is given or the
- ``EP_PREFIX`` directory property is set, then an external project is built
- and installed under the specified prefix::
-
- TMP_DIR = /tmp
- STAMP_DIR = /src/-stamp
- DOWNLOAD_DIR = /src
- SOURCE_DIR = /src/