diff --git a/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmliblzma/COPYING b/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmliblzma/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..20e60d5b2427334e1fec6701e7c5ad0da0bc8a5d --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmliblzma/COPYING @@ -0,0 +1,65 @@ + +XZ Utils Licensing +================== + + Different licenses apply to different files in this package. Here + is a rough summary of which licenses apply to which parts of this + package (but check the individual files to be sure!): + + - liblzma is in the public domain. + + - xz, xzdec, and lzmadec command line tools are in the public + domain unless GNU getopt_long had to be compiled and linked + in from the lib directory. The getopt_long code is under + GNU LGPLv2.1+. + + - The scripts to grep, diff, and view compressed files have been + adapted from gzip. These scripts and their documentation are + under GNU GPLv2+. + + - All the documentation in the doc directory and most of the + XZ Utils specific documentation files in other directories + are in the public domain. + + - Translated messages are in the public domain. + + - The build system contains public domain files, and files that + are under GNU GPLv2+ or GNU GPLv3+. None of these files end up + in the binaries being built. + + - Test files and test code in the tests directory, and debugging + utilities in the debug directory are in the public domain. + + - The extra directory may contain public domain files, and files + that are under various free software licenses. + + You can do whatever you want with the files that have been put into + the public domain. If you find public domain legally problematic, + take the previous sentence as a license grant. If you still find + the lack of copyright legally problematic, you have too many + lawyers. + + As usual, this software is provided "as is", without any warranty. + + If you copy significant amounts of public domain code from XZ Utils + into your project, acknowledging this somewhere in your software is + polite (especially if it is proprietary, non-free software), but + naturally it is not legally required. Here is an example of a good + notice to put into "about box" or into documentation: + + This software includes code from XZ Utils . + + The following license texts are included in the following files: + - COPYING.LGPLv2.1: GNU Lesser General Public License version 2.1 + - COPYING.GPLv2: GNU General Public License version 2 + - COPYING.GPLv3: GNU General Public License version 3 + + Note that the toolchain (compiler, linker etc.) may add some code + pieces that are copyrighted. Thus, it is possible that e.g. liblzma + binary wouldn't actually be in the public domain in its entirety + even though it contains no copyrighted code from the XZ Utils source + package. + + If you have questions, don't hesitate to ask the author(s) for more + information. + diff --git a/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmlibrhash/COPYING b/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmlibrhash/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..be7d4a9fc73daf2c3d75e10b3817b2fe15f7dc4f --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmlibrhash/COPYING @@ -0,0 +1,15 @@ + + BSD Zero Clause License + +Copyright (c) 2005, Aleksey Kravchenko + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmlibuv/LICENSE b/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmlibuv/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..eb126dab3aab52eacffbb506ecc92ffecb7acc0d --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmlibuv/LICENSE @@ -0,0 +1,66 @@ +libuv is licensed for use as follows: + +==== +Copyright (c) 2015-present libuv project contributors. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to +deal in the Software without restriction, including without limitation the +rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +IN THE SOFTWARE. +==== + +This license applies to parts of libuv originating from the +https://github.com/joyent/libuv repository: + +==== + +Copyright Joyent, Inc. and other Node contributors. All rights reserved. +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to +deal in the Software without restriction, including without limitation the +rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +IN THE SOFTWARE. + +==== + +This license applies to all parts of libuv that are not externally +maintained libraries. + +The externally maintained libraries used by libuv are: + + - tree.h (from FreeBSD), copyright Niels Provos. Two clause BSD license. + + - inet_pton and inet_ntop implementations, contained in src/inet.c, are + copyright the Internet Systems Consortium, Inc., and licensed under the ISC + license. + + - stdint-msvc2008.h (from msinttypes), copyright Alexander Chemeris. Three + clause BSD license. + + - pthread-fixes.c, copyright Google Inc. and Sony Mobile Communications AB. + Three clause BSD license. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmnghttp2/COPYING b/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmnghttp2/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..80201792ec7234674ea584ef1303d5f428558ae9 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmnghttp2/COPYING @@ -0,0 +1,23 @@ +The MIT License + +Copyright (c) 2012, 2014, 2015, 2016 Tatsuhiro Tsujikawa +Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmzstd/LICENSE b/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmzstd/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..75800288cc243f164b9d130f125e2ffae28f8e39 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/doc/cmake-3.31/cmzstd/LICENSE @@ -0,0 +1,30 @@ +BSD License + +For Zstandard software + +Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * 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. + + * Neither the name Facebook, nor Meta, nor the names of its 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 HOLDER 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. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/aclocal/cmake.m4 b/mgm/lib/python3.10/site-packages/cmake/data/share/aclocal/cmake.m4 new file mode 100644 index 0000000000000000000000000000000000000000..39826bcd2ee9cf243ea155bb8665ab17251b461c --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/aclocal/cmake.m4 @@ -0,0 +1,44 @@ +dnl Distributed under the OSI-approved BSD 3-Clause License. See accompanying +dnl file Copyright.txt or https://cmake.org/licensing for details. + +AC_DEFUN([CMAKE_FIND_BINARY], +[AC_ARG_VAR([CMAKE_BINARY], [path to the cmake binary])dnl + +if test "x$ac_cv_env_CMAKE_BINARY_set" != "xset"; then + AC_PATH_TOOL([CMAKE_BINARY], [cmake])dnl +fi +])dnl + +# $1: package name +# $2: language (e.g. C/CXX/Fortran) +# $3: The compiler ID, defaults to GNU. +# Possible values are: GNU, Intel, Clang, SunPro, HP, XL, VisualAge, PGI, +# PathScale, Cray, SCO, MSVC, LCC +# $4: optional extra arguments to cmake, e.g. "-DCMAKE_SIZEOF_VOID_P=8" +# $5: optional path to cmake binary +AC_DEFUN([CMAKE_FIND_PACKAGE], [ +AC_REQUIRE([CMAKE_FIND_BINARY])dnl + +AC_ARG_VAR([$1][_][$2][FLAGS], [$2 compiler flags for $1. This overrides the cmake output])dnl +AC_ARG_VAR([$1][_LIBS], [linker flags for $1. This overrides the cmake output])dnl + +failed=false +AC_MSG_CHECKING([for $1]) +if test -z "${$1[]_$2[]FLAGS}"; then + $1[]_$2[]FLAGS=`$CMAKE_BINARY --find-package "-DNAME=$1" "-DCOMPILER_ID=m4_default([$3], [GNU])" "-DLANGUAGE=$2" -DMODE=COMPILE $4` || failed=true +fi +if test -z "${$1[]_LIBS}"; then + $1[]_LIBS=`$CMAKE_BINARY --find-package "-DNAME=$1" "-DCOMPILER_ID=m4_default([$3], [GNU])" "-DLANGUAGE=$2" -DMODE=LINK $4` || failed=true +fi + +if $failed; then + unset $1[]_$2[]FLAGS + unset $1[]_LIBS + + AC_MSG_RESULT([no]) + $6 +else + AC_MSG_RESULT([yes]) + $5 +fi[]dnl +]) diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX.txt b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX.txt new file mode 100644 index 0000000000000000000000000000000000000000..56c77c1e2b5c09817559c1f8670a9dc2f0d94b20 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX.txt @@ -0,0 +1,253 @@ +A short-hand signature is: + +.. parsed-literal:: + + |FIND_XXX| ( name1 [path1 path2 ...]) + +The general signature is: + +.. parsed-literal:: + + |FIND_XXX| ( + + name | |NAMES| + [HINTS [path | ENV var]... ] + [PATHS [path | ENV var]... ] + [REGISTRY_VIEW (64|32|64_32|32_64|HOST|TARGET|BOTH)] + [PATH_SUFFIXES suffix1 [suffix2 ...]] + [VALIDATOR function] + [DOC "cache documentation string"] + [NO_CACHE] + [REQUIRED] + [NO_DEFAULT_PATH] + [NO_PACKAGE_ROOT_PATH] + [NO_CMAKE_PATH] + [NO_CMAKE_ENVIRONMENT_PATH] + [NO_SYSTEM_ENVIRONMENT_PATH] + [NO_CMAKE_SYSTEM_PATH] + [NO_CMAKE_INSTALL_PREFIX] + [CMAKE_FIND_ROOT_PATH_BOTH | + ONLY_CMAKE_FIND_ROOT_PATH | + NO_CMAKE_FIND_ROOT_PATH] + ) + +This command is used to find a |SEARCH_XXX_DESC|. +A cache entry, or a normal variable if ``NO_CACHE`` is specified, +named by ```` is created to store the result of this command. +If the |SEARCH_XXX| is found the result is stored in the variable +and the search will not be repeated unless the variable is cleared. +If nothing is found, the result will be ``-NOTFOUND``. + +Options include: + +``NAMES`` + Specify one or more possible names for the |SEARCH_XXX|. + + When using this to specify names with and without a version + suffix, we recommend specifying the unversioned name first + so that locally-built packages can be found before those + provided by distributions. + +``HINTS``, ``PATHS`` + Specify directories to search in addition to the default locations. + The ``ENV var`` sub-option reads paths from a system environment + variable. + + .. versionchanged:: 3.24 + On ``Windows`` platform, it is possible to include registry queries as part + of the directories, using a :ref:`dedicated syntax `. + Such specifications will be ignored on all other platforms. + +``REGISTRY_VIEW`` + .. versionadded:: 3.24 + + .. include:: FIND_XXX_REGISTRY_VIEW.txt + +``PATH_SUFFIXES`` + Specify additional subdirectories to check below each directory + location otherwise considered. + +``VALIDATOR`` + .. versionadded:: 3.25 + + Specify a :command:`function` to be called for each candidate item found + (a :command:`macro` cannot be provided, that will result in an error). + Two arguments will be passed to the validator function: the name of a + result variable, and the absolute path to the candidate item. The item + will be accepted and the search will end unless the function sets the + value in the result variable to false in the calling scope. The result + variable will hold a true value when the validator function is entered. + + .. parsed-literal:: + + function(my_check validator_result_var item) + if(NOT item MATCHES ...) + set(${validator_result_var} FALSE PARENT_SCOPE) + endif() + endfunction() + + |FIND_XXX| (result NAMES ... VALIDATOR my_check) + + Note that if a cached result is used, the search is skipped and any + ``VALIDATOR`` is ignored. The cached result is not required to pass the + validation function. + +``DOC`` + Specify the documentation string for the ```` cache entry. + +``NO_CACHE`` + .. versionadded:: 3.21 + + The result of the search will be stored in a normal variable rather than + a cache entry. + + .. note:: + + If the variable is already set before the call (as a normal or cache + variable) then the search will not occur. + + .. warning:: + + This option should be used with caution because it can greatly increase + the cost of repeated configure steps. + +``REQUIRED`` + .. versionadded:: 3.18 + + Stop processing with an error message if nothing is found, otherwise + the search will be attempted again the next time |FIND_XXX| is invoked + with the same variable. + +If ``NO_DEFAULT_PATH`` is specified, then no additional paths are +added to the search. +If ``NO_DEFAULT_PATH`` is not specified, the search process is as follows: + +.. |FIND_PACKAGE_ROOT_PREFIX_PATH_XXX_SUBDIR| replace:: + |prefix_XXX_SUBDIR| for each ```` in the + :variable:`_ROOT` CMake variable and the + :envvar:`_ROOT` environment variable if + called from within a find module loaded by + :command:`find_package()` + +.. |CMAKE_PREFIX_PATH_XXX_SUBDIR| replace:: + |prefix_XXX_SUBDIR| for each ```` in :variable:`CMAKE_PREFIX_PATH` + +.. |ENV_CMAKE_PREFIX_PATH_XXX_SUBDIR| replace:: + |prefix_XXX_SUBDIR| for each ```` in :envvar:`CMAKE_PREFIX_PATH` + +.. |SYSTEM_ENVIRONMENT_PREFIX_PATH_XXX_SUBDIR| replace:: + |prefix_XXX_SUBDIR| for each ``/[s]bin`` in ``PATH``, and + |entry_XXX_SUBDIR| for other entries in ``PATH`` + +.. |CMAKE_SYSTEM_PREFIX_PATH_XXX_SUBDIR| replace:: + |prefix_XXX_SUBDIR| for each ```` in + :variable:`CMAKE_SYSTEM_PREFIX_PATH` + +1. If called from within a find module or any other script loaded by a call to + :command:`find_package()`, search prefixes unique to the + current package being found. See policy :policy:`CMP0074`. + + .. versionadded:: 3.12 + + Specifically, search paths specified by the following variables, in order: + + a. :variable:`_ROOT` CMake variable, + where ```` is the case-preserved package name. + + b. :variable:`_ROOT` CMake variable, + where ```` is the upper-cased package name. + See policy :policy:`CMP0144`. + + .. versionadded:: 3.27 + + c. :envvar:`_ROOT` environment variable, + where ```` is the case-preserved package name. + + d. :envvar:`_ROOT` environment variable, + where ```` is the upper-cased package name. + See policy :policy:`CMP0144`. + + .. versionadded:: 3.27 + + The package root variables are maintained as a stack, so if called from + nested find modules or config packages, root paths from the parent's find + module or config package will be searched after paths from the current + module or package. In other words, the search order would be + ``_ROOT``, ``ENV{_ROOT}``, + ``_ROOT``, ``ENV{_ROOT}``, etc. + This can be skipped if ``NO_PACKAGE_ROOT_PATH`` is passed or by setting + the :variable:`CMAKE_FIND_USE_PACKAGE_ROOT_PATH` to ``FALSE``. + + * |FIND_PACKAGE_ROOT_PREFIX_PATH_XXX| + +2. Search paths specified in cmake-specific cache variables. + These are intended to be used on the command line with a ``-DVAR=value``. + The values are interpreted as :ref:`semicolon-separated lists `. + This can be skipped if ``NO_CMAKE_PATH`` is passed or by setting the + :variable:`CMAKE_FIND_USE_CMAKE_PATH` to ``FALSE``. + + * |CMAKE_PREFIX_PATH_XXX| + * |CMAKE_XXX_PATH| + * |CMAKE_XXX_MAC_PATH| + +3. Search paths specified in cmake-specific environment variables. + These are intended to be set in the user's shell configuration, + and therefore use the host's native path separator + (``;`` on Windows and ``:`` on UNIX). + This can be skipped if ``NO_CMAKE_ENVIRONMENT_PATH`` is passed or + by setting the :variable:`CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH` to ``FALSE``. + + * |ENV_CMAKE_PREFIX_PATH_XXX| + * |ENV_CMAKE_XXX_PATH| + * |ENV_CMAKE_XXX_MAC_PATH| + +4. Search the paths specified by the ``HINTS`` option. + These should be paths computed by system introspection, such as a + hint provided by the location of another item already found. + Hard-coded guesses should be specified with the ``PATHS`` option. + +5. Search the standard system environment variables. + This can be skipped if ``NO_SYSTEM_ENVIRONMENT_PATH`` is passed or by + setting the :variable:`CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH` to ``FALSE``. + + * |SYSTEM_ENVIRONMENT_PATH_XXX| + + |SYSTEM_ENVIRONMENT_PATH_WINDOWS_XXX| + +6. Search cmake variables defined in the Platform files + for the current system. The searching of ``CMAKE_INSTALL_PREFIX`` and + ``CMAKE_STAGING_PREFIX`` can be + skipped if ``NO_CMAKE_INSTALL_PREFIX`` is passed or by setting the + :variable:`CMAKE_FIND_USE_INSTALL_PREFIX` to ``FALSE``. All these locations + can be skipped if ``NO_CMAKE_SYSTEM_PATH`` is passed or by setting the + :variable:`CMAKE_FIND_USE_CMAKE_SYSTEM_PATH` to ``FALSE``. + + * |CMAKE_SYSTEM_PREFIX_PATH_XXX| + * |CMAKE_SYSTEM_XXX_PATH| + * |CMAKE_SYSTEM_XXX_MAC_PATH| + + The platform paths that these variables contain are locations that + typically include installed software. An example being ``/usr/local`` for + UNIX based platforms. + +7. Search the paths specified by the PATHS option + or in the short-hand version of the command. + These are typically hard-coded guesses. + +The :variable:`CMAKE_IGNORE_PATH`, :variable:`CMAKE_IGNORE_PREFIX_PATH`, +:variable:`CMAKE_SYSTEM_IGNORE_PATH` and +:variable:`CMAKE_SYSTEM_IGNORE_PREFIX_PATH` variables can also cause some +of the above locations to be ignored. + +.. versionadded:: 3.16 + Added ``CMAKE_FIND_USE__PATH`` variables to globally disable + various search locations. + +.. |FIND_ARGS_XXX| replace:: NAMES name + +On macOS the :variable:`CMAKE_FIND_FRAMEWORK` and +:variable:`CMAKE_FIND_APPBUNDLE` variables determine the order of +preference between Apple-style and unix-style package components. + +.. include:: FIND_XXX_ROOT.txt +.. include:: FIND_XXX_ORDER.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX_ORDER.txt b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX_ORDER.txt new file mode 100644 index 0000000000000000000000000000000000000000..bac2419645ad17f714913bf16637b7d855606d25 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX_ORDER.txt @@ -0,0 +1,12 @@ +The default search order is designed to be most-specific to +least-specific for common use cases. +Projects may override the order by simply calling the command +multiple times and using the ``NO_*`` options: + +.. parsed-literal:: + + |FIND_XXX| (|FIND_ARGS_XXX| PATHS paths... NO_DEFAULT_PATH) + |FIND_XXX| (|FIND_ARGS_XXX|) + +Once one of the calls succeeds the result variable will be set +and stored in the cache so that no call will search again. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX_REGISTRY_VIEW.txt b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX_REGISTRY_VIEW.txt new file mode 100644 index 0000000000000000000000000000000000000000..6cab1d13a4fb14a9a5683a54bca6e8237ca37c25 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/FIND_XXX_REGISTRY_VIEW.txt @@ -0,0 +1,41 @@ +Specify which registry views must be queried. This option is only meaningful +on ``Windows`` platforms and will be ignored on other ones. When not +specified, the |FIND_XXX_REGISTRY_VIEW_DEFAULT| view is used when the +:policy:`CMP0134` policy is ``NEW``. Refer to :policy:`CMP0134` for the +default view when the policy is ``OLD``. + +``64`` + Query the 64-bit registry. On 32-bit Windows, it always returns the string + ``/REGISTRY-NOTFOUND``. + +``32`` + Query the 32-bit registry. + +``64_32`` + Query both views (``64`` and ``32``) and generate a path for each. + +``32_64`` + Query both views (``32`` and ``64``) and generate a path for each. + +``HOST`` + Query the registry matching the architecture of the host: ``64`` on 64-bit + Windows and ``32`` on 32-bit Windows. + +``TARGET`` + Query the registry matching the architecture specified by the + :variable:`CMAKE_SIZEOF_VOID_P` variable. If not defined, fall back to + ``HOST`` view. + +``BOTH`` + Query both views (``32`` and ``64``). The order depends on the following + rules: If the :variable:`CMAKE_SIZEOF_VOID_P` variable is defined, use the + following view depending on the content of this variable: + + * ``8``: ``64_32`` + * ``4``: ``32_64`` + + If the :variable:`CMAKE_SIZEOF_VOID_P` variable is not defined, rely on the + architecture of the host: + + * 64-bit: ``64_32`` + * 32-bit: ``32`` diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/GENEX_NOTE.txt b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/GENEX_NOTE.txt new file mode 100644 index 0000000000000000000000000000000000000000..4a7906ce95f2707a20127a99f05983eabf4ea1ac --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/GENEX_NOTE.txt @@ -0,0 +1,6 @@ +.. |more_see_also| replace:: See the :manual:`cmake-buildsystem(7)` manual + for more on defining buildsystem properties. + +Arguments to |command_name| may use generator expressions +with the syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` +manual for available expressions. |more_see_also| diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/LINK_OPTIONS_LINKER.txt b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/LINK_OPTIONS_LINKER.txt new file mode 100644 index 0000000000000000000000000000000000000000..e71e5ea25dc33555aca9acedf1644d7a7227dd89 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/LINK_OPTIONS_LINKER.txt @@ -0,0 +1,25 @@ +Handling Compiler Driver Differences +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +To pass options to the linker tool, each compiler driver has its own syntax. +The ``LINKER:`` prefix and ``,`` separator can be used to specify, in a portable +way, options to pass to the linker tool. ``LINKER:`` is replaced by the +appropriate driver option and ``,`` by the appropriate driver separator. +The driver prefix and driver separator are given by the values of the +:variable:`CMAKE__LINKER_WRAPPER_FLAG` and +:variable:`CMAKE__LINKER_WRAPPER_FLAG_SEP` variables. + +For example, ``"LINKER:-z,defs"`` becomes ``-Xlinker -z -Xlinker defs`` for +``Clang`` and ``-Wl,-z,defs`` for ``GNU GCC``. + +The ``LINKER:`` prefix can be specified as part of a ``SHELL:`` prefix +expression. + +The ``LINKER:`` prefix supports, as an alternative syntax, specification of +arguments using the ``SHELL:`` prefix and space as separator. The previous +example then becomes ``"LINKER:SHELL:-z defs"``. + +.. note:: + + Specifying the ``SHELL:`` prefix anywhere other than at the beginning of the + ``LINKER:`` prefix is not supported. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_executable.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_executable.rst new file mode 100644 index 0000000000000000000000000000000000000000..b6833b4106bffe78061bfbdc8eb3c5d9eefa103e --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_executable.rst @@ -0,0 +1,123 @@ +add_executable +-------------- + +.. only:: html + + .. contents:: + +Add an executable to the project using the specified source files. + +Normal Executables +^^^^^^^^^^^^^^^^^^ + +.. signature:: + add_executable( ... ...) + :target: normal + + Add an executable target called ```` to be built from the source + files listed in the command invocation. + + The options are: + + ``WIN32`` + Set the :prop_tgt:`WIN32_EXECUTABLE` target property automatically. + See documentation of that target property for details. + + ``MACOSX_BUNDLE`` + Set the :prop_tgt:`MACOSX_BUNDLE` target property automatically. + See documentation of that target property for details. + + ``EXCLUDE_FROM_ALL`` + Set the :prop_tgt:`EXCLUDE_FROM_ALL` target property automatically. + See documentation of that target property for details. + +The ```` corresponds to the logical target name and must be globally +unique within a project. The actual file name of the executable built is +constructed based on conventions of the native platform (such as +``.exe`` or just ````). + +.. versionadded:: 3.1 + Source arguments to ``add_executable`` may use "generator expressions" with + the syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` + manual for available expressions. + +.. versionadded:: 3.11 + The source files can be omitted if they are added later using + :command:`target_sources`. + +By default the executable file will be created in the build tree +directory corresponding to the source tree directory in which the +command was invoked. See documentation of the +:prop_tgt:`RUNTIME_OUTPUT_DIRECTORY` target property to change this +location. See documentation of the :prop_tgt:`OUTPUT_NAME` target property +to change the ```` part of the final file name. + +See the :manual:`cmake-buildsystem(7)` manual for more on defining +buildsystem properties. + +See also :prop_sf:`HEADER_FILE_ONLY` on what to do if some sources are +pre-processed, and you want to have the original sources reachable from +within IDE. + +Imported Executables +^^^^^^^^^^^^^^^^^^^^ + +.. signature:: + add_executable( IMPORTED [GLOBAL]) + :target: IMPORTED + + Add an :ref:`IMPORTED executable target ` to reference + an executable file located outside the project. The target name may be + referenced like any target built within the project, except that by + default it is visible only in the directory in which it is created, + and below. + + The options are: + + ``GLOBAL`` + Make the target name globally visible. + +No rules are generated to build imported targets, and the :prop_tgt:`IMPORTED` +target property is ``True``. Imported executables are useful for convenient +reference from commands like :command:`add_custom_command`. + +Details about the imported executable are specified by setting properties +whose names begin in ``IMPORTED_``. The most important such property is +:prop_tgt:`IMPORTED_LOCATION` (and its per-configuration version +:prop_tgt:`IMPORTED_LOCATION_`) which specifies the location of +the main executable file on disk. See documentation of the ``IMPORTED_*`` +properties for more information. + +Alias Executables +^^^^^^^^^^^^^^^^^ + +.. signature:: + add_executable( ALIAS ) + :target: ALIAS + + Creates an :ref:`Alias Target `, such that ```` can + be used to refer to ```` in subsequent commands. The ```` + does not appear in the generated buildsystem as a make target. The + ```` may not be an ``ALIAS``. + +.. versionadded:: 3.11 + An ``ALIAS`` can target a ``GLOBAL`` :ref:`Imported Target ` + +.. versionadded:: 3.18 + An ``ALIAS`` can target a non-``GLOBAL`` Imported Target. Such alias is + scoped to the directory in which it is created and subdirectories. + The :prop_tgt:`ALIAS_GLOBAL` target property can be used to check if the + alias is global or not. + +``ALIAS`` targets can be used as targets to read properties +from, executables for custom commands and custom targets. They can also be +tested for existence with the regular :command:`if(TARGET)` subcommand. +The ```` may not be used to modify properties of ````, that +is, it may not be used as the operand of :command:`set_property`, +:command:`set_target_properties`, :command:`target_link_libraries` etc. +An ``ALIAS`` target may not be installed or exported. + +See Also +^^^^^^^^ + +* :command:`add_library` diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_library.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_library.rst new file mode 100644 index 0000000000000000000000000000000000000000..cab380e6d1233bba0a7045400f1c03e3986579af --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_library.rst @@ -0,0 +1,302 @@ +add_library +----------- + +.. only:: html + + .. contents:: + +Add a library to the project using the specified source files. + +Normal Libraries +^^^^^^^^^^^^^^^^ + +.. signature:: + add_library( [] [EXCLUDE_FROM_ALL] ...) + :target: normal + + Add a library target called ```` to be built from the source files + listed in the command invocation. + + The optional ```` specifies the type of library to be created: + + ``STATIC`` + An archive of object files for use when linking other targets. + + ``SHARED`` + A dynamic library that may be linked by other targets and loaded + at runtime. + + ``MODULE`` + A plugin that may not be linked by other targets, but may be + dynamically loaded at runtime using dlopen-like functionality. + + If no ```` is given the default is ``STATIC`` or ``SHARED`` + based on the value of the :variable:`BUILD_SHARED_LIBS` variable. + + The options are: + + ``EXCLUDE_FROM_ALL`` + Set the :prop_tgt:`EXCLUDE_FROM_ALL` target property automatically. + See documentation of that target property for details. + +The ```` corresponds to the logical target name and must be globally +unique within a project. The actual file name of the library built is +constructed based on conventions of the native platform (such as +``lib.a`` or ``.lib``). + +.. versionadded:: 3.1 + Source arguments to ``add_library`` may use "generator expressions" with + the syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` + manual for available expressions. + +.. versionadded:: 3.11 + The source files can be omitted if they are added later using + :command:`target_sources`. + +For ``SHARED`` and ``MODULE`` libraries the +:prop_tgt:`POSITION_INDEPENDENT_CODE` target +property is set to ``ON`` automatically. +A ``SHARED`` library may be marked with the :prop_tgt:`FRAMEWORK` +target property to create an macOS Framework. + +.. versionadded:: 3.8 + A ``STATIC`` library may be marked with the :prop_tgt:`FRAMEWORK` + target property to create a static Framework. + +If a library does not export any symbols, it must not be declared as a +``SHARED`` library. For example, a Windows resource DLL or a managed C++/CLI +DLL that exports no unmanaged symbols would need to be a ``MODULE`` library. +This is because CMake expects a ``SHARED`` library to always have an +associated import library on Windows. + +By default the library file will be created in the build tree directory +corresponding to the source tree directory in which the command was +invoked. See documentation of the :prop_tgt:`ARCHIVE_OUTPUT_DIRECTORY`, +:prop_tgt:`LIBRARY_OUTPUT_DIRECTORY`, and +:prop_tgt:`RUNTIME_OUTPUT_DIRECTORY` target properties to change this +location. See documentation of the :prop_tgt:`OUTPUT_NAME` target +property to change the ```` part of the final file name. + +See the :manual:`cmake-buildsystem(7)` manual for more on defining +buildsystem properties. + +See also :prop_sf:`HEADER_FILE_ONLY` on what to do if some sources are +pre-processed, and you want to have the original sources reachable from +within IDE. + +.. versionchanged:: 3.30 + + On platforms that do not support shared libraries, ``add_library`` + now fails on calls creating ``SHARED`` libraries instead of + automatically converting them to ``STATIC`` libraries as before. + See policy :policy:`CMP0164`. + +Object Libraries +^^^^^^^^^^^^^^^^ + +.. signature:: + add_library( OBJECT ...) + :target: OBJECT + + Add an :ref:`Object Library ` to compile source files + without archiving or linking their object files into a library. + +Other targets created by ``add_library`` or :command:`add_executable` +may reference the objects using an expression of the +form :genex:`$\ ` as a source, where +``objlib`` is the object library name. For example: + +.. code-block:: cmake + + add_library(... $ ...) + add_executable(... $ ...) + +will include objlib's object files in a library and an executable +along with those compiled from their own sources. Object libraries +may contain only sources that compile, header files, and other files +that would not affect linking of a normal library (e.g. ``.txt``). +They may contain custom commands generating such sources, but not +``PRE_BUILD``, ``PRE_LINK``, or ``POST_BUILD`` commands. Some native build +systems (such as Xcode) may not like targets that have only object files, so +consider adding at least one real source file to any target that references +:genex:`$\ `. + +.. versionadded:: 3.12 + Object libraries can be linked to with :command:`target_link_libraries`. + +Interface Libraries +^^^^^^^^^^^^^^^^^^^ + +.. signature:: + add_library( INTERFACE) + :target: INTERFACE + + Add an :ref:`Interface Library ` target that may + specify usage requirements for dependents but does not compile sources + and does not produce a library artifact on disk. + + An interface library with no source files is not included as a target + in the generated buildsystem. However, it may have + properties set on it and it may be installed and exported. + Typically, ``INTERFACE_*`` properties are populated on an interface + target using the commands: + + * :command:`set_property`, + * :command:`target_link_libraries(INTERFACE)`, + * :command:`target_link_options(INTERFACE)`, + * :command:`target_include_directories(INTERFACE)`, + * :command:`target_compile_options(INTERFACE)`, + * :command:`target_compile_definitions(INTERFACE)`, and + * :command:`target_sources(INTERFACE)`, + + and then it is used as an argument to :command:`target_link_libraries` + like any other target. + + .. versionadded:: 3.15 + An interface library can have :prop_tgt:`PUBLIC_HEADER` and + :prop_tgt:`PRIVATE_HEADER` properties. The headers specified by those + properties can be installed using the :command:`install(TARGETS)` command. + +.. signature:: + add_library( INTERFACE [EXCLUDE_FROM_ALL] ...) + :target: INTERFACE-with-sources + + .. versionadded:: 3.19 + + Add an :ref:`Interface Library ` target with + source files (in addition to usage requirements and properties as + documented by the :command:`above signature `). + Source files may be listed directly in the ``add_library`` call + or added later by calls to :command:`target_sources` with the + ``PRIVATE`` or ``PUBLIC`` keywords. + + If an interface library has source files (i.e. the :prop_tgt:`SOURCES` + target property is set), or header sets (i.e. the :prop_tgt:`HEADER_SETS` + target property is set), it will appear in the generated buildsystem + as a build target much like a target defined by the + :command:`add_custom_target` command. It does not compile any sources, + but does contain build rules for custom commands created by the + :command:`add_custom_command` command. + + The options are: + + ``EXCLUDE_FROM_ALL`` + Set the :prop_tgt:`EXCLUDE_FROM_ALL` target property automatically. + See documentation of that target property for details. + + .. note:: + In most command signatures where the ``INTERFACE`` keyword appears, + the items listed after it only become part of that target's usage + requirements and are not part of the target's own settings. However, + in this signature of ``add_library``, the ``INTERFACE`` keyword refers + to the library type only. Sources listed after it in the ``add_library`` + call are ``PRIVATE`` to the interface library and do not appear in its + :prop_tgt:`INTERFACE_SOURCES` target property. + +.. _`add_library imported libraries`: + +Imported Libraries +^^^^^^^^^^^^^^^^^^ + +.. signature:: + add_library( IMPORTED [GLOBAL]) + :target: IMPORTED + + Add an :ref:`IMPORTED library target ` called ````. + The target name may be referenced like any target built within the project, + except that by default it is visible only in the directory in which it is + created, and below. + + The ```` must be one of: + + ``STATIC``, ``SHARED``, ``MODULE``, ``UNKNOWN`` + References a library file located outside the project. The + :prop_tgt:`IMPORTED_LOCATION` target property (or its per-configuration + variant :prop_tgt:`IMPORTED_LOCATION_`) specifies the + location of the main library file on disk: + + * For a ``SHARED`` library on most non-Windows platforms, the main library + file is the ``.so`` or ``.dylib`` file used by both linkers and dynamic + loaders. If the referenced library file has a ``SONAME`` (or on macOS, + has a ``LC_ID_DYLIB`` starting in ``@rpath/``), the value of that field + should be set in the :prop_tgt:`IMPORTED_SONAME` target property. + If the referenced library file does not have a ``SONAME``, but the + platform supports it, then the :prop_tgt:`IMPORTED_NO_SONAME` target + property should be set. + + * For a ``SHARED`` library on Windows, the :prop_tgt:`IMPORTED_IMPLIB` + target property (or its per-configuration variant + :prop_tgt:`IMPORTED_IMPLIB_`) specifies the location of the + DLL import library file (``.lib`` or ``.dll.a``) on disk, and the + ``IMPORTED_LOCATION`` is the location of the ``.dll`` runtime + library (and is optional, but needed by the :genex:`TARGET_RUNTIME_DLLS` + generator expression). + + Additional usage requirements may be specified in ``INTERFACE_*`` + properties. + + An ``UNKNOWN`` library type is typically only used in the implementation + of :ref:`Find Modules`. It allows the path to an imported library + (often found using the :command:`find_library` command) to be used + without having to know what type of library it is. This is especially + useful on Windows where a static library and a DLL's import library + both have the same file extension. + + ``OBJECT`` + References a set of object files located outside the project. + The :prop_tgt:`IMPORTED_OBJECTS` target property (or its per-configuration + variant :prop_tgt:`IMPORTED_OBJECTS_`) specifies the locations of + object files on disk. + Additional usage requirements may be specified in ``INTERFACE_*`` + properties. + + ``INTERFACE`` + Does not reference any library or object files on disk, but may + specify usage requirements in ``INTERFACE_*`` properties. + + The options are: + + ``GLOBAL`` + Make the target name globally visible. + +No rules are generated to build imported targets, and the :prop_tgt:`IMPORTED` +target property is ``True``. Imported libraries are useful for convenient +reference from commands like :command:`target_link_libraries`. + +Details about the imported library are specified by setting properties whose +names begin in ``IMPORTED_`` and ``INTERFACE_``. See documentation of +such properties for more information. + +Alias Libraries +^^^^^^^^^^^^^^^ + +.. signature:: + add_library( ALIAS ) + :target: ALIAS + + Creates an :ref:`Alias Target `, such that ```` can be + used to refer to ```` in subsequent commands. The ```` does + not appear in the generated buildsystem as a make target. The ```` + may not be an ``ALIAS``. + +.. versionadded:: 3.11 + An ``ALIAS`` can target a ``GLOBAL`` :ref:`Imported Target ` + +.. versionadded:: 3.18 + An ``ALIAS`` can target a non-``GLOBAL`` Imported Target. Such alias is + scoped to the directory in which it is created and below. + The :prop_tgt:`ALIAS_GLOBAL` target property can be used to check if the + alias is global or not. + +``ALIAS`` targets can be used as linkable targets and as targets to +read properties from. They can also be tested for existence with the +regular :command:`if(TARGET)` subcommand. The ```` may not be used +to modify properties of ````, that is, it may not be used as the +operand of :command:`set_property`, :command:`set_target_properties`, +:command:`target_link_libraries` etc. An ``ALIAS`` target may not be +installed or exported. + +See Also +^^^^^^^^ + +* :command:`add_executable` diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/cmake_file_api.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/cmake_file_api.rst new file mode 100644 index 0000000000000000000000000000000000000000..e7ee7e7adb2b59b3cb564f8fa9e97a0bec8f6500 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/cmake_file_api.rst @@ -0,0 +1,78 @@ +cmake_file_api +-------------- + +.. versionadded:: 3.27 + +Enables interacting with the :manual:`CMake file API `. + +.. signature:: + cmake_file_api(QUERY ...) + + The ``QUERY`` subcommand adds a file API query for the current CMake + invocation. + + .. code-block:: cmake + + cmake_file_api( + QUERY + API_VERSION + [CODEMODEL ...] + [CACHE ...] + [CMAKEFILES ...] + [TOOLCHAINS ...] + ) + + The ``API_VERSION`` must always be given. Currently, the only supported + value for ```` is 1. See :ref:`file-api v1` for details of the + reply content and location. + + Each of the optional keywords ``CODEMODEL``, ``CACHE``, ``CMAKEFILES`` and + ``TOOLCHAINS`` correspond to one of the object kinds that can be requested + by the project. The ``configureLog`` object kind cannot be set with this + command, since it must be set before CMake starts reading the top level + ``CMakeLists.txt`` file. + + For each of the optional keywords, the ```` list must contain one + or more version values of the form ``major`` or ``major.minor``, where + ``major`` and ``minor`` are integers. Projects should list the versions they + accept in their preferred order, as only the first supported value from the + list will be selected. The command will ignore versions with a ``major`` + version higher than any major version it supports for that object kind. + It will raise an error if it encounters an invalid version number, or if none + of the requested versions is supported. + + For each type of object kind requested, a query equivalent to a shared, + stateless query will be added internally. No query file will be created in + the file system. The reply *will* be written to the file system at + generation time. + + It is not an error to add a query for the same thing more than once, whether + from query files or from multiple calls to ``cmake_file_api(QUERY)``. + The final set of queries will be a merged combination of all queries + specified on disk and queries submitted by the project. + +Example +^^^^^^^ + +A project may want to use replies from the file API at build time to implement +some form of verification task. Instead of relying on something outside of +CMake to create a query file, the project can use ``cmake_file_api(QUERY)`` +to request the required information for the current run. It can then create +a custom command to run at build time, knowing that the requested information +should always be available. + +.. code-block:: cmake + + cmake_file_api( + QUERY + API_VERSION 1 + CODEMODEL 2.3 + TOOLCHAINS 1 + ) + + add_custom_target(verify_project + COMMAND ${CMAKE_COMMAND} + -D BUILD_DIR=${CMAKE_BINARY_DIR} + -D CONFIG=$ + -P ${CMAKE_CURRENT_SOURCE_DIR}/verify_project.cmake + ) diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/cmake_language.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/cmake_language.rst new file mode 100644 index 0000000000000000000000000000000000000000..a9c76537338a0d7fd8292b82e3194db43f110871 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/cmake_language.rst @@ -0,0 +1,536 @@ +cmake_language +-------------- + +.. versionadded:: 3.18 + +Call meta-operations on CMake commands. + +Synopsis +^^^^^^^^ + +.. parsed-literal:: + + cmake_language(`CALL`_ [...]) + cmake_language(`EVAL`_ CODE ...) + cmake_language(`DEFER`_ ... CALL [...]) + cmake_language(`SET_DEPENDENCY_PROVIDER`_ SUPPORTED_METHODS ...) + cmake_language(`GET_MESSAGE_LOG_LEVEL`_ ) + cmake_language(`EXIT`_ ) + +Introduction +^^^^^^^^^^^^ + +This command will call meta-operations on built-in CMake commands or +those created via the :command:`macro` or :command:`function` commands. + +``cmake_language`` does not introduce a new variable or policy scope. + +Calling Commands +^^^^^^^^^^^^^^^^ + +.. signature:: + cmake_language(CALL [...]) + + Calls the named ```` with the given arguments (if any). + For example, the code: + + .. code-block:: cmake + + set(message_command "message") + cmake_language(CALL ${message_command} STATUS "Hello World!") + + is equivalent to + + .. code-block:: cmake + + message(STATUS "Hello World!") + + .. note:: + To ensure consistency of the code, the following commands are not allowed: + + * ``if`` / ``elseif`` / ``else`` / ``endif`` + * ``block`` / ``endblock`` + * ``while`` / ``endwhile`` + * ``foreach`` / ``endforeach`` + * ``function`` / ``endfunction`` + * ``macro`` / ``endmacro`` + +Evaluating Code +^^^^^^^^^^^^^^^ + +.. signature:: + cmake_language(EVAL CODE ...) + :target: EVAL + + Evaluates the ``...`` as CMake code. + + For example, the code: + + .. code-block:: cmake + + set(A TRUE) + set(B TRUE) + set(C TRUE) + set(condition "(A AND B) OR C") + + cmake_language(EVAL CODE " + if (${condition}) + message(STATUS TRUE) + else() + message(STATUS FALSE) + endif()" + ) + + is equivalent to + + .. code-block:: cmake + + set(A TRUE) + set(B TRUE) + set(C TRUE) + set(condition "(A AND B) OR C") + + file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/eval.cmake " + if (${condition}) + message(STATUS TRUE) + else() + message(STATUS FALSE) + endif()" + ) + + include(${CMAKE_CURRENT_BINARY_DIR}/eval.cmake) + +Deferring Calls +^^^^^^^^^^^^^^^ + +.. versionadded:: 3.19 + +.. signature:: + cmake_language(DEFER ... CALL [...]) + + Schedules a call to the named ```` with the given arguments (if any) + to occur at a later time. By default, deferred calls are executed as if + written at the end of the current directory's ``CMakeLists.txt`` file, + except that they run even after a :command:`return` call. Variable + references in arguments are evaluated at the time the deferred call is + executed. + + The options are: + + ``DIRECTORY `` + Schedule the call for the end of the given directory instead of the + current directory. The ```` may reference either a source + directory or its corresponding binary directory. Relative paths are + treated as relative to the current source directory. + + The given directory must be known to CMake, being either the top-level + directory or one added by :command:`add_subdirectory`. Furthermore, + the given directory must not yet be finished processing. This means + it can be the current directory or one of its ancestors. + + ``ID `` + Specify an identification for the deferred call. + The ```` may not be empty and may not begin with a capital letter ``A-Z``. + The ```` may begin with an underscore (``_``) only if it was generated + automatically by an earlier call that used ``ID_VAR`` to get the id. + + ``ID_VAR `` + Specify a variable in which to store the identification for the + deferred call. If ``ID `` is not given, a new identification + will be generated and the generated id will start with an underscore (``_``). + + The currently scheduled list of deferred calls may be retrieved: + + .. code-block:: cmake + + cmake_language(DEFER [DIRECTORY ] GET_CALL_IDS ) + + This will store in ```` a :ref:`semicolon-separated list ` of deferred call ids. The ids are for the directory scope in which + the calls have been deferred to (i.e. where they will be executed), which can + be different to the scope in which they were created. The ``DIRECTORY`` + option can be used to specify the scope for which to retrieve the call ids. + If that option is not given, the call ids for the current directory scope + will be returned. + + Details of a specific call may be retrieved from its id: + + .. code-block:: cmake + + cmake_language(DEFER [DIRECTORY ] GET_CALL ) + + This will store in ```` a :ref:`semicolon-separated list ` in which the first element is the name of the command to be + called, and the remaining elements are its unevaluated arguments (any + contained ``;`` characters are included literally and cannot be distinguished + from multiple arguments). If multiple calls are scheduled with the same id, + this retrieves the first one. If no call is scheduled with the given id in + the specified ``DIRECTORY`` scope (or the current directory scope if no + ``DIRECTORY`` option is given), this stores an empty string in the variable. + + Deferred calls may be canceled by their id: + + .. code-block:: cmake + + cmake_language(DEFER [DIRECTORY ] CANCEL_CALL ...) + + This cancels all deferred calls matching any of the given ids in the specified + ``DIRECTORY`` scope (or the current directory scope if no ``DIRECTORY`` option + is given). Unknown ids are silently ignored. + +Deferred Call Examples +"""""""""""""""""""""" + +For example, the code: + +.. code-block:: cmake + + cmake_language(DEFER CALL message "${deferred_message}") + cmake_language(DEFER ID_VAR id CALL message "Canceled Message") + cmake_language(DEFER CANCEL_CALL ${id}) + message("Immediate Message") + set(deferred_message "Deferred Message") + +prints:: + + Immediate Message + Deferred Message + +The ``Canceled Message`` is never printed because its command is +canceled. The ``deferred_message`` variable reference is not evaluated +until the call site, so it can be set after the deferred call is scheduled. + +In order to evaluate variable references immediately when scheduling a +deferred call, wrap it using ``cmake_language(EVAL)``. However, note that +arguments will be re-evaluated in the deferred call, though that can be +avoided by using bracket arguments. For example: + +.. code-block:: cmake + + set(deferred_message "Deferred Message 1") + set(re_evaluated [[${deferred_message}]]) + cmake_language(EVAL CODE " + cmake_language(DEFER CALL message [[${deferred_message}]]) + cmake_language(DEFER CALL message \"${re_evaluated}\") + ") + message("Immediate Message") + set(deferred_message "Deferred Message 2") + +also prints:: + + Immediate Message + Deferred Message 1 + Deferred Message 2 + +.. _dependency_providers: + +Dependency Providers +^^^^^^^^^^^^^^^^^^^^ + +.. versionadded:: 3.24 + +.. note:: A high-level introduction to this feature can be found in the + :ref:`Using Dependencies Guide `. + +.. signature:: + cmake_language(SET_DEPENDENCY_PROVIDER + SUPPORTED_METHODS ...) + + When a call is made to :command:`find_package` or + :command:`FetchContent_MakeAvailable`, the call may be forwarded to a + dependency provider which then has the opportunity to fulfill the request. + If the request is for one of the ```` specified when the provider + was set, CMake calls the provider's ```` with a set of + method-specific arguments. If the provider does not fulfill the request, + or if the provider doesn't support the request's method, or no provider + is set, the built-in :command:`find_package` or + :command:`FetchContent_MakeAvailable` implementation is used to fulfill + the request in the usual way. + + One or more of the following values can be specified for the ```` + when setting the provider: + + ``FIND_PACKAGE`` + The provider command accepts :command:`find_package` requests. + + ``FETCHCONTENT_MAKEAVAILABLE_SERIAL`` + The provider command accepts :command:`FetchContent_MakeAvailable` + requests. It expects each dependency to be fed to the provider command + one at a time, not the whole list in one go. + + Only one provider can be set at any point in time. If a provider is already + set when ``cmake_language(SET_DEPENDENCY_PROVIDER)`` is called, the new + provider replaces the previously set one. The specified ```` must + already exist when ``cmake_language(SET_DEPENDENCY_PROVIDER)`` is called. + As a special case, providing an empty string for the ```` and no + ```` will discard any previously set provider. + + The dependency provider can only be set while processing one of the files + specified by the :variable:`CMAKE_PROJECT_TOP_LEVEL_INCLUDES` variable. + Thus, dependency providers can only be set as part of the first call to + :command:`project`. Calling ``cmake_language(SET_DEPENDENCY_PROVIDER)`` + outside of that context will result in an error. + + .. versionadded:: 3.30 + The :prop_gbl:`PROPAGATE_TOP_LEVEL_INCLUDES_TO_TRY_COMPILE` global + property can be set if the dependency provider also wants to be enabled + in whole-project calls to :command:`try_compile`. + + .. note:: + The choice of dependency provider should always be under the user's control. + As a convenience, a project may choose to provide a file that users can + list in their :variable:`CMAKE_PROJECT_TOP_LEVEL_INCLUDES` variable, but + the use of such a file should always be the user's choice. + +Provider commands +""""""""""""""""" + +Providers define a single ```` to accept requests. The name of +the command should be specific to that provider, not something overly +generic that another provider might also use. This enables users to compose +different providers in their own custom provider. The recommended form is +``xxx_provide_dependency()``, where ``xxx`` is the provider-specific part +(e.g. ``vcpkg_provide_dependency()``, ``conan_provide_dependency()``, +``ourcompany_provide_dependency()``, and so on). + +.. code-block:: cmake + + xxx_provide_dependency( [...]) + +Because some methods expect certain variables to be set in the calling scope, +the provider command should typically be implemented as a macro rather than a +function. This ensures it does not introduce a new variable scope. + +The arguments CMake passes to the dependency provider depend on the type of +request. The first argument is always the method, and it will only ever +be one of the ```` that was specified when setting the provider. + +``FIND_PACKAGE`` + The ```` will be everything passed to the + :command:`find_package` call that requested the dependency. The first of + these ```` will therefore always be the name of the + dependency. Dependency names are case-sensitive for this method because + :command:`find_package` treats them case-sensitively too. + + If the provider command fulfills the request, it must set the same variable + that :command:`find_package` expects to be set. For a dependency named + ``depName``, the provider must set ``depName_FOUND`` to true if it fulfilled + the request. If the provider returns without setting this variable, CMake + will assume the request was not fulfilled and will fall back to the + built-in implementation. + + If the provider needs to call the built-in :command:`find_package` + implementation as part of its processing, it can do so by including the + ``BYPASS_PROVIDER`` keyword as one of the arguments. + +``FETCHCONTENT_MAKEAVAILABLE_SERIAL`` + The ```` will be everything passed to the + :command:`FetchContent_Declare` call that corresponds to the requested + dependency, with the following exceptions: + + * If ``SOURCE_DIR`` or ``BINARY_DIR`` were not part of the original + declared arguments, they will be added with their default values. + * If :variable:`FETCHCONTENT_TRY_FIND_PACKAGE_MODE` is set to ``NEVER``, + any ``FIND_PACKAGE_ARGS`` will be omitted. + * The ``OVERRIDE_FIND_PACKAGE`` keyword is always omitted. + + The first of the ```` will always be the name of the + dependency. Dependency names are case-insensitive for this method because + :module:`FetchContent` also treats them case-insensitively. + + If the provider fulfills the request, it should call + :command:`FetchContent_SetPopulated`, passing the name of the dependency as + the first argument. The ``SOURCE_DIR`` and ``BINARY_DIR`` arguments to that + command should only be given if the provider makes the dependency's source + and build directories available in exactly the same way as the built-in + :command:`FetchContent_MakeAvailable` command. + + If the provider returns without calling :command:`FetchContent_SetPopulated` + for the named dependency, CMake will assume the request was not fulfilled + and will fall back to the built-in implementation. + + Note that empty arguments may be significant for this method (e.g. an empty + string following a ``GIT_SUBMODULES`` keyword). Therefore, if forwarding + these arguments on to another command, extra care must be taken to avoid such + arguments being silently dropped. + + If ``FETCHCONTENT_SOURCE_DIR_`` is set, then the + dependency provider will never see requests for the ```` dependency + for this method. When the user sets such a variable, they are explicitly + overriding where to get that dependency from and are taking on the + responsibility that their overriding version meets any requirements for that + dependency and is compatible with whatever else in the project uses it. + Depending on the value of :variable:`FETCHCONTENT_TRY_FIND_PACKAGE_MODE` + and whether the ``OVERRIDE_FIND_PACKAGE`` option was given to + :command:`FetchContent_Declare`, having + ``FETCHCONTENT_SOURCE_DIR_`` set may also prevent the + dependency provider from seeing requests for a ``find_package(depName)`` + call too. + +Provider Examples +""""""""""""""""" + +This first example only intercepts :command:`find_package` calls. The +provider command runs an external tool which copies the relevant artifacts +into a provider-specific directory, if that tool knows about the dependency. +It then relies on the built-in implementation to then find those artifacts. +:command:`FetchContent_MakeAvailable` calls would not go through the provider. + +.. code-block:: cmake + :caption: mycomp_provider.cmake + + # Always ensure we have the policy settings this provider expects + cmake_minimum_required(VERSION 3.24) + + set(MYCOMP_PROVIDER_INSTALL_DIR ${CMAKE_BINARY_DIR}/mycomp_packages + CACHE PATH "The directory this provider installs packages to" + ) + # Tell the built-in implementation to look in our area first, unless + # the find_package() call uses NO_..._PATH options to exclude it + list(APPEND CMAKE_MODULE_PATH ${MYCOMP_PROVIDER_INSTALL_DIR}/cmake) + list(APPEND CMAKE_PREFIX_PATH ${MYCOMP_PROVIDER_INSTALL_DIR}) + + macro(mycomp_provide_dependency method package_name) + execute_process( + COMMAND some_tool ${package_name} --installdir ${MYCOMP_PROVIDER_INSTALL_DIR} + COMMAND_ERROR_IS_FATAL ANY + ) + endmacro() + + cmake_language( + SET_DEPENDENCY_PROVIDER mycomp_provide_dependency + SUPPORTED_METHODS FIND_PACKAGE + ) + +The user would then typically use the above file like so:: + + cmake -DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=/path/to/mycomp_provider.cmake ... + +The next example demonstrates a provider that accepts both methods, but +only handles one specific dependency. It enforces providing Google Test +using :module:`FetchContent`, but leaves all other dependencies to be +fulfilled by CMake's built-in implementation. It accepts a few different +names, which demonstrates one way of working around projects that hard-code +an unusual or undesirable way of adding this particular dependency to the +build. The example also demonstrates how to use the :command:`list` command +to preserve variables that may be overwritten by a call to +:command:`FetchContent_MakeAvailable`. + +.. code-block:: cmake + :caption: mycomp_provider.cmake + + cmake_minimum_required(VERSION 3.24) + + # Because we declare this very early, it will take precedence over any + # details the project might declare later for the same thing + include(FetchContent) + FetchContent_Declare( + googletest + GIT_REPOSITORY https://github.com/google/googletest.git + GIT_TAG e2239ee6043f73722e7aa812a459f54a28552929 # release-1.11.0 + ) + + # Both FIND_PACKAGE and FETCHCONTENT_MAKEAVAILABLE_SERIAL methods provide + # the package or dependency name as the first method-specific argument. + macro(mycomp_provide_dependency method dep_name) + if("${dep_name}" MATCHES "^(gtest|googletest)$") + # Save our current command arguments in case we are called recursively + list(APPEND mycomp_provider_args ${method} ${dep_name}) + + # This will forward to the built-in FetchContent implementation, + # which detects a recursive call for the same thing and avoids calling + # the provider again if dep_name is the same as the current call. + FetchContent_MakeAvailable(googletest) + + # Restore our command arguments + list(POP_BACK mycomp_provider_args dep_name method) + + # Tell the caller we fulfilled the request + if("${method}" STREQUAL "FIND_PACKAGE") + # We need to set this if we got here from a find_package() call + # since we used a different method to fulfill the request. + # This example assumes projects only use the gtest targets, + # not any of the variables the FindGTest module may define. + set(${dep_name}_FOUND TRUE) + elseif(NOT "${dep_name}" STREQUAL "googletest") + # We used the same method, but were given a different name to the + # one we populated with. Tell the caller about the name it used. + FetchContent_SetPopulated(${dep_name} + SOURCE_DIR "${googletest_SOURCE_DIR}" + BINARY_DIR "${googletest_BINARY_DIR}" + ) + endif() + endif() + endmacro() + + cmake_language( + SET_DEPENDENCY_PROVIDER mycomp_provide_dependency + SUPPORTED_METHODS + FIND_PACKAGE + FETCHCONTENT_MAKEAVAILABLE_SERIAL + ) + +The final example demonstrates how to modify arguments to a +:command:`find_package` call. It forces all such calls to have the +``QUIET`` keyword. It uses the ``BYPASS_PROVIDER`` keyword to prevent +calling the provider command recursively for the same dependency. + +.. code-block:: cmake + :caption: mycomp_provider.cmake + + cmake_minimum_required(VERSION 3.24) + + macro(mycomp_provide_dependency method) + find_package(${ARGN} BYPASS_PROVIDER QUIET) + endmacro() + + cmake_language( + SET_DEPENDENCY_PROVIDER mycomp_provide_dependency + SUPPORTED_METHODS FIND_PACKAGE + ) + +Getting current message log level +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. versionadded:: 3.25 + +.. _query_message_log_level: + +.. signature:: + cmake_language(GET_MESSAGE_LOG_LEVEL ) + + Writes the current :command:`message` logging level + into the given ````. + + See :command:`message` for the possible logging levels. + + The current message logging level can be set either using the + :option:`--log-level ` + command line option of the :manual:`cmake(1)` program or using + the :variable:`CMAKE_MESSAGE_LOG_LEVEL` variable. + + If both the command line option and the variable are set, the command line + option takes precedence. If neither are set, the default logging level + is returned. + +Terminating Scripts +^^^^^^^^^^^^^^^^^^^ + +.. versionadded:: 3.29 + +.. signature:: + cmake_language(EXIT ) + + Terminate the current :option:`cmake -P` script and exit with ````. + + This command works only in :ref:`script mode