diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_test.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_test.rst new file mode 100644 index 0000000000000000000000000000000000000000..2a3c759d7699e8d05793f416fbaec6cdfb8dc5f6 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/add_test.rst @@ -0,0 +1,117 @@ +add_test +-------- + +Add a test to the project to be run by :manual:`ctest(1)`. + +.. code-block:: cmake + + add_test(NAME COMMAND [...] + [CONFIGURATIONS ...] + [WORKING_DIRECTORY ] + [COMMAND_EXPAND_LISTS]) + +Adds a test called ````. The test name may contain arbitrary +characters, expressed as a :ref:`Quoted Argument` or :ref:`Bracket Argument` +if necessary. See policy :policy:`CMP0110`. + +CMake only generates tests if the :command:`enable_testing` command has been +invoked. The :module:`CTest` module invokes ``enable_testing`` automatically +unless ``BUILD_TESTING`` is set to ``OFF``. + +Tests added with the ``add_test(NAME)`` signature support using +:manual:`generator expressions ` +in test properties set by :command:`set_property(TEST)` or +:command:`set_tests_properties`. Test properties may only be set in the +directory the test is created in. + +``add_test`` options are: + +``COMMAND`` + Specify the test command-line. + + If ```` specifies an executable target created by + :command:`add_executable`: + + * It will automatically be replaced by the location of the executable + created at build time. + + * .. versionadded:: 3.3 + + The target's :prop_tgt:`CROSSCOMPILING_EMULATOR`, if set, will be + used to run the command on the host:: + + + + .. versionchanged:: 3.29 + + The emulator is used only when + :variable:`cross-compiling `. + See policy :policy:`CMP0158`. + + * .. versionadded:: 3.29 + + The target's :prop_tgt:`TEST_LAUNCHER`, if set, will be + used to launch the command:: + + + + If the :prop_tgt:`CROSSCOMPILING_EMULATOR` is also set, both are used:: + + + + The command may be specified using + :manual:`generator expressions `. + +``CONFIGURATIONS`` + Restrict execution of the test only to the named configurations. + +``WORKING_DIRECTORY`` + Set the test property :prop_test:`WORKING_DIRECTORY` in which to execute the + test. If not specified, the test will be run in + :variable:`CMAKE_CURRENT_BINARY_DIR`. The working directory may be specified + using :manual:`generator expressions `. + +``COMMAND_EXPAND_LISTS`` + .. versionadded:: 3.16 + + Lists in ``COMMAND`` arguments will be expanded, including those created with + :manual:`generator expressions `. + +If the test command exits with code ``0`` the test passes. Non-zero exit code +is a "failed" test. The test property :prop_test:`WILL_FAIL` inverts this +logic. Note that system-level test failures such as segmentation faults or +heap errors will still fail the test even if ``WILL_FAIL`` is true. Output +written to stdout or stderr is captured by :manual:`ctest(1)` and only +affects the pass/fail status via the :prop_test:`PASS_REGULAR_EXPRESSION`, +:prop_test:`FAIL_REGULAR_EXPRESSION`, or :prop_test:`SKIP_REGULAR_EXPRESSION` +test properties. + +.. versionadded:: 3.16 + Added :prop_test:`SKIP_REGULAR_EXPRESSION` property. + +Example usage: + +.. code-block:: cmake + + add_test(NAME mytest + COMMAND testDriver --config $ + --exe $) + +This creates a test ``mytest`` whose command runs a ``testDriver`` tool +passing the configuration name and the full path to the executable +file produced by target ``myexe``. + +--------------------------------------------------------------------- + +The command syntax above is recommended over the older, less flexible form: + +.. code-block:: cmake + + add_test( [...]) + +Add a test called ```` with the given command-line. + +Unlike the above ``NAME`` signature, target names are not supported +in the command-line. Furthermore, tests added with this signature do not +support :manual:`generator expressions ` +in the command-line or test properties. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/aux_source_directory.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/aux_source_directory.rst new file mode 100644 index 0000000000000000000000000000000000000000..9619f357fa3a3a3dd945cb9561bd167476dad4c5 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/aux_source_directory.rst @@ -0,0 +1,24 @@ +aux_source_directory +-------------------- + +Find all source files in a directory. + +.. code-block:: cmake + + aux_source_directory( ) + +Collects the names of all the source files in the specified directory +and stores the list in the ```` provided. This command is +intended to be used by projects that use explicit template +instantiation. Template instantiation files can be stored in a +``Templates`` subdirectory and collected automatically using this +command to avoid manually listing all instantiations. + +It is tempting to use this command to avoid writing the list of source +files for a library or executable target. While this seems to work, +there is no way for CMake to generate a build system that knows when a +new source file has been added. Normally the generated build system +knows when it needs to rerun CMake because the ``CMakeLists.txt`` file is +modified to add a new source. When the source is just added to the +directory without modifying this file, one would have to manually +rerun CMake to generate a build system incorporating the new file. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/ctest_build.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/ctest_build.rst new file mode 100644 index 0000000000000000000000000000000000000000..bce17396e0892ac376ab0d078e288afde56e2b66 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/ctest_build.rst @@ -0,0 +1,93 @@ +ctest_build +----------- + +Perform the :ref:`CTest Build Step` as a :ref:`Dashboard Client`. + +.. code-block:: cmake + + ctest_build([BUILD ] [APPEND] + [CONFIGURATION ] + [PARALLEL_LEVEL ] + [FLAGS ] + [PROJECT_NAME ] + [TARGET ] + [NUMBER_ERRORS ] + [NUMBER_WARNINGS ] + [RETURN_VALUE ] + [CAPTURE_CMAKE_ERROR ] + ) + +Build the project and store results in ``Build.xml`` +for submission with the :command:`ctest_submit` command. + +The :variable:`CTEST_BUILD_COMMAND` variable may be set to explicitly +specify the build command line. Otherwise the build command line is +computed automatically based on the options given. + +The options are: + +``BUILD `` + Specify the top-level build directory. If not given, the + :variable:`CTEST_BINARY_DIRECTORY` variable is used. + +``APPEND`` + Mark ``Build.xml`` for append to results previously submitted to a + dashboard server since the last :command:`ctest_start` call. + Append semantics are defined by the dashboard server in use. + This does *not* cause results to be appended to a ``.xml`` file + produced by a previous call to this command. + +``CONFIGURATION `` + Specify the build configuration (e.g. ``Debug``). If not + specified the ``CTEST_BUILD_CONFIGURATION`` variable will be checked. + Otherwise the :option:`-C \ ` option given to the + :manual:`ctest(1)` command will be used, if any. + +``PARALLEL_LEVEL `` + .. versionadded:: 3.21 + + Specify the parallel level of the underlying build system. If not + specified, the :envvar:`CMAKE_BUILD_PARALLEL_LEVEL` environment + variable will be checked. + +``FLAGS `` + Pass additional arguments to the underlying build command. + If not specified the ``CTEST_BUILD_FLAGS`` variable will be checked. + This can, e.g., be used to trigger a parallel build using the + ``-j`` option of ``make``. See the :module:`ProcessorCount` module + for an example. + +``PROJECT_NAME `` + Ignored since CMake 3.0. + + .. versionchanged:: 3.14 + This value is no longer required. + +``TARGET `` + Specify the name of a target to build. If not specified the + ``CTEST_BUILD_TARGET`` variable will be checked. Otherwise the + default target will be built. This is the "all" target + (called ``ALL_BUILD`` in :ref:`Visual Studio Generators`). + +``NUMBER_ERRORS `` + Store the number of build errors detected in the given variable. + +``NUMBER_WARNINGS `` + Store the number of build warnings detected in the given variable. + +``RETURN_VALUE `` + Store the return value of the native build tool in the given variable. + +``CAPTURE_CMAKE_ERROR `` + .. versionadded:: 3.7 + + Store in the ```` variable -1 if there are any errors running + the command and prevent ctest from returning non-zero if an error occurs. + +``QUIET`` + .. versionadded:: 3.3 + + Suppress any CTest-specific non-error output that would have been + printed to the console otherwise. The summary of warnings / errors, + as well as the output from the native build tool is unaffected by + this option. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/endmacro.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/endmacro.rst new file mode 100644 index 0000000000000000000000000000000000000000..4290ba7488ac13a7bd5e57a713cd3780d6d19b43 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/endmacro.rst @@ -0,0 +1,14 @@ +endmacro +-------- + +Ends a list of commands in a macro block. + +.. code-block:: cmake + + endmacro([]) + +See the :command:`macro` command. + +The optional ```` argument is supported for backward compatibility +only. If used it must be a verbatim repeat of the ```` argument +of the opening ``macro`` command. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/execute_process.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/execute_process.rst new file mode 100644 index 0000000000000000000000000000000000000000..1154687b45228a44039c6a72e940e6326034f4f3 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/execute_process.rst @@ -0,0 +1,184 @@ +execute_process +--------------- + +Execute one or more child processes. + +.. code-block:: cmake + + execute_process(COMMAND [] + [COMMAND []]... + [WORKING_DIRECTORY ] + [TIMEOUT ] + [RESULT_VARIABLE ] + [RESULTS_VARIABLE ] + [OUTPUT_VARIABLE ] + [ERROR_VARIABLE ] + [INPUT_FILE ] + [OUTPUT_FILE ] + [ERROR_FILE ] + [OUTPUT_QUIET] + [ERROR_QUIET] + [COMMAND_ECHO ] + [OUTPUT_STRIP_TRAILING_WHITESPACE] + [ERROR_STRIP_TRAILING_WHITESPACE] + [ENCODING ] + [ECHO_OUTPUT_VARIABLE] + [ECHO_ERROR_VARIABLE] + [COMMAND_ERROR_IS_FATAL ]) + +Runs the given sequence of one or more commands. + +Commands are executed concurrently as a pipeline, with the standard +output of each process piped to the standard input of the next. +A single standard error pipe is used for all processes. + +``execute_process`` runs commands while CMake is configuring the project, +prior to build system generation. Use the :command:`add_custom_target` and +:command:`add_custom_command` commands to create custom commands that run +at build time. + +Options: + +``COMMAND`` + A child process command line. + + CMake executes the child process using operating system APIs directly: + + * On POSIX platforms, the command line is passed to the + child process in an ``argv[]`` style array. + + * On Windows platforms, the command line is encoded as a string such + that child processes using ``CommandLineToArgvW`` will decode the + original arguments. + + No intermediate shell is used, so shell operators such as ``>`` + are treated as normal arguments. + (Use the ``INPUT_*``, ``OUTPUT_*``, and ``ERROR_*`` options to + redirect stdin, stdout, and stderr.) + + For **sequential execution** of multiple commands use multiple + ``execute_process`` calls each with a single ``COMMAND`` argument. + +``WORKING_DIRECTORY`` + The named directory will be set as the current working directory of + the child processes. + +``TIMEOUT`` + After the specified number of seconds (fractions allowed), all unfinished + child processes will be terminated, and the ``RESULT_VARIABLE`` will be + set to a string mentioning the "timeout". + +``RESULT_VARIABLE`` + The variable will be set to contain the result of last child process. + This will be an integer return code from the last child or a string + describing an error condition. + +``RESULTS_VARIABLE `` + .. versionadded:: 3.10 + + The variable will be set to contain the result of all processes as a + :ref:`semicolon-separated list `, in order of the + given ``COMMAND`` arguments. Each entry will be an integer return code + from the corresponding child or a string describing an error condition. + +``INPUT_FILE `` + ```` is attached to the standard input pipe of the *first* ``COMMAND`` + process. + +``OUTPUT_FILE `` + ```` is attached to the standard output pipe of the *last* ``COMMAND`` + process. + +``ERROR_FILE `` + ```` is attached to the standard error pipe of *all* ``COMMAND`` + processes. + +.. versionadded:: 3.3 + If the same ```` is named for both ``OUTPUT_FILE`` and ``ERROR_FILE`` + then it will be used for both standard output and standard error pipes. + +``OUTPUT_QUIET``, ``ERROR_QUIET`` + The standard output on ``OUTPUT_VARIABLE`` or standard error on + ``ERROR_VARIABLE`` are not connected (no variable content). + The ``*_FILE`` and ``ECHO_*_VARIABLE`` options are not affected. + +``OUTPUT_VARIABLE``, ``ERROR_VARIABLE`` + The variable named will be set with the contents of the standard output + and standard error pipes, respectively. If the same variable is named + for both pipes their output will be merged in the order produced. + +``ECHO_OUTPUT_VARIABLE``, ``ECHO_ERROR_VARIABLE`` + .. versionadded:: 3.18 + + The standard output or standard error will not be exclusively redirected to + the specified variables. + + The output will be duplicated into the specified variables and also onto + standard output or standard error analogous to the ``tee`` Unix command. + +.. note:: + If more than one ``OUTPUT_*`` or ``ERROR_*`` option is given for the + same pipe the precedence is *not specified*. + If no ``OUTPUT_*`` or ``ERROR_*`` options are given the output will + be shared with the corresponding pipes of the CMake process itself. + +``COMMAND_ECHO `` + .. versionadded:: 3.15 + + The command being run will be echo'ed to ```` with ```` + being set to one of ``STDERR``, ``STDOUT`` or ``NONE``. + See the :variable:`CMAKE_EXECUTE_PROCESS_COMMAND_ECHO` variable for a way + to control the default behavior when this option is not present. + +``ENCODING `` + .. versionadded:: 3.8 + + On Windows, the encoding that is used to decode output from the process. + Ignored on other platforms. + Valid encoding names are: + + ``NONE`` + Perform no decoding. This assumes that the process output is encoded + in the same way as CMake's internal encoding (UTF-8). + + This was the default in CMake 3.14 and older. + + ``AUTO`` + Use the current active console's codepage or if that isn't + available then use ANSI. + + This was the default in CMake 3.15 through 3.30. + + ``ANSI`` + Use the ANSI codepage. + + ``OEM`` + Use the original equipment manufacturer (OEM) code page. + + ``UTF-8`` + .. versionadded:: 3.11 + + Use the UTF-8 codepage. + + This is the default. See policy :policy:`CMP0176`. + + ``UTF8`` + Use the UTF-8 codepage. Use of this name is discouraged in favor + of ``UTF-8`` to match the + `UTF-8 RFC `_ + naming convention. + +``COMMAND_ERROR_IS_FATAL `` + .. versionadded:: 3.19 + + The option following ``COMMAND_ERROR_IS_FATAL`` determines the behavior when + an error is encountered: + + ``ANY`` + If any of the commands in the list of commands fail, the + ``execute_process()`` command halts with an error. + + ``LAST`` + If the last command in the list of commands fails, the + ``execute_process()`` command halts with an error. Commands earlier in the + list will not cause a fatal error. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/list.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/list.rst new file mode 100644 index 0000000000000000000000000000000000000000..47d96a790a5cce203ba5f4fa0026d484d89199c7 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/list.rst @@ -0,0 +1,334 @@ +list +---- + +Operations on :ref:`semicolon-separated lists `. + +Synopsis +^^^^^^^^ + +.. parsed-literal:: + + `Reading`_ + list(`LENGTH`_ ) + list(`GET`_ [ ...] ) + list(`JOIN`_ ) + list(`SUBLIST`_ ) + + `Search`_ + list(`FIND`_ ) + + `Modification`_ + list(`APPEND`_ [...]) + list(`FILTER`_ {INCLUDE | EXCLUDE} REGEX ) + list(`INSERT`_ [...]) + list(`POP_BACK`_ [...]) + list(`POP_FRONT`_ [...]) + list(`PREPEND`_ [...]) + list(`REMOVE_ITEM`_ ...) + list(`REMOVE_AT`_ ...) + list(`REMOVE_DUPLICATES`_ ) + list(`TRANSFORM`_ [...]) + + `Ordering`_ + list(`REVERSE`_ ) + list(`SORT`_ [...]) + +Introduction +^^^^^^^^^^^^ + +The list subcommands :cref:`APPEND`, :cref:`INSERT`, :cref:`FILTER`, +:cref:`PREPEND`, :cref:`POP_BACK`, :cref:`POP_FRONT`, :cref:`REMOVE_AT`, +:cref:`REMOVE_ITEM`, :cref:`REMOVE_DUPLICATES`, :cref:`REVERSE` and +:cref:`SORT` may create new values for the list within the current CMake +variable scope. Similar to the :command:`set` command, the ``list`` command +creates new variable values in the current scope, even if the list itself is +actually defined in a parent scope. To propagate the results of these +operations upwards, use :command:`set` with ``PARENT_SCOPE``, +:command:`set` with ``CACHE INTERNAL``, or some other means of value +propagation. + +.. note:: + + A list in cmake is a ``;`` separated group of strings. To create a + list, the :command:`set` command can be used. For example, + ``set(var a b c d e)`` creates a list with ``a;b;c;d;e``, and + ``set(var "a b c d e")`` creates a string or a list with one item in it. + (Note that macro arguments are not variables, and therefore cannot be used + in ``LIST`` commands.) + + Individual elements may not contain an unequal number of ``[`` and ``]`` + characters, and may not end in a backslash (``\``). + See :ref:`semicolon-separated lists ` for details. + +.. note:: + + When specifying index values, if ```` is 0 or greater, it + is indexed from the beginning of the list, with 0 representing the + first list element. If ```` is -1 or lesser, it is indexed + from the end of the list, with -1 representing the last list element. + Be careful when counting with negative indices: they do not start from + 0. -0 is equivalent to 0, the first list element. + +Reading +^^^^^^^ + +.. signature:: + list(LENGTH ) + + Returns the list's length. + +.. signature:: + list(GET [ ...] ) + + Returns the list of elements specified by indices from the list. + +.. signature:: list(JOIN ) + + .. versionadded:: 3.12 + + Returns a string joining all list's elements using the glue string. + To join multiple strings, which are not part of a list, + use :command:`string(JOIN)`. + +.. signature:: + list(SUBLIST ) + + .. versionadded:: 3.12 + + Returns a sublist of the given list. + If ```` is 0, an empty list will be returned. + If ```` is -1 or the list is smaller than ``+`` then + the remaining elements of the list starting at ```` will be returned. + +Search +^^^^^^ + +.. signature:: + list(FIND ) + + Returns the index of the element specified in the list + or ``-1`` if it wasn't found. + +Modification +^^^^^^^^^^^^ + +.. signature:: + list(APPEND [ ...]) + + Appends elements to the list. If no variable named ```` exists in the + current scope its value is treated as empty and the elements are appended to + that empty list. + +.. signature:: + list(FILTER REGEX ) + +.. versionadded:: 3.6 + +Includes or removes items from the list that match the mode's pattern. +In ``REGEX`` mode, items will be matched against the given regular expression. + +For more information on regular expressions look under +:ref:`string(REGEX) `. + +.. signature:: + list(INSERT [ ...]) + + Inserts elements to the list to the specified index. It is an + error to specify an out-of-range index. Valid indexes are 0 to `N` + where `N` is the length of the list, inclusive. An empty list + has length 0. If no variable named ```` exists in the + current scope its value is treated as empty and the elements are + inserted in that empty list. + +.. signature:: + list(POP_BACK [...]) + + .. versionadded:: 3.15 + + If no variable name is given, removes exactly one element. Otherwise, + with `N` variable names provided, assign the last `N` elements' values + to the given variables and then remove the last `N` values from + ````. + +.. signature:: + list(POP_FRONT [...]) + + .. versionadded:: 3.15 + + If no variable name is given, removes exactly one element. Otherwise, + with `N` variable names provided, assign the first `N` elements' values + to the given variables and then remove the first `N` values from + ````. + +.. signature:: + list(PREPEND [ ...]) + + .. versionadded:: 3.15 + + Insert elements to the 0th position in the list. If no variable named + ```` exists in the current scope its value is treated as empty and + the elements are prepended to that empty list. + +.. signature:: + list(REMOVE_ITEM [ ...]) + + Removes all instances of the given items from the list. + +.. signature:: + list(REMOVE_AT [ ...]) + + Removes items at given indices from the list. + +.. signature:: + list(REMOVE_DUPLICATES ) + + Removes duplicated items in the list. The relative order of items + is preserved, but if duplicates are encountered, + only the first instance is preserved. + +.. signature:: + list(TRANSFORM [] + [OUTPUT_VARIABLE ]) + + .. versionadded:: 3.12 + + Transforms the list by applying an ```` to all or, by specifying a + ````, to the selected elements of the list, storing the result + in-place or in the specified output variable. + + .. note:: + + The ``TRANSFORM`` sub-command does not change the number of elements in the + list. If a ```` is specified, only some elements will be changed, + the other ones will remain the same as before the transformation. + + ```` specifies the action to apply to the elements of the list. + The actions have exactly the same semantics as sub-commands of the + :command:`string` command. ```` must be one of the following: + + :command:`APPEND `, :command:`PREPEND ` + Append, prepend specified value to each element of the list. + + .. signature:: + list(TRANSFORM (APPEND|PREPEND) ...) + :target: TRANSFORM_APPEND + + :command:`TOLOWER `, :command:`TOUPPER ` + Convert each element of the list to lower, upper characters. + + .. signature:: + list(TRANSFORM (TOLOWER|TOUPPER) ...) + :target: TRANSFORM_TOLOWER + + :command:`STRIP ` + Remove leading and trailing spaces from each element of the list. + + .. signature:: + list(TRANSFORM STRIP ...) + :target: TRANSFORM_STRIP + + :command:`GENEX_STRIP ` + Strip any + :manual:`generator expressions ` + from each element of the list. + + .. signature:: + list(TRANSFORM GENEX_STRIP ...) + :target: TRANSFORM_GENEX_STRIP + + :command:`REPLACE `: + Match the regular expression as many times as possible and substitute + the replacement expression for the match for each element of the list + (same semantic as :command:`string(REGEX REPLACE)`). + + .. signature:: + list(TRANSFORM REPLACE + ...) + :target: TRANSFORM_REPLACE + + ```` determines which elements of the list will be transformed. + Only one type of selector can be specified at a time. + When given, ```` must be one of the following: + + ``AT`` + Specify a list of indexes. + + .. code-block:: cmake + + list(TRANSFORM AT [ ...] ...) + + ``FOR`` + Specify a range with, optionally, + an increment used to iterate over the range. + + .. code-block:: cmake + + list(TRANSFORM FOR [] ...) + + ``REGEX`` + Specify a regular expression. + Only elements matching the regular expression will be transformed. + + .. code-block:: cmake + + list(TRANSFORM REGEX ...) + + +Ordering +^^^^^^^^ + +.. signature:: + list(REVERSE ) + + Reverses the contents of the list in-place. + +.. signature:: + list(SORT [COMPARE ] [CASE ] [ORDER ]) + + Sorts the list in-place alphabetically. + + .. versionadded:: 3.13 + Added the ``COMPARE``, ``CASE``, and ``ORDER`` options. + + .. versionadded:: 3.18 + Added the ``COMPARE NATURAL`` option. + + Use the ``COMPARE`` keyword to select the comparison method for sorting. + The ```` option should be one of: + + ``STRING`` + Sorts a list of strings alphabetically. + This is the default behavior if the ``COMPARE`` option is not given. + + ``FILE_BASENAME`` + Sorts a list of pathnames of files by their basenames. + + ``NATURAL`` + Sorts a list of strings using natural order + (see ``strverscmp(3)`` manual), i.e. such that contiguous digits + are compared as whole numbers. + For example: the following list `10.0 1.1 2.1 8.0 2.0 3.1` + will be sorted as `1.1 2.0 2.1 3.1 8.0 10.0` if the ``NATURAL`` + comparison is selected where it will be sorted as + `1.1 10.0 2.0 2.1 3.1 8.0` with the ``STRING`` comparison. + + Use the ``CASE`` keyword to select a case sensitive or case insensitive + sort mode. The ```` option should be one of: + + ``SENSITIVE`` + List items are sorted in a case-sensitive manner. + This is the default behavior if the ``CASE`` option is not given. + + ``INSENSITIVE`` + List items are sorted case insensitively. The order of + items which differ only by upper/lowercase is not specified. + + To control the sort order, the ``ORDER`` keyword can be given. + The ```` option should be one of: + + ``ASCENDING`` + Sorts the list in ascending order. + This is the default behavior when the ``ORDER`` option is not given. + + ``DESCENDING`` + Sorts the list in descending order. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/set_property.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/set_property.rst new file mode 100644 index 0000000000000000000000000000000000000000..f14b63d1f5d1ab86c9963d1f1f7657e740b8b812 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/set_property.rst @@ -0,0 +1,135 @@ +set_property +------------ + +Set a named property in a given scope. + +.. code-block:: cmake + + set_property(] | + TARGET [ ...] | + SOURCE [ ...] + [DIRECTORY ...] + [TARGET_DIRECTORY ...] | + INSTALL [ ...] | + TEST [ ...] + [DIRECTORY ] | + CACHE [ ...] > + [APPEND] [APPEND_STRING] + PROPERTY [ ...]) + +Sets one property on zero or more objects of a scope. + +The first argument determines the scope in which the property is set. +It must be one of the following: + +``GLOBAL`` + Scope is unique and does not accept a name. + +``DIRECTORY`` + Scope defaults to the current directory but other directories + (already processed by CMake) may be named by full or relative path. + Relative paths are treated as relative to the current source directory. + See also the :command:`set_directory_properties` command. + + .. versionadded:: 3.19 + ```` may reference a binary directory. + +``TARGET`` + Scope may name zero or more existing targets. + See also the :command:`set_target_properties` command. + + :ref:`Alias Targets` do not support setting target properties. + +``SOURCE`` + Scope may name zero or more source files. By default, source file properties + are only visible to targets added in the same directory (``CMakeLists.txt``). + + .. versionadded:: 3.18 + Visibility can be set in other directory scopes using one or both of the + following sub-options: + + ``DIRECTORY ...`` + The source file property will be set in each of the ```` + directories' scopes. CMake must already know about + each of these directories, either by having added them through a call to + :command:`add_subdirectory` or it being the top level source directory. + Relative paths are treated as relative to the current source directory. + + .. versionadded:: 3.19 + ```` may reference a binary directory. + + ``TARGET_DIRECTORY ...`` + The source file property will be set in each of the directory scopes + where any of the specified ```` were created (the ```` + must therefore already exist). + + See also the :command:`set_source_files_properties` command. + +``INSTALL`` + .. versionadded:: 3.1 + + Scope may name zero or more installed file paths. + These are made available to CPack to influence deployment. + + Both the property key and value may use generator expressions. + Specific properties may apply to installed files and/or directories. + + Path components have to be separated by forward slashes, + must be normalized and are case sensitive. + + To reference the installation prefix itself with a relative path use ``.``. + + Currently installed file properties are only defined for + the WIX generator where the given paths are relative + to the installation prefix. + +``TEST`` + Scope is limited to the directory the command is called in. It may name zero + or more existing tests. See also command :command:`set_tests_properties`. + + Test property values may be specified using + :manual:`generator expressions ` + for tests created by the :command:`add_test(NAME)` signature. + + .. versionadded:: 3.28 + + Visibility can be set in other directory scopes using the following sub-option: + + ``DIRECTORY `` + The test property will be set in the ```` directory's scope. CMake must + already know about this directory, either by having added it through a call + to :command:`add_subdirectory` or it being the top level source directory. + Relative paths are treated as relative to the current source directory. + ```` may reference a binary directory. + +``CACHE`` + Scope must name zero or more existing cache entries. + +The required ``PROPERTY`` option is immediately followed by the name of +the property to set. Remaining arguments are used to compose the +property value in the form of a semicolon-separated list. + +If the ``APPEND`` option is given the list is appended to any existing +property value (except that empty values are ignored and not appended). +If the ``APPEND_STRING`` option is given the string is +appended to any existing property value as string, i.e. it results in a +longer string and not a list of strings. When using ``APPEND`` or +``APPEND_STRING`` with a property defined to support ``INHERITED`` +behavior (see :command:`define_property`), no inheriting occurs when +finding the initial value to append to. If the property is not already +directly set in the nominated scope, the command will behave as though +``APPEND`` or ``APPEND_STRING`` had not been given. + +.. note:: + + The :prop_sf:`GENERATED` source file property may be globally visible. + See its documentation for details. + +See Also +^^^^^^^^ + +* :command:`define_property` +* :command:`get_property` +* The :manual:`cmake-properties(7)` manual for a list of properties + in each scope. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/target_link_libraries.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/target_link_libraries.rst new file mode 100644 index 0000000000000000000000000000000000000000..94a24297db61c30fbab7efd96f59f40633c221c0 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/target_link_libraries.rst @@ -0,0 +1,432 @@ +target_link_libraries +--------------------- + +.. only:: html + + .. contents:: + +Specify libraries or flags to use when linking a given target and/or +its dependents. :ref:`Usage requirements ` +from linked library targets will be propagated. Usage requirements +of a target's dependencies affect compilation of its own sources. + +Overview +^^^^^^^^ + +This command has several signatures as detailed in subsections below. +All of them have the general form + +.. code-block:: cmake + + target_link_libraries( ... ... ...) + +The named ```` must have been created by a command such as +:command:`add_executable` or :command:`add_library` and must not be an +:ref:`ALIAS target `. If policy :policy:`CMP0079` is not +set to ``NEW`` then the target must have been created in the current +directory. Repeated calls for the same ```` append items in +the order called. + +.. versionadded:: 3.13 + The ```` doesn't have to be defined in the same directory as the + ``target_link_libraries`` call. + +Each ```` may be: + +* **A library target name**: The generated link line will have the + full path to the linkable library file associated with the target. + The buildsystem will have a dependency to re-link ```` if + the library file changes. + + The named target must be created by :command:`add_library` within + the project or as an :ref:`IMPORTED library `. + If it is created within the project an ordering dependency will + automatically be added in the build system to make sure the named + library target is up-to-date before the ```` links. + + If an imported library has the :prop_tgt:`IMPORTED_NO_SONAME` + target property set, CMake may ask the linker to search for + the library instead of using the full path + (e.g. ``/usr/lib/libfoo.so`` becomes ``-lfoo``). + + The full path to the target's artifact will be quoted/escaped for + the shell automatically. + +* **A full path to a library file**: The generated link line will + normally preserve the full path to the file. The buildsystem will + have a dependency to re-link ```` if the library file changes. + + There are some cases where CMake may ask the linker to search for + the library (e.g. ``/usr/lib/libfoo.so`` becomes ``-lfoo``), such + as when a shared library is detected to have no ``SONAME`` field. + See policy :policy:`CMP0060` for discussion of another case. + + If the library file is in a macOS framework, the ``Headers`` directory + of the framework will also be processed as a + :ref:`usage requirement `. This has the same + effect as passing the framework directory as an include directory. + + .. versionadded:: 3.28 + + The library file may point to a ``.xcframework`` folder on Apple platforms. + If it does, the target will get the selected library's ``Headers`` + directory as a usage requirement. + + .. versionadded:: 3.8 + On :ref:`Visual Studio Generators` for VS 2010 and above, library files + ending in ``.targets`` will be treated as MSBuild targets files and + imported into generated project files. This is not supported by other + generators. + + The full path to the library file will be quoted/escaped for + the shell automatically. + +* **A plain library name**: The generated link line will ask the linker + to search for the library (e.g. ``foo`` becomes ``-lfoo`` or ``foo.lib``). + + The library name/flag is treated as a command-line string fragment and + will be used with no extra quoting or escaping. + +* **A link flag**: Item names starting with ``-``, but not ``-l`` or + ``-framework``, are treated as linker flags. Note that such flags will + be treated like any other library link item for purposes of transitive + dependencies, so they are generally safe to specify only as private link + items that will not propagate to dependents. + + Link flags specified here are inserted into the link command in the same + place as the link libraries. This might not be correct, depending on + the linker. Use the :prop_tgt:`LINK_OPTIONS` target property or + :command:`target_link_options` command to add link + flags explicitly. The flags will then be placed at the toolchain-defined + flag position in the link command. + + .. versionadded:: 3.13 + :prop_tgt:`LINK_OPTIONS` target property and :command:`target_link_options` + command. For earlier versions of CMake, use :prop_tgt:`LINK_FLAGS` + property instead. + + The link flag is treated as a command-line string fragment and + will be used with no extra quoting or escaping. + +* **A generator expression**: A ``$<...>`` :manual:`generator expression + ` may evaluate to any of the above + items or to a :ref:`semicolon-separated list ` of them. + If the ``...`` contains any ``;`` characters, e.g. after evaluation + of a ``${list}`` variable, be sure to use an explicitly quoted + argument ``"$<...>"`` so that this command receives it as a + single ````. + + Additionally, a generator expression may be used as a fragment of + any of the above items, e.g. ``foo$<1:_d>``. + + Note that generator expressions will not be used in OLD handling of + policy :policy:`CMP0003` or policy :policy:`CMP0004`. + +* A ``debug``, ``optimized``, or ``general`` keyword immediately followed + by another ````. The item following such a keyword will be used + only for the corresponding build configuration. The ``debug`` keyword + corresponds to the ``Debug`` configuration (or to configurations named + in the :prop_gbl:`DEBUG_CONFIGURATIONS` global property if it is set). + The ``optimized`` keyword corresponds to all other configurations. The + ``general`` keyword corresponds to all configurations, and is purely + optional. Higher granularity may be achieved for per-configuration + rules by creating and linking to + :ref:`IMPORTED library targets `. + These keywords are interpreted immediately by this command and therefore + have no special meaning when produced by a generator expression. + +Items containing ``::``, such as ``Foo::Bar``, are assumed to be +:ref:`IMPORTED ` or :ref:`ALIAS ` library +target names and will cause an error if no such target exists. +See policy :policy:`CMP0028`. + +See the :variable:`CMAKE_LINK_LIBRARIES_STRATEGY` variable and +corresponding :prop_tgt:`LINK_LIBRARIES_STRATEGY` target property +for details on how CMake orders direct link dependencies on linker +command lines. + +See the :manual:`cmake-buildsystem(7)` manual for more on defining +buildsystem properties. + +Libraries for a Target and/or its Dependents +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. code-block:: cmake + + target_link_libraries( + ... + [ ...]...) + +The ``PUBLIC``, ``PRIVATE`` and ``INTERFACE`` +:ref:`scope ` keywords can be used to +specify both the link dependencies and the link interface in one command. + +Libraries and targets following ``PUBLIC`` are linked to, and are made +part of the link interface. Libraries and targets following ``PRIVATE`` +are linked to, but are not made part of the link interface. Libraries +following ``INTERFACE`` are appended to the link interface and are not +used for linking ````. + +Libraries for both a Target and its Dependents +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. code-block:: cmake + + target_link_libraries( ...) + +Library dependencies are transitive by default with this signature. +When this target is linked into another target then the libraries +linked to this target will appear on the link line for the other +target too. This transitive "link interface" is stored in the +:prop_tgt:`INTERFACE_LINK_LIBRARIES` target property and may be overridden +by setting the property directly. When :policy:`CMP0022` is not set to +``NEW``, transitive linking is built in but may be overridden by the +:prop_tgt:`LINK_INTERFACE_LIBRARIES` property. Calls to other signatures +of this command may set the property making any libraries linked +exclusively by this signature private. + +Libraries for a Target and/or its Dependents (Legacy) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. code-block:: cmake + + target_link_libraries( + ... + [ ...]...) + +The ``LINK_PUBLIC`` and ``LINK_PRIVATE`` modes can be used to specify both +the link dependencies and the link interface in one command. + +This signature is for compatibility only. Prefer the ``PUBLIC`` or +``PRIVATE`` keywords instead. + +Libraries and targets following ``LINK_PUBLIC`` are linked to, and are +made part of the :prop_tgt:`INTERFACE_LINK_LIBRARIES`. If policy +:policy:`CMP0022` is not ``NEW``, they are also made part of the +:prop_tgt:`LINK_INTERFACE_LIBRARIES`. Libraries and targets following +``LINK_PRIVATE`` are linked to, but are not made part of the +:prop_tgt:`INTERFACE_LINK_LIBRARIES` (or :prop_tgt:`LINK_INTERFACE_LIBRARIES`). + +Libraries for Dependents Only (Legacy) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. code-block:: cmake + + target_link_libraries( LINK_INTERFACE_LIBRARIES ...) + +The ``LINK_INTERFACE_LIBRARIES`` mode appends the libraries to the +:prop_tgt:`INTERFACE_LINK_LIBRARIES` target property instead of using them +for linking. If policy :policy:`CMP0022` is not ``NEW``, then this mode +also appends libraries to the :prop_tgt:`LINK_INTERFACE_LIBRARIES` and its +per-configuration equivalent. + +This signature is for compatibility only. Prefer the ``INTERFACE`` mode +instead. + +Libraries specified as ``debug`` are wrapped in a generator expression to +correspond to debug builds. If policy :policy:`CMP0022` is +not ``NEW``, the libraries are also appended to the +:prop_tgt:`LINK_INTERFACE_LIBRARIES_DEBUG >` +property (or to the properties corresponding to configurations listed in +the :prop_gbl:`DEBUG_CONFIGURATIONS` global property if it is set). +Libraries specified as ``optimized`` are appended to the +:prop_tgt:`INTERFACE_LINK_LIBRARIES` property. If policy :policy:`CMP0022` +is not ``NEW``, they are also appended to the +:prop_tgt:`LINK_INTERFACE_LIBRARIES` property. Libraries specified as +``general`` (or without any keyword) are treated as if specified for both +``debug`` and ``optimized``. + +Linking Object Libraries +^^^^^^^^^^^^^^^^^^^^^^^^ + +.. versionadded:: 3.12 + +:ref:`Object Libraries` may be used as the ```` (first) argument +of ``target_link_libraries`` to specify dependencies of their sources +on other libraries. For example, the code + +.. code-block:: cmake + + add_library(A SHARED a.c) + target_compile_definitions(A PUBLIC A) + + add_library(obj OBJECT obj.c) + target_compile_definitions(obj PUBLIC OBJ) + target_link_libraries(obj PUBLIC A) + +compiles ``obj.c`` with ``-DA -DOBJ`` and establishes usage requirements +for ``obj`` that propagate to its dependents. + +Normal libraries and executables may link to :ref:`Object Libraries` +to get their objects and usage requirements. Continuing the above +example, the code + +.. code-block:: cmake + + add_library(B SHARED b.c) + target_link_libraries(B PUBLIC obj) + +compiles ``b.c`` with ``-DA -DOBJ``, creates shared library ``B`` +with object files from ``b.c`` and ``obj.c``, and links ``B`` to ``A``. +Furthermore, the code + +.. code-block:: cmake + + add_executable(main main.c) + target_link_libraries(main B) + +compiles ``main.c`` with ``-DA -DOBJ`` and links executable ``main`` +to ``B`` and ``A``. The object library's usage requirements are +propagated transitively through ``B``, but its object files are not. + +:ref:`Object Libraries` may "link" to other object libraries to get +usage requirements, but since they do not have a link step nothing +is done with their object files. Continuing from the above example, +the code: + +.. code-block:: cmake + + add_library(obj2 OBJECT obj2.c) + target_link_libraries(obj2 PUBLIC obj) + + add_executable(main2 main2.c) + target_link_libraries(main2 obj2) + +compiles ``obj2.c`` with ``-DA -DOBJ``, creates executable ``main2`` +with object files from ``main2.c`` and ``obj2.c``, and links ``main2`` +to ``A``. + +In other words, when :ref:`Object Libraries` appear in a target's +:prop_tgt:`INTERFACE_LINK_LIBRARIES` property they will be +treated as :ref:`Interface Libraries`, but when they appear in +a target's :prop_tgt:`LINK_LIBRARIES` property their object files +will be included in the link too. + +.. _`Linking Object Libraries via $`: + +Linking Object Libraries via ``$`` +"""""""""""""""""""""""""""""""""""""""""""""""""" + +.. versionadded:: 3.21 + +The object files associated with an object library may be referenced +by the :genex:`$` generator expression. Such object +files are placed on the link line *before* all libraries, regardless +of their relative order. Additionally, an ordering dependency will be +added to the build system to make sure the object library is up-to-date +before the dependent target links. For example, the code + +.. code-block:: cmake + + add_library(obj3 OBJECT obj3.c) + target_compile_definitions(obj3 PUBLIC OBJ3) + + add_executable(main3 main3.c) + target_link_libraries(main3 PRIVATE a3 $ b3) + +links executable ``main3`` with object files from ``main3.c`` +and ``obj3.c`` followed by the ``a3`` and ``b3`` libraries. +``main3.c`` is *not* compiled with usage requirements from ``obj3``, +such as ``-DOBJ3``. + +This approach can be used to achieve transitive inclusion of object +files in link lines as usage requirements. Continuing the above +example, the code + +.. code-block:: cmake + + add_library(iface_obj3 INTERFACE) + target_link_libraries(iface_obj3 INTERFACE obj3 $) + +creates an interface library ``iface_obj3`` that forwards the ``obj3`` +usage requirements and adds the ``obj3`` object files to dependents' +link lines. The code + +.. code-block:: cmake + + add_executable(use_obj3 use_obj3.c) + target_link_libraries(use_obj3 PRIVATE iface_obj3) + +compiles ``use_obj3.c`` with ``-DOBJ3`` and links executable ``use_obj3`` +with object files from ``use_obj3.c`` and ``obj3.c``. + +This also works transitively through a static library. Since a static +library does not link, it does not consume the object files from +object libraries referenced this way. Instead, the object files +become transitive link dependencies of the static library. +Continuing the above example, the code + +.. code-block:: cmake + + add_library(static3 STATIC static3.c) + target_link_libraries(static3 PRIVATE iface_obj3) + + add_executable(use_static3 use_static3.c) + target_link_libraries(use_static3 PRIVATE static3) + +compiles ``static3.c`` with ``-DOBJ3`` and creates ``libstatic3.a`` +using only its own object file. ``use_static3.c`` is compiled *without* +``-DOBJ3`` because the usage requirement is not transitive through +the private dependency of ``static3``. However, the link dependencies +of ``static3`` are propagated, including the ``iface_obj3`` reference +to ``$``. The ``use_static3`` executable is +created with object files from ``use_static3.c`` and ``obj3.c``, and +linked to library ``libstatic3.a``. + +When using this approach, it is the project's responsibility to avoid +linking multiple dependent binaries to ``iface_obj3``, because they will +all get the ``obj3`` object files on their link lines. + +.. note:: + + Referencing :genex:`$` in ``target_link_libraries`` + calls worked in versions of CMake prior to 3.21 for some cases, + but was not fully supported: + + * It did not place the object files before libraries on link lines. + * It did not add an ordering dependency on the object library. + * It did not work in Xcode with multiple architectures. + +Cyclic Dependencies of Static Libraries +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The library dependency graph is normally acyclic (a DAG), but in the case +of mutually-dependent ``STATIC`` libraries CMake allows the graph to +contain cycles (strongly connected components). When another target links +to one of the libraries, CMake repeats the entire connected component. +For example, the code + +.. code-block:: cmake + + add_library(A STATIC a.c) + add_library(B STATIC b.c) + target_link_libraries(A B) + target_link_libraries(B A) + add_executable(main main.c) + target_link_libraries(main A) + +links ``main`` to ``A B A B``. While one repetition is usually +sufficient, pathological object file and symbol arrangements can require +more. One may handle such cases by using the +:prop_tgt:`LINK_INTERFACE_MULTIPLICITY` target property or by manually +repeating the component in the last ``target_link_libraries`` call. +However, if two archives are really so interdependent they should probably +be combined into a single archive, perhaps by using :ref:`Object Libraries`. + +Creating Relocatable Packages +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. |INTERFACE_PROPERTY_LINK| replace:: :prop_tgt:`INTERFACE_LINK_LIBRARIES` +.. include:: /include/INTERFACE_LINK_LIBRARIES_WARNING.txt + +See Also +^^^^^^^^ + +* :command:`target_compile_definitions` +* :command:`target_compile_features` +* :command:`target_compile_options` +* :command:`target_include_directories` +* :command:`target_link_directories` +* :command:`target_link_options` +* :command:`target_precompile_headers` +* :command:`target_sources` diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/try_run.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/try_run.rst new file mode 100644 index 0000000000000000000000000000000000000000..c466a81a87084db32896ecf77543d209ecf908c5 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/try_run.rst @@ -0,0 +1,165 @@ +try_run +------- + +.. only:: html + + .. contents:: + +Try compiling and then running some code. + +Try Compiling and Running Source Files +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. code-block:: cmake + + try_run( + [SOURCES_TYPE ] + | + SOURCE_FROM_CONTENT | + SOURCE_FROM_VAR | + SOURCE_FROM_FILE >... + [LOG_DESCRIPTION ] + [NO_CACHE] + [NO_LOG] + [CMAKE_FLAGS ...] + [COMPILE_DEFINITIONS ...] + [LINK_OPTIONS ...] + [LINK_LIBRARIES ...] + [COMPILE_OUTPUT_VARIABLE ] + [COPY_FILE [COPY_FILE_ERROR ]] + [_STANDARD ] + [_STANDARD_REQUIRED ] + [_EXTENSIONS ] + [RUN_OUTPUT_VARIABLE ] + [RUN_OUTPUT_STDOUT_VARIABLE ] + [RUN_OUTPUT_STDERR_VARIABLE ] + [WORKING_DIRECTORY ] + [ARGS ...] + ) + +.. versionadded:: 3.25 + +Try building an executable from one or more source files. Build success +returns ``TRUE`` and build failure returns ``FALSE`` in ````. +If the build succeeds, this runs the executable and stores the exit code in +````. If the executable was built, but failed to run, then +```` will be set to ``FAILED_TO_RUN``. See command +:command:`try_compile` for documentation of options common to both commands, +and for information on how the test project is constructed to build the source +file. + +One or more source files must be provided. Additionally, one of ``SOURCES`` +and/or ``SOURCE_FROM_*`` must precede other keywords. + +.. versionadded:: 3.26 + This command records a + :ref:`configure-log try_run event ` + if the ``NO_LOG`` option is not specified. + +This command supports an alternate signature for CMake older than 3.25. +The signature above is recommended for clarity. + +.. code-block:: cmake + + try_run( + + [CMAKE_FLAGS ...] + [COMPILE_DEFINITIONS ...] + [LINK_OPTIONS ...] + [LINK_LIBRARIES ...] + [LINKER_LANGUAGE ] + [COMPILE_OUTPUT_VARIABLE ] + [COPY_FILE [COPY_FILE_ERROR ]] + [_STANDARD ] + [_STANDARD_REQUIRED ] + [_EXTENSIONS ] + [RUN_OUTPUT_VARIABLE ] + [OUTPUT_VARIABLE ] + [WORKING_DIRECTORY ] + [ARGS ...] + ) + +.. _`try_run Options`: + +Options +^^^^^^^ + +The options specific to ``try_run`` are: + +``COMPILE_OUTPUT_VARIABLE `` + Report the compile step build output in a given variable. + +``OUTPUT_VARIABLE `` + Report the compile build output and the output from running the executable + in the given variable. This option exists for legacy reasons and is only + supported by the old ``try_run`` signature. + Prefer ``COMPILE_OUTPUT_VARIABLE`` and ``RUN_OUTPUT_VARIABLE`` instead. + +``RUN_OUTPUT_VARIABLE `` + Report the output from running the executable in a given variable. + +``RUN_OUTPUT_STDOUT_VARIABLE `` + .. versionadded:: 3.25 + + Report the output of stdout from running the executable in a given variable. + +``RUN_OUTPUT_STDERR_VARIABLE `` + .. versionadded:: 3.25 + + Report the output of stderr from running the executable in a given variable. + +``WORKING_DIRECTORY `` + .. versionadded:: 3.20 + + Run the executable in the given directory. If no ``WORKING_DIRECTORY`` is + specified, the executable will run in ```` or the current build + directory. + +``ARGS ...`` + Additional arguments to pass to the executable when running it. + +Other Behavior Settings +^^^^^^^^^^^^^^^^^^^^^^^ + +Set variable :variable:`CMAKE_TRY_COMPILE_CONFIGURATION` to choose a build +configuration: + +* For multi-config generators, this selects which configuration to build. + +* For single-config generators, this sets :variable:`CMAKE_BUILD_TYPE` in + the test project. + +Behavior when Cross Compiling +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. versionadded:: 3.3 + Use ``CMAKE_CROSSCOMPILING_EMULATOR`` when running cross-compiled binaries. + +When cross compiling, the executable compiled in the first step +usually cannot be run on the build host. The ``try_run`` command checks +the :variable:`CMAKE_CROSSCOMPILING` variable to detect whether CMake is in +cross-compiling mode. If that is the case, it will still try to compile +the executable, but it will not try to run the executable unless the +:variable:`CMAKE_CROSSCOMPILING_EMULATOR` variable is set. Instead it +will create cache variables which must be filled by the user or by +presetting them in some CMake script file to the values the executable +would have produced if it had been run on its actual target platform. +These cache entries are: + +```` + Exit code if the executable were to be run on the target platform. + +``__TRYRUN_OUTPUT`` + Output from stdout and stderr if the executable were to be run on + the target platform. This is created only if the + ``RUN_OUTPUT_VARIABLE`` or ``OUTPUT_VARIABLE`` option was used. + +In order to make cross compiling your project easier, use ``try_run`` +only if really required. If you use ``try_run``, use the +``RUN_OUTPUT_STDOUT_VARIABLE``, ``RUN_OUTPUT_STDERR_VARIABLE``, +``RUN_OUTPUT_VARIABLE`` or ``OUTPUT_VARIABLE`` options only if really +required. Using them will require that when cross-compiling, the cache +variables will have to be set manually to the output of the executable. +You can also "guard" the calls to ``try_run`` with an :command:`if` +block checking the :variable:`CMAKE_CROSSCOMPILING` variable and +provide an easy-to-preset alternative for this case. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/variable_watch.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/variable_watch.rst new file mode 100644 index 0000000000000000000000000000000000000000..8293f5aabcd04692b7c3ce5c9d39514f5ead13e0 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/command/variable_watch.rst @@ -0,0 +1,48 @@ +variable_watch +-------------- + +Watch the CMake variable for change. + +.. code-block:: cmake + + variable_watch( []) + +If the specified ```` changes and no ```` is given, +a message will be printed to inform about the change. + +If ```` is given, this command will be executed instead. +The command will receive the following arguments: +``COMMAND( )`` + +```` + Name of the variable being accessed. + +```` + One of ``READ_ACCESS``, ``UNKNOWN_READ_ACCESS``, ``MODIFIED_ACCESS``, + ``UNKNOWN_MODIFIED_ACCESS``, or ``REMOVED_ACCESS``. The ``UNKNOWN_`` + values are only used when the variable has never been set. Once set, + they are never used again during the same CMake run, even if the + variable is later unset. + +```` + The value of the variable. On a modification, this is the new + (modified) value of the variable. On removal, the value is empty. + +```` + Full path to the file doing the access. + +```` + List of absolute paths of all files currently on the stack of file + inclusion, with the bottom-most file first and the currently + processed file (that is, ``current_list_file``) last. + +Note that for some accesses such as :command:`list(APPEND)`, the watcher +is executed twice, first with a read access and then with a write one. +Also note that an :command:`if(DEFINED)` query on the variable does not +register as an access and the watcher is not executed. + +Only non-cache variables can be watched using this command. Access to +cache variables is never watched. However, the existence of a cache +variable ``var`` causes accesses to the non-cache variable ``var`` to +not use the ``UNKNOWN_`` prefix, even if a non-cache variable ``var`` +has never existed. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0001.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0001.rst new file mode 100644 index 0000000000000000000000000000000000000000..e06f2a156b462aa10d74d71e6db544c5474d2dcd --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0001.rst @@ -0,0 +1,21 @@ +CMP0001 +------- + +``CMAKE_BACKWARDS_COMPATIBILITY`` should no longer be used. + +The behavior is to check ``CMAKE_BACKWARDS_COMPATIBILITY`` and present +it to the user. The ``NEW`` behavior is to ignore +CMAKE_BACKWARDS_COMPATIBILITY completely. + +In CMake 2.4 and below the variable ``CMAKE_BACKWARDS_COMPATIBILITY`` was +used to request compatibility with earlier versions of CMake. In +CMake 2.6 and above all compatibility issues are handled by policies +and the :command:`cmake_policy` command. However, CMake must still check +``CMAKE_BACKWARDS_COMPATIBILITY`` for projects written for CMake 2.4 and +below. + +.. |INTRODUCED_IN_CMAKE_VERSION| replace:: 2.6.0 +.. |WARNS_OR_DOES_NOT_WARN| replace:: warns +.. include:: STANDARD_ADVICE.txt + +.. include:: DEPRECATED.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0069.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0069.rst new file mode 100644 index 0000000000000000000000000000000000000000..97665e69780c21aaa2700bd2961ef065454a9fb1 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0069.rst @@ -0,0 +1,93 @@ +CMP0069 +------- + +.. versionadded:: 3.9 + +:prop_tgt:`INTERPROCEDURAL_OPTIMIZATION` is enforced when enabled. + +CMake 3.9 and newer prefer to add IPO flags whenever the +:prop_tgt:`INTERPROCEDURAL_OPTIMIZATION` target property is enabled and +produce an error if flags are not known to CMake for the current compiler. +Since a given compiler may not support IPO flags in all environments in which +it is used, it is now the project's responsibility to use the +:module:`CheckIPOSupported` module to check for support before enabling the +:prop_tgt:`INTERPROCEDURAL_OPTIMIZATION` target property. This approach +allows a project to conditionally activate IPO when supported. It also +allows an end user to set the :variable:`CMAKE_INTERPROCEDURAL_OPTIMIZATION` +variable in an environment known to support IPO even if the project does +not enable the property. + +Since CMake 3.8 and lower only honored :prop_tgt:`INTERPROCEDURAL_OPTIMIZATION` +for the Intel compiler on Linux, some projects may unconditionally enable the +target property. Policy ``CMP0069`` provides compatibility with such projects. + +This policy takes effect whenever the IPO property is enabled. The ``OLD`` +behavior for this policy is to add IPO flags only for Intel compiler on Linux. +The ``NEW`` behavior for this policy is to add IPO flags for the current +compiler or produce an error if CMake does not know the flags. + +.. |INTRODUCED_IN_CMAKE_VERSION| replace:: 3.9 +.. |WARNS_OR_DOES_NOT_WARN| replace:: warns +.. include:: STANDARD_ADVICE.txt + +.. include:: DEPRECATED.txt + +Examples +^^^^^^^^ + +Behave like CMake 3.8 and do not apply any IPO flags except for Intel compiler +on Linux: + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.8) + project(foo) + + # ... + + set_property(TARGET ... PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE) + +Use the :module:`CheckIPOSupported` module to detect whether IPO is +supported by the current compiler, environment, and CMake version. +Produce a fatal error if support is not available: + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.9) # CMP0069 NEW + project(foo) + + include(CheckIPOSupported) + check_ipo_supported() + + # ... + + set_property(TARGET ... PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE) + +Apply IPO flags only if compiler supports it: + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.9) # CMP0069 NEW + project(foo) + + include(CheckIPOSupported) + + # ... + + check_ipo_supported(RESULT result) + if(result) + set_property(TARGET ... PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE) + endif() + +Apply IPO flags without any checks. This may lead to build errors if IPO +is not supported by the compiler in the current environment. Produce an +error if CMake does not know IPO flags for the current compiler: + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.9) # CMP0069 NEW + project(foo) + + # ... + + set_property(TARGET ... PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE) diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0077.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0077.rst new file mode 100644 index 0000000000000000000000000000000000000000..f64f92fb7341d678816fb4130775cde4e2379113 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0077.rst @@ -0,0 +1,61 @@ +CMP0077 +------- + +.. versionadded:: 3.13 + +:command:`option` honors normal variables. + +The :command:`option` command is typically used to create a cache entry +to allow users to set the option. However, there are cases in which a +normal (non-cached) variable of the same name as the option may be +defined by the project prior to calling the :command:`option` command. +For example, a project that embeds another project as a subdirectory +may want to hard-code options of the subproject to build the way it needs. + +For historical reasons in CMake 3.12 and below the :command:`option` +command *removes* a normal (non-cached) variable of the same name when: + +* a cache entry of the specified name does not exist at all, or +* a cache entry of the specified name exists but has not been given + a type (e.g. via ``-D=ON`` on the command line). + +In both of these cases (typically on the first run in a new build tree), +the :command:`option` command gives the cache entry type ``BOOL`` and +removes any normal (non-cached) variable of the same name. In the +remaining case that the cache entry of the specified name already +exists and has a type (typically on later runs in a build tree), the +:command:`option` command changes nothing and any normal variable of +the same name remains set. + +In CMake 3.13 and above the :command:`option` command prefers to +do nothing when a normal variable of the given name already exists. +It does not create or update a cache entry or remove the normal variable. +The new behavior is consistent between the first and later runs in a +build tree. This policy provides compatibility with projects that have +not been updated to expect the new behavior. + +When the :command:`option` command sees a normal variable of the given +name: + +* The ``OLD`` behavior for this policy is to proceed even when a normal + variable of the same name exists. If the cache entry does not already + exist and have a type then it is created and/or given a type and the + normal variable is removed. + +* The ``NEW`` behavior for this policy is to do nothing when a normal + variable of the same name exists. The normal variable is not removed. + The cache entry is not created or updated and is ignored if it exists. + +See :policy:`CMP0126` for a similar policy for the :command:`set(CACHE)` +command, but note that there are some differences in ``NEW`` behavior +between the two policies. + +.. |INTRODUCED_IN_CMAKE_VERSION| replace:: 3.13 +.. |WARNS_OR_DOES_NOT_WARN| replace:: warns +.. include:: STANDARD_ADVICE.txt + +Use the :variable:`CMAKE_POLICY_DEFAULT_CMP0077 +>` variable to set the policy for +a third-party project in a subdirectory without modifying it. + +.. include:: DEPRECATED.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0118.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0118.rst new file mode 100644 index 0000000000000000000000000000000000000000..5c049277ecdf68a94f1ff0900833f3076329fe70 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0118.rst @@ -0,0 +1,38 @@ +CMP0118 +------- + +.. versionadded:: 3.20 + +:prop_sf:`GENERATED` sources may be used across directories without manual marking. + +In CMake 3.19 and below, the :prop_sf:`GENERATED` source file property, +like other source file properties, was scoped in every directory separately. +If a source file was generated in one directory, projects had to manually +set the ``GENERATED`` property in another directory in order to use the file. + +Whether or not a source file is generated is an all-or-nothing global +property of the source: a source is either generated or it is not. +CMake 3.20 and above prefer to allow source files generated in one directory +to be used in other directories without manually marking them as ``GENERATED``. +Additionally, the ``GENERATED`` property may now be set only to boolean +values, and may not be turned off once turned on. This policy provides +compatibility for projects that have not been updated for this behavior. + +The ``OLD`` behavior of this policy is to allow generated files to be used +only in directories in which their ``GENERATED`` property has been turned on. +The ``NEW`` behavior of this policy is to allow generated files to be used +in other directories without explicitly turning on the ``GENERATED`` property +for those directories. + +.. versionadded:: 3.30 + + Policy :policy:`CMP0163` additionally makes the :prop_sf:`GENERATED` source + file property visible to :command:`get_property` and + :command:`get_source_file_property` calls in other directories. + +.. |INTRODUCED_IN_CMAKE_VERSION| replace:: 3.20 +.. |WARNS_OR_DOES_NOT_WARN| replace:: + warns about setting the ``GENERATED`` property to a non-boolean value +.. include:: STANDARD_ADVICE.txt + +.. include:: DEPRECATED.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0131.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0131.rst new file mode 100644 index 0000000000000000000000000000000000000000..88999435e9978d1d29fc9c5a62479c011ef784cd --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0131.rst @@ -0,0 +1,30 @@ +CMP0131 +------- + +.. versionadded:: 3.24 + +:prop_tgt:`LINK_LIBRARIES` supports the :genex:`$` +generator expression. + +CMake 3.23 and below documented the :genex:`$` generator +expression only for use in :prop_tgt:`INTERFACE_LINK_LIBRARIES`. +When used in :prop_tgt:`LINK_LIBRARIES`, the content guarded inside +:genex:`$` was always used, even when collecting non-linking +usage requirements such as :prop_tgt:`INTERFACE_COMPILE_DEFINITIONS`. + +CMake 3.24 and above prefer to support :genex:`$`, when +used in :prop_tgt:`LINK_LIBRARIES`, by using the guarded content only +for link dependencies and not other usage requirements. This policy +provides compatibility for projects that have not been updated to +account for this change. + +The ``OLD`` behavior for this policy is to use :prop_tgt:`LINK_LIBRARIES` +content guarded by :genex:`$` even for non-linking +usage requirements. The ``NEW`` behavior for this policy is to use +the guarded content only for link dependencies. + +.. |INTRODUCED_IN_CMAKE_VERSION| replace:: 3.24 +.. |WARNS_OR_DOES_NOT_WARN| replace:: does *not* warn +.. include:: STANDARD_ADVICE.txt + +.. include:: DEPRECATED.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0133.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0133.rst new file mode 100644 index 0000000000000000000000000000000000000000..3bccd15a3168492753e32ef4d721af5dad195d38 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0133.rst @@ -0,0 +1,32 @@ +CMP0133 +------- + +.. versionadded:: 3.24 + +The :module:`CPack` module disables SLA by default in the +:cpack_gen:`CPack DragNDrop Generator`. + +The :cpack_gen:`CPack DragNDrop Generator` in CMake 3.22 and below attach a +Software License Agreement (SLA) to ``.dmg`` files using the file specified +by :variable:`CPACK_RESOURCE_FILE_LICENSE`, if set to a non-default value. +macOS 12.0 deprecated the tools used to do this, so CMake 3.23 added +the :variable:`CPACK_DMG_SLA_USE_RESOURCE_FILE_LICENSE` option to +control the behavior. CMake 3.23 enables that option by default for +compatibility with older versions. CMake 3.24 and above prefer to *not* +enable the :variable:`CPACK_DMG_SLA_USE_RESOURCE_FILE_LICENSE` option by +default. This policy provides compatibility with projects that have not +been updated to account for the lack of a SLA in their ``.dmg`` packages. + +The ``OLD`` behavior for this policy is to enable +:variable:`CPACK_DMG_SLA_USE_RESOURCE_FILE_LICENSE` by default. +The ``NEW`` behavior for this policy is to not enable it by default. + +.. |INTRODUCED_IN_CMAKE_VERSION| replace:: 3.24 +.. |WARNS_OR_DOES_NOT_WARN| replace:: does *not* warn by default +.. include:: STANDARD_ADVICE.txt + +See documentation of the +:variable:`CMAKE_POLICY_WARNING_CMP0133 >` +variable to control the warning. + +.. include:: DEPRECATED.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0169.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0169.rst new file mode 100644 index 0000000000000000000000000000000000000000..38b8dcbb4d167c9f21c9897e6b026943d2776dc9 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0169.rst @@ -0,0 +1,49 @@ +CMP0169 +------- + +.. versionadded:: 3.30 + +Calling :command:`FetchContent_Populate` with a single argument (the name of +a declared dependency) is deprecated. + +Prior to the introduction of :command:`FetchContent_MakeAvailable`, projects +populated previously declared content (with :command:`FetchContent_Declare`) +using the following pattern: + +.. code-block:: cmake + + FetchContent_GetProperties(depname) + if(NOT depname_POPULATED) + FetchContent_Populate(depname) + add_subdirectory(${depname_SOURCE_DIR} ${depname_BINARY_DIR}) + endif() + +The above pattern does not support a number of features that have been added +to :module:`FetchContent` over time. It ignores options like ``SYSTEM`` and +``EXCLUDE_FROM_ALL`` which may be given to :command:`FetchContent_Declare`, +but can't be made known to the above project code. It also does not support +:ref:`dependency providers `. +Projects should call :command:`FetchContent_MakeAvailable` instead of using +the above pattern. + +CMake 3.30 and above prefers to reject calls to +:command:`FetchContent_Populate` with the name of a declared dependency. +This policy provides compatibility for projects that have not been updated +to call :command:`FetchContent_MakeAvailable` instead. + +The ``OLD`` behavior of this policy allows :command:`FetchContent_Populate` +to be called with the name of a declared dependency. +The ``NEW`` behavior halts with a fatal error in such cases. + +.. note:: + Calling :command:`FetchContent_Populate` with the full population details + as command arguments rather than just a dependency name remains fully + supported. Only the form calling :command:`FetchContent_Populate` with a + single argument (the name of a previously declared dependency) is deprecated + with this policy. + +.. |INTRODUCED_IN_CMAKE_VERSION| replace:: 3.30 +.. |WARNS_OR_DOES_NOT_WARN| replace:: warns +.. include:: STANDARD_ADVICE.txt + +.. include:: DEPRECATED.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0175.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0175.rst new file mode 100644 index 0000000000000000000000000000000000000000..a71aadfcce1f0208046b22e547b979ce85a00bd2 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0175.rst @@ -0,0 +1,40 @@ +CMP0175 +------- + +.. versionadded:: 3.31 + +:command:`add_custom_command` rejects invalid arguments. + +CMake 3.30 and earlier silently ignored unsupported keywords and missing or +invalid arguments for the different forms of the :command:`add_custom_command` +command. CMake 3.31 implements more rigorous argument checking and will flag +invalid or missing arguments as errors. + +The ``OLD`` behavior of this policy will accept the same invalid keywords or +arguments as CMake 3.30 and earlier. The ``NEW`` behavior will flag the +following as errors that previously went unreported: + +* The ``OUTPUT`` form does not accept ``PRE_BUILD``, ``PRE_LINK``, or + ``POST_BUILD`` keywords. +* When the ``APPEND`` keyword is given, the ``OUTPUT`` form also does not + accept ``BYPRODUCTS``, ``COMMAND_EXPAND_LISTS``, ``DEPENDS_EXPLICIT_ONLY``, + ``DEPFILE``, ``JOB_POOL``, ``JOB_SERVER_AWARE``, ``USES_TERMINAL``, or + ``VERBATIM`` keywords. +* The ``TARGET`` form requires exactly one of ``PRE_BUILD``, ``PRE_LINK``, or + ``POST_BUILD`` to be given. Previously, if none were given, ``POST_BUILD`` + was assumed, or if multiple keywords were given, the last one was used. +* The ``TARGET`` form does not accept ``DEPENDS``, ``DEPENDS_EXPLICIT_ONLY``, + ``DEPFILE``, ``IMPLICIT_DEPENDS``, ``MAIN_DEPENDENCY``, ``JOB_POOL``, or + ``JOB_SERVER_AWARE`` keywords. +* The ``TARGET`` form now requires at least one ``COMMAND`` to be given. +* If a keyword expects a value to be given after it, but no value is provided, + that was previously treated as though the keyword was not given at all. +* The ``COMMENT`` keyword expects exactly one value after it. If multiple + values are given, or if the ``COMMENT`` keyword is given more than once, + this is an error. + +.. |INTRODUCED_IN_CMAKE_VERSION| replace:: 3.31 +.. |WARNS_OR_DOES_NOT_WARN| replace:: warns +.. include:: STANDARD_ADVICE.txt + +.. include:: DEPRECATED.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0179.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0179.rst new file mode 100644 index 0000000000000000000000000000000000000000..7c9498f119acab6543172ac4126693274ed7c68b --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/policy/CMP0179.rst @@ -0,0 +1,28 @@ +CMP0179 +------- + +.. versionadded:: 3.31 + +De-duplication of static libraries on link lines keeps first occurrence. +This policy is only relevant when policy :policy:`CMP0156` is set to ``NEW``. + +Based on the linker capabilities, the static libraries can +be de-duplicated. See policy :policy:`CMP0156` for more information. + +CMake 3.30 and below may choose to keep, on some platforms, the last occurrence +of the static libraries rather than the fist occurrence when they are +de-duplicated. + +CMake 3.31 and above prefer to keep, on all platforms, the first occurrence of +the static libraries when they are de-duplicated. + +The ``OLD`` behavior for this policy is to keep, on some platforms, the last +occurrence of the static libraries when they are de-duplicated. The ``NEW`` +behavior for this policy is to keep the first occurrence of the static +libraries when they are de-duplicated, regardless of the platform. + +.. |INTRODUCED_IN_CMAKE_VERSION| replace:: 3.31 +.. |WARNS_OR_DOES_NOT_WARN| replace:: does *not* warn +.. include:: STANDARD_ADVICE.txt + +.. include:: DEPRECATED.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_cache/MODIFIED.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_cache/MODIFIED.rst new file mode 100644 index 0000000000000000000000000000000000000000..3ad70354daf8b359809788722f3c7e22e92e6082 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_cache/MODIFIED.rst @@ -0,0 +1,7 @@ +MODIFIED +-------- + +Internal management property. Do not set or get. + +This is an internal cache entry property managed by CMake to track +interactive user modification of entries. Ignore it. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/ANDROID_API_MIN.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/ANDROID_API_MIN.rst new file mode 100644 index 0000000000000000000000000000000000000000..7ca2455ec2c11b31e82ef52f45fac0cbd5c893b3 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/ANDROID_API_MIN.rst @@ -0,0 +1,9 @@ +ANDROID_API_MIN +--------------- + +.. versionadded:: 3.2 + +Set the Android MIN API version (e.g. ``9``). The version number +must be a positive decimal integer. This property is initialized by +the value of the :variable:`CMAKE_ANDROID_API_MIN` variable if it is set +when a target is created. Native code builds using this API version. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/ARCHIVE_OUTPUT_DIRECTORY.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/ARCHIVE_OUTPUT_DIRECTORY.rst new file mode 100644 index 0000000000000000000000000000000000000000..abb627cdad7e94ac2b7041202a354bbcbcc0609e --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/ARCHIVE_OUTPUT_DIRECTORY.rst @@ -0,0 +1,12 @@ +ARCHIVE_OUTPUT_DIRECTORY +------------------------ + +.. |XXX| replace:: :ref:`ARCHIVE ` +.. |xxx| replace:: archive +.. |CMAKE_XXX_OUTPUT_DIRECTORY| replace:: :variable:`CMAKE_ARCHIVE_OUTPUT_DIRECTORY` +.. include:: XXX_OUTPUT_DIRECTORY.txt + +.. |IDEM| replace:: in the same directory +.. include:: MACOS_IMPORT_FILES.txt + +See also the :prop_tgt:`ARCHIVE_OUTPUT_DIRECTORY_` target property. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/ARCHIVE_OUTPUT_NAME_CONFIG.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/ARCHIVE_OUTPUT_NAME_CONFIG.rst new file mode 100644 index 0000000000000000000000000000000000000000..4f62eb995350dbb778e5690f7344d32ffe55d290 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/ARCHIVE_OUTPUT_NAME_CONFIG.rst @@ -0,0 +1,8 @@ +ARCHIVE_OUTPUT_NAME_ +---------------------------- + +Per-configuration output name for +:ref:`ARCHIVE ` target files. + +This is the configuration-specific version of the +:prop_tgt:`ARCHIVE_OUTPUT_NAME` target property. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/AUTOMOC_EXECUTABLE.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/AUTOMOC_EXECUTABLE.rst new file mode 100644 index 0000000000000000000000000000000000000000..a6d5aa03e6731d527f1cd77b0e09983a174c03c1 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/AUTOMOC_EXECUTABLE.rst @@ -0,0 +1,17 @@ +AUTOMOC_EXECUTABLE +------------------ + +.. versionadded:: 3.14 + +``AUTOMOC_EXECUTABLE`` is file path pointing to the ``moc`` +executable to use for :prop_tgt:`AUTOMOC` enabled files. Setting +this property will make CMake skip the automatic detection of the +``moc`` binary as well as the sanity-tests normally run to ensure +that the binary is available and working as expected. + +Usually this property does not need to be set. Only consider this +property if auto-detection of ``moc`` can not work -- e.g. because +you are building the ``moc`` binary as part of your project. + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/AUTOUIC_EXECUTABLE.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/AUTOUIC_EXECUTABLE.rst new file mode 100644 index 0000000000000000000000000000000000000000..be7929094567958b9e96e00955c242c9a0f31a58 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/AUTOUIC_EXECUTABLE.rst @@ -0,0 +1,17 @@ +AUTOUIC_EXECUTABLE +------------------ + +.. versionadded:: 3.14 + +``AUTOUIC_EXECUTABLE`` is file path pointing to the ``uic`` +executable to use for :prop_tgt:`AUTOUIC` enabled files. Setting +this property will make CMake skip the automatic detection of the +``uic`` binary as well as the sanity-tests normally run to ensure +that the binary is available and working as expected. + +Usually this property does not need to be set. Only consider this +property if auto-detection of ``uic`` can not work -- e.g. because +you are building the ``uic`` binary as part of your project. + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/BUILD_RPATH.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/BUILD_RPATH.rst new file mode 100644 index 0000000000000000000000000000000000000000..902e2f7af1d6aac301fc0a3947c4f5af211a38a9 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/BUILD_RPATH.rst @@ -0,0 +1,36 @@ +BUILD_RPATH +----------- + +.. versionadded:: 3.8 + +A :ref:`semicolon-separated list ` specifying +runtime path (``RPATH``) entries to add to binaries linked in the +build tree (for platforms that support it). By default, CMake sets +the runtime path of binaries in the build tree to contain search +paths it knows are needed to find the shared libraries they link. +Projects may set ``BUILD_RPATH`` to specify additional search paths. + +The build-tree runtime path will *not* be used for binaries in the +install tree. It will be replaced with the install-tree runtime path +during the installation step. See also the :prop_tgt:`INSTALL_RPATH` +target property. + +This property is initialized by the value of the variable +:variable:`CMAKE_BUILD_RPATH` if it is set when a target is created. + +This property supports +:manual:`generator expressions `. + +Other settings that affect the build-tree runtime path include: + +* The :variable:`CMAKE_SKIP_RPATH` variable completely disables runtime + paths in both the build tree and install tree. + +* The :prop_tgt:`SKIP_BUILD_RPATH` target property disables setting any + runtime path in the build tree. + +* The :prop_tgt:`BUILD_RPATH_USE_ORIGIN` target property causes the + automatically-generated runtime path to use entries relative to ``$ORIGIN``. + +* The :prop_tgt:`BUILD_WITH_INSTALL_RPATH` target property causes binaries + in the build tree to be built with the install-tree runtime path. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/BUILD_WITH_INSTALL_RPATH.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/BUILD_WITH_INSTALL_RPATH.rst new file mode 100644 index 0000000000000000000000000000000000000000..0244351044a1e8f2112f22be5b94b0bd2b1bdfd4 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/BUILD_WITH_INSTALL_RPATH.rst @@ -0,0 +1,15 @@ +BUILD_WITH_INSTALL_RPATH +------------------------ + +``BUILD_WITH_INSTALL_RPATH`` is a boolean specifying whether to link the target +in the build tree with the :prop_tgt:`INSTALL_RPATH`. This takes precedence +over :prop_tgt:`SKIP_BUILD_RPATH` and avoids the need for relinking before +installation. + +This property is initialized by the value of the +:variable:`CMAKE_BUILD_WITH_INSTALL_RPATH` variable if it is set when a target +is created. + +If policy :policy:`CMP0068` is not ``NEW``, this property also controls use of +:prop_tgt:`INSTALL_NAME_DIR` in the build tree on macOS. Either way, the +:prop_tgt:`BUILD_WITH_INSTALL_NAME_DIR` target property takes precedence. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/COMPILE_FLAGS.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/COMPILE_FLAGS.rst new file mode 100644 index 0000000000000000000000000000000000000000..5229d467d1ef30740de012e92c6e4c7ae9e2dbfe --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/COMPILE_FLAGS.rst @@ -0,0 +1,14 @@ +COMPILE_FLAGS +------------- + +Additional flags to use when compiling this target's sources. + +The ``COMPILE_FLAGS`` property sets additional compiler flags used to +build sources within the target. Use :prop_tgt:`COMPILE_DEFINITIONS` +to pass additional preprocessor definitions. + +.. note:: + + This property has been superseded by the :prop_tgt:`COMPILE_OPTIONS` property. + Alternatively, you can also use the :command:`target_compile_options` command + instead. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/COMPILE_PDB_NAME.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/COMPILE_PDB_NAME.rst new file mode 100644 index 0000000000000000000000000000000000000000..b76afeb0896c05f1c3a2a23687212a0c46b9617b --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/COMPILE_PDB_NAME.rst @@ -0,0 +1,13 @@ +COMPILE_PDB_NAME +---------------- + +.. versionadded:: 3.1 + +Output name for the MS debug symbol ``.pdb`` file generated by the +compiler while building source files. + +This property specifies the base name for the debug symbols file. +If not set, the default is unspecified. + +.. |PDB_XXX| replace:: :prop_tgt:`PDB_NAME` +.. include:: COMPILE_PDB_NOTE.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/COMPILE_PDB_OUTPUT_DIRECTORY_CONFIG.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/COMPILE_PDB_OUTPUT_DIRECTORY_CONFIG.rst new file mode 100644 index 0000000000000000000000000000000000000000..c25c2fc4e5b85a77a2dbff1d5c9fe58e61223345 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/COMPILE_PDB_OUTPUT_DIRECTORY_CONFIG.rst @@ -0,0 +1,18 @@ +COMPILE_PDB_OUTPUT_DIRECTORY_ +------------------------------------- + +.. versionadded:: 3.1 + +Per-configuration output directory for the MS debug symbol ``.pdb`` file +generated by the compiler while building source files. + +This is a per-configuration version of +:prop_tgt:`COMPILE_PDB_OUTPUT_DIRECTORY`, +but multi-configuration generators (Visual Studio, Xcode) do NOT append a +per-configuration subdirectory to the specified directory. This +property is initialized by the value of the +:variable:`CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY_` variable +if it is set when a target is created. + +.. |PDB_XXX| replace:: :prop_tgt:`PDB_OUTPUT_DIRECTORY_` +.. include:: COMPILE_PDB_NOTE.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/C_EXTENSIONS.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/C_EXTENSIONS.rst new file mode 100644 index 0000000000000000000000000000000000000000..a53090c57fd1c5fb9e9585f99b06b711f91bf407 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/C_EXTENSIONS.rst @@ -0,0 +1,21 @@ +C_EXTENSIONS +------------ + +.. versionadded:: 3.1 + +Boolean specifying whether compiler specific extensions are requested. + +This property specifies whether compiler specific extensions should be +used. For some compilers, this results in adding a flag such +as ``-std=gnu11`` instead of ``-std=c11`` to the compile line. This +property is ``ON`` by default. The basic C standard level is +controlled by the :prop_tgt:`C_STANDARD` target property. + +See the :manual:`cmake-compile-features(7)` manual for information on +compile features and a list of supported compilers. + +This property is initialized by the value of +the :variable:`CMAKE_C_EXTENSIONS` variable if set when a target is created and +otherwise by the value of +:variable:`CMAKE_C_EXTENSIONS_DEFAULT _EXTENSIONS_DEFAULT>` (see +:policy:`CMP0128`). diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/DEPLOYMENT_REMOTE_DIRECTORY.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/DEPLOYMENT_REMOTE_DIRECTORY.rst new file mode 100644 index 0000000000000000000000000000000000000000..3f691b1815242c3d9e26903f5d8aa0e15f408af8 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/DEPLOYMENT_REMOTE_DIRECTORY.rst @@ -0,0 +1,20 @@ +DEPLOYMENT_REMOTE_DIRECTORY +--------------------------- + +.. versionadded:: 3.6 + +Set the WinCE project ``RemoteDirectory`` in ``DeploymentTool`` and +``RemoteExecutable`` in ``DebuggerTool`` in ``.vcproj`` files generated +by the :ref:`Visual Studio Generators`. +This is useful when you want to debug on remote WinCE device. +For example: + +.. code-block:: cmake + + set_property(TARGET ${TARGET} PROPERTY + DEPLOYMENT_REMOTE_DIRECTORY "\\FlashStorage") + +produces:: + + + diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/DEPRECATION.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/DEPRECATION.rst new file mode 100644 index 0000000000000000000000000000000000000000..2945c98817fb250e47880ae7abf10e8054edbae2 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/DEPRECATION.rst @@ -0,0 +1,14 @@ +DEPRECATION +----------- + +.. versionadded:: 3.17 + +Deprecation message from imported target's developer. + +``DEPRECATION`` is the message regarding a deprecation status to be displayed +to downstream users of a target. + +The message is formatted as follows: + +* Lines that do not start in whitespace are wrapped as paragraph text. +* Lines that start in whitespace are preserved as preformatted text. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/DOTNET_SDK.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/DOTNET_SDK.rst new file mode 100644 index 0000000000000000000000000000000000000000..ca1dcaca9ab6de976f63e80c24c6fb7825a86a42 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/DOTNET_SDK.rst @@ -0,0 +1,25 @@ +DOTNET_SDK +---------- + +.. versionadded:: 3.23 + +Specify the .NET SDK for C# projects. For example: ``Microsoft.NET.Sdk``. + +This property tells :ref:`Visual Studio Generators` for VS 2019 and +above to generate a .NET SDK-style project using the specified SDK. +The property is meaningful only to these generators, and only in C# +targets. It is ignored for C++ projects, even if they are managed +(e.g. using :prop_tgt:`COMMON_LANGUAGE_RUNTIME`). + +This property must be a non-empty string to generate .NET SDK-style projects. +CMake does not perform any validations for the value of the property. + +This property may be initialized for all targets using the +:variable:`CMAKE_DOTNET_SDK` variable. + +.. note:: + + The :ref:`Visual Studio Generators` in this version of CMake have not + yet learned to support :command:`add_custom_command` in .NET SDK-style + projects. It is currently an error to attach a custom command to a + target with the ``DOTNET_SDK`` property set. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/EXCLUDE_FROM_ALL.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/EXCLUDE_FROM_ALL.rst new file mode 100644 index 0000000000000000000000000000000000000000..f0200f38bc1db86958ad3f6b51b4597fbe31378a --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/EXCLUDE_FROM_ALL.rst @@ -0,0 +1,28 @@ +EXCLUDE_FROM_ALL +---------------- + +Set this target property to a true (or false) value to exclude (or include) +the target from the "all" target of the containing directory and its +ancestors. If excluded, running e.g. ``make`` in the containing directory +or its ancestors will not build the target by default. + +If this target property is not set then the target will be included in +the "all" target of the containing directory. Furthermore, it will be +included in the "all" target of its ancestor directories unless the +:prop_dir:`EXCLUDE_FROM_ALL` directory property is set. + +With ``EXCLUDE_FROM_ALL`` set to false or not set at all, the target +will be brought up to date as part of doing a ``make install`` or its +equivalent for the CMake generator being used. + +If a target has ``EXCLUDE_FROM_ALL`` set to true, it may still be listed +in an :command:`install(TARGETS)` command, but the user is responsible for +ensuring that the target's build artifacts are not missing or outdated when +an install is performed. + +This property may use "generator expressions" with the syntax ``$<...>``. See +the :manual:`cmake-generator-expressions(7)` manual for available expressions. + +Only the "Ninja Multi-Config" generator supports a property value that varies by +configuration. For all other generators the value of this property must be the +same for all configurations. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/EXPORT_NO_SYSTEM.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/EXPORT_NO_SYSTEM.rst new file mode 100644 index 0000000000000000000000000000000000000000..f86abd3c648321a1a72fca1415b99a46b210cbdf --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/EXPORT_NO_SYSTEM.rst @@ -0,0 +1,13 @@ +EXPORT_NO_SYSTEM +---------------- + +.. versionadded:: 3.25 + +This property affects the behavior of the :command:`install(EXPORT)` and +:command:`export` commands when they install or export the target respectively. +When ``EXPORT_NO_SYSTEM`` is set to true, those commands generate an imported +target with :prop_tgt:`SYSTEM` property set to false. + +See the :prop_tgt:`NO_SYSTEM_FROM_IMPORTED` target property to set this +behavior on the target *consuming* the include directories rather than the +one *providing* them. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/Fortran_PREPROCESS.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/Fortran_PREPROCESS.rst new file mode 100644 index 0000000000000000000000000000000000000000..e7e2fbaf8506c354c907884425379c0eabe0b527 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/Fortran_PREPROCESS.rst @@ -0,0 +1,25 @@ +Fortran_PREPROCESS +------------------ + +.. versionadded:: 3.18 + +Control whether the Fortran source file should be unconditionally +preprocessed. + +If unset or empty, rely on the compiler to determine whether the file +should be preprocessed. If explicitly set to ``OFF`` then the file does not +need to be preprocessed. If explicitly set to ``ON``, then the file does +need to be preprocessed as part of the compilation step. + +When using the :generator:`Ninja` generator, all source files are +first preprocessed in order to generate module dependency +information. Setting this property to ``OFF`` will make ``Ninja`` +skip this step. + +Use the source-specific :prop_sf:`Fortran_PREPROCESS` property if a single +file needs to be preprocessed. If the variable +:variable:`CMAKE_Fortran_PREPROCESS` is set when a target is created its +value is used to initialize this property. + +.. note:: For some compilers, ``NAG``, ``PGI`` and ``Solaris Studio``, + setting this to ``OFF`` will have no effect. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/HEADER_SET.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/HEADER_SET.rst new file mode 100644 index 0000000000000000000000000000000000000000..a703fc155a3a8e2bf1846cf1b2aff817819648f2 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/HEADER_SET.rst @@ -0,0 +1,15 @@ +HEADER_SET +---------- + +.. versionadded:: 3.23 + +Semicolon-separated list of files in the target's default header set, +(i.e. the file set with name and type ``HEADERS``). If any of the paths +are relative, they are computed relative to the target's source directory. +The property supports +:manual:`generator expressions `. + +This property is normally only set by :command:`target_sources(FILE_SET)` +rather than being manipulated directly. + +See :prop_tgt:`HEADER_SET_` for the list of files in other header sets. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/HIP_STANDARD.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/HIP_STANDARD.rst new file mode 100644 index 0000000000000000000000000000000000000000..9de873038126d427eabfa3b1229aaf8ad826ec5e --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/HIP_STANDARD.rst @@ -0,0 +1,54 @@ +HIP_STANDARD +------------ + +.. versionadded:: 3.21 + +The HIP/C++ standard requested to build this target. + +Supported values are: + +``98`` + HIP C++98 + +``11`` + HIP C++11 + +``14`` + HIP C++14 + +``17`` + HIP C++17 + +``20`` + HIP C++20 + +``23`` + HIP C++23 + +``26`` + .. versionadded:: 3.25 + + HIP C++26. CMake 3.25 and later *recognize* ``26`` as a valid value, + no version has support for any compiler. + +If the value requested does not result in a compile flag being added for +the compiler in use, a previous standard flag will be added instead. This +means that using: + +.. code-block:: cmake + + set_property(TARGET tgt PROPERTY HIP_STANDARD 11) + +with a compiler which does not support ``-std=gnu++11`` or an equivalent +flag will not result in an error or warning, but will instead add the +``-std=gnu++98`` flag if supported. This "decay" behavior may be controlled +with the :prop_tgt:`HIP_STANDARD_REQUIRED` target property. +Additionally, the :prop_tgt:`HIP_EXTENSIONS` target property may be used to +control whether compiler-specific extensions are enabled on a per-target basis. + +See the :manual:`cmake-compile-features(7)` manual for information on +compile features and a list of supported compilers. + +This property is initialized by the value of +the :variable:`CMAKE_HIP_STANDARD` variable if it is set when a target +is created. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/IMPORTED_CXX_MODULES_COMPILE_FEATURES.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/IMPORTED_CXX_MODULES_COMPILE_FEATURES.rst new file mode 100644 index 0000000000000000000000000000000000000000..cea359f5b09342e3b7f86e40dfcad0d708cf19a8 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/IMPORTED_CXX_MODULES_COMPILE_FEATURES.rst @@ -0,0 +1,9 @@ +IMPORTED_CXX_MODULES_COMPILE_FEATURES +------------------------------------- + +.. versionadded:: 3.28 + +Compiler features enabled for this ``IMPORTED`` target's C++ modules. + +The value of this property is used by the generators to set the include +paths for the compiler. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/IMPORTED_NO_SONAME.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/IMPORTED_NO_SONAME.rst new file mode 100644 index 0000000000000000000000000000000000000000..cbb764226399975f87331b2496257b9f06f40865 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/IMPORTED_NO_SONAME.rst @@ -0,0 +1,9 @@ +IMPORTED_NO_SONAME +------------------ + +Specifies that an ``IMPORTED`` shared library target has no ``soname``. + +Set this property to true for an imported shared library file that has +no ``soname`` field. CMake may adjust generated link commands for some +platforms to prevent the linker from using the path to the library in +place of its missing ``soname``. Ignored for non-imported targets. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/IMPORT_PREFIX.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/IMPORT_PREFIX.rst new file mode 100644 index 0000000000000000000000000000000000000000..17e381be47f155946b1102ed0e4e709bd99466b6 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/IMPORT_PREFIX.rst @@ -0,0 +1,9 @@ +IMPORT_PREFIX +------------- + +What comes before the import library name. + +Similar to the target property :prop_tgt:`PREFIX`, but used for import libraries +(typically corresponding to a ``DLL``) instead of regular libraries. A +target property that can be set to override the prefix (such as ``lib``) +on an import library name. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/INTERFACE_AUTOMOC_MACRO_NAMES.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/INTERFACE_AUTOMOC_MACRO_NAMES.rst new file mode 100644 index 0000000000000000000000000000000000000000..502775c8e3b4816168b71fc9c800a41c4f8cd241 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/INTERFACE_AUTOMOC_MACRO_NAMES.rst @@ -0,0 +1,89 @@ +INTERFACE_AUTOMOC_MACRO_NAMES +----------------------------- + +.. versionadded:: 3.27 + +A :ref:`semicolon-separated list ` of macro names for +:prop_tgt:`AUTOMOC` to be propagated to consumers. + +When a target with :prop_tgt:`AUTOMOC` enabled links to a library that sets +``INTERFACE_AUTOMOC_MACRO_NAMES``, the target inherits the listed macro names +and merges them with those specified in its own :prop_tgt:`AUTOMOC_MACRO_NAMES` +property. The target will then automatically generate MOC files for source +files that contain the inherited macro names too, not just the macro names +specified in its own :prop_tgt:`AUTOMOC_MACRO_NAMES` property. + +By default ``INTERFACE_AUTOMOC_MACRO_NAMES`` is empty. + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. + +Example 1 +^^^^^^^^^ + +In this example, ``myapp`` inherits the macro names ``STATIC_LIB_1`` and +``STATIC_LIB_2`` from ``static_lib``. The ``moc`` tool will then automatically +be run on any of the ``myapp`` sources which contain ``STATIC_LIB_1`` or +``STATIC_LIB_2``. + +.. code-block:: cmake + + set(AUTOMOC ON) + add_executable(myapp main.cpp) + target_link_libraries(myapp PRIVATE static_lib) + + add_library(static_lib STATIC static.cpp) + set_property(TARGET static_lib PROPERTY + INTERFACE_AUTOMOC_MACRO_NAMES "STATIC_LIB_1;STATIC_LIB_2" + ) + +Example 2 +^^^^^^^^^ + +In this example, the ``INTERFACE_AUTOMOC_MACRO_NAMES`` target property of the +various ``*_deep_lib`` libraries will propagate to ``shared_lib``, +``static_lib`` and ``interface_lib``. Because the linking relationships are +specified as ``PUBLIC`` and ``INTERFACE``, those macro names will also further +propagate transitively up to ``app``. + +.. code-block:: cmake + + set(AUTOMOC ON) + + add_library(shared_deep_lib SHARED deep_lib.cpp) + add_library(static_deep_lib STATIC deep_lib.cpp) + add_library(interface_deep_lib INTERFACE) + + set_property(TARGET shared_deep_lib PROPERTY + INTERFACE_AUTOMOC_MACRO_NAMES "SHARED_LINK_LIB" + ) + set_property(TARGET static_deep_lib PROPERTY + INTERFACE_AUTOMOC_MACRO_NAMES "STATIC_LINK_LIB" + ) + set_property(TARGET interface_deep_lib PROPERTY + INTERFACE_AUTOMOC_MACRO_NAMES "INTERFACE_LINK_LIB" + ) + + add_library(shared_lib SHARED lib.cpp) + add_library(static_lib STATIC lib.cpp) + add_library(interface_lib INTERFACE) + + # PUBLIC and INTERFACE here ensure the macro names propagate to any + # consumers of shared_lib, static_lib or interface_lib too + target_link_libraries(shared_lib PUBLIC shared_deep_lib) + target_link_libraries(static_lib PUBLIC static_deep_lib) + target_link_libraries(interface_lib INTERFACE interface_deep_lib) + + # This consumer will receive all three of the above custom macro names as + # transitive usage requirements + add_executable(app main.cpp) + target_link_libraries(app PRIVATE shared_lib static_lib interface_lib) + +In the above: + +* ``shared_lib`` sources will be processed by ``moc`` if they contain + ``SHARED_LINK_LIB``. +* ``static_lib`` sources will be processed by ``moc`` if they contain + ``STATIC_LINK_LIB``. +* ``app`` sources will be processed by ``moc`` if they contain + ``SHARED_LINK_LIB``, ``STATIC_LINK_LIB`` or ``INTERFACE_LINK_LIB``. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/INTERFACE_INCLUDE_DIRECTORIES.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/INTERFACE_INCLUDE_DIRECTORIES.rst new file mode 100644 index 0000000000000000000000000000000000000000..8795c80ab6cc41e88e678242b21dd7a6b0a9d37c --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/INTERFACE_INCLUDE_DIRECTORIES.rst @@ -0,0 +1,28 @@ +INTERFACE_INCLUDE_DIRECTORIES +----------------------------- + +.. |property_name| replace:: include directories +.. |command_name| replace:: :command:`target_include_directories` +.. |PROPERTY_INTERFACE_NAME| replace:: ``INTERFACE_INCLUDE_DIRECTORIES`` +.. |PROPERTY_LINK| replace:: :prop_tgt:`INCLUDE_DIRECTORIES` +.. include:: INTERFACE_BUILD_PROPERTY.txt + +Include directories usage requirements commonly differ between the build-tree +and the install-tree. The ``BUILD_INTERFACE`` and ``INSTALL_INTERFACE`` +generator expressions can be used to describe separate usage requirements +based on the usage location. Relative paths are allowed within the +``INSTALL_INTERFACE`` expression and are interpreted relative to the +installation prefix. For example: + +.. code-block:: cmake + + target_include_directories(mylib INTERFACE + $ + $ # /include/mylib + ) + +Creating Relocatable Packages +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. |INTERFACE_PROPERTY_LINK| replace:: ``INTERFACE_INCLUDE_DIRECTORIES`` +.. include:: /include/INTERFACE_INCLUDE_DIRECTORIES_WARNING.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/JOB_POOL_COMPILE.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/JOB_POOL_COMPILE.rst new file mode 100644 index 0000000000000000000000000000000000000000..5d8e9403873efc9758133c7aa1cb2e7e4b9ecc93 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/JOB_POOL_COMPILE.rst @@ -0,0 +1,17 @@ +JOB_POOL_COMPILE +---------------- + +Ninja only: Pool used for compiling. + +The number of parallel compile processes could be limited by defining +pools with the global :prop_gbl:`JOB_POOLS` +property and then specifying here the pool name. + +For instance: + +.. code-block:: cmake + + set_property(TARGET myexe PROPERTY JOB_POOL_COMPILE ten_jobs) + +This property is initialized by the value of +:variable:`CMAKE_JOB_POOL_COMPILE`. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LANG_CPPLINT.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LANG_CPPLINT.rst new file mode 100644 index 0000000000000000000000000000000000000000..02610daa3246233a5078aef63bff828cfa068723 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LANG_CPPLINT.rst @@ -0,0 +1,29 @@ +_CPPLINT +-------------- + +.. versionadded:: 3.8 + +This property is supported only when ```` is ``C`` or ``CXX``. + +Specify a :ref:`semicolon-separated list ` containing a command line +for the ``cpplint`` style checker. The :ref:`Makefile Generators` and the +:generator:`Ninja` generator will run ``cpplint`` along with the compiler +and report any problems. + +This property is initialized by the value of the +:variable:`CMAKE__CPPLINT` variable if it is set when a target is +created. + +.. versionadded:: 3.27 + + This property supports + :manual:`generator expressions `. + +.. versionadded:: 3.27 + + :prop_sf:`SKIP_LINTING` can be set on individual source files to exclude + them from the linting tools defined by ``_CPPLINT``, + :prop_tgt:`_CLANG_TIDY`, :prop_tgt:`_CPPCHECK`, and + :prop_tgt:`_INCLUDE_WHAT_YOU_USE`. When :prop_sf:`SKIP_LINTING` is + set to true on a source file, those tools will not be run on that specific + file. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LANG_STANDARD.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LANG_STANDARD.rst new file mode 100644 index 0000000000000000000000000000000000000000..4b59af70e257d42212d402892ad09134179361e1 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LANG_STANDARD.rst @@ -0,0 +1,33 @@ +_STANDARD +--------------- + +The variations are: + +* :prop_tgt:`C_STANDARD` +* :prop_tgt:`CXX_STANDARD` +* :prop_tgt:`CUDA_STANDARD` +* :prop_tgt:`HIP_STANDARD` +* :prop_tgt:`OBJC_STANDARD` +* :prop_tgt:`OBJCXX_STANDARD` + +These properties specify language standard versions which are requested. When a +newer standard is specified than is supported by the compiler, then it will +fallback to the latest supported standard. This "decay" behavior may be +controlled with the :prop_tgt:`_STANDARD_REQUIRED` target property. + +Note that the actual language standard used may be higher than that specified +by ``_STANDARD``, regardless of the value of +:prop_tgt:`_STANDARD_REQUIRED`. In particular, +:ref:`usage requirements ` or the use of +:manual:`compile features ` can raise the required +language standard above what ``_STANDARD`` specifies. + +These properties are initialized by the value of the +:variable:`CMAKE__STANDARD` variable if it is set when a target is +created. + +For supported values and CMake versions see the respective pages. +To control compiler-specific extensions see :prop_tgt:`_EXTENSIONS`. + +See the :manual:`cmake-compile-features(7)` manual for information on +compile features and a list of supported compilers. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LINK_DEPENDS.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LINK_DEPENDS.rst new file mode 100644 index 0000000000000000000000000000000000000000..e59d4c014e0e5be01054c31bf8ddf535bd253a94 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LINK_DEPENDS.rst @@ -0,0 +1,18 @@ +LINK_DEPENDS +------------ + +Additional files on which a target binary depends for linking. + +Specifies a semicolon-separated list of full-paths to files on which +the link rule for this target depends. The target binary will be +linked if any of the named files is newer than it. + +This property is supported only by :generator:`Ninja` and +:ref:`Makefile Generators`. It is +intended to specify dependencies on "linker scripts" for custom Makefile link +rules. + +Contents of ``LINK_DEPENDS`` may use "generator expressions" with +the syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` +manual for available expressions. See the :manual:`cmake-buildsystem(7)` +manual for more on defining buildsystem properties. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LINK_LIBRARIES_ONLY_TARGETS.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LINK_LIBRARIES_ONLY_TARGETS.rst new file mode 100644 index 0000000000000000000000000000000000000000..0749c6fb18153440fa1019c771790348b0422139 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/LINK_LIBRARIES_ONLY_TARGETS.rst @@ -0,0 +1,56 @@ +LINK_LIBRARIES_ONLY_TARGETS +--------------------------- + +.. versionadded:: 3.23 + +Enforce that link items that can be target names are actually existing targets. + +Set this property to a true value to enable additional checks on the contents +of the :prop_tgt:`LINK_LIBRARIES` and :prop_tgt:`INTERFACE_LINK_LIBRARIES` +target properties, typically populated by :command:`target_link_libraries`. +Checks are also applied to libraries added to a target through the +:prop_tgt:`INTERFACE_LINK_LIBRARIES_DIRECT` properties of its dependencies. +CMake will verify that link items that might be target names actually name +existing targets. An item is considered a possible target name if: + +* it does not contain a ``/`` or ``\``, and +* it does not start in ``-``, and +* (for historical reasons) it does not start in ``$`` or `````. + +This property is initialized by the value of the +:variable:`CMAKE_LINK_LIBRARIES_ONLY_TARGETS` variable when a non-imported +target is created. The property may be explicitly enabled on an imported +target to check its link interface. + +In the following example, CMake will halt with an error at configure time +because ``miLib`` is not a target: + +.. code-block:: cmake + + set(CMAKE_LINK_LIBRARIES_ONLY_TARGETS ON) + add_library(myLib STATIC myLib.c) + add_executable(myExe myExe.c) + target_link_libraries(myExe PRIVATE miLib) # typo for myLib + +In order to link toolchain-provided libraries by name while still +enforcing ``LINK_LIBRARIES_ONLY_TARGETS``, use an +:ref:`imported ` +:ref:`Interface Library ` with the +:prop_tgt:`IMPORTED_LIBNAME` target property: + +.. code-block:: cmake + + add_library(toolchain::m INTERFACE IMPORTED) + set_property(TARGET toolchain::m PROPERTY IMPORTED_LIBNAME "m") + target_link_libraries(myExe PRIVATE toolchain::m) + +See also policy :policy:`CMP0028`. + +.. note:: + + If :prop_tgt:`INTERFACE_LINK_LIBRARIES` contains generator expressions, + its actual list of link items may depend on the type and properties of + the consuming target. In such cases CMake may not always detect names + of missing targets that only appear for specific consumers. + A future version of CMake with improved heuristics may start triggering + errors on projects accepted by previous versions of CMake. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MACHO_CURRENT_VERSION.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MACHO_CURRENT_VERSION.rst new file mode 100644 index 0000000000000000000000000000000000000000..530f79b1ad06f5dbeae6e5ef7a3cda99956e6ab9 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MACHO_CURRENT_VERSION.rst @@ -0,0 +1,27 @@ +MACHO_CURRENT_VERSION +--------------------- + +.. versionadded:: 3.17 + +What current version number is this target for Mach-O binaries. + +For shared libraries on Mach-O systems (e.g. macOS, iOS) +the :prop_tgt:`MACHO_COMPATIBILITY_VERSION` property corresponds to the +*compatibility version* and ``MACHO_CURRENT_VERSION`` corresponds to the +*current version*. These are both embedded in the shared library binary +and can be checked with the ``otool -L `` command. + +It should be noted that the ``MACHO_CURRENT_VERSION`` and +:prop_tgt:`MACHO_COMPATIBILITY_VERSION` properties do not affect the file +names or version-related symlinks that CMake generates for the library. +The :prop_tgt:`VERSION` and :prop_tgt:`SOVERSION` target properties still +control the file and symlink names. The ``install_name`` is also still +controlled by :prop_tgt:`SOVERSION`. + +When ``MACHO_CURRENT_VERSION`` and :prop_tgt:`MACHO_COMPATIBILITY_VERSION` +are not given, :prop_tgt:`VERSION` and :prop_tgt:`SOVERSION` are used for +the version details to be embedded in the binaries respectively. +The ``MACHO_CURRENT_VERSION`` and :prop_tgt:`MACHO_COMPATIBILITY_VERSION` +properties only need to be given if the project needs to decouple the file +and symlink naming from the version details embedded in the binaries +(e.g. to match libtool conventions). diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MACOS_IMPORT_FILES.txt b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MACOS_IMPORT_FILES.txt new file mode 100644 index 0000000000000000000000000000000000000000..3c98fc8ca8072d8d5618a058c45a198f43ecf561 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MACOS_IMPORT_FILES.txt @@ -0,0 +1,12 @@ +.. note:: + + On macOS, this property will be ignored for the linker import files (e.g. + ``.tbd`` files, see :prop_tgt:`ENABLE_EXPORTS` property for details) when: + + * The :prop_tgt:`FRAMEWORK` is set, because the framework layout cannot be + changed. + * The :generator:`Xcode` generator is used, due to the limitations and + constraints of the ``Xcode`` tool. + + In both cases, the linker import files will be generated |IDEM| as the shared + library. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MAP_IMPORTED_CONFIG_CONFIG.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MAP_IMPORTED_CONFIG_CONFIG.rst new file mode 100644 index 0000000000000000000000000000000000000000..266ccf0787db6ec1daa95043185b03590c04fac9 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MAP_IMPORTED_CONFIG_CONFIG.rst @@ -0,0 +1,70 @@ +MAP_IMPORTED_CONFIG_ +---------------------------- + +Map from project configuration to +:ref:`imported target `'s configuration. + +Set this to the list of configurations of an imported target that may +be used for the current project's ```` configuration. Targets +imported from another project may not provide the same set of +configuration names available in the current project. Setting this +property tells CMake what imported configurations are suitable for use +when building the ```` configuration. The first configuration in +the list found to be provided by the imported target (i.e. via +:prop_tgt:`IMPORTED_LOCATION_` for the mapped-to ````) +is selected. As a special case, an empty list element refers to the +configuration-less imported target location +(i.e. :prop_tgt:`IMPORTED_LOCATION`). + +If this property is set and no matching configurations are available, +then the imported target is considered to be not found. This property +is ignored for non-imported targets. + +This property is initialized by the value of the +:variable:`CMAKE_MAP_IMPORTED_CONFIG_` variable if it is set when a +target is created. + +Example +^^^^^^^ + +For example creating imported C++ library ``foo``: + +.. code-block:: cmake + + add_library(foo STATIC IMPORTED) + +Use ``foo_debug`` path for ``Debug`` build type: + +.. code-block:: cmake + + set_property( + TARGET foo APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG + ) + + set_target_properties(foo PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX" + IMPORTED_LOCATION_DEBUG "${foo_debug}" + ) + +Use ``foo_release`` path for ``Release`` build type: + +.. code-block:: cmake + + set_property( + TARGET foo APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE + ) + + set_target_properties(foo PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX" + IMPORTED_LOCATION_RELEASE "${foo_release}" + ) + +Use ``Release`` version of library for ``MinSizeRel`` and ``RelWithDebInfo`` +build types: + +.. code-block:: cmake + + set_target_properties(foo PROPERTIES + MAP_IMPORTED_CONFIG_MINSIZEREL Release + MAP_IMPORTED_CONFIG_RELWITHDEBINFO Release + ) diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MSVC_DEBUG_INFORMATION_FORMAT.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MSVC_DEBUG_INFORMATION_FORMAT.rst new file mode 100644 index 0000000000000000000000000000000000000000..7e08b483c468c1b124907170d19746a2b75803e8 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/MSVC_DEBUG_INFORMATION_FORMAT.rst @@ -0,0 +1,35 @@ +MSVC_DEBUG_INFORMATION_FORMAT +----------------------------- + +.. versionadded:: 3.25 + +Select debug information format when targeting the MSVC ABI. + +The allowed values are: + +.. include:: MSVC_DEBUG_INFORMATION_FORMAT-VALUES.txt + +Use :manual:`generator expressions ` to +support per-configuration specification. For example, the code: + +.. code-block:: cmake + + add_executable(foo foo.c) + set_property(TARGET foo PROPERTY + MSVC_DEBUG_INFORMATION_FORMAT "$<$:ProgramDatabase>") + +selects for the target ``foo`` the program database debug information format +for the Debug configuration. + +This property is initialized from the value of the +:variable:`CMAKE_MSVC_DEBUG_INFORMATION_FORMAT` variable, if it is set. +If this property is not set, CMake selects a debug information format using +the default value ``$<$:ProgramDatabase>``, if +supported by the compiler, and otherwise +``$<$:Embedded>``. + +.. note:: + + This property has effect only when policy :policy:`CMP0141` is set to ``NEW`` + prior to the first :command:`project` or :command:`enable_language` command + that enables a language using a compiler targeting the MSVC ABI. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/PDB_NOTE.txt b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/PDB_NOTE.txt new file mode 100644 index 0000000000000000000000000000000000000000..b5ada07c9d533a6f9ada2a49ee9c9de1e197e61e --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/PDB_NOTE.txt @@ -0,0 +1,9 @@ +.. note:: + This property does not apply to STATIC library targets because no linker + is invoked to produce them so they have no linker-generated ``.pdb`` file + containing debug symbols. + + The linker-generated program database files are specified by the + ``/pdb`` linker flag and are not the same as compiler-generated + program database files specified by the ``/Fd`` compiler flag. + Use the |COMPILE_PDB_XXX| property to specify the latter. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/PROJECT_LABEL.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/PROJECT_LABEL.rst new file mode 100644 index 0000000000000000000000000000000000000000..a1491ee139892c74ac63339415402ca6e11dc714 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/PROJECT_LABEL.rst @@ -0,0 +1,7 @@ +PROJECT_LABEL +------------- + +Change the name of a target in an IDE. + +Can be used to change the name of the target in an IDE like Visual +Studio. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/PUBLIC_HEADER.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/PUBLIC_HEADER.rst new file mode 100644 index 0000000000000000000000000000000000000000..915e39cd255a30f2b0482fcb923b51685867491a --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/PUBLIC_HEADER.rst @@ -0,0 +1,11 @@ +PUBLIC_HEADER +------------- + +Specify public header files in a :prop_tgt:`FRAMEWORK` shared library target. + +Shared library targets marked with the :prop_tgt:`FRAMEWORK` property generate +frameworks on macOS, iOS and normal shared libraries on other platforms. +This property may be set to a list of header files to be placed in the +``Headers`` directory inside the framework folder. On non-Apple platforms +these headers may be installed using the ``PUBLIC_HEADER`` option to the +:command:`install(TARGETS)` command. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/RESOURCE.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/RESOURCE.rst new file mode 100644 index 0000000000000000000000000000000000000000..e5a1cb677989da86ccb37420140a187b04401cd5 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/RESOURCE.rst @@ -0,0 +1,58 @@ +RESOURCE +-------- + +Specify resource files in a :prop_tgt:`FRAMEWORK` or :prop_tgt:`BUNDLE`. + +Target marked with the :prop_tgt:`FRAMEWORK` or :prop_tgt:`BUNDLE` property +generate framework or application bundle (both macOS and iOS is supported) +or normal shared libraries on other platforms. +This property may be set to a list of files to be placed in the corresponding +directory (eg. ``Resources`` directory for macOS) inside the bundle. +On non-Apple platforms these files may be installed using the ``RESOURCE`` +option to the :command:`install(TARGETS)` command. + +Following example of Application Bundle: + +.. code-block:: cmake + + add_executable(ExecutableTarget + addDemo.c + resourcefile.txt + appresourcedir/appres.txt) + + target_link_libraries(ExecutableTarget heymath mul) + + set(RESOURCE_FILES + resourcefile.txt + appresourcedir/appres.txt) + + set_target_properties(ExecutableTarget PROPERTIES + MACOSX_BUNDLE TRUE + MACOSX_FRAMEWORK_IDENTIFIER org.cmake.ExecutableTarget + RESOURCE "${RESOURCE_FILES}") + +will produce flat structure for iOS systems:: + + ExecutableTarget.app + appres.txt + ExecutableTarget + Info.plist + resourcefile.txt + +For macOS systems it will produce following directory structure:: + + ExecutableTarget.app/ + Contents + Info.plist + MacOS + ExecutableTarget + Resources + appres.txt + resourcefile.txt + +For Linux, such CMake script produce following files:: + + ExecutableTarget + Resources + appres.txt + resourcefile.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/RULE_LAUNCH_LINK.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/RULE_LAUNCH_LINK.rst new file mode 100644 index 0000000000000000000000000000000000000000..da93be259b8e5a0d02e2019d506663137fa7fbda --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/RULE_LAUNCH_LINK.rst @@ -0,0 +1,13 @@ +RULE_LAUNCH_LINK +---------------- + +Specify a launcher for link rules. + +.. note:: + This property is intended for internal use by :manual:`ctest(1)`. Projects + and developers should use the :prop_tgt:`_LINKER_LAUNCHER` target + properties or the associated :variable:`CMAKE__LINKER_LAUNCHER` + variables instead. + +See the :prop_gbl:`global property ` of the same name for +details. This overrides the global and directory property for a target. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/RUNTIME_OUTPUT_NAME.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/RUNTIME_OUTPUT_NAME.rst new file mode 100644 index 0000000000000000000000000000000000000000..11729c3a59b6ba24259a716e2eb3e1dbef17ca37 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/RUNTIME_OUTPUT_NAME.rst @@ -0,0 +1,8 @@ +RUNTIME_OUTPUT_NAME +------------------- + +.. |XXX| replace:: :ref:`RUNTIME ` +.. |xxx| replace:: runtime +.. include:: XXX_OUTPUT_NAME.txt + +See also the :prop_tgt:`RUNTIME_OUTPUT_NAME_` target property. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/STATIC_LIBRARY_FLAGS_CONFIG.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/STATIC_LIBRARY_FLAGS_CONFIG.rst new file mode 100644 index 0000000000000000000000000000000000000000..5b97941dacb9ddf9c6f4db4246030fae7a8718a4 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/STATIC_LIBRARY_FLAGS_CONFIG.rst @@ -0,0 +1,12 @@ +STATIC_LIBRARY_FLAGS_ +----------------------------- + +Per-configuration archiver (or MSVC librarian) flags for a static library +target. + +This is the configuration-specific version of :prop_tgt:`STATIC_LIBRARY_FLAGS`. + +.. note:: + + This property has been superseded by :prop_tgt:`STATIC_LIBRARY_OPTIONS` + property. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/STATIC_LIBRARY_OPTIONS.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/STATIC_LIBRARY_OPTIONS.rst new file mode 100644 index 0000000000000000000000000000000000000000..f5d943723ba9c1dfdd5759490d189930624d07c2 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/STATIC_LIBRARY_OPTIONS.rst @@ -0,0 +1,24 @@ +STATIC_LIBRARY_OPTIONS +---------------------- + +.. versionadded:: 3.13 + +Archiver (or MSVC librarian) flags for a static library target. +Targets that are shared libraries, modules, or executables need to use +the :prop_tgt:`LINK_OPTIONS` target property. + +This property holds a :ref:`semicolon-separated list ` of options +specified so far for its target. Use :command:`set_target_properties` or +:command:`set_property` commands to set its content. + +Contents of ``STATIC_LIBRARY_OPTIONS`` may use "generator expressions" with the +syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` manual +for available expressions. See the :manual:`cmake-buildsystem(7)` manual +for more on defining buildsystem properties. + +.. note:: + + This property must be used in preference to :prop_tgt:`STATIC_LIBRARY_FLAGS` + property. + +.. include:: ../command/OPTIONS_SHELL.txt diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/SUFFIX.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/SUFFIX.rst new file mode 100644 index 0000000000000000000000000000000000000000..32ec42910fb87cec3479c7a7b7b706f118adb2bf --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/SUFFIX.rst @@ -0,0 +1,7 @@ +SUFFIX +------ + +What comes after the target name. + +A target property that can be set to override the suffix (such as +``.so`` or ``.exe``) on the name of a library, module or executable. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/SYSTEM.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/SYSTEM.rst new file mode 100644 index 0000000000000000000000000000000000000000..f5c11bcb8b0c508ef340854e1efb00b22ad067a4 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/SYSTEM.rst @@ -0,0 +1,26 @@ +SYSTEM +------ + +.. versionadded:: 3.25 + +Specifies that a target is a system target. This has the following +effects: + +* Entries of :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` are treated as + system include directories when compiling consumers. + Entries of :prop_tgt:`INTERFACE_SYSTEM_INCLUDE_DIRECTORIES` are not + affected, and will always be treated as system include directories. +* On Apple platforms, If the :prop_tgt:`FRAMEWORK` target property is true, + the frameworks directory is treated as system. + +For imported targets, this property defaults to true, which means +that their :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` and, if the +:prop_tgt:`FRAMEWORK` target property is true, frameworks directory are +treated as system directories by default. If their ``SYSTEM`` property is +false, then their :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` as well as +frameworks will not be treated as system. Use the :prop_tgt:`EXPORT_NO_SYSTEM` +property to change how a target's ``SYSTEM`` property is set when it is +installed. + +For non-imported targets, this target property is initialized from +the :prop_dir:`SYSTEM` directory property when the target is created. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/Swift_LANGUAGE_VERSION.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/Swift_LANGUAGE_VERSION.rst new file mode 100644 index 0000000000000000000000000000000000000000..d1d80a86e5849d76d5acc1bba7290a3588c8acfb --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/Swift_LANGUAGE_VERSION.rst @@ -0,0 +1,9 @@ +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 +:variable:`CMAKE_Swift_LANGUAGE_VERSION` if specified, otherwise it is the +latest version supported by the compiler. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_CONFIGURATION_TYPE.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_CONFIGURATION_TYPE.rst new file mode 100644 index 0000000000000000000000000000000000000000..4adffd4f23dc67475710b64376ed75abecdaad7e --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_CONFIGURATION_TYPE.rst @@ -0,0 +1,14 @@ +VS_CONFIGURATION_TYPE +--------------------- + +.. versionadded:: 3.6 + +Visual Studio project configuration type. + +Sets the ``ConfigurationType`` attribute for a generated Visual Studio project. +The property value may use +:manual:`generator expressions `. +If this property is set, it overrides the default setting that is based on the +target type (e.g. ``StaticLibrary``, ``Application``, ...). + +Supported on :ref:`Visual Studio Generators` for VS 2010 and higher. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DEBUGGER_WORKING_DIRECTORY.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DEBUGGER_WORKING_DIRECTORY.rst new file mode 100644 index 0000000000000000000000000000000000000000..dbf544267637d0f2acb919de7a036c32f1537a49 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DEBUGGER_WORKING_DIRECTORY.rst @@ -0,0 +1,15 @@ +VS_DEBUGGER_WORKING_DIRECTORY +----------------------------- + +.. versionadded:: 3.8 + +Sets the local debugger working directory for Visual Studio C++ targets. +The property value may use +:manual:`generator expressions `. +This is defined in ```` in the Visual Studio +project file. This property is initialized by the value of the variable +:variable:`CMAKE_VS_DEBUGGER_WORKING_DIRECTORY` if it is set when a target is +created. + +This property only works for :ref:`Visual Studio Generators`; +it is ignored on other generators. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DOTNET_REFERENCES.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DOTNET_REFERENCES.rst new file mode 100644 index 0000000000000000000000000000000000000000..a661ad926a7214a4fa35189d7ea2adedad4887eb --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DOTNET_REFERENCES.rst @@ -0,0 +1,7 @@ +VS_DOTNET_REFERENCES +-------------------- + +Visual Studio managed project .NET references + +Adds one or more semicolon-delimited .NET references to a generated +Visual Studio project. For example, "System;System.Windows.Forms". diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DOTNET_REFERENCE_refname.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DOTNET_REFERENCE_refname.rst new file mode 100644 index 0000000000000000000000000000000000000000..9c4d34abe9a7744d2439ddfae1e55555378257af --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DOTNET_REFERENCE_refname.rst @@ -0,0 +1,14 @@ +VS_DOTNET_REFERENCE_ +----------------------------- + +.. versionadded:: 3.8 + +Visual Studio managed project .NET reference with name ```` +and hint path. + +Adds one .NET reference to generated Visual Studio project. The +reference will have the name ```` and will point to the +assembly given as value of the property. + +See also :prop_tgt:`VS_DOTNET_REFERENCES` and +:prop_tgt:`VS_DOTNET_REFERENCES_COPY_LOCAL` diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DOTNET_STARTUP_OBJECT.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DOTNET_STARTUP_OBJECT.rst new file mode 100644 index 0000000000000000000000000000000000000000..8c69fdcb7420e802a71cdb4b8410a37fda5ceb97 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_DOTNET_STARTUP_OBJECT.rst @@ -0,0 +1,21 @@ +VS_DOTNET_STARTUP_OBJECT +------------------------ + +.. versionadded:: 3.24 + +Sets the startup object property in Visual Studio .NET targets. +The property value defines a full qualified class name (including package +name), for example: ``MyCompany.Package.MyStarterClass``. + +If the property is unset, Visual Studio uses the first matching +``static void Main(string[])`` function signature by default. When more +than one ``Main()`` method is available in the current project, the property +becomes mandatory for building the project. + +This property only works for :ref:`Visual Studio Generators`; +it is ignored on other generators. + +.. code-block:: cmake + + set_property(TARGET ${TARGET_NAME} PROPERTY + VS_DOTNET_STARTUP_OBJECT "MyCompany.Package.MyStarterClass") diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_IOT_EXTENSIONS_VERSION.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_IOT_EXTENSIONS_VERSION.rst new file mode 100644 index 0000000000000000000000000000000000000000..ca6a3ca0063817d6a9f87f5517d6a18871c930bd --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_IOT_EXTENSIONS_VERSION.rst @@ -0,0 +1,12 @@ +VS_IOT_EXTENSIONS_VERSION +------------------------- + +.. versionadded:: 3.4 + +Visual Studio Windows 10 IoT Extensions Version + +Specifies the version of the IoT Extensions that should be included in the +target. For example ``10.0.10240.0``. If the value is not specified, the IoT +Extensions will not be included. To use the same version of the extensions as +the Windows 10 SDK that is being used, you can use the +:variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` variable. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_NO_SOLUTION_DEPLOY.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_NO_SOLUTION_DEPLOY.rst new file mode 100644 index 0000000000000000000000000000000000000000..bf6ac10923aa7558a64a67544fecf10b943ca218 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_NO_SOLUTION_DEPLOY.rst @@ -0,0 +1,48 @@ +VS_NO_SOLUTION_DEPLOY +--------------------- + +.. versionadded:: 3.15 + +Specify that the target should not be marked for deployment to a Windows CE +or Windows Phone device in the generated Visual Studio solution. + +Be default, all EXE and shared library (DLL) targets are marked to deploy to +the target device in the generated Visual Studio solution. + +Generator expressions are supported. + +There are reasons one might want to exclude a target / generated project from +deployment: + +- The library or executable may not be necessary in the primary deploy/debug + scenario, and excluding from deployment saves time in the + develop/download/debug cycle. +- There may be insufficient space on the target device to accommodate all of + the build products. +- Visual Studio 2013 requires a target device IP address be entered for each + target marked for deployment. For large numbers of targets, this can be + tedious. + NOTE: Visual Studio *will* deploy all project dependencies of a project + tagged for deployment to the IP address configured for that project even + if those dependencies are not tagged for deployment. + + +Example 1 +^^^^^^^^^ + +This shows setting the variable for the target foo. + +.. code-block:: cmake + + add_library(foo SHARED foo.cpp) + set_property(TARGET foo PROPERTY VS_NO_SOLUTION_DEPLOY ON) + +Example 2 +^^^^^^^^^ + +This shows setting the variable for the Release configuration only. + +.. code-block:: cmake + + add_library(foo SHARED foo.cpp) + set_property(TARGET foo PROPERTY VS_NO_SOLUTION_DEPLOY "$") diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_SCC_PROJECTNAME.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_SCC_PROJECTNAME.rst new file mode 100644 index 0000000000000000000000000000000000000000..6d7f628d92e1214f2a48a73db0677c033078b232 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_SCC_PROJECTNAME.rst @@ -0,0 +1,7 @@ +VS_SCC_PROJECTNAME +------------------ + +Visual Studio Source Code Control Project. + +Can be set to change the visual studio source code control project +name property. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_WINRT_COMPONENT.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_WINRT_COMPONENT.rst new file mode 100644 index 0000000000000000000000000000000000000000..8b4aaf7ac0b7fcce6f8a63eeece92f9898d2bf45 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/VS_WINRT_COMPONENT.rst @@ -0,0 +1,13 @@ +VS_WINRT_COMPONENT +------------------ + +.. versionadded:: 3.1 + +Mark a target as a Windows Runtime component for the Visual Studio generator. +Compile the target with ``C++/CX`` language extensions for Windows Runtime. +For ``SHARED`` and ``MODULE`` libraries, this also defines the +``_WINRT_DLL`` preprocessor macro. + +.. note:: + Currently this is implemented only by Visual Studio generators. + Support may be added to other generators in the future. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/WATCOM_RUNTIME_LIBRARY-VALUES.txt b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/WATCOM_RUNTIME_LIBRARY-VALUES.txt new file mode 100644 index 0000000000000000000000000000000000000000..cdf99d087efd50f925b4c7aa66a262cf67d98f73 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/WATCOM_RUNTIME_LIBRARY-VALUES.txt @@ -0,0 +1,20 @@ +``SingleThreaded`` + Compile without additional flags to use a single-threaded + statically-linked runtime library. +``SingleThreadedDLL`` + Compile with ``-br`` or equivalent flag(s) to use a single-threaded + dynamically-linked runtime library. This is not available for Linux + targets. +``MultiThreaded`` + Compile with ``-bm`` or equivalent flag(s) to use a multi-threaded + statically-linked runtime library. +``MultiThreadedDLL`` + Compile with ``-bm -br`` or equivalent flag(s) to use a multi-threaded + dynamically-linked runtime library. This is not available for Linux + targets. + +The value is ignored on non-Watcom compilers but an unsupported value will +be rejected as an error when using a compiler targeting the Watcom ABI. + +The value may also be the empty string (``""``) in which case no runtime +library selection flag will be added explicitly by CMake. diff --git a/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER.rst b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER.rst new file mode 100644 index 0000000000000000000000000000000000000000..1146130ede04a8dc01d25c2435b0d56cae4581a8 --- /dev/null +++ b/mgm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Help/prop_tgt/XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER.rst @@ -0,0 +1,14 @@ +XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER +------------------------------------------ + +.. versionadded:: 3.13 + +Whether to enable ``Undefined Behavior Sanitizer`` +in the Diagnostics section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER` +if it is set when a target is created. + +Please refer to the :prop_tgt:`XCODE_GENERATE_SCHEME` target property +documentation to see all Xcode schema related properties.