diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/ide-integration/index.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/ide-integration/index.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3a11a345313b872d2d629ec0e6c352ee52c8283f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/ide-integration/index.rst.txt @@ -0,0 +1,161 @@ +IDE Integration Guide +********************* + +.. only:: html + + .. contents:: + +Introduction +============ + +Integrated development environments (IDEs) may want to integrate with CMake to +improve the development experience for CMake users. This document lays out the +recommended best practices for such integration. + +Bundling +======== + +Many IDE vendors will want to bundle a copy of CMake with their IDE. IDEs that +bundle CMake should present the user with the option of using an external CMake +installation instead of the bundled one, in case the bundled copy becomes +outdated and the user wants to use a newer version. + +While IDE vendors may be tempted to bundle different versions of CMake with +their application, such practice is not recommended. CMake has strong +guarantees of backwards compatibility, and there is no reason not to use a +newer version of CMake than what a project requires, or indeed, the very latest +version. Therefore, it is recommended that IDE vendors that bundle CMake with +their application always include the very latest patch version of CMake +available at the time of release. + +As a suggestion, IDEs may also ship a copy of the Ninja buildsystem alongside +CMake. Ninja is highly performant and well-supported on all platforms that +support CMake. IDEs that bundle Ninja should use Ninja 1.10 or later, which +contains features needed to support Fortran builds. + +Presets +======= + +CMake supports a file format called ``CMakePresets.json``, and its +user-specific counterpart, ``CMakeUserPresets.json``. This file contains +information on the various configure presets that a user may want. Each preset +may have a different compiler, build flags, etc. The details of this format are +explained in the :manual:`cmake(1)` manual. + +IDE vendors are encouraged to read and evaluate this file the same way CMake +does, and present the user with the presets listed in the file. Users should be +able to see (and possibly edit) the CMake cache variables, environment +variables, and command line options that are defined for a given preset. The +IDE should then construct the list of appropriate :manual:`cmake(1)` command +line arguments based on these settings, rather than using the +:option:`--preset= ` option directly. The +:option:`--preset= ` option is intended only as a convenient +frontend for command line users, and should not be used by the IDE. + +For example, if a preset named ``ninja`` specifies ``Ninja`` as the generator +and ``${sourceDir}/build`` as the build directory, instead of running: + +.. code-block:: console + + cmake -S /path/to/source --preset=ninja + +the IDE should instead calculate the settings of the ``ninja`` preset, and then +run: + +.. code-block:: console + + cmake -S /path/to/source -B /path/to/source/build -G Ninja + +In cases where a preset contains lots of cache variables, and passing all of +them as :option:`-D ` flags would cause the command line length limit +of the platform to be exceeded, the IDE should instead construct a temporary +cache script and pass it with the :option:`-C ` flag. + +While reading, parsing, and evaluating the contents of ``CMakePresets.json`` is +straightforward, it is not trivial. In addition to the documentation, IDE +vendors may also wish to refer to the CMake source code and test cases for a +better understanding of how to implement the format. +:download:`This file <../../manual/presets/schema.json>` provides a +machine-readable JSON schema for the ``CMakePresets.json`` format that IDE +vendors may find useful for validation and providing editing assistance. + +Configuring +=========== + +IDEs that invoke :manual:`cmake(1)` to run the configure step may wish to +receive information about the artifacts that the build will produce, as well +as the include directories, compile definitions, etc. used to build the +artifacts. Such information can be obtained by using the +:manual:`File API `. The manual page for the File API +contains more information about the API and how to invoke it. +:manual:`Server mode ` was removed as of CMake 3.20 and +should not be used on CMake 3.14 or later. + +IDEs should avoid creating more build trees than necessary, and only create +multiple build trees if the user wishes to switch to a different compiler, +use different compile flags, etc. In particular, IDEs should NOT create +multiple single-config build trees which all have the same properties except +for a differing :variable:`CMAKE_BUILD_TYPE`, effectively creating a +multi-config environment. Instead, the :generator:`Ninja Multi-Config` +generator, in conjunction with the :manual:`File API ` to +get the list of build configurations, should be used for this purpose. + +IDEs should not use the "extra generators" with Makefile or Ninja generators, +which generate IDE project files in addition to the Makefile or Ninja files. +Instead the :manual:`File API ` should be used to get the +list of build artifacts. + +Building +======== + +If a Makefile or Ninja generator is used to generate the build tree, it is not +recommended to invoke ``make`` or ``ninja`` directly. Instead, it is +recommended that the IDE invoke :manual:`cmake(1)` with the +:option:`--build ` argument, which will in turn invoke the +appropriate build tool. + +If an IDE project generator is used, such as :generator:`Xcode` or one of the +Visual Studio generators, and the IDE understands the project format used, the +IDE should read the project file and build it the same way it would otherwise. + +The :manual:`File API ` can be used to obtain a list of +build configurations from the build tree, and the IDE should present this list +to the user to select a build configuration. + +Testing +======= + +:manual:`ctest(1)` supports outputting a JSON format with information about the +available tests and test configurations. IDEs which want to run CTest should +obtain this information and use it to present the user with a list of tests. + +IDEs should not invoke the ``test`` target of the generated buildsystem. +Instead, they should invoke :manual:`ctest(1)` directly. + +IDEs with CMake integration +=========================== + +The following IDEs support CMake natively: + +* `CLion`_ +* `KDevelop`_ +* `QtCreator`_ +* `Vim`_ (via a plugin) +* `Visual Studio`_ +* `VSCode`_ (via a plugin) + +.. _CLion: https://www.jetbrains.com/clion/ +.. _KDevelop: https://kdevelop.org/ +.. _QtCreator: https://www.qt.io/product/development-tools +.. _Vim: https://www.vim.org/ +.. _Visual Studio: https://visualstudio.microsoft.com/ +.. _VSCode: https://code.visualstudio.com/ + +Additionally, CMake has builtin support for some IDEs: + +* :ref:`IDE Build Tool Generators`: + Generate IDE native build systems such as Visual Studio or Xcode. +* :ref:`Extra Generators`: + Extend :ref:`Command-Line Build Tool Generators` to generate IDE + project files that hook into the command-line build system. + Superseded by the :manual:`File API `. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/importing-exporting/index.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/importing-exporting/index.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..91c50ddf970efe4e0ac2aa25a3997ea1904ea94d --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/importing-exporting/index.rst.txt @@ -0,0 +1,772 @@ +Importing and Exporting Guide +***************************** + +.. only:: html + + .. contents:: + +Introduction +============ + +In this guide, we will present the concept of :prop_tgt:`IMPORTED` targets +and demonstrate how to import existing executable or library files from disk +into a CMake project. We will then show how CMake supports exporting targets +from one CMake-based project and importing them into another. Finally, we +will demonstrate how to package a project with a configuration file to allow +for easy integration into other CMake projects. This guide and the complete +example source code can be found in the ``Help/guide/importing-exporting`` +directory of the CMake source code tree. + + +Importing Targets +================= + +:prop_tgt:`IMPORTED` targets are used to convert files outside of a CMake +project into logical targets inside of the project. :prop_tgt:`IMPORTED` +targets are created using the ``IMPORTED`` option of the +:command:`add_executable` and :command:`add_library` commands. No build +files are generated for :prop_tgt:`IMPORTED` targets. Once imported, +:prop_tgt:`IMPORTED` targets may be referenced like any other target within +the project and provide a convenient, flexible reference to outside +executables and libraries. + +By default, the :prop_tgt:`IMPORTED` target name has scope in the directory in +which it is created and below. We can use the ``GLOBAL`` option to extended +visibility so that the target is accessible globally in the build system. + +Details about the :prop_tgt:`IMPORTED` target are specified by setting +properties whose names begin in ``IMPORTED_`` and ``INTERFACE_``. For example, +:prop_tgt:`IMPORTED_LOCATION` contains the full path to the target on +disk. + +Importing Executables +--------------------- + +To start, we will walk through a simple example that creates an +:prop_tgt:`IMPORTED` executable target and then references it from the +:command:`add_custom_command` command. + +We'll need to do some setup to get started. We want to create an executable +that when run creates a basic ``main.cc`` file in the current directory. The +details of this project are not important. Navigate to +``Help/guide/importing-exporting/MyExe``, create a build directory, run +:manual:`cmake ` and build and install the project. + +.. code-block:: console + + $ cd Help/guide/importing-exporting/MyExe + $ mkdir build + $ cd build + $ cmake .. + $ cmake --build . + $ cmake --install . --prefix + $ /myexe + $ ls + [...] main.cc [...] + +Now we can import this executable into another CMake project. The source code +for this section is available in ``Help/guide/importing-exporting/Importing``. +In the CMakeLists file, use the :command:`add_executable` command to create a +new target called ``myexe``. Use the ``IMPORTED`` option to tell CMake that +this target references an executable file located outside of the project. No +rules will be generated to build it and the :prop_tgt:`IMPORTED` target +property will be set to ``true``. + +.. literalinclude:: Importing/CMakeLists.txt + :language: cmake + :start-after: # Add executable + :end-before: # Set imported location + +Next, set the :prop_tgt:`IMPORTED_LOCATION` property of the target using +the :command:`set_property` command. This will tell CMake the location of the +target on disk. The location may need to be adjusted to the +```` specified in the previous step. + +.. literalinclude:: Importing/CMakeLists.txt + :language: cmake + :start-after: # Set imported location + :end-before: # Add custom command + +We can now reference this :prop_tgt:`IMPORTED` target just like any target +built within the project. In this instance, let's imagine that we want to use +the generated source file in our project. Use the :prop_tgt:`IMPORTED` +target in the :command:`add_custom_command` command: + +.. literalinclude:: Importing/CMakeLists.txt + :language: cmake + :start-after: # Add custom command + :end-before: # Use source file + +As ``COMMAND`` specifies an executable target name, it will automatically be +replaced by the location of the executable given by the +:prop_tgt:`IMPORTED_LOCATION` property above. + +Finally, use the output from :command:`add_custom_command`: + +.. literalinclude:: Importing/CMakeLists.txt + :language: cmake + :start-after: # Use source file + +Importing Libraries +------------------- + +In a similar manner, libraries from other projects may be accessed through +:prop_tgt:`IMPORTED` targets. + +Note: The full source code for the examples in this section is not provided +and is left as an exercise for the reader. + +In the CMakeLists file, add an :prop_tgt:`IMPORTED` library and specify its +location on disk: + +.. code-block:: cmake + + add_library(foo STATIC IMPORTED) + set_property(TARGET foo PROPERTY + IMPORTED_LOCATION "/path/to/libfoo.a") + +Then use the :prop_tgt:`IMPORTED` library inside of our project: + +.. code-block:: cmake + + add_executable(myexe src1.c src2.c) + target_link_libraries(myexe PRIVATE foo) + + +On Windows, a .dll and its .lib import library may be imported together: + +.. code-block:: cmake + + add_library(bar SHARED IMPORTED) + set_property(TARGET bar PROPERTY + IMPORTED_LOCATION "c:/path/to/bar.dll") + set_property(TARGET bar PROPERTY + IMPORTED_IMPLIB "c:/path/to/bar.lib") + add_executable(myexe src1.c src2.c) + target_link_libraries(myexe PRIVATE bar) + +A library with multiple configurations may be imported with a single target: + +.. code-block:: cmake + + find_library(math_REL NAMES m) + find_library(math_DBG NAMES md) + add_library(math STATIC IMPORTED GLOBAL) + set_target_properties(math PROPERTIES + IMPORTED_LOCATION "${math_REL}" + IMPORTED_LOCATION_DEBUG "${math_DBG}" + IMPORTED_CONFIGURATIONS "RELEASE;DEBUG" + ) + add_executable(myexe src1.c src2.c) + target_link_libraries(myexe PRIVATE math) + +The generated build system will link ``myexe`` to ``m.lib`` when built in the +release configuration, and ``md.lib`` when built in the debug configuration. + +Exporting Targets +================= + +While :prop_tgt:`IMPORTED` targets on their own are useful, they still +require that the project that imports them knows the locations of the target +files on disk. The real power of :prop_tgt:`IMPORTED` targets is when the +project providing the target files also provides a CMake file to help import +them. A project can be setup to produce the necessary information so that it +can easily be used by other CMake projects be it from a build directory, a +local install or when packaged. + +In the remaining sections, we will walk through a set of example projects +step-by-step. The first project will create and install a library and +corresponding CMake configuration and package files. The second project will +use the generated package. + +Let's start by looking at the ``MathFunctions`` project in the +``Help/guide/importing-exporting/MathFunctions`` directory. Here we have a +header file ``MathFunctions.h`` that declares a ``sqrt`` function: + +.. literalinclude:: MathFunctions/MathFunctions.h + :language: c++ + +And a corresponding source file ``MathFunctions.cxx``: + +.. literalinclude:: MathFunctions/MathFunctions.cxx + :language: c++ + +Don't worry too much about the specifics of the C++ files, they are just meant +to be a simple example that will compile and run on many build systems. + +Now we can create a ``CMakeLists.txt`` file for the ``MathFunctions`` +project. Start by specifying the :command:`cmake_minimum_required` version and +:command:`project` name: + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :end-before: # create library + +The :module:`GNUInstallDirs` module is included in order to provide the +project with the flexibility to install into different platform layouts by +making the directories available as cache variables. + +Create a library called ``MathFunctions`` with the :command:`add_library` +command: + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :start-after: # create library + :end-before: # add include directories + +And then use the :command:`target_include_directories` command to specify the +include directories for the target: + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :start-after: # add include directories + :end-before: # install the target and create export-set + +We need to tell CMake that we want to use different include directories +depending on if we're building the library or using it from an installed +location. If we don't do this, when CMake creates the export information it +will export a path that is specific to the current build directory +and will not be valid for other projects. We can use +:manual:`generator expressions ` to specify +that if we're building the library include the current source directory. +Otherwise, when installed, include the ``include`` directory. See the `Creating +Relocatable Packages`_ section for more details. + +The :command:`install(TARGETS)` and :command:`install(EXPORT)` commands +work together to install both targets (a library in our case) and a CMake +file designed to make it easy to import the targets into another CMake project. + +First, in the :command:`install(TARGETS)` command we will specify the target, +the ``EXPORT`` name and the destinations that tell CMake where to install the +targets. + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :start-after: # install the target and create export-set + :end-before: # install header file + +Here, the ``EXPORT`` option tells CMake to create an export called +``MathFunctionsTargets``. The generated :prop_tgt:`IMPORTED` targets have +appropriate properties set to define their +:ref:`usage requirements `, such as +:prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES`, +:prop_tgt:`INTERFACE_COMPILE_DEFINITIONS` and other relevant built-in +``INTERFACE_`` properties. The ``INTERFACE`` variant of user-defined +properties listed in :prop_tgt:`COMPATIBLE_INTERFACE_STRING` and other +:ref:`Compatible Interface Properties` are also propagated to the +generated :prop_tgt:`IMPORTED` targets. For example, in this case, the +:prop_tgt:`IMPORTED` target will have its +:prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` property populated with +the directory specified by the ``INCLUDES DESTINATION`` property. As a +relative path was given, it is treated as relative to the +:variable:`CMAKE_INSTALL_PREFIX`. + +Note, we have *not* asked CMake to install the export yet. + +We don't want to forget to install the ``MathFunctions.h`` header file with the +:command:`install(FILES)` command. The header file should be installed to the +``include`` directory, as specified by the +:command:`target_include_directories` command above. + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :start-after: # install header file + :end-before: # generate and install export file + +Now that the ``MathFunctions`` library and header file are installed, we also +need to explicitly install the ``MathFunctionsTargets`` export details. Use +the :command:`install(EXPORT)` command to export the targets in +``MathFunctionsTargets``, as defined by the :command:`install(TARGETS)` +command. + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :start-after: # generate and install export file + :end-before: # include CMakePackageConfigHelpers macro + +This command generates the ``MathFunctionsTargets.cmake`` file and arranges +to install it to ``${CMAKE_INSTALL_LIBDIR}/cmake/MathFunctions``. The file +contains code suitable for use by downstreams to import all targets listed in +the install command from the installation tree. + +The ``NAMESPACE`` option will prepend ``MathFunctions::`` to the target names +as they are written to the export file. This convention of double-colons +gives CMake a hint that the name is an :prop_tgt:`IMPORTED` target when it +is used by downstream projects. This way, CMake can issue a diagnostic +message if the package providing it was not found. + +The generated export file contains code that creates an :prop_tgt:`IMPORTED` library. + +.. code-block:: cmake + + # Create imported target MathFunctions::MathFunctions + add_library(MathFunctions::MathFunctions STATIC IMPORTED) + + set_target_properties(MathFunctions::MathFunctions PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" + ) + +This code is very similar to the example we created by hand in the +`Importing Libraries`_ section. Note that ``${_IMPORT_PREFIX}`` is computed +relative to the file location. + +An outside project may load this file with the :command:`include` command and +reference the ``MathFunctions`` library from the installation tree as if it +were built in its own tree. For example: + +.. code-block:: cmake + :linenos: + + include(GNUInstallDirs) + include(${INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/cmake/MathFunctions/MathFunctionTargets.cmake) + add_executable(myexe src1.c src2.c ) + target_link_libraries(myexe PRIVATE MathFunctions::MathFunctions) + +Line 2 loads the target CMake file. Although we only exported a single +target, this file may import any number of targets. Their locations are +computed relative to the file location so that the install tree may be +easily moved. Line 4 references the imported ``MathFunctions`` library. The +resulting build system will link to the library from its installed location. + +Executables may also be exported and imported using the same process. + +Any number of target installations may be associated with the same +export name. Export names are considered global so any directory may +contribute a target installation. The :command:`install(EXPORT)` command only +needs to be called once to install a file that references all targets. Below +is an example of how multiple exports may be combined into a single +export file, even if they are in different subdirectories of the project. + +.. code-block:: cmake + + # A/CMakeLists.txt + add_executable(myexe src1.c) + install(TARGETS myexe DESTINATION lib/myproj + EXPORT myproj-targets) + + # B/CMakeLists.txt + add_library(foo STATIC foo1.c) + install(TARGETS foo DESTINATION lib EXPORTS myproj-targets) + + # Top CMakeLists.txt + add_subdirectory (A) + add_subdirectory (B) + install(EXPORT myproj-targets DESTINATION lib/myproj) + +Creating Packages +----------------- + +At this point, the ``MathFunctions`` project is exporting the target +information required to be used by other projects. We can make this project +even easier for other projects to use by generating a configuration file so +that the CMake :command:`find_package` command can find our project. + +To start, we will need to make a few additions to the ``CMakeLists.txt`` +file. First, include the :module:`CMakePackageConfigHelpers` module to get +access to some helper functions for creating config files. + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :start-after: # include CMakePackageConfigHelpers macro + :end-before: # set version + +Then we will create a package configuration file and a package version file. + +Creating a Package Configuration File +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Use the :command:`configure_package_config_file` command provided by the +:module:`CMakePackageConfigHelpers` to generate the package configuration +file. Note that this command should be used instead of the plain +:command:`configure_file` command. It helps to ensure that the resulting +package is relocatable by avoiding hardcoded paths in the installed +configuration file. The path given to ``INSTALL_DESTINATION`` must be the +destination where the ``MathFunctionsConfig.cmake`` file will be installed. +We will examine the contents of the package configuration file in the next +section. + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :start-after: # create config file + :end-before: # install config files + +Install the generated configuration files with the :command:`INSTALL(files)` +command. Both ``MathFunctionsConfigVersion.cmake`` and +``MathFunctionsConfig.cmake`` are installed to the same location, completing +the package. + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :start-after: # install config files + :end-before: # generate the export targets for the build tree + +Now we need to create the package configuration file itself. In this case, the +``Config.cmake.in`` file is very simple but sufficient to allow downstreams +to use the :prop_tgt:`IMPORTED` targets. + +.. literalinclude:: MathFunctions/Config.cmake.in + +The first line of the file contains only the string ``@PACKAGE_INIT@``. This +expands when the file is configured and allows the use of relocatable paths +prefixed with ``PACKAGE_``. It also provides the ``set_and_check()`` and +``check_required_components()`` macros. + +The ``check_required_components`` helper macro ensures that all requested, +non-optional components have been found by checking the +``__FOUND`` variables for all required components. This +macro should be called at the end of the package configuration file even if the +package does not have any components. This way, CMake can make sure that the +downstream project hasn't specified any non-existent components. If +``check_required_components`` fails, the ``_FOUND`` variable is set to +FALSE, and the package is considered to be not found. + +The ``set_and_check()`` macro should be used in configuration files instead +of the normal ``set()`` command for setting directories and file locations. +If a referenced file or directory does not exist, the macro will fail. + +If any macros should be provided by the ``MathFunctions`` package, they should +be in a separate file which is installed to the same location as the +``MathFunctionsConfig.cmake`` file, and included from there. + +**All required dependencies of a package must also be found in the package +configuration file.** Let's imagine that we require the ``Stats`` library in +our project. In the CMakeLists file, we would add: + +.. code-block:: cmake + + find_package(Stats 2.6.4 REQUIRED) + target_link_libraries(MathFunctions PUBLIC Stats::Types) + +As the ``Stats::Types`` target is a ``PUBLIC`` dependency of ``MathFunctions``, +downstreams must also find the ``Stats`` package and link to the +``Stats::Types`` library. The ``Stats`` package should be found in the +configuration file to ensure this. + +.. code-block:: cmake + + include(CMakeFindDependencyMacro) + find_dependency(Stats 2.6.4) + +The ``find_dependency`` macro from the :module:`CMakeFindDependencyMacro` +module helps by propagating whether the package is ``REQUIRED``, or +``QUIET``, etc. The ``find_dependency`` macro also sets +``MathFunctions_FOUND`` to ``False`` if the dependency is not found, along +with a diagnostic that the ``MathFunctions`` package cannot be used without +the ``Stats`` package. + +**Exercise:** Add a required library to the ``MathFunctions`` project. + +Creating a Package Version File +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The :module:`CMakePackageConfigHelpers` module provides the +:command:`write_basic_package_version_file` command for creating a simple +package version file. This file is read by CMake when :command:`find_package` +is called to determine the compatibility with the requested version, and to set +some version-specific variables such as ``_VERSION``, +``_VERSION_MAJOR``, ``_VERSION_MINOR``, etc. See +:manual:`cmake-packages ` documentation for more details. + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :start-after: # set version + :end-before: # create config file + +In our example, ``MathFunctions_MAJOR_VERSION`` is defined as a +:prop_tgt:`COMPATIBLE_INTERFACE_STRING` which means that it must be +compatible among the dependencies of any depender. By setting this +custom defined user property in this version and in the next version of +``MathFunctions``, :manual:`cmake ` will issue a diagnostic if +there is an attempt to use version 3 together with version 4. Packages can +choose to employ such a pattern if different major versions of the package +are designed to be incompatible. + + +Exporting Targets from the Build Tree +------------------------------------- + +Typically, projects are built and installed before being used by an outside +project. However, in some cases, it is desirable to export targets directly +from a build tree. The targets may then be used by an outside project that +references the build tree with no installation involved. The :command:`export` +command is used to generate a file exporting targets from a project build tree. + +If we want our example project to also be used from a build directory we only +have to add the following to ``CMakeLists.txt``: + +.. literalinclude:: MathFunctions/CMakeLists.txt + :language: cmake + :start-after: # generate the export targets for the build tree + +Here we use the :command:`export` command to generate the export targets for +the build tree. In this case, we'll create a file called +``MathFunctionsTargets.cmake`` in the ``cmake`` subdirectory of the build +directory. The generated file contains the required code to import the target +and may be loaded by an outside project that is aware of the project build +tree. This file is specific to the build-tree, and **is not relocatable**. + +It is possible to create a suitable package configuration file and package +version file to define a package for the build tree which may be used without +installation. Consumers of the build tree can simply ensure that the +:variable:`CMAKE_PREFIX_PATH` contains the build directory, or set the +``MathFunctions_DIR`` to ``/MathFunctions`` in the cache. + +An example application of this feature is for building an executable on a host +platform when cross-compiling. The project containing the executable may be +built on the host platform and then the project that is being cross-compiled +for another platform may load it. + +Building and Installing a Package +--------------------------------- + +At this point, we have generated a relocatable CMake configuration for our +project that can be used after the project has been installed. Let's try to +build the ``MathFunctions`` project: + +.. code-block:: console + + mkdir MathFunctions_build + cd MathFunctions_build + cmake ../MathFunctions + cmake --build . + +In the build directory, notice that the file ``MathFunctionsTargets.cmake`` +has been created in the ``cmake`` subdirectory. + +Now install the project: + +.. code-block:: console + + $ cmake --install . --prefix "/home/myuser/installdir" + +Creating Relocatable Packages +============================= + +Packages created by :command:`install(EXPORT)` are designed to be relocatable, +using paths relative to the location of the package itself. They must not +reference absolute paths of files on the machine where the package is built +that will not exist on the machines where the package may be installed. + +When defining the interface of a target for ``EXPORT``, keep in mind that the +include directories should be specified as relative paths to the +:variable:`CMAKE_INSTALL_PREFIX` but should not explicitly include the +:variable:`CMAKE_INSTALL_PREFIX`: + +.. code-block:: cmake + + target_include_directories(tgt INTERFACE + # Wrong, not relocatable: + $ + ) + + target_include_directories(tgt INTERFACE + # Ok, relocatable: + $ + ) + +The :genex:`$` generator expression may be used as +a placeholder for the install prefix without resulting in a non-relocatable +package. This is necessary if complex generator expressions are used: + +.. code-block:: cmake + + target_include_directories(tgt INTERFACE + # Ok, relocatable: + $/include/TgtName> + ) + +This also applies to paths referencing external dependencies. +It is not advisable to populate any properties which may contain +paths, such as :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` or +:prop_tgt:`INTERFACE_LINK_LIBRARIES`, with paths relevant to dependencies. +For example, this code may not work well for a relocatable package: + +.. code-block:: cmake + + target_link_libraries(MathFunctions INTERFACE + ${Foo_LIBRARIES} ${Bar_LIBRARIES} + ) + target_include_directories(MathFunctions INTERFACE + "$" + ) + +The referenced variables may contain the absolute paths to libraries +and include directories **as found on the machine the package was made on**. +This would create a package with hard-coded paths to dependencies not +suitable for relocation. + +Ideally such dependencies should be used through their own +:ref:`IMPORTED targets ` that have their own +:prop_tgt:`IMPORTED_LOCATION` and usage requirement properties +such as :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` populated +appropriately. Those imported targets may then be used with +the :command:`target_link_libraries` command for ``MathFunctions``: + +.. code-block:: cmake + + target_link_libraries(MathFunctions INTERFACE Foo::Foo Bar::Bar) + +With this approach the package references its external dependencies +only through the names of :ref:`IMPORTED targets `. +When a consumer uses the installed package, the consumer will run the +appropriate :command:`find_package` commands (via the ``find_dependency`` +macro described above) to find the dependencies and populate the +imported targets with appropriate paths on their own machine. + +Using the Package Configuration File +==================================== + +Now we're ready to create a project to use the installed ``MathFunctions`` +library. In this section we will be using source code from +``Help\guide\importing-exporting\Downstream``. In this directory, there is a +source file called ``main.cc`` that uses the ``MathFunctions`` library to +calculate the square root of a given number and then prints the results: + +.. literalinclude:: Downstream/main.cc + :language: c++ + +As before, we'll start with the :command:`cmake_minimum_required` and +:command:`project` commands in the ``CMakeLists.txt`` file. For this project, +we'll also specify the C++ standard. + +.. literalinclude:: Downstream/CMakeLists.txt + :language: cmake + :end-before: # find MathFunctions + +We can use the :command:`find_package` command: + +.. literalinclude:: Downstream/CMakeLists.txt + :language: cmake + :start-after: # find MathFunctions + :end-before: # create executable + +Create an executable: + +.. literalinclude:: Downstream/CMakeLists.txt + :language: cmake + :start-after: # create executable + :end-before: # use MathFunctions library + +And link to the ``MathFunctions`` library: + +.. literalinclude:: Downstream/CMakeLists.txt + :language: cmake + :start-after: # use MathFunctions library + +That's it! Now let's try to build the ``Downstream`` project. + +.. code-block:: console + + mkdir Downstream_build + cd Downstream_build + cmake ../Downstream + cmake --build . + +A warning may have appeared during CMake configuration: + +.. code-block:: console + + CMake Warning at CMakeLists.txt:4 (find_package): + By not providing "FindMathFunctions.cmake" in CMAKE_MODULE_PATH this + project has asked CMake to find a package configuration file provided by + "MathFunctions", but CMake did not find one. + + Could not find a package configuration file provided by "MathFunctions" + with any of the following names: + + MathFunctionsConfig.cmake + mathfunctions-config.cmake + + Add the installation prefix of "MathFunctions" to CMAKE_PREFIX_PATH or set + "MathFunctions_DIR" to a directory containing one of the above files. If + "MathFunctions" provides a separate development package or SDK, be sure it + has been installed. + +Set the ``CMAKE_PREFIX_PATH`` to where MathFunctions was installed previously +and try again. Ensure that the newly created executable runs as expected. + +Adding Components +================= + +Let's edit the ``MathFunctions`` project to use components. The source code for +this section can be found in +``Help\guide\importing-exporting\MathFunctionsComponents``. The CMakeLists file +for this project adds two subdirectories: ``Addition`` and ``SquareRoot``. + +.. literalinclude:: MathFunctionsComponents/CMakeLists.txt + :language: cmake + :end-before: # include CMakePackageConfigHelpers macro + +Generate and install the package configuration and package version files: + +.. literalinclude:: MathFunctionsComponents/CMakeLists.txt + :language: cmake + :start-after: # include CMakePackageConfigHelpers macro + +If ``COMPONENTS`` are specified when the downstream uses +:command:`find_package`, they are listed in the +``_FIND_COMPONENTS`` variable. We can use this variable to verify +that all necessary component targets are included in ``Config.cmake.in``. At +the same time, this function will act as a custom ``check_required_components`` +macro to ensure that the downstream only attempts to use supported components. + +.. literalinclude:: MathFunctionsComponents/Config.cmake.in + +Here, the ``MathFunctions_NOT_FOUND_MESSAGE`` is set to a diagnosis that the +package could not be found because an invalid component was specified. This +message variable can be set for any case where the ``_FOUND`` variable is set +to ``False``, and will be displayed to the user. + +The ``Addition`` and ``SquareRoot`` directories are similar. Let's look at one +of the CMakeLists files: + +.. literalinclude:: MathFunctionsComponents/SquareRoot/CMakeLists.txt + :language: cmake + +Now we can build the project as described in earlier sections. To test using +this package, we can use the project in +``Help\guide\importing-exporting\DownstreamComponents``. There's two +differences from the previous ``Downstream`` project. First, we need to find +the package components. Change the ``find_package`` line from: + +.. literalinclude:: Downstream/CMakeLists.txt + :language: cmake + :start-after: # find MathFunctions + :end-before: # create executable + +To: + +.. literalinclude:: DownstreamComponents/CMakeLists.txt + :language: cmake + :start-after: # find MathFunctions + :end-before: # create executable + +and the ``target_link_libraries`` line from: + +.. literalinclude:: Downstream/CMakeLists.txt + :language: cmake + :start-after: # use MathFunctions library + +To: + +.. literalinclude:: DownstreamComponents/CMakeLists.txt + :language: cmake + :start-after: # use MathFunctions library + :end-before: # Workaround for GCC on AIX to avoid -isystem + +In ``main.cc``, replace ``#include MathFunctions.h`` with: + +.. literalinclude:: DownstreamComponents/main.cc + :language: c + :start-after: #include + :end-before: int main + +Finally, use the ``Addition`` library: + +.. literalinclude:: DownstreamComponents/main.cc + :language: c + :start-after: // calculate sum + :end-before: return 0; + +Build the ``Downstream`` project and confirm that it can find and use the +package components. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/A Basic Starting Point.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/A Basic Starting Point.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..37b0668d4e68165eb768571118ecc8cfd718e307 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/A Basic Starting Point.rst.txt @@ -0,0 +1,460 @@ +Step 1: A Basic Starting Point +============================== + +Where do I start with CMake? This step will provide an introduction to some of +CMake's basic syntax, commands, and variables. As these concepts are +introduced, we will work through three exercises and create a simple CMake +project. + +Each exercise in this step will start with some background information. Then, a +goal and list of helpful resources are provided. Each file in the +``Files to Edit`` section is in the ``Step1`` directory and contains one or +more ``TODO`` comments. Each ``TODO`` represents a line or two of code to +change or add. The ``TODO`` s are intended to be completed in numerical order, +first complete ``TODO 1`` then ``TODO 2``, etc. The ``Getting Started`` +section will give some helpful hints and guide you through the exercise. Then +the ``Build and Run`` section will walk step-by-step through how to build and +test the exercise. Finally, at the end of each exercise the intended solution +is discussed. + +Also note that each step in the tutorial builds on the next. So, for example, +the starting code for ``Step2`` is the complete solution to ``Step1``. + +Exercise 1 - Building a Basic Project +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The most basic CMake project is an executable built from a single source code +file. For simple projects like this, a ``CMakeLists.txt`` file with three +commands is all that is required. + +**Note:** Although upper, lower and mixed case commands are supported by CMake, +lower case commands are preferred and will be used throughout the tutorial. + +Any project's top most CMakeLists.txt must start by specifying a minimum CMake +version using the :command:`cmake_minimum_required` command. This establishes +policy settings and ensures that the following CMake functions are run with a +compatible version of CMake. + +To start a project, we use the :command:`project` command to set the project +name. This call is required with every project and should be called soon after +:command:`cmake_minimum_required`. As we will see later, this command can +also be used to specify other project level information such as the language +or version number. + +Finally, the :command:`add_executable` command tells CMake to create an +executable using the specified source code files. + +Goal +---- + +Understand how to create a simple CMake project. + +Helpful Resources +----------------- + +* :command:`add_executable` +* :command:`cmake_minimum_required` +* :command:`project` + +Files to Edit +------------- + +* ``CMakeLists.txt`` + +Getting Started +---------------- + +The source code for ``tutorial.cxx`` is provided in the +``Help/guide/tutorial/Step1`` directory and can be used to compute the square +root of a number. This file does not need to be edited in this step. + +In the same directory is a ``CMakeLists.txt`` file which you will complete. +Start with ``TODO 1`` and work through ``TODO 3``. + +Build and Run +------------- + +Once ``TODO 1`` through ``TODO 3`` have been completed, we are ready to build +and run our project! First, run the :manual:`cmake ` executable or the +:manual:`cmake-gui ` to configure the project and then build it +with your chosen build tool. + +For example, from the command line we could navigate to the +``Help/guide/tutorial`` directory of the CMake source code tree and create a +build directory: + +.. code-block:: console + + mkdir Step1_build + +Next, navigate to that build directory and run +:manual:`cmake ` to configure the project and generate a native build +system: + +.. code-block:: console + + cd Step1_build + cmake ../Step1 + +Then call that build system to actually compile/link the project: + +.. code-block:: console + + cmake --build . + +Finally, try to use the newly built ``Tutorial`` with these commands: + +.. code-block:: console + + Tutorial 4294967296 + Tutorial 10 + Tutorial + +Solution +-------- + +As mentioned above, a three line ``CMakeLists.txt`` is all that we need to get +up and running. The first line is to use :command:`cmake_minimum_required` to +set the CMake version as follows: + +.. raw:: html + +
TODO 1: Click to show/hide answer + +.. literalinclude:: Step2/CMakeLists.txt + :caption: TODO 1: CMakeLists.txt + :name: CMakeLists.txt-cmake_minimum_required + :language: cmake + :end-before: # set the project name and version + +.. raw:: html + +
+ +The next step to make a basic project is to use the :command:`project` +command as follows to set the project name: + +.. raw:: html + +
TODO 2: Click to show/hide answer + +.. code-block:: cmake + :caption: TODO 2: CMakeLists.txt + :name: CMakeLists.txt-project + + project(Tutorial) + +.. raw:: html + +
+ +The last command to call for a basic project is +:command:`add_executable`. We call it as follows: + +.. raw:: html + +
TODO 3: Click to show/hide answer + +.. literalinclude:: Step2/CMakeLists.txt + :caption: TODO 3: CMakeLists.txt + :name: CMakeLists.txt-add_executable + :language: cmake + :start-after: # add the executable + :end-before: # TODO 3: + +.. raw:: html + +
+ +Exercise 2 - Specifying the C++ Standard +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +CMake has some special variables that are either created behind the scenes or +have meaning to CMake when set by project code. Many of these variables start +with ``CMAKE_``. Avoid this naming convention when creating variables for your +projects. Two of these special user settable variables are +:variable:`CMAKE_CXX_STANDARD` and :variable:`CMAKE_CXX_STANDARD_REQUIRED`. +These may be used together to specify the C++ standard needed to build the +project. + +Goal +---- + +Add a feature that requires C++11. + +Helpful Resources +----------------- + +* :variable:`CMAKE_CXX_STANDARD` +* :variable:`CMAKE_CXX_STANDARD_REQUIRED` +* :command:`set` + +Files to Edit +------------- + +* ``CMakeLists.txt`` +* ``tutorial.cxx`` + +Getting Started +--------------- + +Continue editing files in the ``Step1`` directory. Start with ``TODO 4`` and +complete through ``TODO 6``. + +First, edit ``tutorial.cxx`` by adding a feature that requires C++11. Then +update ``CMakeLists.txt`` to require C++11. + +Build and Run +------------- + +Let's build our project again. Since we already created a build directory and +ran CMake for Exercise 1, we can skip to the build step: + +.. code-block:: console + + cd Step1_build + cmake --build . + +Now we can try to use the newly built ``Tutorial`` with same commands as +before: + +.. code-block:: console + + Tutorial 4294967296 + Tutorial 10 + Tutorial + +Solution +-------- + +We start by adding some C++11 features to our project by replacing +``atof`` with ``std::stod`` in ``tutorial.cxx``. This looks like +the following: + +.. raw:: html + +
TODO 4: Click to show/hide answer + +.. literalinclude:: Step2/tutorial.cxx + :caption: TODO 4: tutorial.cxx + :name: tutorial.cxx-cxx11 + :language: c++ + :start-after: // convert input to double + :end-before: // TODO 6: + +.. raw:: html + +
+ +To complete ``TODO 5``, simply remove ``#include ``. + +We will need to explicitly state in the CMake code that it should use the +correct flags. One way to enable support for a specific C++ standard in CMake +is by using the :variable:`CMAKE_CXX_STANDARD` variable. For this tutorial, set +the :variable:`CMAKE_CXX_STANDARD` variable in the ``CMakeLists.txt`` file to +``11`` and :variable:`CMAKE_CXX_STANDARD_REQUIRED` to ``True``. Make sure to +add the :variable:`CMAKE_CXX_STANDARD` declarations above the call to +:command:`add_executable`. + +.. raw:: html + +
TODO 6: Click to show/hide answer + +.. literalinclude:: Step2/CMakeLists.txt + :caption: TODO 6: CMakeLists.txt + :name: CMakeLists.txt-CXX_STANDARD + :language: cmake + :start-after: # specify the C++ standard + :end-before: # configure a header file + +.. raw:: html + +
+ +Exercise 3 - Adding a Version Number and Configured Header File +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Sometimes it may be useful to have a variable that is defined in your +``CMakelists.txt`` file also be available in your source code. In this case, we +would like to print the project version. + +One way to accomplish this is by using a configured header file. We create an +input file with one or more variables to replace. These variables have special +syntax which looks like ``@VAR@``. +Then, we use the :command:`configure_file` command to copy the input file to a +given output file and replace these variables with the current value of ``VAR`` +in the ``CMakelists.txt`` file. + +While we could edit the version directly in the source code, using this +feature is preferred since it creates a single source of truth and avoids +duplication. + +Goal +---- + +Define and report the project's version number. + +Helpful Resources +----------------- + +* :variable:`_VERSION_MAJOR` +* :variable:`_VERSION_MINOR` +* :command:`configure_file` +* :command:`target_include_directories` + +Files to Edit +------------- + +* ``CMakeLists.txt`` +* ``tutorial.cxx`` + +Getting Started +--------------- + +Continue to edit files from ``Step1``. Start on ``TODO 7`` and complete through +``TODO 12``. In this exercise, we start by adding a project version number in +``CMakeLists.txt``. In that same file, use :command:`configure_file` to copy a +given input file to an output file and substitute some variable values in the +input file content. + +Next, create an input header file ``TutorialConfig.h.in`` defining version +numbers which will accept variables passed from :command:`configure_file`. + +Finally, update ``tutorial.cxx`` to print out its version number. + +Build and Run +------------- + +Let's build our project again. As before, we already created a build directory +and ran CMake so we can skip to the build step: + +.. code-block:: console + + cd Step1_build + cmake --build . + +Verify that the version number is now reported when running the executable +without any arguments. + +Solution +-------- + +In this exercise, we improve our executable by printing a version number. +While we could do this exclusively in the source code, using ``CMakeLists.txt`` +lets us maintain a single source of data for the version number. + +First, we modify the ``CMakeLists.txt`` file to use the +:command:`project` command to set both the project name and version number. +When the :command:`project` command is called, CMake defines +``Tutorial_VERSION_MAJOR`` and ``Tutorial_VERSION_MINOR`` behind the scenes. + +.. raw:: html + +
TODO 7: Click to show/hide answer + +.. literalinclude:: Step2/CMakeLists.txt + :caption: TODO 7: CMakeLists.txt + :name: CMakeLists.txt-project-VERSION + :language: cmake + :start-after: # set the project name and version + :end-before: # specify the C++ standard + +.. raw:: html + +
+ +Then we used :command:`configure_file` to copy the input file with the +specified CMake variables replaced: + +.. raw:: html + +
TODO 8: Click to show/hide answer + +.. literalinclude:: Step2/CMakeLists.txt + :caption: TODO 8: CMakeLists.txt + :name: CMakeLists.txt-configure_file + :language: cmake + :start-after: # to the source code + :end-before: # TODO 2: + +.. raw:: html + +
+ +Since the configured file will be written into the project binary +directory, we must add that directory to the list of paths to search for +include files. + +**Note:** Throughout this tutorial, we will refer to the project build and +the project binary directory interchangeably. These are the same and are not +meant to refer to a `bin/` directory. + +We used :command:`target_include_directories` to specify +where the executable target should look for include files. + +.. raw:: html + +
TODO 9: Click to show/hide answer + +.. literalinclude:: Step2/CMakeLists.txt + :caption: TODO 9: CMakeLists.txt + :name: CMakeLists.txt-target_include_directories + :language: cmake + :start-after: # so that we will find TutorialConfig.h + +.. raw:: html + +
+ +``TutorialConfig.h.in`` is the input header file to be configured. +When :command:`configure_file` is called from our ``CMakeLists.txt``, the +values for ``@Tutorial_VERSION_MAJOR@`` and ``@Tutorial_VERSION_MINOR@`` will +be replaced with the corresponding version numbers from the project in +``TutorialConfig.h``. + +.. raw:: html + +
TODO 10: Click to show/hide answer + +.. literalinclude:: Step2/TutorialConfig.h.in + :caption: TODO 10: TutorialConfig.h.in + :name: TutorialConfig.h.in + :language: c++ + +.. raw:: html + +
+ +Next, we need to modify ``tutorial.cxx`` to include the configured header file, +``TutorialConfig.h``. + +.. raw:: html + +
TODO 11: Click to show/hide answer + +.. code-block:: c++ + :caption: TODO 11: tutorial.cxx + + #include "TutorialConfig.h" + +.. raw:: html + +
+ +Finally, we print out the executable name and version number by updating +``tutorial.cxx`` as follows: + +.. raw:: html + +
TODO 12: Click to show/hide answer + +.. literalinclude:: Step2/tutorial.cxx + :caption: TODO 12 : tutorial.cxx + :name: tutorial.cxx-print-version + :language: c++ + :start-after: { + :end-before: // convert input to double + +.. raw:: html + +
diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Export Configuration.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Export Configuration.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6c83276a4ce674a6251f0a9fda2ff772d4cc6aa5 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Export Configuration.rst.txt @@ -0,0 +1,140 @@ +Step 11: Adding Export Configuration +==================================== + +During :guide:`tutorial/Installing and Testing` of the tutorial we added the +ability for CMake to install the library and headers of the project. During +:guide:`tutorial/Packaging an Installer` we added the ability to package up +this information so it could be distributed to other people. + +The next step is to add the necessary information so that other CMake projects +can use our project, be it from a build directory, a local install or when +packaged. + +The first step is to update our :command:`install(TARGETS)` commands to not +only specify a ``DESTINATION`` but also an ``EXPORT``. The ``EXPORT`` keyword +generates a CMake file containing code to import all targets listed in the +install command from the installation tree. So let's go ahead and explicitly +``EXPORT`` the ``MathFunctions`` library by updating the ``install`` command +in ``MathFunctions/CMakeLists.txt`` to look like: + +.. literalinclude:: Complete/MathFunctions/CMakeLists.txt + :caption: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-install-TARGETS-EXPORT + :language: cmake + :start-after: # install libs + +Now that we have ``MathFunctions`` being exported, we also need to explicitly +install the generated ``MathFunctionsTargets.cmake`` file. This is done by +adding the following to the bottom of the top-level ``CMakeLists.txt``: + +.. literalinclude:: Complete/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-install-EXPORT + :language: cmake + :start-after: # install the configuration targets + :end-before: include(CMakePackageConfigHelpers) + +At this point you should try and run CMake. If everything is setup properly +you will see that CMake will generate an error that looks like: + +.. code-block:: console + + Target "MathFunctions" INTERFACE_INCLUDE_DIRECTORIES property contains + path: + + "/Users/robert/Documents/CMakeClass/Tutorial/Step11/MathFunctions" + + which is prefixed in the source directory. + +What CMake is trying to say is that during generating the export information +it will export a path that is intrinsically tied to the current machine and +will not be valid on other machines. The solution to this is to update the +``MathFunctions`` :command:`target_include_directories` to understand that it +needs different ``INTERFACE`` locations when being used from within the build +directory and from an install / package. This means converting the +:command:`target_include_directories` call for ``MathFunctions`` to look like: + +.. literalinclude:: Step12/MathFunctions/CMakeLists.txt + :caption: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-target_include_directories + :language: cmake + :start-after: # to find MathFunctions.h, while we don't. + :end-before: # should we use our own math functions + +Once this has been updated, we can re-run CMake and verify that it doesn't +warn anymore. + +At this point, we have CMake properly packaging the target information that is +required but we will still need to generate a ``MathFunctionsConfig.cmake`` so +that the CMake :command:`find_package` command can find our project. So let's go +ahead and add a new file to the top-level of the project called +``Config.cmake.in`` with the following contents: + +.. literalinclude:: Step12/Config.cmake.in + :caption: Config.cmake.in + :name: Config.cmake.in + +Then, to properly configure and install that file, add the following to the +bottom of the top-level ``CMakeLists.txt``: + +.. literalinclude:: Step12/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-install-Config.cmake + :language: cmake + :start-after: # install the configuration targets + :end-before: # generate the config file + + +Next, we execute the :command:`configure_package_config_file`. This command +will configure a provided file but with a few specific differences from the +standard :command:`configure_file` way. +To properly utilize this function, the input file should have a single line +with the text ``@PACKAGE_INIT@`` in addition to the content that is desired. +That variable will be replaced with a block of code which turns set values into +relative paths. These values which are new can be referenced by the same name +but prepended with a ``PACKAGE_`` prefix. + +.. literalinclude:: Step12/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-configure-package-config.cmake + :language: cmake + :start-after: # install the configuration targets + :end-before: # generate the version file + +The :command:`write_basic_package_version_file` is next. This command writes +a file which is used by :command:`find_package`, documenting the version and +compatibility of the desired package. Here, we use the ``Tutorial_VERSION_*`` +variables and say that it is compatible with ``AnyNewerVersion``, which +denotes that this version or any higher one are compatible with the requested +version. + +.. literalinclude:: Step12/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-basic-version-file.cmake + :language: cmake + :start-after: # generate the version file + :end-before: # install the generated configuration files + +Finally, set both generated files to be installed: + +.. literalinclude:: Step12/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-install-configured-files.cmake + :language: cmake + :start-after: # install the generated configuration files + :end-before: # generate the export + +At this point, we have generated a relocatable CMake Configuration for our +project that can be used after the project has been installed or packaged. If +we want our project to also be used from a build directory we only have to add +the following to the bottom of the top level ``CMakeLists.txt``: + +.. literalinclude:: Step12/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-export + :language: cmake + :start-after: # needs to be after the install(TARGETS) command + +With this export call we now generate a ``MathFunctionsTargets.cmake``, allowing the +configured ``MathFunctionsConfig.cmake`` in the build directory to be used by +other projects, without needing it to be installed. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Generator Expressions.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Generator Expressions.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3dab97ff0481cf7947c50eb84b32fff0f541ce4c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Generator Expressions.rst.txt @@ -0,0 +1,168 @@ +Step 4: Adding Generator Expressions +===================================== + +:manual:`Generator expressions ` are evaluated +during build system generation to produce information specific to each build +configuration. + +:manual:`Generator expressions ` are allowed in +the context of many target properties, such as :prop_tgt:`LINK_LIBRARIES`, +:prop_tgt:`INCLUDE_DIRECTORIES`, :prop_tgt:`COMPILE_DEFINITIONS` and others. +They may also be used when using commands to populate those properties, such as +:command:`target_link_libraries`, :command:`target_include_directories`, +:command:`target_compile_definitions` and others. + +:manual:`Generator expressions ` may be used +to enable conditional linking, conditional definitions used when compiling, +conditional include directories and more. The conditions may be based on the +build configuration, target properties, platform information or any other +queryable information. + +There are different types of +:manual:`generator expressions ` including +Logical, Informational, and Output expressions. + +Logical expressions are used to create conditional output. The basic +expressions are the ``0`` and ``1`` expressions. A ``$<0:...>`` results in the +empty string, and ``<1:...>`` results in the content of ``...``. They can also +be nested. + +Exercise 1 - Adding Compiler Warning Flags with Generator Expressions +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +A common usage of +:manual:`generator expressions ` is to +conditionally add compiler flags, such as those for language levels or +warnings. A nice pattern is to associate this information to an ``INTERFACE`` +target allowing this information to propagate. + +Goal +---- + +Add compiler warning flags when building but not for installed versions. + +Helpful Resources +----------------- + +* :manual:`cmake-generator-expressions(7)` +* :command:`cmake_minimum_required` +* :command:`set` +* :command:`target_compile_options` + +Files to Edit +------------- + +* ``CMakeLists.txt`` + +Getting Started +--------------- + +Open the file ``Step4/CMakeLists.txt`` and complete ``TODO 1`` through +``TODO 4``. + +First, in the top level ``CMakeLists.txt`` file, we need to set the +:command:`cmake_minimum_required` to ``3.15``. In this exercise we are going +to use a generator expression which was introduced in CMake 3.15. + +Next we add the desired compiler warning flags that we want for our project. +As warning flags vary based on the compiler, we use the +``COMPILE_LANG_AND_ID`` generator expression to control which flags to apply +given a language and a set of compiler ids. + +Build and Run +------------- + +Make a new directory called ``Step4_build``, run the :manual:`cmake ` +executable or the :manual:`cmake-gui ` to configure the project +and then build it with your chosen build tool or by using ``cmake --build .`` +from the build directory. + +.. code-block:: console + + mkdir Step4_build + cd Step4_build + cmake ../Step4 + cmake --build . + +Solution +-------- + +Update the :command:`cmake_minimum_required` to require at least CMake +version ``3.15``: + +.. raw:: html + +
TODO 1: Click to show/hide answer + +.. literalinclude:: Step5/CMakeLists.txt + :caption: TODO 1: CMakeLists.txt + :name: MathFunctions-CMakeLists.txt-minimum-required-step4 + :language: cmake + :end-before: # set the project name and version + +.. raw:: html + +
+ +Next we determine which compiler our system is currently using to build +since warning flags vary based on the compiler we use. This is done with +the ``COMPILE_LANG_AND_ID`` generator expression. We set the result in the +variables ``gcc_like_cxx`` and ``msvc_cxx`` as follows: + +.. raw:: html + +
TODO 2: Click to show/hide answer + +.. literalinclude:: Step5/CMakeLists.txt + :caption: TODO 2: CMakeLists.txt + :name: CMakeLists.txt-compile_lang_and_id + :language: cmake + :start-after: # the BUILD_INTERFACE genex + :end-before: target_compile_options(tutorial_compiler_flags INTERFACE + +.. raw:: html + +
+ +Next we add the desired compiler warning flags that we want for our project. +Using our variables ``gcc_like_cxx`` and ``msvc_cxx``, we can use another +generator expression to apply the respective flags only when the variables are +true. We use :command:`target_compile_options` to apply these flags to our +interface library. + +.. raw:: html + +
TODO 3: Click to show/hide answer + +.. code-block:: cmake + :caption: TODO 3: CMakeLists.txt + :name: CMakeLists.txt-compile_flags + + target_compile_options(tutorial_compiler_flags INTERFACE + "$<${gcc_like_cxx}:-Wall;-Wextra;-Wshadow;-Wformat=2;-Wunused>" + "$<${msvc_cxx}:-W3>" + ) + +.. raw:: html + +
+ +Lastly, we only want these warning flags to be used during builds. Consumers +of our installed project should not inherit our warning flags. To specify +this, we wrap our flags in a generator expression using the ``BUILD_INTERFACE`` +condition. The resulting full code looks like the following: + +.. raw:: html + +
TODO 4: Click to show/hide answer + +.. literalinclude:: Step5/CMakeLists.txt + :caption: TODO 4: CMakeLists.txt + :name: CMakeLists.txt-target_compile_options-genex + :language: cmake + :start-after: set(msvc_cxx "$") + :end-before: # configure a header file to pass some of the CMake settings + +.. raw:: html + +
diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Support for a Testing Dashboard.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Support for a Testing Dashboard.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..787e777dc4f2b9e6b217b575090c547f00c1f82f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Support for a Testing Dashboard.rst.txt @@ -0,0 +1,110 @@ +Step 6: Adding Support for a Testing Dashboard +============================================== + +Adding support for submitting our test results to a dashboard is simple. We +already defined a number of tests for our project in +:ref:`Testing Support `. Now we just have to run +those tests and submit them to CDash. + + +Exercise 1 - Send Results to a Testing Dashboard +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Goal +---- + +Display our CTest results with CDash. + +Helpful Resources +----------------- + +* :manual:`ctest(1)` +* :command:`include` +* :module:`CTest` + +Files to Edit +------------- + +* ``CMakeLists.txt`` + +Getting Started +--------------- + +For this exercise, complete ``TODO 1`` in the top-level ``CMakeLists.txt`` by +including the :module:`CTest` module. This will enable testing with CTest as +well as dashboard submissions to CDash, so we can safely remove the call to +:command:`enable_testing`. + +We will also need to acquire a ``CTestConfig.cmake`` file to be placed in the +top-level directory. When run, the :manual:`ctest ` executable will +read this file to gather information about the testing dashboard. It contains: + +* The project name + +* The project "Nightly" start time + + * The time when a 24 hour "day" starts for this project. + +* The URL of the CDash instance where the submission's generated documents + will be sent + +For this tutorial, a public dashboard server is used and its corresponding +``CTestConfig.cmake`` file is provided for you in this step's root directory. +In practice, this file would be downloaded from a project's ``Settings`` page +on the CDash instance intended to host the test results. Once downloaded from +CDash, the file should not be modified locally. + +.. literalinclude:: Step7/CTestConfig.cmake + :caption: CTestConfig.cmake + :name: CTestConfig.cmake + :language: cmake + + +Build and Run +------------- + +Note that as part of the CDash submission some information about your +development system (e.g. site name or full pathnames) may displayed publicly. + +To create a simple test dashboard, run the :manual:`cmake ` +executable or the :manual:`cmake-gui ` to configure the project +but do not build it yet. Instead, navigate to the build directory and run: + +.. code-block:: console + + ctest [-VV] -D Experimental + +Remember, for multi-config generators (e.g. Visual Studio), the configuration +type must be specified: + +.. code-block:: console + + ctest [-VV] -C Debug -D Experimental + +Or, from an IDE, build the ``Experimental`` target. + +The :manual:`ctest ` executable will build the project, run any +tests, and submit the results to Kitware's public dashboard: +https://my.cdash.org/index.php?project=CMakeTutorial. + +Solution +-------- + +The only CMake code changed needed in this step was to enable dashboard +submissions to CDash by including the :module:`CTest` module in our top-level +``CMakeLists.txt``: + +.. raw:: html + +
TODO 1: Click to show/hide answer + +.. literalinclude:: Step7/CMakeLists.txt + :caption: TODO 1: CMakeLists.txt + :name: CMakeLists.txt-include-CTest + :language: cmake + :start-after: # enable testing + :end-before: # does the application run + +.. raw:: html + +
diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding System Introspection.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding System Introspection.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..117b2306d940b241b69e7bb09b2cbbd3682db2ec --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding System Introspection.rst.txt @@ -0,0 +1,163 @@ +Step 7: Adding System Introspection +=================================== + +Let us consider adding some code to our project that depends on features the +target platform may not have. For this example, we will add some code that +depends on whether or not the target platform has the ``log`` and ``exp`` +functions. Of course almost every platform has these functions but for this +tutorial assume that they are not common. + +Exercise 1 - Assessing Dependency Availability +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Goal +---- + +Change implementation based on available system dependencies. + +Helpful Resources +----------------- + +* :module:`CheckCXXSourceCompiles` +* :command:`target_compile_definitions` + +Files to Edit +------------- + +* ``MathFunctions/CMakeLists.txt`` +* ``MathFunctions/mysqrt.cxx`` + +Getting Started +--------------- + +The starting source code is provided in the ``Step7`` directory. In this +exercise, complete ``TODO 1`` through ``TODO 5``. + +Start by editing ``MathFunctions/CMakeLists.txt``. Include the +:module:`CheckCXXSourceCompiles` module. Then, use +``check_cxx_source_compiles`` to determine whether ``log`` and ``exp`` are +available from ``cmath``. If they are available, use +:command:`target_compile_definitions` to specify ``HAVE_LOG`` and ``HAVE_EXP`` +as compile definitions. + +In the ``MathFunctions/mysqrt.cxx``, include ``cmath``. Then, if the system has +``log`` and ``exp``, use them to compute the square root. + +Build and Run +------------- + +Make a new directory called ``Step7_build``. Run the +:manual:`cmake ` executable or the +:manual:`cmake-gui ` to configure the project and then build it +with your chosen build tool and run the ``Tutorial`` executable. + +This can look like the following: + +.. code-block:: console + + mkdir Step7_build + cd Step7_build + cmake ../Step7 + cmake --build . + +Which function gives better results now, ``sqrt`` or ``mysqrt``? + +Solution +-------- + +In this exercise we will use functions from the +:module:`CheckCXXSourceCompiles` module so first we must include it in +``MathFunctions/CMakeLists.txt``. + +.. raw:: html + +
TODO 1: Click to show/hide answer + +.. literalinclude:: Step8/MathFunctions/CMakeLists.txt + :caption: TODO 1: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-include-check_cxx_source_compiles + :language: cmake + :start-after: # does this system provide the log and exp functions? + :end-before: check_cxx_source_compiles + +.. raw:: html + +
+ +Then test for the availability of +``log`` and ``exp`` using ``check_cxx_compiles_source``. This function +lets us try compiling simple code with the required dependency prior to +the true source code compilation. The resulting variables ``HAVE_LOG`` +and ``HAVE_EXP`` represent whether those dependencies are available. + +.. raw:: html + +
TODO 2: Click to show/hide answer + +.. literalinclude:: Step8/MathFunctions/CMakeLists.txt + :caption: TODO 2: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-check_cxx_source_compiles + :language: cmake + :start-after: include(CheckCXXSourceCompiles) + :end-before: # add compile definitions + +.. raw:: html + +
+ +Next, we need to pass these CMake variables to our source code. This way, +our source code can tell what resources are available. If both ``log`` and +``exp`` are available, use :command:`target_compile_definitions` to specify +``HAVE_LOG`` and ``HAVE_EXP`` as ``PRIVATE`` compile definitions. + +.. raw:: html + +
TODO 3: Click to show/hide answer + +.. literalinclude:: Step8/MathFunctions/CMakeLists.txt + :caption: TODO 3: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-target_compile_definitions + :language: cmake + :start-after: # add compile definitions + :end-before: # state + +.. raw:: html + +
+ +Since we may be using ``log`` and ``exp``, we need to modify +``mysqrt.cxx`` to include ``cmath``. + +.. raw:: html + +
TODO 4: Click to show/hide answer + +.. literalinclude:: Step8/MathFunctions/mysqrt.cxx + :caption: TODO 4: MathFunctions/mysqrt.cxx + :name: MathFunctions/mysqrt.cxx-include-cmath + :language: c++ + :start-after: #include "mysqrt.h" + :end-before: include + +.. raw:: html + +
+ +If ``log`` and ``exp`` are available on the system, then use them to +compute the square root in the ``mysqrt`` function. The ``mysqrt`` function in +``MathFunctions/mysqrt.cxx`` will look as follows: + +.. raw:: html + +
TODO 5: Click to show/hide answer + +.. literalinclude:: Step8/MathFunctions/mysqrt.cxx + :caption: TODO 5: MathFunctions/mysqrt.cxx + :name: MathFunctions/mysqrt.cxx-ifdef + :language: c++ + :start-after: // if we have both log and exp then use them + :end-before: return result; + +.. raw:: html + +
diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Usage Requirements for a Library.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Usage Requirements for a Library.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..227306393e4119c7930164cd805b4231aed5b137 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding Usage Requirements for a Library.rst.txt @@ -0,0 +1,323 @@ +Step 3: Adding Usage Requirements for a Library +=============================================== + +Exercise 1 - Adding Usage Requirements for a Library +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:ref:`Usage requirements ` of a target parameters +allow for far better control over a library or executable's link and include +line while also giving more control over the transitive property of targets +inside CMake. The primary commands that +leverage usage requirements are: + +* :command:`target_compile_definitions` +* :command:`target_compile_options` +* :command:`target_include_directories` +* :command:`target_link_directories` +* :command:`target_link_options` +* :command:`target_precompile_headers` +* :command:`target_sources` + + +Goal +---- + +Add usage requirements for a library. + +Helpful Materials +----------------- + +* :variable:`CMAKE_CURRENT_SOURCE_DIR` + +Files to Edit +------------- + +* ``MathFunctions/CMakeLists.txt`` +* ``CMakeLists.txt`` + +Getting Started +--------------- + +In this exercise, we will refactor our code from +:guide:`tutorial/Adding a Library` to use the modern CMake approach. We will +let our library define its own usage requirements so they are passed +transitively to other targets as necessary. In this case, ``MathFunctions`` +will specify any needed include directories itself. Then, the consuming target +``Tutorial`` simply needs to link to ``MathFunctions`` and not worry about +any additional include directories. + +The starting source code is provided in the ``Step3`` directory. In this +exercise, complete ``TODO 1`` through ``TODO 3``. + +First, add a call to :command:`target_include_directories` in +``MathFunctions/CMakeLists``. Remember that +:variable:`CMAKE_CURRENT_SOURCE_DIR` is the path to the source directory +currently being processed. + +Then, update (and simplify!) the call to +:command:`target_include_directories` in the top-level ``CMakeLists.txt``. + +Build and Run +------------- + +Make a new directory called ``Step3_build``, run the :manual:`cmake +` executable or the :manual:`cmake-gui ` to +configure the project and then build it with your chosen build tool or by +using :option:`cmake --build . ` from the build directory. +Here's a refresher of what that looks like from the command line: + +.. code-block:: console + + mkdir Step3_build + cd Step3_build + cmake ../Step3 + cmake --build . + +Next, use the newly built ``Tutorial`` and verify that it is working as +expected. + +Solution +-------- + +Let's update the code from the previous step to use the modern CMake +approach of usage requirements. + +We want to state that anybody linking to ``MathFunctions`` needs to include +the current source directory, while ``MathFunctions`` itself doesn't. This +can be expressed with an ``INTERFACE`` usage requirement. Remember +``INTERFACE`` means things that consumers require but the producer doesn't. + +At the end of ``MathFunctions/CMakeLists.txt``, use +:command:`target_include_directories` with the ``INTERFACE`` keyword, as +follows: + +.. raw:: html + +
TODO 1: Click to show/hide answer + +.. literalinclude:: Step4/MathFunctions/CMakeLists.txt + :caption: TODO 1: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-target_include_directories-INTERFACE + :language: cmake + :start-after: # to find MathFunctions.h + :end-before: # should we use our own + +.. raw:: html + +
+ +Now that we've specified usage requirements for ``MathFunctions`` we can +safely remove our uses of the ``EXTRA_INCLUDES`` variable from the top-level +``CMakeLists.txt``. + +Remove this line: + +.. raw:: html + +
TODO 2: Click to show/hide answer + +.. literalinclude:: Step3/CMakeLists.txt + :caption: TODO 2: CMakeLists.txt + :name: CMakeLists.txt-remove-EXTRA_INCLUDES + :language: cmake + :start-after: add_subdirectory(MathFunctions) + :end-before: # add the executable + +.. raw:: html + +
+ +And the lines: + +.. raw:: html + +
TODO 3: Click to show/hide answer + +.. literalinclude:: Step4/CMakeLists.txt + :caption: TODO 3: CMakeLists.txt + :name: CMakeLists.txt-target_include_directories-remove-EXTRA_INCLUDES + :language: cmake + :start-after: # so that we will find TutorialConfig.h + +.. raw:: html + +
+ +The remaining code looks like: + +.. raw:: html + +
Click to show/hide the resulting code + +.. literalinclude:: Step4/CMakeLists.txt + :caption: Remaining code after removing EXTRA_INCLUDES + :name: CMakeLists.txt-after-removing-EXTRA_INCLUDES + :language: cmake + :start-after: add_subdirectory(MathFunctions) + +.. raw:: html + +
+ + +Notice that with this technique, the only thing our executable target does to +use our library is call :command:`target_link_libraries` with the name +of the library target. In larger projects, the classic method of specifying +library dependencies manually becomes very complicated very quickly. + +Exercise 2 - Setting the C++ Standard with Interface Libraries +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Now that we have switched our code to a more modern approach, let's demonstrate +a modern technique to set properties to multiple targets. + +Let's refactor our existing code to use an ``INTERFACE`` library. We will +use that library in the next step to demonstrate a common use for +:manual:`generator expressions `. + +Goal +---- + +Add an ``INTERFACE`` library target to specify the required C++ standard. + +Helpful Resources +----------------- + +* :command:`add_library` +* :command:`target_compile_features` +* :command:`target_link_libraries` + +Files to Edit +------------- + +* ``CMakeLists.txt`` +* ``MathFunctions/CMakeLists.txt`` + +Getting Started +--------------- + +In this exercise, we will refactor our code to use an ``INTERFACE`` library to +specify the C++ standard. + +Start this exercise from what we left at the end of Step3 exercise 1. You will +have to complete ``TODO 4`` through ``TODO 7``. + +Start by editing the top level ``CMakeLists.txt`` file. Construct an +``INTERFACE`` library target called ``tutorial_compiler_flags`` and +specify ``cxx_std_11`` as a target compiler feature. + +Modify ``CMakeLists.txt`` and ``MathFunctions/CMakeLists.txt`` so that all +targets have a :command:`target_link_libraries` call to +``tutorial_compiler_flags``. + +Build and Run +------------- + +Since we have our build directory already configured from Exercise 1, simply +rebuild our code by calling the following: + +.. code-block:: console + + cd Step3_build + cmake --build . + +Next, use the newly built ``Tutorial`` and verify that it is working as +expected. + +Solution +-------- + +Let's update our code from the previous step to use interface libraries +to set our C++ requirements. + +To start, we need to remove the two :command:`set` calls on the variables +:variable:`CMAKE_CXX_STANDARD` and :variable:`CMAKE_CXX_STANDARD_REQUIRED`. +The specific lines to remove are as follows: + +.. literalinclude:: Step3/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-CXX_STANDARD-variable-remove + :language: cmake + :start-after: # specify the C++ standard + :end-before: # configure a header file + +Next, we need to create an interface library, ``tutorial_compiler_flags``. And +then use :command:`target_compile_features` to add the compiler feature +``cxx_std_11``. + + +.. raw:: html + +
TODO 4: Click to show/hide answer + +.. literalinclude:: Step4/CMakeLists.txt + :caption: TODO 4: CMakeLists.txt + :name: CMakeLists.txt-cxx_std-feature + :language: cmake + :start-after: # specify the C++ standard + :end-before: # TODO 2: Create helper + +.. raw:: html + +
+ +Finally, with our interface library set up, we need to link our +executable ``Target``, our ``MathFunctions`` library, and our ``SqrtLibrary`` +library to our new +``tutorial_compiler_flags`` library. Respectively, the code will look like +this: + +.. raw:: html + +
TODO 5: Click to show/hide answer + +.. literalinclude:: Step4/CMakeLists.txt + :caption: TODO 5: CMakeLists.txt + :name: CMakeLists.txt-target_link_libraries-step4 + :language: cmake + :start-after: add_executable(Tutorial tutorial.cxx) + :end-before: # add the binary tree to the search path for include file + +.. raw:: html + +
+ +this: + +.. raw:: html + +
TODO 6: Click to show/hide answer + +.. literalinclude:: Step4/MathFunctions/CMakeLists.txt + :caption: TODO 6: MathFunctions/CMakeLists.txt + :name: MathFunctions-CMakeLists.txt-target_link_libraries-step4 + :language: cmake + :start-after: # link our compiler flags interface library + :end-before: target_link_libraries(MathFunctions + +.. raw:: html + +
+ +and this: + +.. raw:: html + +
TODO 7: Click to show/hide answer + +.. literalinclude:: Step4/MathFunctions/CMakeLists.txt + :caption: TODO 7: MathFunctions/CMakeLists.txt + :name: MathFunctions-SqrtLibrary-target_link_libraries-step4 + :language: cmake + :start-after: target_link_libraries(SqrtLibrary + :end-before: endif() + +.. raw:: html + +
+ + +With this, all of our code still requires C++ 11 to build. Notice +though that with this method, it gives us the ability to be specific about +which targets get specific requirements. In addition, we create a single +source of truth in our interface library. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding a Custom Command and Generated File.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding a Custom Command and Generated File.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..c71a88972508ea73c6831ce9692a2935a36c8da0 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding a Custom Command and Generated File.rst.txt @@ -0,0 +1,103 @@ +Step 8: Adding a Custom Command and Generated File +================================================== + +Suppose, for the purpose of this tutorial, we decide that we never want to use +the platform ``log`` and ``exp`` functions and instead would like to +generate a table of precomputed values to use in the ``mysqrt`` function. +In this section, we will create the table as part of the build process, +and then compile that table into our application. + +First, let's remove the check for the ``log`` and ``exp`` functions in +``MathFunctions/CMakeLists.txt``. Then remove the check for ``HAVE_LOG`` and +``HAVE_EXP`` from ``mysqrt.cxx``. At the same time, we can remove +:code:`#include `. + +In the ``MathFunctions`` subdirectory, a new source file named +``MakeTable.cxx`` has been provided to generate the table. + +After reviewing the file, we can see that the table is produced as valid C++ +code and that the output filename is passed in as an argument. + +The next step is to create ``MathFunctions/MakeTable.cmake``. Then, add the +appropriate commands to the file to build the ``MakeTable`` executable and +then run it as part of the build process. A few commands are needed to +accomplish this. + +First, we add an executable for ``MakeTable``. + +.. literalinclude:: Step9/MathFunctions/MakeTable.cmake + :caption: MathFunctions/MakeTable.cmake + :name: MathFunctions/MakeTable.cmake-add_executable-MakeTable + :language: cmake + :start-after: # first we add the executable that generates the table + :end-before: target_link_libraries + +After creating the executable, we add the ``tutorial_compiler_flags`` to our +executable using :command:`target_link_libraries`. + +.. literalinclude:: Step9/MathFunctions/MakeTable.cmake + :caption: MathFunctions/MakeTable.cmake + :name: MathFunctions/MakeTable.cmake-link-tutorial-compiler-flags + :language: cmake + :start-after: add_executable + :end-before: # add the command to generate + +Then we add a custom command that specifies how to produce ``Table.h`` +by running MakeTable. + +.. literalinclude:: Step9/MathFunctions/MakeTable.cmake + :caption: MathFunctions/MakeTable.cmake + :name: MathFunctions/MakeTable.cmake-add_custom_command-Table.h + :language: cmake + :start-after: # add the command to generate the source code + +Next we have to let CMake know that ``mysqrt.cxx`` depends on the generated +file ``Table.h``. This is done by adding the generated ``Table.h`` to the list +of sources for the library ``SqrtLibrary``. + +.. literalinclude:: Step9/MathFunctions/CMakeLists.txt + :caption: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-add_library-Table.h + :language: cmake + :start-after: # library that just does sqrt + :end-before: # state that we depend on + +We also have to add the current binary directory to the list of include +directories so that ``Table.h`` can be found and included by ``mysqrt.cxx``. + +.. literalinclude:: Step9/MathFunctions/CMakeLists.txt + :caption: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-target_include_directories-Table.h + :language: cmake + :start-after: # state that we depend on our bin + :end-before: target_link_libraries + +As the last step, we need to include +``MakeTable.cmake`` at the top of the ``MathFunctions/CMakeLists.txt``. + +.. literalinclude:: Step9/MathFunctions/CMakeLists.txt + :caption: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-include-MakeTable.cmake + :language: cmake + :start-after: # generate Table.h + :end-before: # library that just does sqrt + +Now let's use the generated table. First, modify ``mysqrt.cxx`` to include +``Table.h``. Next, we can rewrite the ``mysqrt`` function to use the table: + +.. literalinclude:: Step9/MathFunctions/mysqrt.cxx + :caption: MathFunctions/mysqrt.cxx + :name: MathFunctions/mysqrt.cxx + :language: c++ + :start-after: // a hack square root calculation using simple operations + +Run the :manual:`cmake ` executable or the +:manual:`cmake-gui ` to configure the project and then build it +with your chosen build tool. + +When this project is built it will first build the ``MakeTable`` executable. +It will then run ``MakeTable`` to produce ``Table.h``. Finally, it will +compile ``mysqrt.cxx`` which includes ``Table.h`` to produce the +``MathFunctions`` library. + +Run the Tutorial executable and verify that it is using the table. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding a Library.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding a Library.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..694dfaf621c7132692e91fdc05fe21f94c3efe7e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Adding a Library.rst.txt @@ -0,0 +1,455 @@ +Step 2: Adding a Library +======================== + +At this point, we have seen how to create a basic project using CMake. In this +step, we will learn how to create and use a library in our project. We will +also see how to make the use of our library optional. + +Exercise 1 - Creating a Library +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +To add a library in CMake, use the :command:`add_library` command and specify +which source files should make up the library. + +Rather than placing all of the source files in one directory, we can organize +our project with one or more subdirectories. In this case, we will create a +subdirectory specifically for our library. Here, we can add a new +``CMakeLists.txt`` file and one or more source files. In the top level +``CMakeLists.txt`` file, we will use the :command:`add_subdirectory` command +to add the subdirectory to the build. + +Once the library is created, it is connected to our executable target with +:command:`target_include_directories` and :command:`target_link_libraries`. + +Goal +---- + +Add and use a library. + +Helpful Resources +----------------- + +* :command:`add_library` +* :command:`add_subdirectory` +* :command:`target_include_directories` +* :command:`target_link_libraries` +* :variable:`PROJECT_SOURCE_DIR` + +Files to Edit +------------- + +* ``CMakeLists.txt`` +* ``tutorial.cxx`` +* ``MathFunctions/CMakeLists.txt`` + +Getting Started +--------------- + +In this exercise, we will add a library to our project that contains our own +implementation for computing the square root of a number. The executable can +then use this library instead of the standard square root function provided by +the compiler. + +For this tutorial we will put the library into a subdirectory called +``MathFunctions``. This directory already contains the header files +``MathFunctions.h`` and ``mysqrt.h``. Their respective source files +``MathFunctions.cxx`` and ``mysqrt.cxx`` are also provided. We will not need +to modify any of these files. ``mysqrt.cxx`` has one function called +``mysqrt`` that provides similar functionality to the compiler's ``sqrt`` +function. ``MathFunctions.cxx`` contains one function ``sqrt`` which serves +to hide the implementation details of ``sqrt``. + +From the ``Help/guide/tutorial/Step2`` directory, start with ``TODO 1`` and +complete through ``TODO 6``. + +First, fill in the one line ``CMakeLists.txt`` in the ``MathFunctions`` +subdirectory. + +Next, edit the top level ``CMakeLists.txt``. + +Finally, use the newly created ``MathFunctions`` library in ``tutorial.cxx`` + +Build and Run +------------- + +Run the :manual:`cmake ` executable or the +:manual:`cmake-gui ` to configure the project and then build it +with your chosen build tool. + +Below is a refresher of what that looks like from the command line: + +.. code-block:: console + + mkdir Step2_build + cd Step2_build + cmake ../Step2 + cmake --build . + +Try to use the newly built ``Tutorial`` and ensure that it is still +producing accurate square root values. + +Solution +-------- + +In the ``CMakeLists.txt`` file in the ``MathFunctions`` directory, we create +a library target called ``MathFunctions`` with :command:`add_library`. The +source files for the library are passed as an argument to +:command:`add_library`. This looks like the following line: + +.. raw:: html/ + +
TODO 1: Click to show/hide answer + +.. code-block:: cmake + :caption: TODO 1: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-add_library + + add_library(MathFunctions MathFunctions.cxx mysqrt.cxx) + +.. raw:: html + +
+ +To make use of the new library we will add an :command:`add_subdirectory` +call in the top-level ``CMakeLists.txt`` file so that the library will get +built. + +.. raw:: html + +
TODO 2: Click to show/hide answer + +.. code-block:: cmake + :caption: TODO 2: CMakeLists.txt + :name: CMakeLists.txt-add_subdirectory + + add_subdirectory(MathFunctions) + +.. raw:: html + +
+ +Next, the new library target is linked to the executable target using +:command:`target_link_libraries`. + +.. raw:: html + +
TODO 3: Click to show/hide answer + +.. code-block:: cmake + :caption: TODO 3: CMakeLists.txt + :name: CMakeLists.txt-target_link_libraries + + target_link_libraries(Tutorial PUBLIC MathFunctions) + +.. raw:: html + +
+ +Finally we need to specify the library's header file location. Modify +:command:`target_include_directories` to add the ``MathFunctions`` subdirectory +as an include directory so that the ``MathFunctions.h`` header file can be +found. + +.. raw:: html + +
TODO 4: Click to show/hide answer + +.. code-block:: cmake + :caption: TODO 4: CMakeLists.txt + :name: CMakeLists.txt-target_include_directories-step2 + + target_include_directories(Tutorial PUBLIC + "${PROJECT_BINARY_DIR}" + "${PROJECT_SOURCE_DIR}/MathFunctions" + ) + +.. raw:: html + +
+ +Now let's use our library. In ``tutorial.cxx``, include ``MathFunctions.h``: + +.. raw:: html + +
TODO 5: Click to show/hide answer + +.. literalinclude:: Step3/tutorial.cxx + :caption: TODO 5: tutorial.cxx + :name: CMakeLists.txt-include-MathFunctions.h + :language: cmake + :start-after: #include + :end-before: #include "TutorialConfig.h" + +.. raw:: html + +
+ +Lastly, replace ``sqrt`` with our library function ``mathfunctions::mysqrt``. + +.. raw:: html + +
TODO 6: Click to show/hide answer + +.. literalinclude:: Step3/tutorial.cxx + :caption: TODO 6: tutorial.cxx + :name: CMakeLists.txt-option + :language: cmake + :start-after: const double inputValue = std::stod(argv[1]); + :end-before: std::cout + +.. raw:: html + +
+ +Exercise 2 - Adding an Option +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Now let us add an option in the MathFunctions library to allow developers to +select either the custom square root implementation or the built in standard +implementation. While for the tutorial +there really isn't any need to do so, for larger projects this is a common +occurrence. + +CMake can do this using the :command:`option` command. This gives users a +variable which they can change when configuring their cmake build. This +setting will be stored in the cache so that the user does not need to set +the value each time they run CMake on a build directory. + +Goal +---- + +Add the option to build without ``MathFunctions``. + + +Helpful Resources +----------------- + +* :command:`if` +* :command:`option` +* :command:`target_compile_definitions` + +Files to Edit +------------- + +* ``MathFunctions/CMakeLists.txt`` +* ``MathFunctions/MathFunctions.cxx`` + +Getting Started +--------------- + +Start with the resulting files from Exercise 1. Complete ``TODO 7`` through +``TODO 14``. + +First create a variable ``USE_MYMATH`` using the :command:`option` command +in ``MathFunctions/CMakeLists.txt``. In that same file, use that option +to pass a compile definition to the ``MathFunctions`` library. + +Then, update ``MathFunctions.cxx`` to redirect compilation based on +``USE_MYMATH``. + +Lastly, prevent ``mysqrt.cxx`` from being compiled when ``USE_MYMATH`` is on +by making it its own library inside of the ``USE_MYMATH`` block of +``MathFunctions/CMakeLists.txt``. + +Build and Run +------------- + +Since we have our build directory already configured from Exercise 1, we can +rebuild by simply calling the following: + +.. code-block:: console + + cd ../Step2_build + cmake --build . + +Next, run the ``Tutorial`` executable on a few numbers to verify that it's +still correct. + +Now let's update the value of ``USE_MYMATH`` to ``OFF``. The easiest way is to +use the :manual:`cmake-gui ` or :manual:`ccmake ` +if you're in the terminal. Or, alternatively, if you want to change the +option from the command-line, try: + +.. code-block:: console + + cmake ../Step2 -DUSE_MYMATH=OFF + +Now, rebuild the code with the following: + +.. code-block:: console + + cmake --build . + +Then, run the executable again to ensure that it still works with +``USE_MYMATH`` set to ``OFF``. Which function gives better results, ``sqrt`` +or ``mysqrt``? + +Solution +-------- + +The first step is to add an option to ``MathFunctions/CMakeLists.txt``. +This option will be displayed in the :manual:`cmake-gui ` and +:manual:`ccmake ` with a default value of ``ON`` that can be +changed by the user. + +.. raw:: html + +
TODO 7: Click to show/hide answer + +.. literalinclude:: Step3/MathFunctions/CMakeLists.txt + :caption: TODO 7: MathFunctions/CMakeLists.txt + :name: CMakeLists.txt-option-library-level + :language: cmake + :start-after: # should we use our own math functions + :end-before: if (USE_MYMATH) + +.. raw:: html + +
+ +Next, make building and linking our library with ``mysqrt`` function +conditional using this new option. + +Create an :command:`if` statement which checks the value of +``USE_MYMATH``. Inside the :command:`if` block, put the +:command:`target_compile_definitions` command with the compile +definition ``USE_MYMATH``. + +.. raw:: html + +
TODO 8: Click to show/hide answer + +.. code-block:: cmake + :caption: TODO 8: MathFunctions/CMakeLists.txt + :name: CMakeLists.txt-USE_MYMATH + + if (USE_MYMATH) + target_compile_definitions(MathFunctions PRIVATE "USE_MYMATH") + endif() + +.. raw:: html + +
+ +When ``USE_MYMATH`` is ``ON``, the compile definition ``USE_MYMATH`` will +be set. We can then use this compile definition to enable or disable +sections of our source code. + +The corresponding changes to the source code are fairly straightforward. +In ``MathFunctions.cxx``, we make ``USE_MYMATH`` control which square root +function is used: + +.. raw:: html + +
TODO 9: Click to show/hide answer + +.. literalinclude:: Step3/MathFunctions/MathFunctions.cxx + :caption: TODO 9: MathFunctions/MathFunctions.cxx + :name: MathFunctions-USE_MYMATH-if + :language: c++ + :start-after: which square root function should we use? + :end-before: } + +.. raw:: html + +
+ +Next, we need to include ``mysqrt.h`` if ``USE_MYMATH`` is defined. + +.. raw:: html + +
TODO 10: Click to show/hide answer + +.. literalinclude:: Step3/MathFunctions/MathFunctions.cxx + :caption: TODO 10: MathFunctions/MathFunctions.cxx + :name: MathFunctions-USE_MYMATH-if-include + :language: c++ + :start-after: include + :end-before: namespace mathfunctions + +.. raw:: html + +
+ +Finally, we need to include ``cmath`` now that we are using ``std::sqrt``. + +.. raw:: html + +
TODO 11: Click to show/hide answer + +.. code-block:: c++ + :caption: TODO 11 : MathFunctions/MathFunctions.cxx + :name: tutorial.cxx-include_cmath + + #include + +.. raw:: html + +
+ +At this point, if ``USE_MYMATH`` is ``OFF``, ``mysqrt.cxx`` would not be used +but it will still be compiled because the ``MathFunctions`` target has +``mysqrt.cxx`` listed under sources. + +There are a few ways to fix this. The first option is to use +:command:`target_sources` to add ``mysqrt.cxx`` from within the ``USE_MYMATH`` +block. Another option is to create an additional library within the +``USE_MYMATH`` block which is responsible for compiling ``mysqrt.cxx``. For +the sake of this tutorial, we are going to create an additional library. + +First, from within ``USE_MYMATH`` create a library called ``SqrtLibrary`` +that has sources ``mysqrt.cxx``. + +.. raw:: html + +
TODO 12: Click to show/hide answer + +.. literalinclude:: Step3/MathFunctions/CMakeLists.txt + :caption: TODO 12 : MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-add_library-SqrtLibrary + :language: cmake + :start-after: # library that just does sqrt + :end-before: # TODO 7: Link + +.. raw:: html + +
+ +Next, we link ``SqrtLibrary`` onto ``MathFunctions`` when ``USE_MYMATH`` is +enabled. + +.. raw:: html + +
TODO 13: Click to show/hide answer + +.. literalinclude:: Step3/MathFunctions/CMakeLists.txt + :caption: TODO 13 : MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-target_link_libraries-SqrtLibrary + :language: cmake + :start-after: to tutorial_compiler_flags + :end-before: endif() + +.. raw:: html + +
+ +Finally, we can remove ``mysqrt.cxx`` from our ``MathFunctions`` library +source list because it will be pulled in when ``SqrtLibrary`` is included. + +.. raw:: html + +
TODO 14: Click to show/hide answer + +.. literalinclude:: Step3/MathFunctions/CMakeLists.txt + :caption: TODO 14 : MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-remove-mysqrt.cxx-MathFunctions + :language: cmake + :end-before: # TODO 1: + +.. raw:: html + +
+ +With these changes, the ``mysqrt`` function is now completely optional to +whoever is building and using the ``MathFunctions`` library. Users can toggle +``USE_MYMATH`` to manipulate what library is used in the build. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Installing and Testing.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Installing and Testing.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..7a59fcba21dfa98d637da51d7b8d35b29dc6f3fd --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Installing and Testing.rst.txt @@ -0,0 +1,311 @@ +Step 5: Installing and Testing +============================== + +Exercise 1 - Install Rules +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Often, it is not enough to only build an executable, it should also be +installable. With CMake, we can specify install rules using the +:command:`install` command. Supporting local installations for your builds in +CMake is often as simple as specifying an install location and the targets and +files to be installed. + +Goal +---- + +Install the ``Tutorial`` executable and the ``MathFunctions`` library. + +Helpful Materials +----------------- + +* :command:`install` + +Files to Edit +------------- + +* ``MathFunctions/CMakeLists.txt`` +* ``CMakeLists.txt`` + +Getting Started +--------------- + +The starting code is provided in the ``Step5`` directory. In this +exercise, complete ``TODO 1`` through ``TODO 4``. + +First, update ``MathFunctions/CMakeLists.txt`` to install the +``MathFunctions`` and ``tutorial_compiler_flags`` libraries to the ``lib`` +directory. In that same file, specify the install rules needed to install +``MathFunctions.h`` to the ``include`` directory. + +Then, update the top level ``CMakeLists.txt`` to install +the ``Tutorial`` executable to the ``bin`` directory. Lastly, any header files +should be installed to the ``include`` directory. Remember that +``TutorialConfig.h`` is in the :variable:`PROJECT_BINARY_DIR`. + +Build and Run +------------- + +Make a new directory called ``Step5_build``. Run the +:manual:`cmake ` executable or the +:manual:`cmake-gui ` to configure the project and then build it +with your chosen build tool. + +Then, run the install step by using the :option:`--install ` +option of the :manual:`cmake ` command (introduced in 3.15, older +versions of CMake must use ``make install``) from the command line. This step +will install the appropriate header files, libraries, and executables. +For example: + +.. code-block:: console + + cmake --install . + +For multi-configuration tools, don't forget to use the +:option:`--config ` argument to specify the configuration. + +.. code-block:: console + + cmake --install . --config Release + +If using an IDE, simply build the ``INSTALL`` target. You can build the same +install target from the command line like the following: + +.. code-block:: console + + cmake --build . --target install --config Debug + +The CMake variable :variable:`CMAKE_INSTALL_PREFIX` is used to determine the +root of where the files will be installed. If using the :option:`cmake --install` +command, the installation prefix can be overridden via the +:option:`--prefix ` argument. For example: + +.. code-block:: console + + cmake --install . --prefix "/home/myuser/installdir" + +Navigate to the install directory and verify that the installed ``Tutorial`` +runs. + +Solution +-------- + +The install rules for our project are fairly simple: + +* For ``MathFunctions``, we want to install the libraries and header file to + the ``lib`` and ``include`` directories respectively. + +* For the ``Tutorial`` executable, we want to install the executable and + configured header file to the ``bin`` and ``include`` directories + respectively. + +So to the end of ``MathFunctions/CMakeLists.txt`` we add: + +.. raw:: html + +
TODO 1: Click to show/hide answer + +.. literalinclude:: Step6/MathFunctions/CMakeLists.txt + :caption: TODO 1: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-install-TARGETS + :language: cmake + :start-after: # install libs + :end-before: # install include headers + +.. raw:: html + +
+ +and + +.. raw:: html + +
TODO 2: Click to show/hide answer + +.. literalinclude:: Step6/MathFunctions/CMakeLists.txt + :caption: TODO 2: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-install-headers + :language: cmake + :start-after: # install include headers + +.. raw:: html + +
+ +The install rules for the ``Tutorial`` executable and configured header file +are similar. To the end of the top-level ``CMakeLists.txt`` we add: + +.. raw:: html + +
TODO 3,4: Click to show/hide answer + +.. literalinclude:: Step6/CMakeLists.txt + :caption: CMakeLists.txt + :name: TODO 3,4: CMakeLists.txt-install-TARGETS + :language: cmake + :start-after: # add the install targets + :end-before: # TODO 1: Replace enable_testing() with include(CTest) + +.. raw:: html + +
+ +That is all that is needed to create a basic local +install of the tutorial. + +.. _`Tutorial Testing Support`: + +Exercise 2 - Testing Support +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +CTest offers a way to easily manage tests for your project. Tests can be +added through the :command:`add_test` command. Although it is not +explicitly covered in this tutorial, there is a lot of compatibility +between CTest and other testing frameworks such as :module:`GoogleTest`. + +Goal +---- + +Create unit tests for our executable using CTest. + +Helpful Materials +----------------- + +* :command:`enable_testing` +* :command:`add_test` +* :command:`function` +* :command:`set_tests_properties` +* :manual:`ctest ` + +Files to Edit +------------- + +* ``CMakeLists.txt`` + +Getting Started +--------------- + +The starting source code is provided in the ``Step5`` directory. In this +exercise, complete ``TODO 5`` through ``TODO 9``. + +First, we need to enable testing. Next, begin adding tests to our project +using :command:`add_test`. We will work through adding 3 simple tests and +then you can add additional testing as you see fit. + +Build and Run +------------- + +Navigate to the build directory and rebuild the application. Then, run the +:program:`ctest` executable: :option:`ctest -N` and :option:`ctest -VV`. For +multi-config generators (e.g. Visual Studio), the configuration type must be +specified with the :option:`-C \ ` flag. For example, to run tests in Debug +mode use ``ctest -C Debug -VV`` from the build directory +(not the Debug subdirectory!). Release mode would be executed from the same +location but with a ``-C Release``. Alternatively, build the ``RUN_TESTS`` +target from the IDE. + +Solution +-------- + +Let's test our application. At the end of the top-level ``CMakeLists.txt`` +file we first need to enable testing with the +:command:`enable_testing` command. + +.. raw:: html + +
TODO 5: Click to show/hide answer + +.. literalinclude:: Step6/CMakeLists.txt + :caption: TODO 5: CMakeLists.txt + :name: CMakeLists.txt-enable_testing + :language: cmake + :start-after: # enable testing + :end-before: # does the application run + +.. raw:: html + +
+ +With testing enabled, we will add a number of basic tests to verify +that the application is working correctly. First, we create a test using +:command:`add_test` which runs the ``Tutorial`` executable with the +parameter 25 passed in. For this test, we are not going to check the +executable's computed answer. This test will verify that +application runs, does not segfault or otherwise crash, and has a zero +return value. This is the basic form of a CTest test. + +.. raw:: html + +
TODO 6: Click to show/hide answer + +.. literalinclude:: Step6/CMakeLists.txt + :caption: TODO 6: CMakeLists.txt + :name: CMakeLists.txt-test-runs + :language: cmake + :start-after: # does the application run + :end-before: # does the usage message work + +.. raw:: html + +
+ +Next, let's use the :prop_test:`PASS_REGULAR_EXPRESSION` test property to +verify that the output of the test contains certain strings. In this case, +verifying that the usage message is printed when an incorrect number of +arguments are provided. + +.. raw:: html + +
TODO 7: Click to show/hide answer + +.. literalinclude:: Step6/CMakeLists.txt + :caption: TODO 7: CMakeLists.txt + :name: CMakeLists.txt-test-usage + :language: cmake + :start-after: # does the usage message work? + :end-before: # define a function to simplify adding tests + +.. raw:: html + +
+ +The next test we will add verifies the computed value is truly the +square root. + +.. raw:: html + +
TODO 8: Click to show/hide answer + +.. code-block:: cmake + :caption: TODO 8: CMakeLists.txt + :name: CMakeLists.txt-test-standard + + add_test(NAME StandardUse COMMAND Tutorial 4) + set_tests_properties(StandardUse + PROPERTIES PASS_REGULAR_EXPRESSION "4 is 2" + ) + +.. raw:: html + +
+ +This one test is not enough to give us confidence that it will +work for all values passed in. We should add more tests to verify this. +To easily add more tests, we make a function called ``do_test`` that runs the +application and verifies that the computed square root is correct for +given input. For each invocation of ``do_test``, another test is added to +the project with a name, input, and expected results based on the passed +arguments. + +.. raw:: html + +
TODO 9: Click to show/hide answer + +.. literalinclude:: Step6/CMakeLists.txt + :caption: TODO 9: CMakeLists.txt + :name: CMakeLists.txt-generalized-tests + :language: cmake + :start-after: # define a function to simplify adding tests + +.. raw:: html + +
diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Packaging Debug and Release.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Packaging Debug and Release.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..8c660a3115cb626191d2483f67cf58f02bdfab5f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Packaging Debug and Release.rst.txt @@ -0,0 +1,86 @@ +Step 12: Packaging Debug and Release +==================================== + +**Note:** This example is valid for single-configuration generators and will +not work for multi-configuration generators (e.g. Visual Studio). + +By default, CMake's model is that a build directory only contains a single +configuration, be it Debug, Release, MinSizeRel, or RelWithDebInfo. It is +possible, however, to setup CPack to bundle multiple build directories and +construct a package that contains multiple configurations of the same project. + +First, we want to ensure that the debug and release builds use different names +for the libraries that will be installed. Let's use `d` as the +postfix for the debug libraries. + +Set :variable:`CMAKE_DEBUG_POSTFIX` near the beginning of the top-level +``CMakeLists.txt`` file: + +.. literalinclude:: Complete/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-CMAKE_DEBUG_POSTFIX-variable + :language: cmake + :start-after: project(Tutorial VERSION 1.0) + :end-before: target_compile_features(tutorial_compiler_flags + +And the :prop_tgt:`DEBUG_POSTFIX` property on the tutorial executable: + +.. literalinclude:: Complete/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-DEBUG_POSTFIX-property + :language: cmake + :start-after: # add the executable + :end-before: # add the binary tree to the search path for include files + +Let's also add version numbering to the ``MathFunctions`` library. In +``MathFunctions/CMakeLists.txt``, set the :prop_tgt:`VERSION` and +:prop_tgt:`SOVERSION` properties: + +.. literalinclude:: Complete/MathFunctions/CMakeLists.txt + :caption: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-VERSION-properties + :language: cmake + :start-after: # setup the version numbering + :end-before: # install libs + +From the ``Step12`` directory, create ``debug`` and ``release`` +subdirectories. The layout will look like: + +.. code-block:: none + + - Step12 + - debug + - release + +Now we need to setup debug and release builds. We can use +:variable:`CMAKE_BUILD_TYPE` to set the configuration type: + +.. code-block:: console + + cd debug + cmake -DCMAKE_BUILD_TYPE=Debug .. + cmake --build . + cd ../release + cmake -DCMAKE_BUILD_TYPE=Release .. + cmake --build . + +Now that both the debug and release builds are complete, we can use a custom +configuration file to package both builds into a single release. In the +``Step12`` directory, create a file called ``MultiCPackConfig.cmake``. In this +file, first include the default configuration file that was created by the +:manual:`cmake ` executable. + +Next, use the ``CPACK_INSTALL_CMAKE_PROJECTS`` variable to specify which +projects to install. In this case, we want to install both debug and release. + +.. literalinclude:: Complete/MultiCPackConfig.cmake + :caption: MultiCPackConfig.cmake + :name: MultiCPackConfig.cmake + :language: cmake + +From the ``Step12`` directory, run :manual:`cpack ` specifying our +custom configuration file with the ``config`` option: + +.. code-block:: console + + cpack --config MultiCPackConfig.cmake diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Packaging an Installer.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Packaging an Installer.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..11a1952c8525a2b3ff2b0d5d71de95bc7c2bd328 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Packaging an Installer.rst.txt @@ -0,0 +1,62 @@ +Step 9: Packaging an Installer +============================== + +Next suppose that we want to distribute our project to other people so that +they can use it. We want to provide both binary and source distributions on a +variety of platforms. This is a little different from the install we did +previously in :guide:`tutorial/Installing and Testing`, where we were +installing the binaries that we had built from the source code. In this +example we will be building installation packages that support binary +installations and package management features. To accomplish this we will use +CPack to create platform specific installers. Specifically we need to add a +few lines to the bottom of our top-level ``CMakeLists.txt`` file. + +.. literalinclude:: Step10/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-include-CPack + :language: cmake + :start-after: # setup installer + +That is all there is to it. We start by including +:module:`InstallRequiredSystemLibraries`. This module will include any runtime +libraries that are needed by the project for the current platform. Next we set +some CPack variables to where we have stored the license and version +information for this project. The version information was set earlier in this +tutorial and the ``License.txt`` has been included in the top-level source +directory for this step. The :variable:`CPACK_SOURCE_GENERATOR` variable +selects a file format for the source package. + +Finally we include the :module:`CPack module ` which will use these +variables and some other properties of the current system to setup an +installer. + +The next step is to build the project in the usual manner and then run the +:manual:`cpack ` executable. To build a binary distribution, from the +binary directory run: + +.. code-block:: console + + cpack + +To specify the generator, use the :option:`-G ` option. For multi-config builds, +use :option:`-C ` to specify the configuration. For example: + +.. code-block:: console + + cpack -G ZIP -C Debug + +For a list of available generators, see :manual:`cpack-generators(7)` or call +:option:`cpack --help`. An :cpack_gen:`archive generator ` +like ZIP creates a compressed archive of all *installed* files. + +To create an archive of the *full* source tree you would type: + +.. code-block:: console + + cpack --config CPackSourceConfig.cmake + +Alternatively, run ``make package`` or right click the ``Package`` target and +``Build Project`` from an IDE. + +Run the installer found in the binary directory. Then run the installed +executable and verify that it works. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Selecting Static or Shared Libraries.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Selecting Static or Shared Libraries.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..504e42fd58d3117843a3b1f0e3584de921d9baf5 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/Selecting Static or Shared Libraries.rst.txt @@ -0,0 +1,50 @@ +Step 10: Selecting Static or Shared Libraries +============================================= + +In this section we will show how the :variable:`BUILD_SHARED_LIBS` variable can +be used to control the default behavior of :command:`add_library`, +and allow control over how libraries without an explicit type (``STATIC``, +``SHARED``, ``MODULE`` or ``OBJECT``) are built. + +To accomplish this we need to add :variable:`BUILD_SHARED_LIBS` to the +top-level ``CMakeLists.txt``. We use the :command:`option` command as it allows +users to optionally select if the value should be ``ON`` or ``OFF``. + +.. literalinclude:: Step11/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-option-BUILD_SHARED_LIBS + :language: cmake + :start-after: set(CMAKE_RUNTIME_OUTPUT_DIRECTORY + :end-before: # configure a header file to pass the version number only + +Next, we need to specify output directories for our static and shared +libraries. + +.. literalinclude:: Step11/CMakeLists.txt + :caption: CMakeLists.txt + :name: CMakeLists.txt-cmake-output-directories + :language: cmake + :start-after: # we don't need to tinker with the path to run the executable + :end-before: # configure a header file to pass the version number only + +Finally, update ``MathFunctions/MathFunctions.h`` to use dll export defines: + +.. literalinclude:: Step11/MathFunctions/MathFunctions.h + :caption: MathFunctions/MathFunctions.h + :name: MathFunctions/MathFunctions.h + :language: c++ + +At this point, if you build everything, you may notice that linking fails +as we are combining a static library without position independent code with a +library that has position independent code. The solution to this is to +explicitly set the :prop_tgt:`POSITION_INDEPENDENT_CODE` target property of +SqrtLibrary to be ``True`` when building shared libraries. + +.. literalinclude:: Step11/MathFunctions/CMakeLists.txt + :caption: MathFunctions/CMakeLists.txt + :name: MathFunctions/CMakeLists.txt-POSITION_INDEPENDENT_CODE + :language: cmake + :lines: 37-42 + +**Exercise**: We modified ``MathFunctions.h`` to use dll export defines. +Using CMake documentation can you find a helper module to simplify this? diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/index.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/index.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..1ab00093d4405c267845df9ceab2bd5fcd6b4c02 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/tutorial/index.rst.txt @@ -0,0 +1,44 @@ +CMake Tutorial +************** + +Introduction +============ + +The CMake tutorial provides a step-by-step guide that covers common build +system issues that CMake helps address. Seeing how various topics all +work together in an example project can be very helpful. + +Steps +===== + +.. include:: source.txt + +|tutorial_source| +Each step has its own subdirectory containing code that may be used as a +starting point. The tutorial examples are progressive so that each step +provides the complete solution for the previous step. + +.. toctree:: + :maxdepth: 2 + + A Basic Starting Point + Adding a Library + Adding Usage Requirements for a Library + Adding Generator Expressions + Installing and Testing + Adding Support for a Testing Dashboard + Adding System Introspection + Adding a Custom Command and Generated File + Packaging an Installer + Selecting Static or Shared Libraries + Adding Export Configuration + Packaging Debug and Release + +.. + Whenever a step above is renamed or removed, leave forwarding text in + its original document file, and list it below to preserve old links + to cmake.org/cmake/help/latest/ URLs. + +.. toctree:: + :maxdepth: 1 + :hidden: diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/user-interaction/index.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/user-interaction/index.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..335599223a4424dee17a5583748d2d2a9f83da9c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/user-interaction/index.rst.txt @@ -0,0 +1,772 @@ +User Interaction Guide +********************** + +.. only:: html + + .. contents:: + +Introduction +============ + +Where a software package supplies a CMake-based buildsystem +with the source of their software, the consumer of the +software is required to run a CMake user interaction tool +in order to build it. + +Well-behaved CMake-based buildsystems do not create any +output in the source directory, so typically, the user +performs an out-of-source build and performs the build +there. First, CMake must be instructed to generate a +suitable buildsystem, then the user invokes a build tool +to process that generated buildsystem. The generated +buildsystem is specific to the machine used to generate +it and is not redistributable. Each consumer of a provided +source software package is required to use CMake to +generate a buildsystem specific to their system. + +Generated buildsystems should generally be treated as +read-only. The CMake files as a primary artifact should +completely specify the buildsystem and there should be no +reason to populate properties manually in an IDE for +example after generating the buildsystem. CMake will +periodically rewrite the generated buildsystem, so +modifications by users will be overwritten. + +The features and user interfaces described in this manual +are available for all CMake-based build systems by virtue +of providing CMake files. + +The CMake tooling may report errors to the user when +processing provided CMake files, such as reporting that +the compiler is not supported, or the compiler does not +support a required compile option, or a dependency can +not be found. These errors must be resolved by the user +by choosing a different compiler, +:guide:`installing dependencies `, +or instructing CMake where to find them, etc. + +Command Line cmake tool +----------------------- + +A simple but typical use of :manual:`cmake(1)` with a fresh +copy of software source code is to create a build directory +and invoke cmake there: + +.. code-block:: console + + $ cd some_software-1.4.2 + $ mkdir build + $ cd build + $ cmake .. -DCMAKE_INSTALL_PREFIX=/opt/the/prefix + $ cmake --build . + $ cmake --build . --target install + +It is recommended to build in a separate directory to the +source because that keeps the source directory pristine, +allows for building a single source with multiple +toolchains, and allows easy clearing of build artifacts by +simply deleting the build directory. + +The CMake tooling may report warnings which are intended +for the provider of the software, not intended for the +consumer of the software. Such warnings end with "This +warning is for project developers". Users may disable +such warnings by passing the :option:`-Wno-dev ` +flag to :manual:`cmake(1)`. + +cmake-gui tool +-------------- + +Users more accustomed to GUI interfaces may use the +:manual:`cmake-gui(1)` tool to invoke CMake and generate +a buildsystem. + +The source and binary directories must first be +populated. It is always advised to use different +directories for the source and the build. + +.. image:: GUI-Source-Binary.png + :alt: Choosing source and binary directories + +Generating a Buildsystem +======================== + +There are several user interface tools which may be used +to generate a buildsystem from CMake files. The +:manual:`ccmake(1)` and :manual:`cmake-gui(1)` tools guide +the user through setting the various necessary options. +The :manual:`cmake(1)` tool can be invoked to specify +options on the command line. This manual describes options +which may be set using any of the user interface tools, +though the mode of setting an option is different for each +tool. + +Command line environment +------------------------ + +When invoking :manual:`cmake(1)` with a command line +buildsystem such as ``Makefiles`` or ``Ninja``, it is +necessary to use the correct build environment to +ensure that build tools are available. CMake must be +able to find the appropriate +:variable:`build tool `, +compiler, linker and other tools as needed. + +On Linux systems, the appropriate tools are often +provided in system-wide locations and may be readily +installed through the system package manager. Other +toolchains provided by the user or installed in +non-default locations can also be used. + +When cross-compiling, some platforms may require +environment variables to be set or may provide +scripts to set the environment. + +Visual Studio ships multiple command prompts and +``vcvarsall.bat`` scripts for setting up the +correct environments for command line buildsystems. While +not strictly necessary to use a corresponding +command line environment when using a Visual Studio +generator, doing so has no disadvantages. + +When using Xcode, there can be more than one Xcode +version installed. Which one to use can be selected +in a number of different ways, but the most common +methods are: + +* Setting the default version in the preferences + of the Xcode IDE. +* Setting the default version via the ``xcode-select`` + command line tool. +* Overriding the default version by setting the + ``DEVELOPER_DIR`` environment variable when running + CMake and the build tool. + +For convenience, :manual:`cmake-gui(1)` provides an +environment variable editor. + +Command line ``-G`` option +-------------------------- + +CMake chooses a generator by default based on the +platform. Usually, the default generator is sufficient +to allow the user to proceed to build the software. + +The user may override the default generator with +the :option:`-G ` option: + +.. code-block:: console + + $ cmake .. -G Ninja + +The output of :option:`cmake --help` includes a list of +:manual:`generators ` available +for the user to choose from. Note that generator +names are case sensitive. + +On Unix-like systems (including Mac OS X), the +:generator:`Unix Makefiles` generator is used by +default. A variant of that generator can also be used +on Windows in various environments, such as the +:generator:`NMake Makefiles` and +:generator:`MinGW Makefiles` generator. These generators +generate a ``Makefile`` variant which can be executed +with ``make``, ``gmake``, ``nmake`` or similar tools. +See the individual generator documentation for more +information on targeted environments and tools. + +The :generator:`Ninja` generator is available on all +major platforms. ``ninja`` is a build tool similar +in use-cases to ``make``, but with a focus on +performance and efficiency. + +On Windows, :manual:`cmake(1)` can be used to generate +solutions for the Visual Studio IDE. Visual Studio +versions may be specified by the product name of the +IDE, which includes a four-digit year. Aliases are +provided for other means by which Visual Studio +versions are sometimes referred to, such as two +digits which correspond to the product version of the +VisualC++ compiler, or a combination of the two: + +.. code-block:: console + + $ cmake .. -G "Visual Studio 2019" + $ cmake .. -G "Visual Studio 16" + $ cmake .. -G "Visual Studio 16 2019" + +Visual Studio generators can target different architectures. +One can specify the target architecture using the +:option:`-A ` option: + +.. code-block:: console + + cmake .. -G "Visual Studio 2019" -A x64 + cmake .. -G "Visual Studio 16" -A ARM + cmake .. -G "Visual Studio 16 2019" -A ARM64 + +On Apple, the :generator:`Xcode` generator may be used to +generate project files for the Xcode IDE. + +Some IDEs such as KDevelop4, QtCreator and CLion have +native support for CMake-based buildsystems. Those IDEs +provide user interface for selecting an underlying +generator to use, typically a choice between a ``Makefile`` +or a ``Ninja`` based generator. + +Note that it is not possible to change the generator +with :option:`-G ` after the first invocation of CMake. +To change the generator, the build directory must be +deleted and the build must be started from scratch. + +When generating Visual Studio project and solutions +files several other options are available to use when +initially running :manual:`cmake(1)`. + +The Visual Studio toolset can be specified with the +:option:`cmake -T` option: + +.. code-block:: console + + $ # Build with the clang-cl toolset + $ cmake.exe .. -G "Visual Studio 16 2019" -A x64 -T ClangCL + $ # Build targeting Windows XP + $ cmake.exe .. -G "Visual Studio 16 2019" -A x64 -T v120_xp + +Whereas the :option:`-A ` option specifies the _target_ +architecture, the :option:`-T ` option can be used to specify +details of the toolchain used. For example, ``-Thost=x64`` +can be given to select the 64-bit version of the host +tools. The following demonstrates how to use 64-bit +tools and also build for a 64-bit target architecture: + +.. code-block:: console + + $ cmake .. -G "Visual Studio 16 2019" -A x64 -Thost=x64 + +Choosing a generator in cmake-gui +--------------------------------- + +The "Configure" button triggers a new dialog to +select the CMake generator to use. + +.. image:: GUI-Configure-Dialog.png + :alt: Configuring a generator + +All generators available on the command line are also +available in :manual:`cmake-gui(1)`. + +.. image:: GUI-Choose-Generator.png + :alt: Choosing a generator + +When choosing a Visual Studio generator, further options +are available to set an architecture to generate for. + +.. image:: VS-Choose-Arch.png + :alt: Choosing an architecture for Visual Studio generators + +.. _`Setting Build Variables`: + +Setting Build Variables +======================= + +Software projects often require variables to be +set on the command line when invoking CMake. Some of +the most commonly used CMake variables are listed in +the table below: + +========================================== ============================================================ + Variable Meaning +========================================== ============================================================ + :variable:`CMAKE_PREFIX_PATH` Path to search for + :guide:`dependent packages ` + :variable:`CMAKE_MODULE_PATH` Path to search for additional CMake modules + :variable:`CMAKE_BUILD_TYPE` Build configuration, such as + ``Debug`` or ``Release``, determining + debug/optimization flags. This is only + relevant for single-configuration buildsystems such + as ``Makefile`` and ``Ninja``. Multi-configuration + buildsystems such as those for Visual Studio and Xcode + ignore this setting. + :variable:`CMAKE_INSTALL_PREFIX` Location to install the + software to with the + ``install`` build target + :variable:`CMAKE_TOOLCHAIN_FILE` File containing cross-compiling + data such as + :manual:`toolchains and sysroots `. + :variable:`BUILD_SHARED_LIBS` Whether to build shared + instead of static libraries + for :command:`add_library` + commands used without a type + :variable:`CMAKE_EXPORT_COMPILE_COMMANDS` Generate a ``compile_commands.json`` + file for use with clang-based tools +========================================== ============================================================ + +Other project-specific variables may be available +to control builds, such as enabling or disabling +components of the project. + +There is no convention provided by CMake for how +such variables are named between different +provided buildsystems, except that variables with +the prefix ``CMAKE_`` usually refer to options +provided by CMake itself and should not be used +in third-party options, which should use +their own prefix instead. The +:manual:`cmake-gui(1)` tool can display options +in groups defined by their prefix, so it makes +sense for third parties to ensure that they use a +self-consistent prefix. + +Setting variables on the command line +------------------------------------- + +CMake variables can be set on the command line either +when creating the initial build: + +.. code-block:: console + + $ mkdir build + $ cd build + $ cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Debug + +or later on a subsequent invocation of +:manual:`cmake(1)`: + +.. code-block:: console + + $ cd build + $ cmake . -DCMAKE_BUILD_TYPE=Debug + +The :option:`-U ` flag may be used to unset variables +on the :manual:`cmake(1)` command line: + +.. code-block:: console + + $ cd build + $ cmake . -UMyPackage_DIR + +A CMake buildsystem which was initially created +on the command line can be modified using the +:manual:`cmake-gui(1)` and vice-versa. + +The :manual:`cmake(1)` tool allows specifying a +file to use to populate the initial cache using +the :option:`-C ` option. This can be useful to simplify +commands and scripts which repeatedly require the +same cache entries. + +Setting variables with cmake-gui +-------------------------------- + +Variables may be set in the cmake-gui using the "Add Entry" +button. This triggers a new dialog to set the value of +the variable. + +.. image:: GUI-Add-Entry.png + :alt: Editing a cache entry + +The main view of the :manual:`cmake-gui(1)` user interface +can be used to edit existing variables. + +The CMake Cache +--------------- + +When CMake is executed, it needs to find the locations of +compilers, tools and dependencies. It also needs to be +able to consistently re-generate a buildsystem to use the +same compile/link flags and paths to dependencies. Such +parameters are also required to be configurable by the +user because they are paths and options specific to the +users system. + +When it is first executed, CMake generates a +``CMakeCache.txt`` file in the build directory containing +key-value pairs for such artifacts. The cache file can be +viewed or edited by the user by running the +:manual:`cmake-gui(1)` or :manual:`ccmake(1)` tool. The +tools provide an interactive interface for re-configuring +the provided software and re-generating the buildsystem, +as is needed after editing cached values. Each cache +entry may have an associated short help text which is +displayed in the user interface tools. + +The cache entries may also have a type to signify how it +should be presented in the user interface. For example, +a cache entry of type ``BOOL`` can be edited by a +checkbox in a user interface, a ``STRING`` can be edited +in a text field, and a ``FILEPATH`` while similar to a +``STRING`` should also provide a way to locate filesystem +paths using a file dialog. An entry of type ``STRING`` +may provide a restricted list of allowed values which are +then provided in a drop-down menu in the +:manual:`cmake-gui(1)` user interface (see the +:prop_cache:`STRINGS` cache property). + +The CMake files shipped with a software package may also +define boolean toggle options using the :command:`option` +command. The command creates a cache entry which has a +help text and a default value. Such cache entries are +typically specific to the provided software and affect +the configuration of the build, such as whether tests +and examples are built, whether to build with exceptions +enabled etc. + +Presets +======= + +CMake understands a file, ``CMakePresets.json``, and its +user-specific counterpart, ``CMakeUserPresets.json``, for +saving presets for commonly-used configure settings. These +presets can set the build directory, generator, cache +variables, environment variables, and other command-line +options. All of these options can be overridden by the +user. The full details of the ``CMakePresets.json`` format +are listed in the :manual:`cmake-presets(7)` manual. + +Using presets on the command-line +--------------------------------- + +When using the :manual:`cmake(1)` command line tool, a +preset can be invoked by using the :option:`--preset ` +option. If :option:`--preset ` is specified, +the generator and build directory are not required, but can be +specified to override them. For example, if you have the following +``CMakePresets.json`` file: + +.. code-block:: json + + { + "version": 1, + "configurePresets": [ + { + "name": "ninja-release", + "binaryDir": "${sourceDir}/build/${presetName}", + "generator": "Ninja", + "cacheVariables": { + "CMAKE_BUILD_TYPE": "Release" + } + } + ] + } + +and you run the following: + +.. code-block:: console + + cmake -S /path/to/source --preset=ninja-release + +This will generate a build directory in +``/path/to/source/build/ninja-release`` with the +:generator:`Ninja` generator, and with +:variable:`CMAKE_BUILD_TYPE` set to ``Release``. + +If you want to see the list of available presets, you can +run: + +.. code-block:: console + + cmake -S /path/to/source --list-presets + +This will list the presets available in +``/path/to/source/CMakePresets.json`` and +``/path/to/source/CMakeUsersPresets.json`` without +generating a build tree. + +Using presets in cmake-gui +-------------------------- + +If a project has presets available, either through +``CMakePresets.json`` or ``CMakeUserPresets.json``, the +list of presets will appear in a drop-down menu in +:manual:`cmake-gui(1)` between the source directory and +the binary directory. Choosing a preset sets the binary +directory, generator, environment variables, and cache +variables, but all of these options can be overridden after +a preset is selected. + +Invoking the Buildsystem +======================== + +After generating the buildsystem, the software can be +built by invoking the particular build tool. In the +case of the IDE generators, this can involve loading +the generated project file into the IDE to invoke the +build. + +CMake is aware of the specific build tool needed to invoke +a build so in general, to build a buildsystem or project +from the command line after generating, the following +command may be invoked in the build directory: + +.. code-block:: console + + $ cmake --build . + +The :option:`--build ` flag enables a +particular mode of operation for the :manual:`cmake(1)` +tool. It invokes the :variable:`CMAKE_MAKE_PROGRAM` +command associated with the +:manual:`generator `, or +the build tool configured by the user. + +The :option:`--build ` mode also accepts +the parameter :option:`--target ` to +specify a particular target to build, for example a +particular library, executable or custom target, or a +particular special target like ``install``: + +.. code-block:: console + + $ cmake --build . --target myexe + +The :option:`--build ` mode also accepts a +:option:`--config ` parameter +in the case of multi-config generators to specify which +particular configuration to build: + +.. code-block:: console + + $ cmake --build . --target myexe --config Release + +The :option:`--config ` option has no +effect if the generator generates a buildsystem specific +to a configuration which is chosen when invoking cmake +with the :variable:`CMAKE_BUILD_TYPE` variable. + +Some buildsystems omit details of command lines invoked +during the build. The :option:`--verbose ` +flag can be used to cause those command lines to be shown: + +.. code-block:: console + + $ cmake --build . --target myexe --verbose + +The :option:`--build ` mode can also pass +particular command line options to the underlying build +tool by listing them after ``--``. This can be useful +to specify options to the build tool, such as to continue the +build after a failed job, where CMake does not +provide a high-level user interface. + +For all generators, it is possible to run the underlying +build tool after invoking CMake. For example, ``make`` +may be executed after generating with the +:generator:`Unix Makefiles` generator to invoke the build, +or ``ninja`` after generating with the :generator:`Ninja` +generator etc. The IDE buildsystems usually provide +command line tooling for building a project which can +also be invoked. + +Selecting a Target +------------------ + +Each executable and library described in the CMake files +is a build target, and the buildsystem may describe +custom targets, either for internal use, or for user +consumption, for example to create documentation. + +CMake provides some built-in targets for all buildsystems +providing CMake files. + +``all`` + The default target used by ``Makefile`` and ``Ninja`` + generators. Builds all targets in the buildsystem, + except those which are excluded by their + :prop_tgt:`EXCLUDE_FROM_ALL` target property or + :prop_dir:`EXCLUDE_FROM_ALL` directory property. The + name ``ALL_BUILD`` is used for this purpose for the + Xcode and Visual Studio generators. +``help`` + Lists the targets available for build. This target is + available when using the :generator:`Unix Makefiles` or + :generator:`Ninja` generator, and the exact output is + tool-specific. +``clean`` + Delete built object files and other output files. The + ``Makefile`` based generators create a ``clean`` target + per directory, so that an individual directory can be + cleaned. The ``Ninja`` tool provides its own granular + ``-t clean`` system. +``test`` + Runs tests. This target is only automatically available + if the CMake files provide CTest-based tests. See also + `Running Tests`_. +``install`` + Installs the software. This target is only automatically + available if the software defines install rules with the + :command:`install` command. See also + `Software Installation`_. +``package`` + Creates a binary package. This target is only + automatically available if the CMake files provide + CPack-based packages. +``package_source`` + Creates a source package. This target is only + automatically available if the CMake files provide + CPack-based packages. + +For ``Makefile`` based systems, ``/fast`` variants of binary +build targets are provided. The ``/fast`` variants are used +to build the specified target without regard for its +dependencies. The dependencies are not checked and +are not rebuilt if out of date. The :generator:`Ninja` +generator is sufficiently fast at dependency checking that +such targets are not provided for that generator. + +``Makefile`` based systems also provide build-targets to +preprocess, assemble and compile individual files in a +particular directory. + +.. code-block:: console + + $ make foo.cpp.i + $ make foo.cpp.s + $ make foo.cpp.o + +The file extension is built into the name of the target +because another file with the same name but a different +extension may exist. However, build-targets without the +file extension are also provided. + +.. code-block:: console + + $ make foo.i + $ make foo.s + $ make foo.o + +In buildsystems which contain ``foo.c`` and ``foo.cpp``, +building the ``foo.i`` target will preprocess both files. + +Specifying a Build Program +-------------------------- + +The program invoked by the :option:`--build ` +mode is determined by the :variable:`CMAKE_MAKE_PROGRAM` variable. +For most generators, the particular program does not need to be +configured. + +===================== =========================== =========================== + Generator Default make program Alternatives +===================== =========================== =========================== + XCode ``xcodebuild`` + Unix Makefiles ``make`` + NMake Makefiles ``nmake`` ``jom`` + NMake Makefiles JOM ``jom`` ``nmake`` + MinGW Makefiles ``mingw32-make`` + MSYS Makefiles ``make`` + Ninja ``ninja`` + Visual Studio ``msbuild`` + Watcom WMake ``wmake`` +===================== =========================== =========================== + +The ``jom`` tool is capable of reading makefiles of the +``NMake`` flavor and building in parallel, while the +``nmake`` tool always builds serially. After generating +with the :generator:`NMake Makefiles` generator a user +can run ``jom`` instead of ``nmake``. The +:option:`--build ` +mode would also use ``jom`` if the +:variable:`CMAKE_MAKE_PROGRAM` was set to ``jom`` while +using the :generator:`NMake Makefiles` generator, and +as a convenience, the :generator:`NMake Makefiles JOM` +generator is provided to find ``jom`` in the normal way +and use it as the :variable:`CMAKE_MAKE_PROGRAM`. For +completeness, ``nmake`` is an alternative tool which +can process the output of the +:generator:`NMake Makefiles JOM` generator, but doing +so would be a pessimization. + +Software Installation +===================== + +The :variable:`CMAKE_INSTALL_PREFIX` variable can be +set in the CMake cache to specify where to install the +provided software. If the provided software has install +rules, specified using the :command:`install` command, +they will install artifacts into that prefix. On Windows, +the default installation location corresponds to the +``ProgramFiles`` system directory which may be +architecture specific. On Unix hosts, ``/usr/local`` is +the default installation location. + +The :variable:`CMAKE_INSTALL_PREFIX` variable always +refers to the installation prefix on the target +filesystem. + +In cross-compiling or packaging scenarios where the +sysroot is read-only or where the sysroot should otherwise +remain pristine, the :variable:`CMAKE_STAGING_PREFIX` +variable can be set to a location to actually install +the files. + +The commands: + +.. code-block:: console + + $ cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local \ + -DCMAKE_SYSROOT=$HOME/root \ + -DCMAKE_STAGING_PREFIX=/tmp/package + $ cmake --build . + $ cmake --build . --target install + +result in files being installed to paths such +as ``/tmp/package/lib/libfoo.so`` on the host machine. +The ``/usr/local`` location on the host machine is +not affected. + +Some provided software may specify ``uninstall`` rules, +but CMake does not generate such rules by default itself. + +Running Tests +============= + +The :manual:`ctest(1)` tool is shipped with the CMake +distribution to execute provided tests and report +results. The ``test`` build-target is provided to run +all available tests, but the :manual:`ctest(1)` tool +allows granular control over which tests to run, how to +run them, and how to report results. Executing +:manual:`ctest(1)` in the build directory is equivalent +to running the ``test`` target: + +.. code-block:: console + + $ ctest + +A regular expression can be passed to run only tests +which match the expression. To run only tests with +``Qt`` in their name: + +.. code-block:: console + + $ ctest -R Qt + +Tests can be excluded by regular expression too. To +run only tests without ``Qt`` in their name: + +.. code-block:: console + + $ ctest -E Qt + +Tests can be run in parallel by passing :option:`-j ` +arguments to :manual:`ctest(1)`: + +.. code-block:: console + + $ ctest -R Qt -j8 + +The environment variable :envvar:`CTEST_PARALLEL_LEVEL` +can alternatively be set to avoid the need to pass +:option:`-j `. + +By default :manual:`ctest(1)` does not print the output +from the tests. The command line argument :option:`-V ` +(or ``--verbose``) enables verbose mode to print the +output from all tests. +The :option:`--output-on-failure ` +option prints the test output for failing tests only. +The environment variable :envvar:`CTEST_OUTPUT_ON_FAILURE` +can be set to ``1`` as an alternative to passing the +:option:`--output-on-failure ` +option to :manual:`ctest(1)`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/using-dependencies/index.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/using-dependencies/index.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b270aad4866206618a9fe8a4f604476f8d704d3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/guide/using-dependencies/index.rst.txt @@ -0,0 +1,419 @@ +Using Dependencies Guide +************************ + +.. only:: html + + .. contents:: + +Introduction +============ + +Projects will frequently depend on other projects, assets, and artifacts. +CMake provides a number of ways to incorporate such things into the build. +Projects and users have the flexibility to choose between methods that +best suit their needs. + +The primary methods of bringing dependencies into the build are the +:command:`find_package` command and the :module:`FetchContent` module. +The :module:`FindPkgConfig` module is also sometimes used, although it +lacks some of the integration of the other two and is not discussed any +further in this guide. + +Dependencies can also be made available by a custom +:ref:`dependency provider `. +This might be a third party package manager, or it might be custom code +implemented by the developer. Dependency providers co-operate with the +primary methods mentioned above to extend their flexibility. + +.. _prebuilt_find_package: + +Using Pre-built Packages With ``find_package()`` +================================================ + +A package needed by the project may already be built and available at some +location on the user's system. That package might have also been built by +CMake, or it could have used a different build system entirely. It might +even just be a collection of files that didn't need to be built at all. +CMake provides the :command:`find_package` command for these scenarios. +It searches well-known locations, along with additional hints and paths +provided by the project or user. It also supports package components and +packages being optional. Result variables are provided to allow the project +to customize its own behavior according to whether the package or specific +components were found. + +In most cases, projects should generally use the :ref:`basic signature`. +Most of the time, this will involve just the package name, maybe a version +constraint, and the ``REQUIRED`` keyword if the dependency is not optional. +A set of package components may also be specified. + +.. code-block:: cmake + :caption: Examples of ``find_package()`` basic signature + + find_package(Catch2) + find_package(GTest REQUIRED) + find_package(Boost 1.79 COMPONENTS date_time) + +The :command:`find_package` command supports two main methods for carrying +out the search: + +**Config mode** + With this method, the command looks for files that are typically provided + by the package itself. This is the more reliable method of the two, since + the package details should always be in sync with the package. + +**Module mode** + Not all packages are CMake-aware. Many don't provide the files needed to + support config mode. For such cases, a Find module file can be provided + separately, either by the project or by CMake. A Find module is typically + a heuristic implementation which knows what the package normally provides + and how to present that package to the project. Since Find modules are + usually distributed separately from the package, they are not as reliable. + They are typically maintained separately, and they are likely to follow + different release schedules, so they can easily become out-of-date. + +Depending on the arguments used, :command:`find_package` may use one or both +of the above methods. By restricting the options to just the basic signature, +both config mode and module mode can be used to satisfy the dependency. +The presence of other options may restrict the call to using only one of the +two methods, potentially reducing the command's ability to find the dependency. +See the :command:`find_package` documentation for full details about this +complex topic. + +For both search methods, the user can also set cache variables on the +:manual:`cmake(1)` command line or in the :manual:`ccmake(1)` or +:manual:`cmake-gui(1)` UI tools to influence and override where to find +packages. See the :ref:`User Interaction Guide ` +for more on how to set cache variables. + +.. _Libraries providing Config-file packages: + +Config-file packages +-------------------- + +The preferred way for a third party to provide executables, libraries, +headers, and other files for use with CMake is to provide +:ref:`config files `. These are text files shipped +with the package, which define CMake targets, variables, commands, and so on. +The config file is an ordinary CMake script, which is read in by the +:command:`find_package` command. + +The config files can usually be found in a directory whose name matches the +pattern ``lib/cmake/``, although they may be in other locations +instead (see :ref:`search procedure`). The ```` is usually the +first argument to the :command:`find_package` command, and it may even be the +only argument. Alternative names can also be specified with the ``NAMES`` +option: + +.. code-block:: cmake + :caption: Providing alternative names when finding a package + + find_package(SomeThing + NAMES + SameThingOtherName # Another name for the package + SomeThing # Also still look for its canonical name + ) + +The config file must be named either ``Config.cmake`` or +``-config.cmake`` (the former is used for the remainder +of this guide, but both are supported). This file is the entry point +to the package for CMake. A separate optional file named +``ConfigVersion.cmake`` or +``-config-version.cmake`` may also exist in the same +directory. This file is used by CMake to determine whether the version of +the package satisfies any version constraint included in the call to +:command:`find_package`. It is optional to specify a version when calling +:command:`find_package`, even if a ``ConfigVersion.cmake`` +file is present. + +If the ``Config.cmake`` file is found and any version constraint +is satisfied, the :command:`find_package` command considers the package to be +found, and the entire package is assumed to be complete as designed. + +There may be additional files providing CMake commands or +:ref:`imported targets` for you to use. CMake does not enforce any naming +convention for these files. They are related to the primary +``Config.cmake`` file by use of the CMake :command:`include` +command. The ``Config.cmake`` file would typically include +these for you, so they won't usually require any additional step other than +the call to :command:`find_package`. + +If the location of the package is in a +:ref:`directory known to CMake `, the +:command:`find_package` call should succeed. The directories known to CMake +are platform-specific. For example, packages installed on Linux with a +standard system package manager will be found in the ``/usr`` prefix +automatically. Packages installed in ``Program Files`` on Windows will +similarly be found automatically. + +Packages will not be found automatically without help if they are in +locations not known to CMake, such as ``/opt/mylib`` or ``$HOME/dev/prefix``. +This is a normal situation, and CMake provides several ways for users to +specify where to find such libraries. + +The :variable:`CMAKE_PREFIX_PATH` variable may be +:ref:`set when invoking CMake `. +It is treated as a list of base paths in which to search for +:ref:`config files `. A package installed in +``/opt/somepackage`` will typically install config files such as +``/opt/somepackage/lib/cmake/somePackage/SomePackageConfig.cmake``. +In that case, ``/opt/somepackage`` should be added to +:variable:`CMAKE_PREFIX_PATH`. + +The environment variable ``CMAKE_PREFIX_PATH`` may also be populated with +prefixes to search for packages. Like the ``PATH`` environment variable, +this is a list, but it needs to use the platform-specific environment variable +list item separator (``:`` on Unix and ``;`` on Windows). + +The :variable:`CMAKE_PREFIX_PATH` variable provides convenience in cases +where multiple prefixes need to be specified, or when multiple packages +are available under the same prefix. Paths to packages may also be +specified by setting variables matching ``_DIR``, such as +``SomePackage_DIR``. Note that this is not a prefix, but should be a full +path to a directory containing a config-style package file, such as +``/opt/somepackage/lib/cmake/SomePackage`` in the above example. +See the :command:`find_package` documentation for other CMake variables and +environment variables that can affect the search. + +.. _Libraries not Providing Config-file Packages: + +Find Module Files +----------------- + +Packages which do not provide config files can still be found with the +:command:`find_package` command, if a ``FindSomePackage.cmake`` file is +available. These Find module files are different to config files in that: + +#. Find module files should not be provided by the package itself. +#. The availability of a ``Find.cmake`` file does not indicate + the availability of the package, or any particular part of the package. +#. CMake does not search the locations specified in the + :variable:`CMAKE_PREFIX_PATH` variable for ``Find.cmake`` + files. Instead, CMake searches for such files in the locations given + by the :variable:`CMAKE_MODULE_PATH` variable. It is common for users to + set the :variable:`CMAKE_MODULE_PATH` when running CMake, and it is common + for CMake projects to append to :variable:`CMAKE_MODULE_PATH` to allow use + of local Find module files. +#. CMake ships ``Find.cmake`` files for some + :manual:`third party packages `. These files are a + maintenance burden for CMake, and it is not unusual for these to fall + behind the latest releases of the packages they are associated with. + In general, new Find modules are not added to CMake any more. Projects + should encourage the upstream packages to provide a config file where + possible. If that is unsuccessful, the project should provide its own + Find module for the package. + +See :ref:`Find Modules` for a detailed discussion of how to write a +Find module file. + +.. _Imported Targets from Packages: + +Imported Targets +---------------- + +Both config files and Find module files can define :ref:`Imported targets`. +These will typically have names of the form ``SomePrefix::ThingName``. +Where these are available, the project should prefer to use them instead of +any CMake variables that may also be provided. Such targets typically carry +usage requirements and apply things like header search paths, compiler +definitions, etc. automatically to other targets that link to them (e.g. using +:command:`target_link_libraries`). This is both more robust and more +convenient than trying to apply the same things manually using variables. +Check the documentation for the package or Find module to see what imported +targets it defines, if any. + +Imported targets should also encapsulate any configuration-specific paths. +This includes the location of binaries (libraries, executables), compiler +flags, and any other configuration-dependent quantities. Find modules may +be less reliable in providing these details than config files. + +A complete example which finds a third party package and uses a library +from it might look like the following: + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.10) + project(MyExeProject VERSION 1.0.0) + + # Make project-provided Find modules available + list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + + find_package(SomePackage REQUIRED) + add_executable(MyExe main.cpp) + target_link_libraries(MyExe PRIVATE SomePrefix::LibName) + +Note that the above call to :command:`find_package` could be resolved by +a config file or a Find module. It uses only the basic arguments supported +by the :ref:`basic signature`. A ``FindSomePackage.cmake`` file in the +``${CMAKE_CURRENT_SOURCE_DIR}/cmake`` directory would allow the +:command:`find_package` command to succeed using module mode, for example. +If no such module file is present, the system would be searched for a config +file. + + +Downloading And Building From Source With ``FetchContent`` +========================================================== + +Dependencies do not necessarily have to be pre-built in order to use them +with CMake. They can be built from sources as part of the main project. +The :module:`FetchContent` module provides functionality to download +content (typically sources, but can be anything) and add it to the main +project if the dependency also uses CMake. The dependency's sources will +be built along with the rest of the project, just as though the sources were +part of the project's own sources. + +The general pattern is that the project should first declare all the +dependencies it wants to use, then ask for them to be made available. +The following demonstrates the principle (see :ref:`fetch-content-examples` +for more): + +.. code-block:: cmake + + include(FetchContent) + FetchContent_Declare( + googletest + GIT_REPOSITORY https://github.com/google/googletest.git + GIT_TAG 703bd9caab50b139428cea1aaff9974ebee5742e # release-1.10.0 + ) + FetchContent_Declare( + Catch2 + GIT_REPOSITORY https://github.com/catchorg/Catch2.git + GIT_TAG 605a34765aa5d5ecbf476b4598a862ada971b0cc # v3.0.1 + ) + FetchContent_MakeAvailable(googletest Catch2) + +Various download methods are supported, including downloading and extracting +archives from a URL (a range of archive formats are supported), and a number +of repository formats including Git, Subversion, and Mercurial. +Custom download, update, and patch commands can also be used to support +arbitrary use cases. + +When a dependency is added to the project with :module:`FetchContent`, the +project links to the dependency's targets just like any other target from the +project. If the dependency provides namespaced targets of the form +``SomePrefix::ThingName``, the project should link to those rather than to +any non-namespaced targets. See the next section for why this is recommended. + +Not all dependencies can be brought into the project this way. Some +dependencies define targets whose names clash with other targets from the +project or other dependencies. Concrete executable and library targets +created by :command:`add_executable` and :command:`add_library` are global, +so each one must be unique across the whole build. If a dependency would +add a clashing target name, it cannot be brought directly into the build +with this method. + +``FetchContent`` And ``find_package()`` Integration +=================================================== + +.. versionadded:: 3.24 + +Some dependencies support being added by either :command:`find_package` or +:module:`FetchContent`. Such dependencies must ensure they define the same +namespaced targets in both installed and built-from-source scenarios. +A consuming project then links to those namespaced targets and can handle +both scenarios transparently, as long as the project does not use anything +else that isn't provided by both methods. + +The project can indicate it is happy to accept a dependency by either method +using the ``FIND_PACKAGE_ARGS`` option to :command:`FetchContent_Declare`. +This allows :command:`FetchContent_MakeAvailable` to try satisfying the +dependency with a call to :command:`find_package` first, using the arguments +after the ``FIND_PACKAGE_ARGS`` keyword, if any. If that doesn't find the +dependency, it is built from source as described previously instead. + +.. code-block:: cmake + + include(FetchContent) + FetchContent_Declare( + googletest + GIT_REPOSITORY https://github.com/google/googletest.git + GIT_TAG 703bd9caab50b139428cea1aaff9974ebee5742e # release-1.10.0 + FIND_PACKAGE_ARGS NAMES GTest + ) + FetchContent_MakeAvailable(googletest) + + add_executable(ThingUnitTest thing_ut.cpp) + target_link_libraries(ThingUnitTest GTest::gtest_main) + +The above example calls +:command:`find_package(googletest NAMES GTest) ` first. +CMake provides a :module:`FindGTest` module, so if that finds a GTest package +installed somewhere, it will make it available, and the dependency will not be +built from source. If no GTest package is found, it *will* be built from +source. In either case, the ``GTest::gtest_main`` target is expected to be +defined, so we link our unit test executable to that target. + +High-level control is also available through the +:variable:`FETCHCONTENT_TRY_FIND_PACKAGE_MODE` variable. This can be set to +``NEVER`` to disable all redirection to :command:`find_package`. It can be +set to ``ALWAYS`` to try :command:`find_package` even if ``FIND_PACKAGE_ARGS`` +was not specified (this should be used with caution). + +The project might also decide that a particular dependency must be built from +source. This might be needed if a patched or unreleased version of the +dependency is required, or to satisfy some policy that requires all +dependencies to be built from source. The project can enforce this by adding +the ``OVERRIDE_FIND_PACKAGE`` keyword to :command:`FetchContent_Declare`. +A call to :command:`find_package` for that dependency will then be redirected +to :command:`FetchContent_MakeAvailable` instead. + +.. code-block:: cmake + + include(FetchContent) + FetchContent_Declare( + Catch2 + URL https://intranet.mycomp.com/vendored/Catch2_2.13.4_patched.tgz + URL_HASH MD5=abc123... + OVERRIDE_FIND_PACKAGE + ) + + # The following is automatically redirected to FetchContent_MakeAvailable(Catch2) + find_package(Catch2) + +For more advanced use cases, see the +:variable:`CMAKE_FIND_PACKAGE_REDIRECTS_DIR` variable. + +.. _dependency_providers_overview: + +Dependency Providers +==================== + +.. versionadded:: 3.24 + +The preceding section discussed techniques that projects can use to specify +their dependencies. Ideally, the project shouldn't really care where a +dependency comes from, as long as it provides the things it expects (often +just some imported targets). The project says what it needs and may also +specify where to get it from, in the absence of any other details, so that it +can still be built out-of-the-box. + +The developer, on the other hand, may be much more interested in controlling +*how* a dependency is provided to the project. You might want to use a +particular version of a package that you built yourself. You might want +to use a third party package manager. You might want to redirect some +requests to a different URL on a system you control for security or +performance reasons. CMake supports these sort of scenarios through +:ref:`dependency_providers`. + +A dependency provider can be set to intercept :command:`find_package` and +:command:`FetchContent_MakeAvailable` calls. The provider is given an +opportunity to satisfy such requests before falling back to the built-in +implementation if the provider doesn't fulfill it. + +Only one dependency provider can be set, and it can only be set at a very +specific point early in the CMake run. +The :variable:`CMAKE_PROJECT_TOP_LEVEL_INCLUDES` variable lists CMake files +that will be read while processing the first :command:`project()` call (and +only that call). This is the only time a dependency provider may be set. +At most, one single provider is expected to be used throughout the whole +project. + +For some scenarios, the user wouldn't need to know the details of how the +dependency provider is set. A third party may provide a file that can be +added to :variable:`CMAKE_PROJECT_TOP_LEVEL_INCLUDES`, which will set up +the dependency provider on the user's behalf. This is the recommended +approach for package managers. The developer can use such a file like so:: + + cmake -DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=/path/to/package_manager/setup.cmake ... + +For details on how to implement your own custom dependency provider, see the +:command:`cmake_language(SET_DEPENDENCY_PROVIDER)` command. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/ADVANCED.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/ADVANCED.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ec4de9d8552b70f087881cd1cd7592d78142430b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/ADVANCED.rst.txt @@ -0,0 +1,8 @@ +ADVANCED +-------- + +True if entry should be hidden by default in GUIs. + +This is a boolean value indicating whether the entry is considered +interesting only for advanced configuration. The :command:`mark_as_advanced` +command modifies this property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/HELPSTRING.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/HELPSTRING.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..71a86d0551d021a096dd0b673fa85e19fc9c07a1 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/HELPSTRING.rst.txt @@ -0,0 +1,7 @@ +HELPSTRING +---------- + +Help associated with entry in GUIs. + +This string summarizes the purpose of an entry to help users set it +through a CMake GUI. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/MODIFIED.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/MODIFIED.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3ad70354daf8b359809788722f3c7e22e92e6082 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/MODIFIED.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/STRINGS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/STRINGS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0e3c326d2c68ee59b91c3504664d36addbb3dce2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/STRINGS.rst.txt @@ -0,0 +1,9 @@ +STRINGS +------- + +Enumerate possible ``STRING`` entry values for GUI selection. + +For cache entries with type ``STRING``, this enumerates a set of values. +CMake GUIs may use this to provide a selection widget instead of a +generic string entry field. This is for convenience only. CMake does +not enforce that the value matches one of those listed. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/TYPE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/TYPE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..7ca859f68b6d7671f21c3a0621fd18bbb41e7c2e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/TYPE.rst.txt @@ -0,0 +1,21 @@ +TYPE +---- + +Widget type for entry in GUIs. + +Cache entry values are always strings, but CMake GUIs present widgets +to help users set values. The GUIs use this property as a hint to +determine the widget type. Valid ``TYPE`` values are: + +:: + + BOOL = Boolean ON/OFF value. + PATH = Path to a directory. + FILEPATH = Path to a file. + STRING = Generic string value. + INTERNAL = Do not present in GUI at all. + STATIC = Value managed by CMake, do not change. + UNINITIALIZED = Type not yet specified. + +Generally the ``TYPE`` of a cache entry should be set by the command which +creates it ( :command:`set`, :command:`option`, :command:`find_library`, etc.). diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/VALUE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/VALUE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..59aabd431aa009aa925fcc697bf4f4d6771c3001 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_cache/VALUE.rst.txt @@ -0,0 +1,7 @@ +VALUE +----- + +Value of a cache entry. + +This property maps to the actual value of a cache entry. Setting this +property always sets the value without checking, so use with care. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ALLOW_DUPLICATE_CUSTOM_TARGETS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ALLOW_DUPLICATE_CUSTOM_TARGETS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..19775ff2dc6c4138a08d31fee09a496afc914949 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ALLOW_DUPLICATE_CUSTOM_TARGETS.rst.txt @@ -0,0 +1,21 @@ +ALLOW_DUPLICATE_CUSTOM_TARGETS +------------------------------ + +Allow duplicate custom targets to be created. + +Normally CMake requires that all targets built in a project have +globally unique logical names (see policy :policy:`CMP0002`). +This is necessary to generate meaningful project file names in +:generator:`Xcode` and :ref:`Visual Studio Generators` IDE +generators. It also allows the target names to be referenced +unambiguously. + +Makefile generators are capable of supporting duplicate :command:`add_custom_target` +names. For projects that care only about :ref:`Makefile Generators` and do +not wish to support :generator:`Xcode` or :ref:`Visual Studio Generators` IDE +generators, one may set this property to ``True`` +to allow duplicate custom targets. The property +allows multiple :command:`add_custom_target` command calls in different +directories to specify the same target name. However, setting this +property will cause non-Makefile generators to produce an error and +refuse to generate the project. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOGEN_SOURCE_GROUP.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOGEN_SOURCE_GROUP.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..600a64a400c23897c91332c21f0ca015a53c4dd4 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOGEN_SOURCE_GROUP.rst.txt @@ -0,0 +1,18 @@ +AUTOGEN_SOURCE_GROUP +-------------------- + +.. versionadded:: 3.9 + +Name of the :command:`source_group` for :prop_tgt:`AUTOMOC`, +:prop_tgt:`AUTORCC` and :prop_tgt:`AUTOUIC` generated files. + +Files generated by :prop_tgt:`AUTOMOC`, :prop_tgt:`AUTORCC` and +:prop_tgt:`AUTOUIC` are not always known at configure time and therefore can't +be passed to :command:`source_group`. +``AUTOGEN_SOURCE_GROUP`` can be used instead to generate or select +a source group for :prop_tgt:`AUTOMOC`, :prop_tgt:`AUTORCC` and +:prop_tgt:`AUTOUIC` generated files. + +For :prop_tgt:`AUTOMOC`, :prop_tgt:`AUTORCC` and :prop_tgt:`AUTOUIC` specific +overrides see :prop_gbl:`AUTOMOC_SOURCE_GROUP`, :prop_gbl:`AUTORCC_SOURCE_GROUP` +and :prop_gbl:`AUTOUIC_SOURCE_GROUP` respectively. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOGEN_TARGETS_FOLDER.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOGEN_TARGETS_FOLDER.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0b747b207405783ec7527a6ae164a334e90635bd --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOGEN_TARGETS_FOLDER.rst.txt @@ -0,0 +1,9 @@ +AUTOGEN_TARGETS_FOLDER +---------------------- + +Name of :prop_tgt:`FOLDER` for ``*_autogen`` targets that are added +automatically by CMake for targets for which :prop_tgt:`AUTOMOC` is enabled. + +If not set, CMake uses the :prop_tgt:`FOLDER` property of the parent target as a +default value for this property. See also the documentation for the +:prop_tgt:`FOLDER` target property and the :prop_tgt:`AUTOMOC` target property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOMOC_SOURCE_GROUP.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOMOC_SOURCE_GROUP.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a266fdebf4c3c3ab4cd814857f02e25876532540 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOMOC_SOURCE_GROUP.rst.txt @@ -0,0 +1,9 @@ +AUTOMOC_SOURCE_GROUP +-------------------- + +.. versionadded:: 3.9 + +Name of the :command:`source_group` for :prop_tgt:`AUTOMOC` generated files. + +When set this is used instead of :prop_gbl:`AUTOGEN_SOURCE_GROUP` for +files generated by :prop_tgt:`AUTOMOC`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOMOC_TARGETS_FOLDER.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOMOC_TARGETS_FOLDER.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..17666e45a1665dd4b79e821aa942f043ef5b1777 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOMOC_TARGETS_FOLDER.rst.txt @@ -0,0 +1,11 @@ +AUTOMOC_TARGETS_FOLDER +---------------------- + +Name of :prop_tgt:`FOLDER` for ``*_autogen`` targets that are added automatically by +CMake for targets for which :prop_tgt:`AUTOMOC` is enabled. + +This property is obsolete. Use :prop_gbl:`AUTOGEN_TARGETS_FOLDER` instead. + +If not set, CMake uses the :prop_tgt:`FOLDER` property of the parent target as a +default value for this property. See also the documentation for the +:prop_tgt:`FOLDER` target property and the :prop_tgt:`AUTOMOC` target property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTORCC_SOURCE_GROUP.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTORCC_SOURCE_GROUP.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..54ebabb0d8fe62b66b9549dc2115fc6a82cbec76 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTORCC_SOURCE_GROUP.rst.txt @@ -0,0 +1,9 @@ +AUTORCC_SOURCE_GROUP +-------------------- + +.. versionadded:: 3.9 + +Name of the :command:`source_group` for :prop_tgt:`AUTORCC` generated files. + +When set this is used instead of :prop_gbl:`AUTOGEN_SOURCE_GROUP` for +files generated by :prop_tgt:`AUTORCC`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOUIC_SOURCE_GROUP.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOUIC_SOURCE_GROUP.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..79ebfe0eccce8750e2592f13161546a52460486b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/AUTOUIC_SOURCE_GROUP.rst.txt @@ -0,0 +1,9 @@ +AUTOUIC_SOURCE_GROUP +-------------------- + +.. versionadded:: 3.21 + +Name of the :command:`source_group` for :prop_tgt:`AUTOUIC` generated files. + +When set this is used instead of :prop_gbl:`AUTOGEN_SOURCE_GROUP` for +files generated by :prop_tgt:`AUTOUIC`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_CUDA_KNOWN_FEATURES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_CUDA_KNOWN_FEATURES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a31ee3aae4c713660c49c134116d37d9942cdfec --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_CUDA_KNOWN_FEATURES.rst.txt @@ -0,0 +1,44 @@ +CMAKE_CUDA_KNOWN_FEATURES +------------------------- + +.. versionadded:: 3.17 + +List of CUDA features known to this version of CMake. + +The features listed in this global property may be known to be available to the +CUDA compiler. If the feature is available with the C++ compiler, it will +be listed in the :variable:`CMAKE_CUDA_COMPILE_FEATURES` variable. + +The features listed here may be used with the :command:`target_compile_features` +command. See the :manual:`cmake-compile-features(7)` manual for information on +compile features and a list of supported compilers. + + +The features known to this version of CMake are: + +``cuda_std_03`` + Compiler mode is at least CUDA/C++ 03. + +``cuda_std_11`` + Compiler mode is at least CUDA/C++ 11. + +``cuda_std_14`` + Compiler mode is at least CUDA/C++ 14. + +``cuda_std_17`` + Compiler mode is at least CUDA/C++ 17. + +``cuda_std_20`` + Compiler mode is at least CUDA/C++ 20. + +``cuda_std_23`` + .. versionadded:: 3.20 + + Compiler mode is at least CUDA/C++ 23. + +``cuda_std_26`` + .. versionadded:: 3.25 + + Compiler mode is at least CUDA/C++ 26. + +.. include:: CMAKE_LANG_STD_FLAGS.txt diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e54b927c4eeecf498f4fdce5010e185ec48ce570 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.rst.txt @@ -0,0 +1,367 @@ +CMAKE_CXX_KNOWN_FEATURES +------------------------ + +.. versionadded:: 3.1 + +List of C++ features known to this version of CMake. + +The features listed in this global property may be known to be available to the +C++ compiler. If the feature is available with the C++ compiler, it will +be listed in the :variable:`CMAKE_CXX_COMPILE_FEATURES` variable. + +The features listed here may be used with the :command:`target_compile_features` +command. See the :manual:`cmake-compile-features(7)` manual for information on +compile features and a list of supported compilers. + +The features known to this version of CMake are listed below. + +High level meta features indicating C++ standard support +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. versionadded:: 3.8 + +The following meta features indicate general support for the associated +language standard. It reflects the language support claimed by the compiler, +but it does not necessarily imply complete conformance to that standard. + +``cxx_std_98`` + Compiler mode is at least C++ 98. + +``cxx_std_11`` + Compiler mode is at least C++ 11. + +``cxx_std_14`` + Compiler mode is at least C++ 14. + +``cxx_std_17`` + Compiler mode is at least C++ 17. + +``cxx_std_20`` + .. versionadded:: 3.12 + + Compiler mode is at least C++ 20. + +``cxx_std_23`` + .. versionadded:: 3.20 + + Compiler mode is at least C++ 23. + +``cxx_std_26`` + .. versionadded:: 3.25 + + Compiler mode is at least C++ 26. + +.. include:: CMAKE_LANG_STD_FLAGS.txt + +Low level individual compile features +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +For C++ 11 and C++ 14, compilers were sometimes slow to implement certain +language features. CMake provided some individual compile features to help +projects determine whether specific features were available. These individual +features are now less relevant and projects should generally prefer to use the +high level meta features instead. Individual compile features are not provided +for C++ 17 or later. + +See the :manual:`cmake-compile-features(7)` manual for further discussion of +the use of individual compile features. + +Individual features from C++ 98 +""""""""""""""""""""""""""""""" + +``cxx_template_template_parameters`` + Template template parameters, as defined in ``ISO/IEC 14882:1998``. + + +Individual features from C++ 11 +""""""""""""""""""""""""""""""" + +``cxx_alias_templates`` + Template aliases, as defined in N2258_. + + .. _N2258: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf + +``cxx_alignas`` + Alignment control ``alignas``, as defined in N2341_. + + .. _N2341: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf + +``cxx_alignof`` + Alignment control ``alignof``, as defined in N2341_. + + .. _N2341: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf + +``cxx_attributes`` + Generic attributes, as defined in N2761_. + + .. _N2761: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf + +``cxx_auto_type`` + Automatic type deduction, as defined in N1984_. + + .. _N1984: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf + +``cxx_constexpr`` + Constant expressions, as defined in N2235_. + + .. _N2235: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf + + +``cxx_decltype_incomplete_return_types`` + Decltype on incomplete return types, as defined in N3276_. + + .. _N3276 : https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf + +``cxx_decltype`` + Decltype, as defined in N2343_. + + .. _N2343: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf + +``cxx_default_function_template_args`` + Default template arguments for function templates, as defined in DR226_ + + .. _DR226: https://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226 + +``cxx_defaulted_functions`` + Defaulted functions, as defined in N2346_. + + .. _N2346: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm + +``cxx_defaulted_move_initializers`` + Defaulted move initializers, as defined in N3053_. + + .. _N3053: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html + +``cxx_delegating_constructors`` + Delegating constructors, as defined in N1986_. + + .. _N1986: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf + +``cxx_deleted_functions`` + Deleted functions, as defined in N2346_. + + .. _N2346: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm + +``cxx_enum_forward_declarations`` + Enum forward declarations, as defined in N2764_. + + .. _N2764: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf + +``cxx_explicit_conversions`` + Explicit conversion operators, as defined in N2437_. + + .. _N2437: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf + +``cxx_extended_friend_declarations`` + Extended friend declarations, as defined in N1791_. + + .. _N1791: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf + +``cxx_extern_templates`` + Extern templates, as defined in N1987_. + + .. _N1987: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm + +``cxx_final`` + Override control ``final`` keyword, as defined in N2928_, N3206_ and N3272_. + + .. _N2928: https://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm + .. _N3206: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm + .. _N3272: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm + +``cxx_func_identifier`` + Predefined ``__func__`` identifier, as defined in N2340_. + + .. _N2340: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm + +``cxx_generalized_initializers`` + Initializer lists, as defined in N2672_. + + .. _N2672: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm + +``cxx_inheriting_constructors`` + Inheriting constructors, as defined in N2540_. + + .. _N2540: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm + +``cxx_inline_namespaces`` + Inline namespaces, as defined in N2535_. + + .. _N2535: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm + +``cxx_lambdas`` + Lambda functions, as defined in N2927_. + + .. _N2927: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2927.pdf + +``cxx_local_type_template_args`` + Local and unnamed types as template arguments, as defined in N2657_. + + .. _N2657: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm + +``cxx_long_long_type`` + ``long long`` type, as defined in N1811_. + + .. _N1811: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf + +``cxx_noexcept`` + Exception specifications, as defined in N3050_. + + .. _N3050: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html + +``cxx_nonstatic_member_init`` + Non-static data member initialization, as defined in N2756_. + + .. _N2756: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2756.htm + +``cxx_nullptr`` + Null pointer, as defined in N2431_. + + .. _N2431: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf + +``cxx_override`` + Override control ``override`` keyword, as defined in N2928_, N3206_ + and N3272_. + + .. _N2928: https://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm + .. _N3206: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm + .. _N3272: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm + +``cxx_range_for`` + Range-based for, as defined in N2930_. + + .. _N2930: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html + +``cxx_raw_string_literals`` + Raw string literals, as defined in N2442_. + + .. _N2442: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm + +``cxx_reference_qualified_functions`` + Reference qualified functions, as defined in N2439_. + + .. _N2439: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm + +``cxx_right_angle_brackets`` + Right angle bracket parsing, as defined in N1757_. + + .. _N1757: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html + +``cxx_rvalue_references`` + R-value references, as defined in N2118_. + + .. _N2118: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html + +``cxx_sizeof_member`` + Size of non-static data members, as defined in N2253_. + + .. _N2253: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html + +``cxx_static_assert`` + Static assert, as defined in N1720_. + + .. _N1720: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html + +``cxx_strong_enums`` + Strongly typed enums, as defined in N2347_. + + .. _N2347: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf + +``cxx_thread_local`` + Thread-local variables, as defined in N2659_. + + .. _N2659: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm + +``cxx_trailing_return_types`` + Automatic function return type, as defined in N2541_. + + .. _N2541: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm + +``cxx_unicode_literals`` + Unicode string literals, as defined in N2442_. + + .. _N2442: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm + +``cxx_uniform_initialization`` + Uniform initialization, as defined in N2640_. + + .. _N2640: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2640.pdf + +``cxx_unrestricted_unions`` + Unrestricted unions, as defined in N2544_. + + .. _N2544: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf + +``cxx_user_literals`` + User-defined literals, as defined in N2765_. + + .. _N2765: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf + +``cxx_variadic_macros`` + Variadic macros, as defined in N1653_. + + .. _N1653: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm + +``cxx_variadic_templates`` + Variadic templates, as defined in N2242_. + + .. _N2242: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf + + +Individual features from C++ 14 +""""""""""""""""""""""""""""""" + +``cxx_aggregate_default_initializers`` + Aggregate default initializers, as defined in N3605_. + + .. _N3605: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3605.html + +``cxx_attribute_deprecated`` + ``[[deprecated]]`` attribute, as defined in N3760_. + + .. _N3760: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3760.html + +``cxx_binary_literals`` + Binary literals, as defined in N3472_. + + .. _N3472: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf + +``cxx_contextual_conversions`` + Contextual conversions, as defined in N3323_. + + .. _N3323: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3323.pdf + +``cxx_decltype_auto`` + ``decltype(auto)`` semantics, as defined in N3638_. + + .. _N3638: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3638.html + +``cxx_digit_separators`` + Digit separators, as defined in N3781_. + + .. _N3781: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3781.pdf + +``cxx_generic_lambdas`` + Generic lambdas, as defined in N3649_. + + .. _N3649: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3649.html + +``cxx_lambda_init_captures`` + Initialized lambda captures, as defined in N3648_. + + .. _N3648: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3648.html + +``cxx_relaxed_constexpr`` + Relaxed constexpr, as defined in N3652_. + + .. _N3652: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html + +``cxx_return_type_deduction`` + Return type deduction on normal functions, as defined in N3386_. + + .. _N3386: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3386.html + +``cxx_variable_templates`` + Variable templates, as defined in N3651_. + + .. _N3651: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3651.pdf diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_C_KNOWN_FEATURES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_C_KNOWN_FEATURES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..7aca9e8342ae7380f9479dee717240f8e79e3317 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_C_KNOWN_FEATURES.rst.txt @@ -0,0 +1,57 @@ +CMAKE_C_KNOWN_FEATURES +---------------------- + +.. versionadded:: 3.1 + +List of C features known to this version of CMake. + +The features listed in this global property may be known to be available to the +C compiler. If the feature is available with the C compiler, it will +be listed in the :variable:`CMAKE_C_COMPILE_FEATURES` variable. + +The features listed here may be used with the :command:`target_compile_features` +command. See the :manual:`cmake-compile-features(7)` manual for information on +compile features and a list of supported compilers. + +The features known to this version of CMake are listed below. + +High level meta features indicating C standard support +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. versionadded:: 3.8 + +``c_std_90`` + Compiler mode is at least C 90. + +``c_std_99`` + Compiler mode is at least C 99. + +``c_std_11`` + Compiler mode is at least C 11. + +``c_std_17`` + .. versionadded:: 3.21 + + Compiler mode is at least C 17. + +``c_std_23`` + .. versionadded:: 3.21 + + Compiler mode is at least C 23. + +.. include:: CMAKE_LANG_STD_FLAGS.txt + +Low level individual compile features +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``c_function_prototypes`` + Function prototypes, as defined in ``ISO/IEC 9899:1990``. + +``c_restrict`` + ``restrict`` keyword, as defined in ``ISO/IEC 9899:1999``. + +``c_static_assert`` + Static assert, as defined in ``ISO/IEC 9899:2011``. + +``c_variadic_macros`` + Variadic macros, as defined in ``ISO/IEC 9899:1999``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_ROLE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_ROLE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3f4492f0c80453545532a4513d0c2cd269f7a795 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/CMAKE_ROLE.rst.txt @@ -0,0 +1,22 @@ +CMAKE_ROLE +---------- + +.. versionadded:: 3.14 + +Tells what mode the current running script is in. Could be one of several +values: + +``PROJECT`` + Running in project mode (processing a ``CMakeLists.txt`` file). + +``SCRIPT`` + Running in ``-P`` script mode. + +``FIND_PACKAGE`` + Running in ``--find-package`` mode. + +``CTEST`` + Running in CTest script mode. + +``CPACK`` + Running in CPack. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/DEBUG_CONFIGURATIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/DEBUG_CONFIGURATIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..fec6fdac86a6f269d7048bcaba2c6eb27d4826ba --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/DEBUG_CONFIGURATIONS.rst.txt @@ -0,0 +1,13 @@ +DEBUG_CONFIGURATIONS +-------------------- + +Specify which configurations are for debugging. + +The value must be a semi-colon separated list of configuration names. +Currently this property is used only by the :command:`target_link_libraries` +command. Additional uses may be defined in the future. + +This property must be set at the top level of the project and before +the first :command:`target_link_libraries` command invocation. If any entry in +the list does not match a valid configuration for the project the +behavior is undefined. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/DISABLED_FEATURES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/DISABLED_FEATURES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..882bbfacde2c5744903fce0c94088dd00c8367e9 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/DISABLED_FEATURES.rst.txt @@ -0,0 +1,11 @@ +DISABLED_FEATURES +----------------- + +List of features which are disabled during the CMake run. + +List of features which are disabled during the CMake run. By default +it contains the names of all packages which were not found. This is +determined using the ``_FOUND`` variables. Packages which are +searched ``QUIET`` are not listed. A project can add its own features to +this list. This property is used by the macros in +``FeatureSummary.cmake``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ECLIPSE_EXTRA_CPROJECT_CONTENTS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ECLIPSE_EXTRA_CPROJECT_CONTENTS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2f110a74e2f075a50cfad502824ab5bc26639aa6 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ECLIPSE_EXTRA_CPROJECT_CONTENTS.rst.txt @@ -0,0 +1,14 @@ +ECLIPSE_EXTRA_CPROJECT_CONTENTS +------------------------------- + +.. versionadded:: 3.12 + +Additional contents to be inserted into the generated Eclipse cproject file. + +The cproject file defines the CDT specific information. Some third party IDE's +are based on Eclipse with the addition of other information specific to that IDE. +Through this property, it is possible to add this additional contents to +the generated project. +It is expected to contain valid XML. + +Also see the :prop_gbl:`ECLIPSE_EXTRA_NATURES` property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ECLIPSE_EXTRA_NATURES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ECLIPSE_EXTRA_NATURES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a46575ffaa9cc7b5348807af146429b619cfdf0e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ECLIPSE_EXTRA_NATURES.rst.txt @@ -0,0 +1,10 @@ +ECLIPSE_EXTRA_NATURES +--------------------- + +List of natures to add to the generated Eclipse project file. + +Eclipse projects specify language plugins by using natures. This property +should be set to the unique identifier for a nature (which looks like a Java +package name). + +Also see the :prop_gbl:`ECLIPSE_EXTRA_CPROJECT_CONTENTS` property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ENABLED_FEATURES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ENABLED_FEATURES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..acbb3d0189bcaee74e39f3a9c8780947ec902332 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ENABLED_FEATURES.rst.txt @@ -0,0 +1,11 @@ +ENABLED_FEATURES +---------------- + +List of features which are enabled during the CMake run. + +List of features which are enabled during the CMake run. By default +it contains the names of all packages which were found. This is +determined using the ``_FOUND`` variables. Packages which are +searched ``QUIET`` are not listed. A project can add its own features to +this list. This property is used by the macros in +``FeatureSummary.cmake``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ENABLED_LANGUAGES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ENABLED_LANGUAGES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..43e3c09f7f9b1f689f67e2bd39c185cc79c64621 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/ENABLED_LANGUAGES.rst.txt @@ -0,0 +1,6 @@ +ENABLED_LANGUAGES +----------------- + +Read-only property that contains the list of currently enabled languages + +Set to list of currently enabled languages. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_LIB32_PATHS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_LIB32_PATHS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..f6cad66b8195d38d792ce641793d396b11c0c206 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_LIB32_PATHS.rst.txt @@ -0,0 +1,14 @@ +FIND_LIBRARY_USE_LIB32_PATHS +---------------------------- + +.. versionadded:: 3.7 + +Whether the :command:`find_library` command should automatically search +``lib32`` directories. + +``FIND_LIBRARY_USE_LIB32_PATHS`` is a boolean specifying whether the +:command:`find_library` command should automatically search the ``lib32`` +variant of directories called ``lib`` in the search path when building 32-bit +binaries. + +See also the :variable:`CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX` variable. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_LIB64_PATHS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_LIB64_PATHS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ed343ba41bd3a347942753ac49af5029e059688c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_LIB64_PATHS.rst.txt @@ -0,0 +1,12 @@ +FIND_LIBRARY_USE_LIB64_PATHS +---------------------------- + +Whether :command:`find_library` should automatically search lib64 +directories. + +FIND_LIBRARY_USE_LIB64_PATHS is a boolean specifying whether the +:command:`find_library` command should automatically search the lib64 +variant of directories called lib in the search path when building +64-bit binaries. + +See also the :variable:`CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX` variable. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_LIBX32_PATHS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_LIBX32_PATHS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..851f8590258b58c3059db0c5627c1116bda5d21e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_LIBX32_PATHS.rst.txt @@ -0,0 +1,14 @@ +FIND_LIBRARY_USE_LIBX32_PATHS +----------------------------- + +.. versionadded:: 3.9 + +Whether the :command:`find_library` command should automatically search +``libx32`` directories. + +``FIND_LIBRARY_USE_LIBX32_PATHS`` is a boolean specifying whether the +:command:`find_library` command should automatically search the ``libx32`` +variant of directories called ``lib`` in the search path when building +x32-abi binaries. + +See also the :variable:`CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX` variable. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_OPENBSD_VERSIONING.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_OPENBSD_VERSIONING.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..beb94ac4142ff42b472414a6a7852e76b75efbe7 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/FIND_LIBRARY_USE_OPENBSD_VERSIONING.rst.txt @@ -0,0 +1,10 @@ +FIND_LIBRARY_USE_OPENBSD_VERSIONING +----------------------------------- + +Whether :command:`find_library` should find OpenBSD-style shared +libraries. + +This property is a boolean specifying whether the +:command:`find_library` command should find shared libraries with +OpenBSD-style versioned extension: ".so..". The +property is set to true on OpenBSD and false on other platforms. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/GENERATOR_IS_MULTI_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/GENERATOR_IS_MULTI_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..761a1dd2a2d5c12cca778d05a0e719b182414a56 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/GENERATOR_IS_MULTI_CONFIG.rst.txt @@ -0,0 +1,15 @@ +GENERATOR_IS_MULTI_CONFIG +------------------------- + +.. versionadded:: 3.9 + +Read-only property that is true on multi-configuration generators. + +True when using a multi-configuration generator such as: + +* :generator:`Ninja Multi-Config` +* :ref:`Visual Studio Generators` +* :generator:`Xcode` + +Multi-config generators use :variable:`CMAKE_CONFIGURATION_TYPES` +as the set of configurations and ignore :variable:`CMAKE_BUILD_TYPE`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/GLOBAL_DEPENDS_DEBUG_MODE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/GLOBAL_DEPENDS_DEBUG_MODE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..832503b5129ea649df6a5413452bd23a0fa2147f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/GLOBAL_DEPENDS_DEBUG_MODE.rst.txt @@ -0,0 +1,8 @@ +GLOBAL_DEPENDS_DEBUG_MODE +------------------------- + +Enable global target dependency graph debug mode. + +CMake automatically analyzes the global inter-target dependency graph +at the beginning of native build system generation. This property +causes it to display details of its analysis to stderr. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/GLOBAL_DEPENDS_NO_CYCLES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/GLOBAL_DEPENDS_NO_CYCLES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d10661e6295280bb1a2b47d1e1750f1f562deea0 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/GLOBAL_DEPENDS_NO_CYCLES.rst.txt @@ -0,0 +1,10 @@ +GLOBAL_DEPENDS_NO_CYCLES +------------------------ + +Disallow global target dependency graph cycles. + +CMake automatically analyzes the global inter-target dependency graph +at the beginning of native build system generation. It reports an +error if the dependency graph contains a cycle that does not consist +of all STATIC library targets. This property tells CMake to disallow +all cycles completely, even among static libraries. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/IN_TRY_COMPILE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/IN_TRY_COMPILE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..fd2d2e196843a0a024fa993a8387dff1c0ba1f54 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/IN_TRY_COMPILE.rst.txt @@ -0,0 +1,7 @@ +IN_TRY_COMPILE +-------------- + +Read-only property that is true during a try-compile configuration. + +True when building a project inside a :command:`try_compile` or +:command:`try_run` command. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/JOB_POOLS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/JOB_POOLS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5dfe6de33df3eddb61c7aaf229a4ec21ca95b844 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/JOB_POOLS.rst.txt @@ -0,0 +1,31 @@ +JOB_POOLS +--------- + +Ninja only: List of available pools. + +A pool is a named integer property and defines the maximum number +of concurrent jobs which can be started by a rule assigned to the pool. +The ``JOB_POOLS`` property is a semicolon-separated list of +pairs using the syntax ``NAME=integer`` (without a space after the equality sign). + +For instance: + +.. code-block:: cmake + + set_property(GLOBAL PROPERTY JOB_POOLS two_jobs=2 ten_jobs=10) + +Defined pools could be used globally by setting +:variable:`CMAKE_JOB_POOL_COMPILE` and :variable:`CMAKE_JOB_POOL_LINK` +or per target by setting the target properties +:prop_tgt:`JOB_POOL_COMPILE` and :prop_tgt:`JOB_POOL_LINK`. +:command:`Custom commands ` and +:command:`custom targets ` can specify pools using the +option ``JOB_POOL``. +Using a pool that is not defined by ``JOB_POOLS`` causes +an error by ninja at build time. + +If not set, this property uses the value of the :variable:`CMAKE_JOB_POOLS` +variable. + +Build targets provided by CMake that are meant for individual interactive +use, such as ``install``, are placed in the ``console`` pool automatically. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/PACKAGES_FOUND.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/PACKAGES_FOUND.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..61cce1fd8d3002d8b9cd54a16cb2ed9f3185718b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/PACKAGES_FOUND.rst.txt @@ -0,0 +1,7 @@ +PACKAGES_FOUND +-------------- + +List of packages which were found during the CMake run. + +List of packages which were found during the CMake run. Whether a +package has been found is determined using the _FOUND variables. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/PACKAGES_NOT_FOUND.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/PACKAGES_NOT_FOUND.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ca3c5bac6f14819dbf81dc32b73a7ad0bed784c3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/PACKAGES_NOT_FOUND.rst.txt @@ -0,0 +1,7 @@ +PACKAGES_NOT_FOUND +------------------ + +List of packages which were not found during the CMake run. + +List of packages which were not found during the CMake run. Whether a +package has been found is determined using the _FOUND variables. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/PREDEFINED_TARGETS_FOLDER.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/PREDEFINED_TARGETS_FOLDER.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..bf8c9a354fc3a70e56f1ee5b60428558545e34ed --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/PREDEFINED_TARGETS_FOLDER.rst.txt @@ -0,0 +1,9 @@ +PREDEFINED_TARGETS_FOLDER +------------------------- + +Name of FOLDER for targets that are added automatically by CMake. + +If not set, CMake uses "CMakePredefinedTargets" as a default value for +this property. Targets such as INSTALL, PACKAGE and RUN_TESTS will be +organized into this FOLDER. See also the documentation for the +:prop_tgt:`FOLDER` target property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/REPORT_UNDEFINED_PROPERTIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/REPORT_UNDEFINED_PROPERTIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..29ba36557f04c55be07bf9236cf5da73b5b881b1 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/REPORT_UNDEFINED_PROPERTIES.rst.txt @@ -0,0 +1,8 @@ +REPORT_UNDEFINED_PROPERTIES +--------------------------- + +If set, report any undefined properties to this file. + +If this property is set to a filename then when CMake runs it will +report any properties or variables that were accessed but not defined +into the filename specified in this property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_LAUNCH_COMPILE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_LAUNCH_COMPILE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a43e9e554b26657118508f91773931bc14d391a5 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_LAUNCH_COMPILE.rst.txt @@ -0,0 +1,17 @@ +RULE_LAUNCH_COMPILE +------------------- + +Specify a launcher for compile rules. + +.. note:: + This property is intended for internal use by :manual:`ctest(1)`. Projects + and developers should use the :prop_tgt:`_COMPILER_LAUNCHER` target + properties or the associated :variable:`CMAKE__COMPILER_LAUNCHER` + variables instead. + +:ref:`Makefile Generators` and the :generator:`Ninja` generator prefix +compiler commands with the given launcher command line. +This is intended to allow launchers to intercept build problems +with high granularity. Other generators ignore this property +because their underlying build systems provide no hook to wrap +individual commands with a launcher. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_LAUNCH_CUSTOM.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_LAUNCH_CUSTOM.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b20c59bcc4234c1b550fc6bf0c3cbf250f5d920a --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_LAUNCH_CUSTOM.rst.txt @@ -0,0 +1,11 @@ +RULE_LAUNCH_CUSTOM +------------------ + +Specify a launcher for custom rules. + +:ref:`Makefile Generators` and the :generator:`Ninja` generator prefix +custom commands with the given launcher command line. +This is intended to allow launchers to intercept build problems +with high granularity. Other generators ignore this property +because their underlying build systems provide no hook to wrap +individual commands with a launcher. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_LAUNCH_LINK.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_LAUNCH_LINK.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..da376fe5faccb7268170914ba478e34927fd6a73 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_LAUNCH_LINK.rst.txt @@ -0,0 +1,17 @@ +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. + +:ref:`Makefile Generators` and the :generator:`Ninja` generator prefix +link and archive commands with the given launcher command line. +This is intended to allow launchers to intercept build problems +with high granularity. Other generators ignore this property +because their underlying build systems provide no hook to wrap +individual commands with a launcher. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_MESSAGES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_MESSAGES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a9734a73028ca1f6e67dbad64598265876cf6967 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/RULE_MESSAGES.rst.txt @@ -0,0 +1,13 @@ +RULE_MESSAGES +------------- + +Specify whether to report a message for each make rule. + +This property specifies whether Makefile generators should add a +progress message describing what each build rule does. If the +property is not set the default is ON. Set the property to OFF to +disable granular messages and report only as each target completes. +This is intended to allow scripted builds to avoid the build time cost +of detailed reports. If a :variable:`CMAKE_RULE_MESSAGES` cache entry exists +its value initializes the value of this property. Non-Makefile +generators currently ignore this property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/TARGET_ARCHIVES_MAY_BE_SHARED_LIBS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/TARGET_ARCHIVES_MAY_BE_SHARED_LIBS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..930febae718aba2a7c6252dea46380a0164afb8e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/TARGET_ARCHIVES_MAY_BE_SHARED_LIBS.rst.txt @@ -0,0 +1,7 @@ +TARGET_ARCHIVES_MAY_BE_SHARED_LIBS +---------------------------------- + +Set if shared libraries may be named like archives. + +On AIX shared libraries may be named "lib.a". This property is +set to true on such platforms. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/TARGET_MESSAGES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/TARGET_MESSAGES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..bb917723e33ea37940e959fa0ec2145cb1ce12f0 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/TARGET_MESSAGES.rst.txt @@ -0,0 +1,22 @@ +TARGET_MESSAGES +--------------- + +.. versionadded:: 3.4 + +Specify whether to report the completion of each target. + +This property specifies whether :ref:`Makefile Generators` should +add a progress message describing that each target has been completed. +If the property is not set the default is ``ON``. Set the property +to ``OFF`` to disable target completion messages. + +This option is intended to reduce build output when little or no +work needs to be done to bring the build tree up to date. + +If a ``CMAKE_TARGET_MESSAGES`` cache entry exists its value +initializes the value of this property. + +Non-Makefile generators currently ignore this property. + +See the counterpart property :prop_gbl:`RULE_MESSAGES` to disable +everything except for target completion messages. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/TARGET_SUPPORTS_SHARED_LIBS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/TARGET_SUPPORTS_SHARED_LIBS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..f6e89fb83339bc99a3b79d673992f54f939e8c77 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/TARGET_SUPPORTS_SHARED_LIBS.rst.txt @@ -0,0 +1,9 @@ +TARGET_SUPPORTS_SHARED_LIBS +--------------------------- + +Does the target platform support shared libraries. + +TARGET_SUPPORTS_SHARED_LIBS is a boolean specifying whether the target +platform supports shared libraries. Basically all current general +general purpose OS do so, the exception are usually embedded systems +with no or special OSs. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/USE_FOLDERS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/USE_FOLDERS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6f5a083fbcaeb73324209438958d69dacae42a56 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/USE_FOLDERS.rst.txt @@ -0,0 +1,17 @@ +USE_FOLDERS +----------- + +Controls whether to use the :prop_tgt:`FOLDER` target property to organize +targets into folders. The value of ``USE_FOLDERS`` at the end of the top level +``CMakeLists.txt`` file is what determines the behavior. + +.. versionchanged:: 3.26 + + CMake treats this property as ``ON`` by default. + See policy :policy:`CMP0143`. + +Not all CMake generators support recording folder details for targets. +The :generator:`Xcode` and :ref:`Visual Studio ` +generators are examples of generators that do. Similarly, not all IDEs +support presenting targets using folder hierarchies, even if the CMake +generator used provides the necessary information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/XCODE_EMIT_EFFECTIVE_PLATFORM_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/XCODE_EMIT_EFFECTIVE_PLATFORM_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..392b704f890da5752691e40ee7c2b3ad15419c69 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_gbl/XCODE_EMIT_EFFECTIVE_PLATFORM_NAME.rst.txt @@ -0,0 +1,27 @@ +XCODE_EMIT_EFFECTIVE_PLATFORM_NAME +---------------------------------- + +.. versionadded:: 3.8 + +Control emission of ``EFFECTIVE_PLATFORM_NAME`` by the :generator:`Xcode` +generator. + +It is required for building the same target with multiple SDKs. A +common use case is the parallel use of ``iphoneos`` and +``iphonesimulator`` SDKs. + +Three different states possible that control when the :generator:`Xcode` +generator emits the ``EFFECTIVE_PLATFORM_NAME`` variable: + +- If set to ``ON`` it will always be emitted +- If set to ``OFF`` it will never be emitted +- If unset (the default) it will only be emitted when the project was + configured for an embedded Xcode SDK like iOS, tvOS, watchOS or any + of the simulators. + +.. note:: + + When this behavior is enable for generated Xcode projects, the + ``EFFECTIVE_PLATFORM_NAME`` variable will leak into + :manual:`Generator expressions ` + like ``TARGET_FILE`` and will render those mostly unusable. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/ABSTRACT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/ABSTRACT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..339d11528752e38b7d721296b2c168542b323a67 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/ABSTRACT.rst.txt @@ -0,0 +1,9 @@ +ABSTRACT +-------- + +Is this source file an abstract class. + +A property on a source file that indicates if the source file +represents a class that is abstract. This only makes sense for +languages that have a notion of an abstract class and it is only used +by some tools that wrap classes into other languages. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/AUTORCC_OPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/AUTORCC_OPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2bec033e4657eb70200e526c8c1af149c6fc413b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/AUTORCC_OPTIONS.rst.txt @@ -0,0 +1,22 @@ +AUTORCC_OPTIONS +--------------- + +Additional options for ``rcc`` when using :prop_tgt:`AUTORCC` + +This property holds additional command line options which will be used when +``rcc`` is executed during the build via :prop_tgt:`AUTORCC`, i.e. it is equivalent to the +optional ``OPTIONS`` argument of the :module:`qt4_add_resources() ` macro. + +By default it is empty. + +The options set on the ``.qrc`` source file may override +:prop_tgt:`AUTORCC_OPTIONS` set on the target. + +EXAMPLE +^^^^^^^ + +.. code-block:: cmake + + # ... + set_property(SOURCE resources.qrc PROPERTY AUTORCC_OPTIONS "--compress;9") + # ... diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/AUTOUIC_OPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/AUTOUIC_OPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e2f47ecd291191a1076989bc104674e921a3495c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/AUTOUIC_OPTIONS.rst.txt @@ -0,0 +1,23 @@ +AUTOUIC_OPTIONS +--------------- + +Additional options for ``uic`` when using :prop_tgt:`AUTOUIC` + +This property holds additional command line options +which will be used when ``uic`` is executed during the build via +:prop_tgt:`AUTOUIC`, i.e. it is equivalent to the optional ``OPTIONS`` +argument of the :module:`qt4_wrap_ui() ` macro. + +By default it is empty. + +The options set on the ``.ui`` source file may override +:prop_tgt:`AUTOUIC_OPTIONS` set on the target. + +EXAMPLE +^^^^^^^ + +.. code-block:: cmake + + # ... + set_property(SOURCE widget.ui PROPERTY AUTOUIC_OPTIONS "--no-protection") + # ... diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_DEFINITIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_DEFINITIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2af896ebf4b885502b57761443c256dee973afb4 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_DEFINITIONS.rst.txt @@ -0,0 +1,32 @@ +COMPILE_DEFINITIONS +------------------- + +Preprocessor definitions for compiling a source file. + +The ``COMPILE_DEFINITIONS`` property may be set to a semicolon-separated +list of preprocessor definitions using the syntax ``VAR`` or ``VAR=value``. +Function-style definitions are not supported. CMake will +automatically escape the value correctly for the native build system +(note that CMake language syntax may require escapes to specify some +values). This property may be set on a per-configuration basis using +the name ``COMPILE_DEFINITIONS_`` where ```` is an upper-case +name (ex. ``COMPILE_DEFINITIONS_DEBUG``). + +CMake will automatically drop some definitions that are not supported +by the native build tool. Xcode does not support per-configuration +definitions on source files. + +.. versionadded:: 3.26 + Any leading ``-D`` on an item will be removed. + +.. include:: /include/COMPILE_DEFINITIONS_DISCLAIMER.txt + +Contents of ``COMPILE_DEFINITIONS`` may use :manual:`cmake-generator-expressions(7)` +with the syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` +manual for available expressions. However, :generator:`Xcode` +does not support per-config per-source settings, so expressions +that depend on the build configuration are not allowed with that +generator. + +Generator expressions should be preferred instead of setting the alternative per-configuration +property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_DEFINITIONS_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_DEFINITIONS_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ec867b65d900d4719ba681c7c683ad890108cdab --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_DEFINITIONS_CONFIG.rst.txt @@ -0,0 +1,10 @@ +COMPILE_DEFINITIONS_ +---------------------------- + +Ignored. See CMake Policy :policy:`CMP0043`. + +Per-configuration preprocessor definitions on a source file. + +This is the configuration-specific version of :prop_tgt:`COMPILE_DEFINITIONS`. +Note that :generator:`Xcode` does not support per-configuration source +file flags so this property will be ignored by the :generator:`Xcode` generator. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_FLAGS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_FLAGS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..eefe7bff3a1bb1c71862d04598e0c80934e4c744 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_FLAGS.rst.txt @@ -0,0 +1,22 @@ +COMPILE_FLAGS +------------- + +Additional flags to be added when compiling this source file. + +The ``COMPILE_FLAGS`` property, managed as a string, sets additional compiler +flags used that will be added to the list of compile flags when this source +file builds. The flags will be added after target-wide flags (except in +some cases not supported by the :generator:`Visual Studio 9 2008` generator). + +Use :prop_sf:`COMPILE_DEFINITIONS` to pass additional preprocessor definitions. + +Contents of ``COMPILE_FLAGS`` may use "generator expressions" +with the syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` +manual for available expressions. However, :generator:`Xcode` +does not support per-config per-source settings, so expressions +that depend on the build configuration are not allowed with that +generator. + +.. note:: + + This property has been superseded by the :prop_sf:`COMPILE_OPTIONS` property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_OPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_OPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..84c543a2c175c60a0272c90ae1c348a32bc78585 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/COMPILE_OPTIONS.rst.txt @@ -0,0 +1,35 @@ +COMPILE_OPTIONS +--------------- + +.. versionadded:: 3.11 + +List of additional options to pass to the compiler. + +This property holds a :ref:`semicolon-separated list ` +of options and will be added to the list of compile flags when this source +file builds. The options will be added after target-wide options (except in +some cases not supported by the :generator:`Visual Studio 9 2008` generator). + +Contents of ``COMPILE_OPTIONS`` may use "generator expressions" with the +syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` manual +for available expressions. However, :generator:`Xcode` +does not support per-config per-source settings, so expressions +that depend on the build configuration are not allowed with that +generator. + +Usage example: + +.. code-block:: cmake + + set_source_files_properties(foo.cpp PROPERTIES COMPILE_OPTIONS "-Wno-unused-parameter;-Wno-missing-field-initializer") + +Related properties: + +* Prefer this property over :prop_sf:`COMPILE_FLAGS`. +* Use :prop_sf:`COMPILE_DEFINITIONS` to pass additional preprocessor definitions. +* Use :prop_sf:`INCLUDE_DIRECTORIES` to pass additional include directories. + +Related commands: + +* :command:`add_compile_options` for directory-wide settings +* :command:`target_compile_options` for target-specific settings diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/CXX_SCAN_FOR_MODULES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/CXX_SCAN_FOR_MODULES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5b704dccbdd647cb03cdb43f2371de39d09f27e6 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/CXX_SCAN_FOR_MODULES.rst.txt @@ -0,0 +1,23 @@ +CXX_SCAN_FOR_MODULES +-------------------- + +.. versionadded:: 3.26 + +``CXX_SCAN_FOR_MODULES`` is a boolean specifying whether CMake will scan the +source for C++ module dependencies. See also the +:prop_tgt:`CXX_SCAN_FOR_MODULES` for target-wide settings. + +When this property is set ``ON``, CMake will scan the source at build time and +add module dependency information to the compile line as necessary. When this +property is set ``OFF``, CMake will not scan the source at build time. When +this property is unset, the :prop_tgt:`CXX_SCAN_FOR_MODULES` property is +consulted. + +Note that scanning is only performed if C++20 or higher is enabled for the +target and the source uses the ``CXX`` language. Scanning for modules in +sources belonging to file sets of type ``CXX_MODULES`` is always performed. + +.. note :: + + This setting is meaningful only when experimental support for C++ modules + has been enabled by the ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API`` gate. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/EXTERNAL_OBJECT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/EXTERNAL_OBJECT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..351c04d515a61606fce2503dba536f108cc3ff4a --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/EXTERNAL_OBJECT.rst.txt @@ -0,0 +1,8 @@ +EXTERNAL_OBJECT +--------------- + +If set to true then this is an object file. + +If this property is set to ``True`` then the source file is really an +object file and should not be compiled. It will still be linked into +the target though. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Fortran_FORMAT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Fortran_FORMAT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ef33926190dbda93cce142241db13afb29a38106 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Fortran_FORMAT.rst.txt @@ -0,0 +1,12 @@ +Fortran_FORMAT +-------------- + +Set to ``FIXED`` or ``FREE`` to indicate the Fortran source layout. + +This property tells CMake whether a given Fortran source file uses +fixed-format or free-format. CMake will pass the corresponding format flag +to the compiler. Consider using the target-wide :prop_tgt:`Fortran_FORMAT` +property if all source files in a target share the same format. + +.. note:: For some compilers, ``NAG``, ``PGI`` and ``Solaris Studio``, + setting this to ``OFF`` will have no effect. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Fortran_PREPROCESS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Fortran_PREPROCESS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..548a97b147da35c8f281d558a95b68af72e820db --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Fortran_PREPROCESS.rst.txt @@ -0,0 +1,19 @@ +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. + +Consider using the target-wide :prop_tgt:`Fortran_PREPROCESS` property +if all source files in a target need to be preprocessed. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/GENERATED.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/GENERATED.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5ecc86cea89b0b8485a728207ad26cdbe6f50658 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/GENERATED.rst.txt @@ -0,0 +1,48 @@ +GENERATED +--------- + +Is this source file generated as part of the build or CMake process. + +.. versionchanged:: 3.20 + The GENERATED source file property is now visible in all directories. + +Tells the internal CMake engine that a source file is generated by an outside +process such as another build step, or the execution of CMake itself. +This information is then used to exempt the file from any existence or +validity checks. + +Any file that is + +- created by the execution of commands such as + :command:`add_custom_command` which run during the build +- listed as one of the ``BYPRODUCTS`` of an :command:`add_custom_command` + or :command:`add_custom_target` command, or +- created by a CMake ``AUTOGEN`` operation such as :prop_tgt:`AUTOMOC`, + :prop_tgt:`AUTORCC`, or :prop_tgt:`AUTOUIC` + +will be marked with the ``GENERATED`` property. + +When a generated file created as the ``OUTPUT`` of an +:command:`add_custom_command` command is explicitly listed as a source file +for any target in the same directory scope (which usually means the same +``CMakeLists.txt`` file), CMake will automatically create a dependency to +make sure the file is generated before building that target. + +The :ref:`Makefile Generators` will remove ``GENERATED`` files during +``make clean``. + +Generated sources may be hidden in some IDE tools, while in others they might +be shown. For the special case of sources generated by CMake's :prop_tgt:`AUTOMOC`, +:prop_tgt:`AUTORCC` or :prop_tgt:`AUTOUIC` functionality, the +:prop_gbl:`AUTOGEN_SOURCE_GROUP`, :prop_gbl:`AUTOMOC_SOURCE_GROUP`, +:prop_gbl:`AUTORCC_SOURCE_GROUP` and :prop_gbl:`AUTOUIC_SOURCE_GROUP` target +properties may influence where the generated sources are grouped in the project's +file lists. + +.. note:: + + Starting with CMake 3.20 the ``GENERATED`` source file property can be set + and retrieved from any directory scope. It is an all-or-nothing property. + It also can no longer be removed or unset if it was set to ``TRUE``. Policy + :policy:`CMP0118` was introduced to allow supporting the ``OLD`` behavior + for some time. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/HEADER_FILE_ONLY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/HEADER_FILE_ONLY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..71d62ae800f86162a1311c7ed8d3747a3fc7abb4 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/HEADER_FILE_ONLY.rst.txt @@ -0,0 +1,24 @@ +HEADER_FILE_ONLY +---------------- + +Is this source file only a header file. + +A property on a source file that indicates if the source file is a +header file with no associated implementation. This is set +automatically based on the file extension and is used by CMake to +determine if certain dependency information should be computed. + +By setting this property to ``ON``, you can disable compilation of +the given source file, even if it should be compiled because it is +part of the library's/executable's sources. + +This is useful if you have some source files which you somehow +pre-process, and then add these pre-processed sources via +:command:`add_library` or :command:`add_executable`. Normally, in IDE, +there would be no reference of the original sources, only of these +pre-processed sources. So by setting this property for all the original +source files to ``ON``, and then either calling :command:`add_library` +or :command:`add_executable` while passing both the pre-processed +sources and the original sources, or by using :command:`target_sources` +to add original source files will do exactly what would one expect, i.e. +the original source files would be visible in IDE, and will not be built. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/INCLUDE_DIRECTORIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/INCLUDE_DIRECTORIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..89ffd15605b072c508f6ce0b97d3588e8bab841b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/INCLUDE_DIRECTORIES.rst.txt @@ -0,0 +1,20 @@ +INCLUDE_DIRECTORIES +------------------- + +.. versionadded:: 3.11 + +List of preprocessor include file search directories. + +This property holds a :ref:`semicolon-separated list ` of paths +and will be added to the list of include directories when this +source file builds. These directories will take precedence over directories +defined at target level except for :generator:`Xcode` generator due to technical +limitations. + +Relative paths should not be added to this property directly. + +Contents of ``INCLUDE_DIRECTORIES`` may use "generator expressions" with +the syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` manual +for available expressions. However, :generator:`Xcode` does not support +per-config per-source settings, so expressions that depend on the build +configuration are not allowed with that generator. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/KEEP_EXTENSION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/KEEP_EXTENSION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a32f96834d12d65b54b3a26ebe89323fab934833 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/KEEP_EXTENSION.rst.txt @@ -0,0 +1,9 @@ +KEEP_EXTENSION +-------------- + +Make the output file have the same extension as the source file. + +If this property is set then the file extension of the output file +will be the same as that of the source file. Normally the output file +extension is computed based on the language of the source file, for +example ``.cxx`` will go to a ``.o`` extension. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/LABELS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/LABELS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d0d2a0a926e8d8713d1e060df3157f47e6ab8934 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/LABELS.rst.txt @@ -0,0 +1,8 @@ +LABELS +------ + +Specify a list of text labels associated with a source file. + +This property has meaning only when the source file is listed in a +target whose ``LABELS`` property is also set. No other semantics are +currently specified. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/LANGUAGE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/LANGUAGE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..92bd227e0f172e790a3c5b4d384f35bbd8d8ca76 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/LANGUAGE.rst.txt @@ -0,0 +1,17 @@ +LANGUAGE +-------- + +Specify the programming language in which a source file is written. + +A property that can be set to indicate what programming language the +source file is. If it is not set the language is determined based on +the file extension. Typical values are ``CXX`` (i.e. C++), ``C``, +``CSharp``, ``CUDA``, ``Fortran``, ``HIP``, ``ISPC``, and ``ASM``. Setting +this property for a file means this file will be compiled, unless +:prop_sf:`HEADER_FILE_ONLY` is set. + +.. versionchanged:: 3.20 + Setting this property causes the source file to be compiled as the + specified language, using explicit flags if possible. Previously it + only caused the specified language's compiler to be used. + See policy :policy:`CMP0119`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/LOCATION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/LOCATION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..252d6802404f8f4ebfca37193b76f39fcc8a183f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/LOCATION.rst.txt @@ -0,0 +1,7 @@ +LOCATION +-------- + +The full path to a source file. + +A read only property on a SOURCE FILE that contains the full path to +the source file. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/MACOSX_PACKAGE_LOCATION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/MACOSX_PACKAGE_LOCATION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d185d91978bf83d73f1cb79e34faf9dfd186768a --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/MACOSX_PACKAGE_LOCATION.rst.txt @@ -0,0 +1,30 @@ +MACOSX_PACKAGE_LOCATION +----------------------- + +Place a source file inside a Application Bundle +(:prop_tgt:`MACOSX_BUNDLE`), Core Foundation Bundle (:prop_tgt:`BUNDLE`), +or Framework Bundle (:prop_tgt:`FRAMEWORK`). It is applicable for macOS +and iOS. + +Executable targets with the :prop_tgt:`MACOSX_BUNDLE` property set are +built as macOS or iOS application bundles on Apple platforms. Shared +library targets with the :prop_tgt:`FRAMEWORK` property set are built as +macOS or iOS frameworks on Apple platforms. Module library targets with +the :prop_tgt:`BUNDLE` property set are built as macOS ``CFBundle`` bundles +on Apple platforms. Source files listed in the target with this property +set will be copied to a directory inside the bundle or framework content +folder specified by the property value. For macOS Application Bundles the +content folder is ``.app/Contents``. For macOS Frameworks the +content folder is ``.framework/Versions/``. For macOS +CFBundles the content folder is ``.bundle/Contents`` (unless the +extension is changed). See the :prop_tgt:`PUBLIC_HEADER`, +:prop_tgt:`PRIVATE_HEADER`, and :prop_tgt:`RESOURCE` target properties for +specifying files meant for ``Headers``, ``PrivateHeaders``, or +``Resources`` directories. + +If the specified location is equal to ``Resources``, the resulting location +will be the same as if the :prop_tgt:`RESOURCE` property had been used. If +the specified location is a sub-folder of ``Resources``, it will be placed +into the respective sub-folder. Note: For iOS Apple uses a flat bundle layout +where no ``Resources`` folder exist. Therefore CMake strips the ``Resources`` +folder name from the specified location. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/OBJECT_DEPENDS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/OBJECT_DEPENDS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..aaff95659d1e8d7f362683f575a0e78f396a8d7e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/OBJECT_DEPENDS.rst.txt @@ -0,0 +1,21 @@ +OBJECT_DEPENDS +-------------- + +Additional files on which a compiled object file depends. + +Specifies a :ref:`semicolon-separated list ` of full-paths to +files on which any object files compiled from this source file depend. +On :ref:`Makefile Generators` and the :generator:`Ninja` generator an +object file will be recompiled if any of the named files is newer than it. +:ref:`Visual Studio Generators` and the :generator:`Xcode` generator +cannot implement such compilation dependencies. + +This property need not be used to specify the dependency of a source +file on a generated header file that it includes. Although the +property was originally introduced for this purpose, it is no longer +necessary. If the generated header file is created by a custom +command in the same target as the source file, the automatic +dependency scanning process will recognize the dependency. If the +generated header file is created by another target, an inter-target +dependency should be created with the :command:`add_dependencies` +command (if one does not already exist due to linking relationships). diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/OBJECT_OUTPUTS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/OBJECT_OUTPUTS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3e799ed88647f1b15991e8ce6176fff69df334b3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/OBJECT_OUTPUTS.rst.txt @@ -0,0 +1,12 @@ +OBJECT_OUTPUTS +-------------- + +Additional outputs for a :generator:`Ninja` or :ref:`Makefile Generators` rule. + +Additional outputs created by compilation of this source file. If any +of these outputs is missing the object will be recompiled. This is +supported only on the :generator:`Ninja` and :ref:`Makefile Generators` +and will be ignored on other generators. + +This property supports +:manual:`generator expressions `. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTOGEN.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTOGEN.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2173f59964f385596dc209280a3d83f0f2f4e096 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTOGEN.rst.txt @@ -0,0 +1,19 @@ +SKIP_AUTOGEN +------------ + +.. versionadded:: 3.8 + +Exclude the source file from :prop_tgt:`AUTOMOC`, :prop_tgt:`AUTOUIC` and +:prop_tgt:`AUTORCC` processing (for Qt projects). + +For finer exclusion control see :prop_sf:`SKIP_AUTOMOC`, +:prop_sf:`SKIP_AUTOUIC` and :prop_sf:`SKIP_AUTORCC`. + +EXAMPLE +^^^^^^^ + +.. code-block:: cmake + + # ... + set_property(SOURCE file.h PROPERTY SKIP_AUTOGEN ON) + # ... diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTOMOC.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTOMOC.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e92cfe0d70a5e4df93ba42369985b30a230f0a51 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTOMOC.rst.txt @@ -0,0 +1,17 @@ +SKIP_AUTOMOC +------------ + +.. versionadded:: 3.8 + +Exclude the source file from :prop_tgt:`AUTOMOC` processing (for Qt projects). + +For broader exclusion control see :prop_sf:`SKIP_AUTOGEN`. + +EXAMPLE +^^^^^^^ + +.. code-block:: cmake + + # ... + set_property(SOURCE file.h PROPERTY SKIP_AUTOMOC ON) + # ... diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTORCC.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTORCC.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2829c259dfbc8cf44e88dacb2085a4fa470b42e3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTORCC.rst.txt @@ -0,0 +1,17 @@ +SKIP_AUTORCC +------------ + +.. versionadded:: 3.8 + +Exclude the source file from :prop_tgt:`AUTORCC` processing (for Qt projects). + +For broader exclusion control see :prop_sf:`SKIP_AUTOGEN`. + +EXAMPLE +^^^^^^^ + +.. code-block:: cmake + + # ... + set_property(SOURCE file.qrc PROPERTY SKIP_AUTORCC ON) + # ... diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTOUIC.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTOUIC.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..45ed3f8a52902321d43352a9d98f49b68be361ee --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_AUTOUIC.rst.txt @@ -0,0 +1,22 @@ +SKIP_AUTOUIC +------------ + +.. versionadded:: 3.8 + +Exclude the source file from :prop_tgt:`AUTOUIC` processing (for Qt projects). + +``SKIP_AUTOUIC`` can be set on C++ header and source files and on +``.ui`` files. + +For broader exclusion control see :prop_sf:`SKIP_AUTOGEN`. + +EXAMPLE +^^^^^^^ + +.. code-block:: cmake + + # ... + set_property(SOURCE file.h PROPERTY SKIP_AUTOUIC ON) + set_property(SOURCE file.cpp PROPERTY SKIP_AUTOUIC ON) + set_property(SOURCE widget.ui PROPERTY SKIP_AUTOUIC ON) + # ... diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_LINTING.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_LINTING.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0e0a616f5efb8d2a981978da422356fbc98f4fbf --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_LINTING.rst.txt @@ -0,0 +1,42 @@ +SKIP_LINTING +------------ + +.. versionadded:: 3.27 + +This property allows you to exclude a specific source file +from the linting process. The linting process involves running +tools such as :prop_tgt:`_CPPLINT`, :prop_tgt:`_CLANG_TIDY`, +:prop_tgt:`_CPPCHECK`, and :prop_tgt:`_INCLUDE_WHAT_YOU_USE` +on the source files, as well as compiling header files as part of +:prop_tgt:`VERIFY_INTERFACE_HEADER_SETS`. By setting ``SKIP_LINTING`` on a +source file, the mentioned linting tools will not be executed for that +particular file. + +Example +^^^^^^^ + +Consider a C++ project that includes multiple source files, +such as ``main.cpp``, ``things.cpp``, and ``generatedBindings.cpp``. +In this example, you want to exclude the ``generatedBindings.cpp`` +file from the linting process. To achieve this, you can utilize +the ``SKIP_LINTING`` property with the :command:`set_source_files_properties` +command as shown below: + +.. code-block:: cmake + + add_executable(MyApp main.cpp things.cpp generatedBindings.cpp) + + set_source_files_properties(generatedBindings.cpp PROPERTIES + SKIP_LINTING ON + ) + +In the provided code snippet, the ``SKIP_LINTING`` property is set to true +for the ``generatedBindings.cpp`` source file. As a result, when the linting +tools specified by :prop_tgt:`_CPPLINT`, :prop_tgt:`_CLANG_TIDY`, +:prop_tgt:`_CPPCHECK`, or :prop_tgt:`_INCLUDE_WHAT_YOU_USE` +are executed, they will skip analyzing the ``generatedBindings.cpp`` file. + +By using the ``SKIP_LINTING`` property, you can selectively exclude specific +source files from the linting process. This allows you to focus the +linting tools on the relevant parts of your project, enhancing the efficiency +and effectiveness of the linting workflow. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_PRECOMPILE_HEADERS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_PRECOMPILE_HEADERS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..660de3fe404929da84e4942cc8747971623a4a2b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_PRECOMPILE_HEADERS.rst.txt @@ -0,0 +1,15 @@ +SKIP_PRECOMPILE_HEADERS +----------------------- + +.. versionadded:: 3.16 + +Is this source file skipped by :prop_tgt:`PRECOMPILE_HEADERS` feature. + +This property helps with build problems that one would run into +when using the :prop_tgt:`PRECOMPILE_HEADERS` feature. + +One example would be the usage of Objective-C (``*.m``) files, and +Objective-C++ (``*.mm``) files, which lead to compilation failure +because they are treated (in case of Ninja / Makefile generator) +as C, and CXX respectively. The precompile headers are not +compatible between languages. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_UNITY_BUILD_INCLUSION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_UNITY_BUILD_INCLUSION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ae526ac1d6999fb90de52c45a08c4aead7fdb3de --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SKIP_UNITY_BUILD_INCLUSION.rst.txt @@ -0,0 +1,13 @@ +SKIP_UNITY_BUILD_INCLUSION +-------------------------- + +.. versionadded:: 3.16 + +Setting this property to true ensures the source file will be skipped by +unity builds when its associated target has its :prop_tgt:`UNITY_BUILD` +property set to true. The source file will instead be compiled on its own +in the same way as it would with unity builds disabled. + +This property helps with "ODR (One definition rule)" problems where combining +a particular source file with others might lead to build errors or other +unintended side effects. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SYMBOLIC.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SYMBOLIC.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..8bebe30bb424a4b65408dcd030e7dc5186ca770b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/SYMBOLIC.rst.txt @@ -0,0 +1,8 @@ +SYMBOLIC +-------- + +Is this just a name for a rule. + +If ``SYMBOLIC`` (boolean) is set to ``True`` the build system will be informed +that the source file is not actually created on disk but instead used +as a symbolic name for a build rule. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Swift_DEPENDENCIES_FILE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Swift_DEPENDENCIES_FILE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a90c7ebcb6b11607092cf08c8cf4332e61872cf0 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Swift_DEPENDENCIES_FILE.rst.txt @@ -0,0 +1,7 @@ +Swift_DEPENDENCIES_FILE +----------------------- + +.. versionadded:: 3.15 + +This property sets the path for the Swift dependency file (swiftdeps) for the +source. If one is not specified, it will default to ``.swiftdeps``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Swift_DIAGNOSTICS_FILE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Swift_DIAGNOSTICS_FILE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..47d5ac378485401d39fe7b1c072db0d9ae85351f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/Swift_DIAGNOSTICS_FILE.rst.txt @@ -0,0 +1,6 @@ +Swift_DIAGNOSTICS_FILE +---------------------- + +.. versionadded:: 3.15 + +This property controls where the Swift diagnostics are serialized. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/UNITY_GROUP.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/UNITY_GROUP.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9c18b70587b380e9d3f9f7f1b5c674b8355b40e8 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/UNITY_GROUP.rst.txt @@ -0,0 +1,7 @@ +UNITY_GROUP +----------- + +.. versionadded:: 3.18 + +This property controls which *bucket* the source will be part of when +the :prop_tgt:`UNITY_BUILD_MODE` is set to ``GROUP``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_COPY_TO_OUT_DIR.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_COPY_TO_OUT_DIR.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ebc306113e6d56910408cc914e2e12630dad4cbc --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_COPY_TO_OUT_DIR.rst.txt @@ -0,0 +1,8 @@ +VS_COPY_TO_OUT_DIR +------------------ + +.. versionadded:: 3.8 + +Sets the ```` tag for a source file in a +Visual Studio project file. Valid values are ``Never``, ``Always`` +and ``PreserveNewest``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_CSHARP_tagname.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_CSHARP_tagname.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..77b1e16e8bc1160a32488d3689919642108a32b0 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_CSHARP_tagname.rst.txt @@ -0,0 +1,22 @@ +VS_CSHARP_ +------------------- + +.. versionadded:: 3.8 + +Visual Studio and CSharp source-file-specific configuration. + +Tell the :manual:`Visual Studio generators ` +to set the source file tag ```` +to a given value in the generated Visual Studio CSharp +project. Ignored on other generators and languages. This property +can be used to define dependencies between source files or set any +other Visual Studio specific parameters. + +Example usage: + +.. code-block:: cmake + + set_source_files_properties( + PROPERTIES + VS_CSHARP_DependentUpon + VS_CSHARP_SubType "Form") diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_DEPLOYMENT_CONTENT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_DEPLOYMENT_CONTENT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ee49b2736c9630b63992c840acc09ce1e56ead93 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_DEPLOYMENT_CONTENT.rst.txt @@ -0,0 +1,14 @@ +VS_DEPLOYMENT_CONTENT +--------------------- + +.. versionadded:: 3.1 + +Mark a source file as content for deployment with a Windows Phone or +Windows Store application when built with a +:manual:`Visual Studio generators `. +The value must evaluate to either ``1`` or ``0`` and may use +:manual:`generator expressions ` +to make the choice based on the build configuration. +The ``.vcxproj`` file entry for the source file will be +marked either ``DeploymentContent`` or ``ExcludedFromBuild`` +for values ``1`` and ``0``, respectively. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_DEPLOYMENT_LOCATION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_DEPLOYMENT_LOCATION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b17054488ab041fddb135ce7426dd0909399d6c6 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_DEPLOYMENT_LOCATION.rst.txt @@ -0,0 +1,11 @@ +VS_DEPLOYMENT_LOCATION +---------------------- + +.. versionadded:: 3.1 + +Specifies the deployment location for a content source file with a Windows +Phone or Windows Store application when built +with a :manual:`Visual Studio generators `. +This property is only applicable when using :prop_sf:`VS_DEPLOYMENT_CONTENT`. +The value represent the path relative to the app package and applies to all +configurations. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_INCLUDE_IN_VSIX.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_INCLUDE_IN_VSIX.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..16c56bfaad4c496576f0d723f1b39f9be46a1241 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_INCLUDE_IN_VSIX.rst.txt @@ -0,0 +1,8 @@ +VS_INCLUDE_IN_VSIX +------------------ + +.. versionadded:: 3.8 + +Boolean property to specify if the file should be included within a +VSIX (Visual Studio Integration Extension) extension package. +This is needed for development of Visual Studio extensions. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_RESOURCE_GENERATOR.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_RESOURCE_GENERATOR.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..c5bb4f60babf8b901b5fc42e4adf2fc4a8a2983e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_RESOURCE_GENERATOR.rst.txt @@ -0,0 +1,10 @@ +VS_RESOURCE_GENERATOR +--------------------- + +.. versionadded:: 3.8 + +This property allows to specify the resource generator to be used +on this file. It defaults to ``PublicResXFileCodeGenerator`` if +not set. + +This property only applies to C# projects. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SETTINGS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SETTINGS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..871e36e855d7bb69494571504111c2359d2f7bc5 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SETTINGS.rst.txt @@ -0,0 +1,25 @@ +VS_SETTINGS +----------- + +.. versionadded:: 3.18 + +Set any item metadata on a file. + +.. versionadded:: 3.22 + + This property is honored for all source file types. + Previously it worked only for non-built files. + +Takes a list of ``Key=Value`` pairs. Tells the Visual Studio generator to set +``Key`` to ``Value`` as item metadata on the file. + +For example: + +.. code-block:: cmake + + set_property(SOURCE file.hlsl PROPERTY VS_SETTINGS "Key=Value" "Key2=Value2") + +will set ``Key`` to ``Value`` and ``Key2`` to ``Value2`` on the +``file.hlsl`` item as metadata. + +:manual:`Generator expressions ` are supported. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_DISABLE_OPTIMIZATIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_DISABLE_OPTIMIZATIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6fb677833cd3750266a7c3e39b1b84cfb506aee6 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_DISABLE_OPTIMIZATIONS.rst.txt @@ -0,0 +1,8 @@ +VS_SHADER_DISABLE_OPTIMIZATIONS +------------------------------- + +.. versionadded:: 3.11 + +Disable compiler optimizations for an ``.hlsl`` source file. This adds the +``-Od`` flag to the command line for the FxCompiler tool. Specify the value +``true`` for this property to disable compiler optimizations. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_ENABLE_DEBUG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_ENABLE_DEBUG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9c8f9d7e8dc2d807d51fb9f8d48d9822cc2fc731 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_ENABLE_DEBUG.rst.txt @@ -0,0 +1,8 @@ +VS_SHADER_ENABLE_DEBUG +---------------------- + +.. versionadded:: 3.11 + +Enable debugging information for an ``.hlsl`` source file. This adds the +``-Zi`` flag to the command line for the FxCompiler tool. Specify the value +``true`` to generate debugging information for the compiled shader. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_ENTRYPOINT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_ENTRYPOINT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..4b311ba99d6ddc2f0887308ecce7e0c155973970 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_ENTRYPOINT.rst.txt @@ -0,0 +1,7 @@ +VS_SHADER_ENTRYPOINT +-------------------- + +.. versionadded:: 3.1 + +Specifies the name of the entry point for the shader of a ``.hlsl`` source +file. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_FLAGS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_FLAGS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..07f8497e88e571427f403f717824848c49331f53 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_FLAGS.rst.txt @@ -0,0 +1,6 @@ +VS_SHADER_FLAGS +--------------- + +.. versionadded:: 3.2 + +Set additional Visual Studio shader flags of a ``.hlsl`` source file. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_MODEL.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_MODEL.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..072df89aaf070f4d563790faa8a15134d89c17e1 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_MODEL.rst.txt @@ -0,0 +1,7 @@ +VS_SHADER_MODEL +--------------- + +.. versionadded:: 3.1 + +Specifies the shader model of a ``.hlsl`` source file. Some shader types can +only be used with recent shader models diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_OBJECT_FILE_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_OBJECT_FILE_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3647a5ed3abfa29caa249a5054112d134ee1ec46 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_OBJECT_FILE_NAME.rst.txt @@ -0,0 +1,8 @@ +VS_SHADER_OBJECT_FILE_NAME +-------------------------- + +.. versionadded:: 3.12 + +Specifies a file name for the compiled shader object file for an ``.hlsl`` +source file. This adds the ``-Fo`` flag to the command line for the FxCompiler +tool. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_OUTPUT_HEADER_FILE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_OUTPUT_HEADER_FILE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..4113a165d7fc047dcf7c1c561adc5c963c6c46e6 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_OUTPUT_HEADER_FILE.rst.txt @@ -0,0 +1,7 @@ +VS_SHADER_OUTPUT_HEADER_FILE +---------------------------- + +.. versionadded:: 3.10 + +Set filename for output header file containing object code of a ``.hlsl`` +source file. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_TYPE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_TYPE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3fb7e60265a9192629be6d476938ae9cb5692b10 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_TYPE.rst.txt @@ -0,0 +1,6 @@ +VS_SHADER_TYPE +-------------- + +.. versionadded:: 3.1 + +Set the Visual Studio shader type of a ``.hlsl`` source file. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_VARIABLE_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_VARIABLE_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3361b400163f00f0d8fbcfe7d6d2cda485540037 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_SHADER_VARIABLE_NAME.rst.txt @@ -0,0 +1,7 @@ +VS_SHADER_VARIABLE_NAME +----------------------- + +.. versionadded:: 3.10 + +Set name of variable in header file containing object code of a ``.hlsl`` +source file. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_TOOL_OVERRIDE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_TOOL_OVERRIDE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b2f41120fd9166130933fa80453a52e5a72f2e55 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_TOOL_OVERRIDE.rst.txt @@ -0,0 +1,7 @@ +VS_TOOL_OVERRIDE +---------------- + +.. versionadded:: 3.7 + +Override the default Visual Studio tool that will be applied to the source file +with a new tool not based on the extension of the file. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_XAML_TYPE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_XAML_TYPE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..612b07ba2211b0f28a5753c6080f6e588d13cc88 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/VS_XAML_TYPE.rst.txt @@ -0,0 +1,9 @@ +VS_XAML_TYPE +------------ + +.. versionadded:: 3.3 + +Mark a Extensible Application Markup Language (XAML) source file +as a different type than the default ``Page``. +The most common usage would be to set the default ``App.xaml`` file as +``ApplicationDefinition``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/WRAP_EXCLUDE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/WRAP_EXCLUDE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..638ff0398accc8c171e1e75c1e0df124746780db --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/WRAP_EXCLUDE.rst.txt @@ -0,0 +1,11 @@ +WRAP_EXCLUDE +------------ + +Exclude this source file from any code wrapping techniques. + +Some packages can wrap source files into alternate languages to +provide additional functionality. + +For example, C++ code can be wrapped into Java or Python, using SWIG. +If ``WRAP_EXCLUDE`` is set to ``True``, that indicates that this +source file should not be wrapped. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/XCODE_EXPLICIT_FILE_TYPE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/XCODE_EXPLICIT_FILE_TYPE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5a50d7dcf40daa423f685f4497f1b5a9e08f2a49 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/XCODE_EXPLICIT_FILE_TYPE.rst.txt @@ -0,0 +1,10 @@ +XCODE_EXPLICIT_FILE_TYPE +------------------------ + +.. versionadded:: 3.1 + +Set the :generator:`Xcode` ``explicitFileType`` attribute on its reference to a +source file. CMake computes a default based on file extension but +can be told explicitly with this property. + +See also :prop_sf:`XCODE_LAST_KNOWN_FILE_TYPE`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/XCODE_FILE_ATTRIBUTES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/XCODE_FILE_ATTRIBUTES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ba51e00ef59a5db37865a2a43decf9b45321b35c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/XCODE_FILE_ATTRIBUTES.rst.txt @@ -0,0 +1,13 @@ +XCODE_FILE_ATTRIBUTES +--------------------- + +.. versionadded:: 3.7 + +Add values to the :generator:`Xcode` ``ATTRIBUTES`` setting on its reference to a +source file. Among other things, this can be used to set the role on +a ``.mig`` file:: + + set_source_files_properties(defs.mig + PROPERTIES + XCODE_FILE_ATTRIBUTES "Client;Server" + ) diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/XCODE_LAST_KNOWN_FILE_TYPE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/XCODE_LAST_KNOWN_FILE_TYPE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0b84e314c3fd70c9c61b4460f3655c09b4129c21 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_sf/XCODE_LAST_KNOWN_FILE_TYPE.rst.txt @@ -0,0 +1,11 @@ +XCODE_LAST_KNOWN_FILE_TYPE +-------------------------- + +.. versionadded:: 3.1 + +Set the :generator:`Xcode` ``lastKnownFileType`` attribute on its reference to +a source file. CMake computes a default based on file extension but +can be told explicitly with this property. + +See also :prop_sf:`XCODE_EXPLICIT_FILE_TYPE`, which is preferred +over this property if set. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ADDITIONAL_CLEAN_FILES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ADDITIONAL_CLEAN_FILES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..dc87d23ef606abfcded8a608c29b90b8d3b01fe7 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ADDITIONAL_CLEAN_FILES.rst.txt @@ -0,0 +1,25 @@ +ADDITIONAL_CLEAN_FILES +---------------------- + +.. versionadded:: 3.15 + +A :ref:`;-list ` of files or directories that will be +removed as a part of the global ``clean`` target. It can be used to specify +files and directories that are generated as part of building the target or +that are directly associated with the target in some way (e.g. created as a +result of running the target). + +For custom targets, if such files can be captured as outputs or byproducts +instead, then that should be preferred over adding them to this property. +If an additional clean file is used by multiple targets or isn't +target-specific, then the :prop_dir:`ADDITIONAL_CLEAN_FILES` directory +property may be the more appropriate property to use. + +Relative paths are allowed and are interpreted relative to the +current binary directory. + +Contents of ``ADDITIONAL_CLEAN_FILES`` may use +:manual:`generator expressions `. + +This property only works for the :generator:`Ninja` and the Makefile +generators. It is ignored by other generators. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ALIAS_GLOBAL.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ALIAS_GLOBAL.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a8859c6b9ac4647ffba088a162b80eedd36e0313 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ALIAS_GLOBAL.rst.txt @@ -0,0 +1,19 @@ +ALIAS_GLOBAL +------------ + +.. versionadded:: 3.18 + +Read-only property indicating of whether an :ref:`ALIAS target ` +is globally visible. + +The boolean value of this property is ``TRUE`` for aliases to +:ref:`IMPORTED targets ` created +with the ``GLOBAL`` options to :command:`add_executable()` or +:command:`add_library()`, ``FALSE`` otherwise. It is undefined for +targets built within the project. + +.. note:: + + Promoting an :ref:`IMPORTED target ` from ``LOCAL`` + to ``GLOBAL`` scope by changing the value or :prop_tgt:`IMPORTED_GLOBAL` + target property do not change the scope of local aliases. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_API.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_API.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..7664f1833f2c4b877e418144298644c8680dfa33 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_API.rst.txt @@ -0,0 +1,10 @@ +ANDROID_API +----------- + +.. versionadded:: 3.1 + +When :ref:`Cross Compiling for Android with NVIDIA Nsight Tegra Visual Studio +Edition`, this property sets the Android target API version (e.g. ``15``). +The version number must be a positive decimal integer. This property is +initialized by the value of the :variable:`CMAKE_ANDROID_API` variable if +it is set when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_API_MIN.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_API_MIN.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..7ca2455ec2c11b31e82ef52f45fac0cbd5c893b3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_API_MIN.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_NATIVE_LIB_DEPENDENCIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_NATIVE_LIB_DEPENDENCIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3aa741f90ed3fce2d1ac7aa94f5f2c947099dc21 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_NATIVE_LIB_DEPENDENCIES.rst.txt @@ -0,0 +1,16 @@ +ANDROID_NATIVE_LIB_DEPENDENCIES +------------------------------- + +.. versionadded:: 3.4 + +Set the Android property that specifies the .so dependencies. +This is a string property. + +This property is initialized by the value of the +:variable:`CMAKE_ANDROID_NATIVE_LIB_DEPENDENCIES` variable if it is set +when a target is created. + +Contents of ``ANDROID_NATIVE_LIB_DEPENDENCIES`` may use +"generator expressions" with the syntax ``$<...>``. See the +:manual:`cmake-generator-expressions(7)` manual for +available expressions. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_PROCESS_MAX.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_PROCESS_MAX.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0b6aba7aa1d13a603169070bdbb6969606095e86 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_PROCESS_MAX.rst.txt @@ -0,0 +1,10 @@ +ANDROID_PROCESS_MAX +------------------- + +.. versionadded:: 3.4 + +Set the Android property that defines the maximum number of a +parallel Android NDK compiler processes (e.g. ``4``). +This property is initialized by the value of the +:variable:`CMAKE_ANDROID_PROCESS_MAX` variable if it is set +when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_PROGUARD.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_PROGUARD.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b5ce166a8841f63a40df02bb5c4d799f6537827f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_PROGUARD.rst.txt @@ -0,0 +1,11 @@ +ANDROID_PROGUARD +---------------- + +.. versionadded:: 3.4 + +When this property is set to true that enables the ProGuard tool to shrink, +optimize, and obfuscate the code by removing unused code and renaming +classes, fields, and methods with semantically obscure names. +This property is initialized by the value of the +:variable:`CMAKE_ANDROID_PROGUARD` variable if it is set +when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_SECURE_PROPS_PATH.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_SECURE_PROPS_PATH.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..f2ffa2e354939c79defc3cf7300b769dad152f8c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_SECURE_PROPS_PATH.rst.txt @@ -0,0 +1,10 @@ +ANDROID_SECURE_PROPS_PATH +------------------------- + +.. versionadded:: 3.4 + +Set the Android property that states the location of the secure properties file. +This is a string property that contains the file path. +This property is initialized by the value of the +:variable:`CMAKE_ANDROID_SECURE_PROPS_PATH` variable +if it is set when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_SKIP_ANT_STEP.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_SKIP_ANT_STEP.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..1a54bce91825935cfcac65487c67c61019d1c7b2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ANDROID_SKIP_ANT_STEP.rst.txt @@ -0,0 +1,8 @@ +ANDROID_SKIP_ANT_STEP +--------------------- + +.. versionadded:: 3.4 + +Set the Android property that defines whether or not to skip the Ant build step. +This is a boolean property initialized by the value of the +:variable:`CMAKE_ANDROID_SKIP_ANT_STEP` variable if it is set when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ARCHIVE_OUTPUT_DIRECTORY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ARCHIVE_OUTPUT_DIRECTORY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..abb627cdad7e94ac2b7041202a354bbcbcc0609e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ARCHIVE_OUTPUT_DIRECTORY.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ARCHIVE_OUTPUT_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ARCHIVE_OUTPUT_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..1f1c4671f1b1a1bd5d15f78898bc8506df7ecb1f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ARCHIVE_OUTPUT_NAME.rst.txt @@ -0,0 +1,11 @@ +ARCHIVE_OUTPUT_NAME +------------------- + +.. |XXX| replace:: :ref:`ARCHIVE ` +.. |xxx| replace:: archive +.. include:: XXX_OUTPUT_NAME.txt + +.. |IDEM| replace:: with the same name +.. include:: MACOS_IMPORT_FILES.txt + +See also the :prop_tgt:`ARCHIVE_OUTPUT_NAME_` target property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ARCHIVE_OUTPUT_NAME_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ARCHIVE_OUTPUT_NAME_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..4f62eb995350dbb778e5690f7344d32ffe55d290 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ARCHIVE_OUTPUT_NAME_CONFIG.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOGEN_ORIGIN_DEPENDS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOGEN_ORIGIN_DEPENDS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9350a4f014c07183c5511550d4bbd639c79fc1ed --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOGEN_ORIGIN_DEPENDS.rst.txt @@ -0,0 +1,40 @@ +AUTOGEN_ORIGIN_DEPENDS +---------------------- + +.. versionadded:: 3.14 + +Switch for forwarding origin target dependencies to the corresponding +``_autogen`` target. + +Targets which have their :prop_tgt:`AUTOMOC` or :prop_tgt:`AUTOUIC` property +``ON`` have a corresponding ``_autogen`` target which generates +``moc`` and ``uic`` files. As this ``_autogen`` target is created at +generate-time, it is not possible to define dependencies of it using +e.g. :command:`add_dependencies`. Instead the +``AUTOGEN_ORIGIN_DEPENDS`` target property decides whether the origin +target dependencies should be forwarded to the ``_autogen`` target or not. + +By default ``AUTOGEN_ORIGIN_DEPENDS`` is initialized from +:variable:`CMAKE_AUTOGEN_ORIGIN_DEPENDS` which is ``ON`` by default. + +In total the dependencies of the ``_autogen`` target are composed from + +- forwarded origin target dependencies + (enabled by default via ``AUTOGEN_ORIGIN_DEPENDS``) +- additional user defined dependencies from :prop_tgt:`AUTOGEN_TARGET_DEPENDS` + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. + +Note +^^^^ + +Disabling ``AUTOGEN_ORIGIN_DEPENDS`` is useful to avoid building of +origin target dependencies when building the ``_autogen`` target only. +This is especially interesting when a +:variable:`global autogen target ` is enabled. + +When the ``_autogen`` target doesn't require all the origin target's +dependencies, and ``AUTOGEN_ORIGIN_DEPENDS`` is disabled, it might be +necessary to extend :prop_tgt:`AUTOGEN_TARGET_DEPENDS` to add missing +dependencies. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOGEN_TARGET_DEPENDS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOGEN_TARGET_DEPENDS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5286d2d0b0b99f42f441f97e814c648bdd00c81c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOGEN_TARGET_DEPENDS.rst.txt @@ -0,0 +1,36 @@ +AUTOGEN_TARGET_DEPENDS +---------------------- + +Additional target dependencies of the corresponding ``_autogen`` target. + +Targets which have their :prop_tgt:`AUTOMOC` or :prop_tgt:`AUTOUIC` property +``ON`` have a corresponding ``_autogen`` target which generates +``moc`` and ``uic`` files. As this ``_autogen`` target is created at +generate-time, it is not possible to define dependencies of it using +e.g. :command:`add_dependencies`. Instead the +``AUTOGEN_TARGET_DEPENDS`` target property can be set to a +:ref:`;-list ` of additional dependencies for the +``_autogen`` target. Dependencies can be target names or file names. + +In total the dependencies of the ``_autogen`` target are composed from + +- forwarded origin target dependencies + (enabled by default via :prop_tgt:`AUTOGEN_ORIGIN_DEPENDS`) +- additional user defined dependencies from ``AUTOGEN_TARGET_DEPENDS`` + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. + +Use cases +^^^^^^^^^ + +If :prop_tgt:`AUTOMOC` or :prop_tgt:`AUTOUIC` depends on a file that is either + +- a :prop_sf:`GENERATED` non C++ file (e.g. a :prop_sf:`GENERATED` ``.json`` + or ``.ui`` file) or +- a :prop_sf:`GENERATED` C++ file that isn't recognized by :prop_tgt:`AUTOMOC` + and :prop_tgt:`AUTOUIC` because it's skipped by :prop_sf:`SKIP_AUTOMOC`, + :prop_sf:`SKIP_AUTOUIC`, :prop_sf:`SKIP_AUTOGEN` or :policy:`CMP0071` or +- a file that isn't in the origin target's sources + +it must be added to ``AUTOGEN_TARGET_DEPENDS``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOGEN_USE_SYSTEM_INCLUDE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOGEN_USE_SYSTEM_INCLUDE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..37d6276db4ff0619871d860d08383ce32f1b1487 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOGEN_USE_SYSTEM_INCLUDE.rst.txt @@ -0,0 +1,19 @@ +AUTOGEN_USE_SYSTEM_INCLUDE +-------------------------- + +.. versionadded:: 3.27 + +``AUTOGEN_USE_SYSTEM_INCLUDE`` is a boolean property that can be set +on a target to indicate that the autogen target include directory should +be added as a system include directory or normal include directory to the +target. + +If this property is not set, the autogen target include directory is added +as a system include directory by default. See policy :policy:`CMP0151`. + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. + +This property is initialized by the +:variable:`CMAKE_AUTOGEN_USE_SYSTEM_INCLUDE` variable if it is set when +a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_COMPILER_PREDEFINES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_COMPILER_PREDEFINES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..82aa61e8b3dd6843cdf5959321942f573d21b11c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_COMPILER_PREDEFINES.rst.txt @@ -0,0 +1,26 @@ +AUTOMOC_COMPILER_PREDEFINES +--------------------------- + +.. versionadded:: 3.10 + +Boolean value used by :prop_tgt:`AUTOMOC` to determine if the +compiler pre definitions file ``moc_predefs.h`` should be generated. + +CMake generates a ``moc_predefs.h`` file with compiler pre definitions +from the output of the command defined in +:variable:`CMAKE_CXX_COMPILER_PREDEFINES_COMMAND _COMPILER_PREDEFINES_COMMAND>` +when + +- :prop_tgt:`AUTOMOC` is enabled, +- ``AUTOMOC_COMPILER_PREDEFINES`` is enabled, +- :variable:`CMAKE_CXX_COMPILER_PREDEFINES_COMMAND _COMPILER_PREDEFINES_COMMAND>` isn't empty and +- the Qt version is greater or equal 5.8. + +The ``moc_predefs.h`` file, which is generated in :prop_tgt:`AUTOGEN_BUILD_DIR`, +is passed to ``moc`` as the argument to the ``--include`` option. + +By default ``AUTOMOC_COMPILER_PREDEFINES`` is initialized from +:variable:`CMAKE_AUTOMOC_COMPILER_PREDEFINES`, which is ON by default. + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_DEPEND_FILTERS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_DEPEND_FILTERS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..c4277d74cc9cf1929eaa00aa15cc883f4791823b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_DEPEND_FILTERS.rst.txt @@ -0,0 +1,109 @@ +AUTOMOC_DEPEND_FILTERS +---------------------- + +.. versionadded:: 3.9 + +Filter definitions used by :prop_tgt:`AUTOMOC` to extract file names from a +source file that are registered as additional dependencies for the +``moc`` file of the source file. + +Filters are defined as ``KEYWORD;REGULAR_EXPRESSION`` pairs. First the file +content is searched for ``KEYWORD``. If it is found at least once, then file +names are extracted by successively searching for ``REGULAR_EXPRESSION`` and +taking the first match group. + +The file name found in the first match group is searched for + +- first in the vicinity of the source file +- and afterwards in the target's :prop_tgt:`INCLUDE_DIRECTORIES`. + +If any of the extracted files changes, then the ``moc`` file for the source +file gets rebuilt even when the source file itself doesn't change. + +If any of the extracted files is :prop_sf:`GENERATED` or if it is not in the +target's sources, then it might be necessary to add it to the +``_autogen`` target dependencies. +See :prop_tgt:`AUTOGEN_TARGET_DEPENDS` for reference. + +By default ``AUTOMOC_DEPEND_FILTERS`` is initialized from +:variable:`CMAKE_AUTOMOC_DEPEND_FILTERS`, which is empty by default. + +From Qt 5.15.0 on this variable is ignored as moc is able to output the correct +dependencies. + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. + + +Example 1 +^^^^^^^^^ + +A header file ``my_class.hpp`` uses a custom macro ``JSON_FILE_MACRO`` which +is defined in an other header ``macros.hpp``. +We want the ``moc`` file of ``my_class.hpp`` to depend on the file name +argument of ``JSON_FILE_MACRO``:: + + // my_class.hpp + class My_Class : public QObject + { + Q_OBJECT + JSON_FILE_MACRO ( "info.json" ) + ... + }; + +In ``CMakeLists.txt`` we add a filter to +:variable:`CMAKE_AUTOMOC_DEPEND_FILTERS` like this:: + + list( APPEND CMAKE_AUTOMOC_DEPEND_FILTERS + "JSON_FILE_MACRO" + "[\n][ \t]*JSON_FILE_MACRO[ \t]*\\([ \t]*\"([^\"]+)\"" + ) + +We assume ``info.json`` is a plain (not :prop_sf:`GENERATED`) file that is +listed in the target's source. Therefore we do not need to add it to +:prop_tgt:`AUTOGEN_TARGET_DEPENDS`. + +Example 2 +^^^^^^^^^ + +In the target ``my_target`` a header file ``complex_class.hpp`` uses a +custom macro ``JSON_BASED_CLASS`` which is defined in an other header +``macros.hpp``:: + + // macros.hpp + ... + #define JSON_BASED_CLASS(name, json) \ + class name : public QObject \ + { \ + Q_OBJECT \ + Q_PLUGIN_METADATA(IID "demo" FILE json) \ + name() {} \ + }; + ... + +:: + + // complex_class.hpp + #pragma once + JSON_BASED_CLASS(Complex_Class, "meta.json") + // end of file + +Since ``complex_class.hpp`` doesn't contain a ``Q_OBJECT`` macro it would be +ignored by :prop_tgt:`AUTOMOC`. We change this by adding ``JSON_BASED_CLASS`` +to :variable:`CMAKE_AUTOMOC_MACRO_NAMES`:: + + list(APPEND CMAKE_AUTOMOC_MACRO_NAMES "JSON_BASED_CLASS") + +We want the ``moc`` file of ``complex_class.hpp`` to depend on +``meta.json``. So we add a filter to +:variable:`CMAKE_AUTOMOC_DEPEND_FILTERS`:: + + list(APPEND CMAKE_AUTOMOC_DEPEND_FILTERS + "JSON_BASED_CLASS" + "[\n^][ \t]*JSON_BASED_CLASS[ \t]*\\([^,]*,[ \t]*\"([^\"]+)\"" + ) + +Additionally we assume ``meta.json`` is :prop_sf:`GENERATED` which is +why we have to add it to :prop_tgt:`AUTOGEN_TARGET_DEPENDS`:: + + set_property(TARGET my_target APPEND PROPERTY AUTOGEN_TARGET_DEPENDS "meta.json") diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_EXECUTABLE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_EXECUTABLE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a6d5aa03e6731d527f1cd77b0e09983a174c03c1 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_EXECUTABLE.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_MACRO_NAMES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_MACRO_NAMES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a4a9ba230338bd12838deaccfbb25ab4c1126629 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_MACRO_NAMES.rst.txt @@ -0,0 +1,38 @@ +AUTOMOC_MACRO_NAMES +------------------- + +.. versionadded:: 3.10 + +A :ref:`semicolon-separated list ` of macro names used by +:prop_tgt:`AUTOMOC` to determine if a C++ file needs to be processed by ``moc``. + +This property is only used if the :prop_tgt:`AUTOMOC` property is ``ON`` +for this target. + +When running :prop_tgt:`AUTOMOC`, CMake searches for the strings listed in +``AUTOMOC_MACRO_NAMES`` in C++ source and header files. +If any of the strings is found + +- as the first non space string on a new line or +- as the first non space string after a ``{`` on a new line, + +then the file will be processed by ``moc``. + +By default ``AUTOMOC_MACRO_NAMES`` is initialized from +:variable:`CMAKE_AUTOMOC_MACRO_NAMES`. + +See also the :prop_tgt:`INTERFACE_AUTOMOC_MACRO_NAMES` target property. + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. + +Example +^^^^^^^ + +In this case the ``Q_OBJECT`` macro is hidden inside another macro +called ``CUSTOM_MACRO``. To let CMake know that source files that contain +``CUSTOM_MACRO`` need to be ``moc`` processed, we call: + +.. code-block:: cmake + + set_property(TARGET tgt APPEND PROPERTY AUTOMOC_MACRO_NAMES "CUSTOM_MACRO") diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_MOC_OPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_MOC_OPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..11ab147c09ed0515f798d2e25e14d8f5fa42c1ba --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOMOC_MOC_OPTIONS.rst.txt @@ -0,0 +1,53 @@ +AUTOMOC_MOC_OPTIONS +------------------- + +Additional options for ``moc`` when using :prop_tgt:`AUTOMOC` + +This property is only used if the :prop_tgt:`AUTOMOC` property is ``ON`` +for this target. In this case, it holds additional command line +options which will be used when ``moc`` is executed during the build, i.e. +it is equivalent to the optional ``OPTIONS`` argument of the +:module:`qt4_wrap_cpp() ` macro. + +This property is initialized by the value of the +:variable:`CMAKE_AUTOMOC_MOC_OPTIONS` variable if it is set when a target +is created, or an empty string otherwise. + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. + +EXAMPLE +^^^^^^^ + +In this example, the ``moc`` tool is invoked with the ``-D_EXTRA_DEFINE`` +option when generating the moc file for ``object.cpp``. + +``CMakeLists.txt`` + .. code-block:: cmake + + add_executable(mocOptions object.cpp main.cpp) + set_property(TARGET mocOptions PROPERTY AUTOMOC ON) + target_compile_options(mocOptions PRIVATE "-D_EXTRA_DEFINE") + set_property(TARGET mocOptions PROPERTY AUTOMOC_MOC_OPTIONS "-D_EXTRA_DEFINE") + target_link_libraries(mocOptions Qt6::Core) + +``object.hpp`` + .. code-block:: c++ + + #ifndef Object_HPP + #define Object_HPP + + #include + + #ifdef _EXTRA_DEFINE + class Object : public QObject + { + Q_OBJECT + public: + + Object(); + + }; + #endif + + #endif diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTORCC_OPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTORCC_OPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5261aff230c712d921067fe81ffe25118cdc3bdf --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTORCC_OPTIONS.rst.txt @@ -0,0 +1,28 @@ +AUTORCC_OPTIONS +--------------- + +Additional options for ``rcc`` when using :prop_tgt:`AUTORCC` + +This property holds additional command line options which will be used +when ``rcc`` is executed during the build via :prop_tgt:`AUTORCC`, +i.e. it is equivalent to the optional ``OPTIONS`` argument of the +:module:`qt4_add_resources() ` macro. + +This property is initialized by the value of the +:variable:`CMAKE_AUTORCC_OPTIONS` variable if it is set when a target is +created, or an empty string otherwise. + +The options set on the target may be overridden by :prop_sf:`AUTORCC_OPTIONS` +set on the ``.qrc`` source file. + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. + +EXAMPLE +^^^^^^^ + +.. code-block:: cmake + + # ... + set_property(TARGET tgt PROPERTY AUTORCC_OPTIONS "--compress;9") + # ... diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOUIC_EXECUTABLE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOUIC_EXECUTABLE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..be7929094567958b9e96e00955c242c9a0f31a58 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOUIC_EXECUTABLE.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOUIC_SEARCH_PATHS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOUIC_SEARCH_PATHS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..87fea48b299d977c3335a6285936a70e7476cd77 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/AUTOUIC_SEARCH_PATHS.rst.txt @@ -0,0 +1,14 @@ +AUTOUIC_SEARCH_PATHS +-------------------- + +.. versionadded:: 3.9 + +Search path list used by :prop_tgt:`AUTOUIC` to find included +``.ui`` files. + +This property is initialized by the value of the +:variable:`CMAKE_AUTOUIC_SEARCH_PATHS` variable if it is set +when a target is created. Otherwise it is empty. + +See the :manual:`cmake-qt(7)` manual for more information on using CMake +with Qt. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BINARY_DIR.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BINARY_DIR.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..beab12c8acfbcb322c4dfbc22d215c2d76648890 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BINARY_DIR.rst.txt @@ -0,0 +1,8 @@ +BINARY_DIR +---------- + +.. versionadded:: 3.4 + +This read-only property reports the value of the +:variable:`CMAKE_CURRENT_BINARY_DIR` variable in the directory in which +the target was defined. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUILD_RPATH.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUILD_RPATH.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..902e2f7af1d6aac301fc0a3947c4f5af211a38a9 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUILD_RPATH.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUILD_WITH_INSTALL_NAME_DIR.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUILD_WITH_INSTALL_NAME_DIR.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..073dce5cb62003b77e40fb9a3c01101e3c7129f6 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUILD_WITH_INSTALL_NAME_DIR.rst.txt @@ -0,0 +1,15 @@ +BUILD_WITH_INSTALL_NAME_DIR +--------------------------- + +.. versionadded:: 3.9 + +``BUILD_WITH_INSTALL_NAME_DIR`` is a boolean specifying whether the macOS +``install_name`` of a target in the build tree uses the directory given by +:prop_tgt:`INSTALL_NAME_DIR`. This setting only applies to targets on macOS. + +This property is initialized by the value of the variable +:variable:`CMAKE_BUILD_WITH_INSTALL_NAME_DIR` if it is set when a target is +created. + +If this property is not set and policy :policy:`CMP0068` is not ``NEW``, the +value of :prop_tgt:`BUILD_WITH_INSTALL_RPATH` is used in its place. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUNDLE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUNDLE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..c556ac32cf5d6c8391b7aa682f7f507416800a27 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUNDLE.rst.txt @@ -0,0 +1,9 @@ +BUNDLE +------ + +This target is a ``CFBundle`` on the macOS. + +If a module library target has this property set to true it will be +built as a ``CFBundle`` when built on the mac. It will have the directory +structure required for a ``CFBundle`` and will be suitable to be used for +creating Browser Plugins or other application resources. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUNDLE_EXTENSION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUNDLE_EXTENSION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..70de11c403c790484c1174d99dd431ef6cd36f39 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/BUNDLE_EXTENSION.rst.txt @@ -0,0 +1,8 @@ +BUNDLE_EXTENSION +---------------- + +The file extension used to name a :prop_tgt:`BUNDLE`, a :prop_tgt:`FRAMEWORK`, +or a :prop_tgt:`MACOSX_BUNDLE` target on the macOS and iOS. + +The default value is ``bundle``, ``framework``, or ``app`` for the respective +target types. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPATIBLE_INTERFACE_BOOL.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPATIBLE_INTERFACE_BOOL.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6910367e4e8759833db5f57f874445d66d1d9f4f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPATIBLE_INTERFACE_BOOL.rst.txt @@ -0,0 +1,20 @@ +COMPATIBLE_INTERFACE_BOOL +------------------------- + +Properties which must be compatible with their link interface + +The ``COMPATIBLE_INTERFACE_BOOL`` property may contain a list of +properties for this target which must be consistent when evaluated as a +boolean with the ``INTERFACE`` variant of the property in all linked +dependees. For example, if a property ``FOO`` appears in the list, then +for each dependee, the ``INTERFACE_FOO`` property content in all of its +dependencies must be consistent with each other, and with the ``FOO`` +property in the depender. + +Consistency in this sense has the meaning that if the property is set, +then it must have the same boolean value as all others, and if the +property is not set, then it is ignored. + +Note that for each dependee, the set of properties specified in this +property must not intersect with the set specified in any of the other +:ref:`Compatible Interface Properties`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPATIBLE_INTERFACE_NUMBER_MAX.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPATIBLE_INTERFACE_NUMBER_MAX.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..298acf1ba374c824e276bc40343b5f3ee33e3463 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPATIBLE_INTERFACE_NUMBER_MAX.rst.txt @@ -0,0 +1,18 @@ +COMPATIBLE_INTERFACE_NUMBER_MAX +------------------------------- + +Properties whose maximum value from the link interface will be used. + +The ``COMPATIBLE_INTERFACE_NUMBER_MAX`` property may contain a list of +properties for this target whose maximum value may be read at generate +time when evaluated in the ``INTERFACE`` variant of the property in all +linked dependees. For example, if a property ``FOO`` appears in the list, +then for each dependee, the ``INTERFACE_FOO`` property content in all of +its dependencies will be compared with each other and with the ``FOO`` +property in the depender. When reading the ``FOO`` property at generate +time, the maximum value will be returned. If the property is not set, +then it is ignored. + +Note that for each dependee, the set of properties specified in this +property must not intersect with the set specified in any of the other +:ref:`Compatible Interface Properties`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_DEFINITIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_DEFINITIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..c128a9be0fc8e5ae82e30444535d5343213e1862 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_DEFINITIONS.rst.txt @@ -0,0 +1,28 @@ +COMPILE_DEFINITIONS +------------------- + +Preprocessor definitions for compiling a target's sources. + +The ``COMPILE_DEFINITIONS`` property may be set to a semicolon-separated +list of preprocessor definitions using the syntax ``VAR`` or ``VAR=value``. +Function-style definitions are not supported. CMake will +automatically escape the value correctly for the native build system +(note that CMake language syntax may require escapes to specify some +values). + +CMake will automatically drop some definitions that are not supported +by the native build tool. + +.. versionadded:: 3.26 + Any leading ``-D`` on an item will be removed. + +.. include:: /include/COMPILE_DEFINITIONS_DISCLAIMER.txt + +Contents of ``COMPILE_DEFINITIONS`` 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. + +The corresponding :prop_tgt:`COMPILE_DEFINITIONS_` property may +be set to specify per-configuration definitions. Generator expressions +should be preferred instead of setting the alternative property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_DEFINITIONS_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_DEFINITIONS_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..84bd5e48316b22038895f0313ba8e875d294b83c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_DEFINITIONS_CONFIG.rst.txt @@ -0,0 +1,16 @@ +COMPILE_DEFINITIONS_ +---------------------------- + +Ignored. See CMake Policy :policy:`CMP0043`. + +Per-configuration preprocessor definitions on a target. + +This is the configuration-specific version of :prop_tgt:`COMPILE_DEFINITIONS` +where ```` is an upper-case name (ex. ``COMPILE_DEFINITIONS_DEBUG``). + +Contents of ``COMPILE_DEFINITIONS_`` 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. + +Generator expressions should be preferred instead of setting this property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_FEATURES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_FEATURES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9b937ed973e54490dd87a988d5018a1ef63cb604 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_FEATURES.rst.txt @@ -0,0 +1,15 @@ +COMPILE_FEATURES +---------------- + +.. versionadded:: 3.1 + +Compiler features enabled for this target. + +The list of features in this property are a subset of the features listed +in the :variable:`CMAKE_C_COMPILE_FEATURES`, :variable:`CMAKE_CUDA_COMPILE_FEATURES`, and +:variable:`CMAKE_CXX_COMPILE_FEATURES` variables. + +Contents of ``COMPILE_FEATURES`` may use "generator expressions" with the +syntax ``$<...>``. See the :manual:`cmake-generator-expressions(7)` manual for +available expressions. See the :manual:`cmake-compile-features(7)` manual +for information on compile features and a list of supported compilers. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b76afeb0896c05f1c3a2a23687212a0c46b9617b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_NAME.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_NAME_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_NAME_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..4c9825db248310d2303bea8ed62419c6785807c9 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_NAME_CONFIG.rst.txt @@ -0,0 +1,12 @@ +COMPILE_PDB_NAME_ +------------------------- + +.. versionadded:: 3.1 + +Per-configuration output name for the MS debug symbol ``.pdb`` file +generated by the compiler while building source files. + +This is the configuration-specific version of :prop_tgt:`COMPILE_PDB_NAME`. + +.. |PDB_XXX| replace:: :prop_tgt:`PDB_NAME_` +.. include:: COMPILE_PDB_NOTE.txt diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_OUTPUT_DIRECTORY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_OUTPUT_DIRECTORY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3f3df660d89ee383b2026055f9f44aeebf32f886 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_OUTPUT_DIRECTORY.rst.txt @@ -0,0 +1,15 @@ +COMPILE_PDB_OUTPUT_DIRECTORY +---------------------------- + +.. versionadded:: 3.1 + +Output directory for the MS debug symbol ``.pdb`` file +generated by the compiler while building source files. + +This property specifies the directory into which the MS debug symbols +will be placed by the compiler. 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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_OUTPUT_DIRECTORY_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_OUTPUT_DIRECTORY_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..c25c2fc4e5b85a77a2dbff1d5c9fe58e61223345 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/COMPILE_PDB_OUTPUT_DIRECTORY_CONFIG.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CONFIG_POSTFIX.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CONFIG_POSTFIX.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..69caa39d55f2e91b489de7e5f92471635ecdd6ed --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CONFIG_POSTFIX.rst.txt @@ -0,0 +1,13 @@ +_POSTFIX +---------------- + +Postfix to append to the target file name for configuration ````. + +When building with configuration ```` the value of this property +is appended to the target file name built on disk. For non-executable +targets, this property is initialized by the value of the +:variable:`CMAKE__POSTFIX` variable if it is set when a target is +created. This property is ignored on macOS for Frameworks and App Bundles. + +For macOS see also the :prop_tgt:`FRAMEWORK_MULTI_CONFIG_POSTFIX_` +target property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_ARCHITECTURES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_ARCHITECTURES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..05c25999bbdcd6cbb7fa14e25996e85fe50704aa --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_ARCHITECTURES.rst.txt @@ -0,0 +1,61 @@ +CUDA_ARCHITECTURES +------------------ + +.. versionadded:: 3.18 + +List of architectures to generate device code for. + +An architecture can be suffixed by either ``-real`` or ``-virtual`` to specify +the kind of architecture to generate code for. +If no suffix is given then code is generated for both real and virtual +architectures. + +A non-empty false value (e.g. ``OFF``) disables adding architectures. +This is intended to support packagers and rare cases where full control +over the passed flags is required. + +This property is initialized by the value of the :variable:`CMAKE_CUDA_ARCHITECTURES` +variable if it is set when a target is created. + +The ``CUDA_ARCHITECTURES`` target property must be set to a non-empty value on targets +that compile CUDA sources, or it is an error. See policy :policy:`CMP0104`. + +The ``CUDA_ARCHITECTURES`` may be set to one of the following special values: + +``all`` + .. versionadded:: 3.23 + + Compile for all supported major and minor real architectures, + and the highest major virtual architecture. + +``all-major`` + .. versionadded:: 3.23 + + Compile for all supported major real architectures, and the highest + major virtual architecture. + +``native`` + .. versionadded:: 3.24 + + Compile for the architecture(s) of the host's GPU(s). + +Examples +^^^^^^^^ + +.. code-block:: cmake + + set_target_properties(tgt PROPERTIES CUDA_ARCHITECTURES "35;50;72") + +Generates code for real and virtual architectures ``30``, ``50`` and ``72``. + +.. code-block:: cmake + + set_property(TARGET tgt PROPERTY CUDA_ARCHITECTURES 70-real 72-virtual) + +Generates code for real architecture ``70`` and virtual architecture ``72``. + +.. code-block:: cmake + + set_property(TARGET tgt PROPERTY CUDA_ARCHITECTURES OFF) + +CMake will not pass any architecture flags to the compiler. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_PTX_COMPILATION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_PTX_COMPILATION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..4e90afee98b4f9edef7c4b7e8920f25a0c7f8065 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_PTX_COMPILATION.rst.txt @@ -0,0 +1,14 @@ +CUDA_PTX_COMPILATION +-------------------- + +.. versionadded:: 3.9 + +Compile CUDA sources to ``.ptx`` files instead of ``.obj`` files +within :ref:`Object Libraries`. + +For example: + +.. code-block:: cmake + + add_library(myptx OBJECT a.cu b.cu) + set_property(TARGET myptx PROPERTY CUDA_PTX_COMPILATION ON) diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_RUNTIME_LIBRARY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_RUNTIME_LIBRARY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e937fc68ac1a6f7714b9c62b5ceeb1473fb2d4b4 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_RUNTIME_LIBRARY.rst.txt @@ -0,0 +1,23 @@ +CUDA_RUNTIME_LIBRARY +-------------------- + +.. versionadded:: 3.17 + +Select the CUDA runtime library for use by compilers targeting the CUDA language. + +The allowed case insensitive values are: + +.. include:: CUDA_RUNTIME_LIBRARY-VALUES.txt + +Contents of ``CUDA_RUNTIME_LIBRARY`` may use +:manual:`generator expressions `. + +If that property is not set then CMake uses an appropriate default +value based on the compiler to select the CUDA runtime library. + +.. note:: + + This property has effect only when the ``CUDA`` language is enabled. To + control the CUDA runtime linking when only using the CUDA SDK with the + ``C`` or ``C++`` language we recommend using the :module:`FindCUDAToolkit` + module. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_SEPARABLE_COMPILATION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_SEPARABLE_COMPILATION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..32222f91ba0273a564f7180ea1cf6ebee96608fb --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_SEPARABLE_COMPILATION.rst.txt @@ -0,0 +1,19 @@ +CUDA_SEPARABLE_COMPILATION +-------------------------- + +.. versionadded:: 3.8 + +CUDA only: Enables separate compilation of device code + +If set this will enable separable compilation for all CUDA files for +the given target. + +For instance: + +.. code-block:: cmake + + set_property(TARGET myexe PROPERTY CUDA_SEPARABLE_COMPILATION ON) + +This property is initialized by the value of the +:variable:`CMAKE_CUDA_SEPARABLE_COMPILATION` variable if it is set when a +target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_STANDARD.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_STANDARD.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ada69b93f88f493d66e7d33acff25d1c7235857a --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CUDA_STANDARD.rst.txt @@ -0,0 +1,68 @@ +CUDA_STANDARD +------------- + +.. versionadded:: 3.8 + +The CUDA/C++ standard whose features are requested to build this target. + +This property specifies the CUDA/C++ standard whose features are requested +to build this target. For some compilers, this results in adding a +flag such as ``-std=gnu++11`` to the compile line. + +Supported values are: + +``98`` + CUDA C++98. Note that this maps to the same as ``03`` internally. + +``03`` + CUDA C++03 + +``11`` + CUDA C++11 + +``14`` + CUDA C++14. While CMake 3.8 and later *recognize* ``14`` as a valid value, + CMake 3.9 was the first version to include support for any compiler. + +``17`` + CUDA C++17. While CMake 3.8 and later *recognize* ``17`` as a valid value, + CMake 3.18 was the first version to include support for any compiler. + +``20`` + .. versionadded:: 3.12 + + CUDA C++20. While CMake 3.12 and later *recognize* ``20`` as a valid value, + CMake 3.18 was the first version to include support for any compiler. + +``23`` + .. versionadded:: 3.20 + + CUDA C++23 + +``26`` + .. versionadded:: 3.25 + + CUDA 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 CUDA_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++03`` flag if supported. This "decay" behavior may be controlled +with the :prop_tgt:`CUDA_STANDARD_REQUIRED` target property. +Additionally, the :prop_tgt:`CUDA_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_CUDA_STANDARD` variable if it is set when a target +is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_MODULE_DIRS_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_MODULE_DIRS_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..91909910500e68faef5103f0ad0afc501c051d79 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_MODULE_DIRS_NAME.rst.txt @@ -0,0 +1,19 @@ +CXX_MODULE_DIRS_ +---------------------- + +.. versionadded:: 3.25 + +.. note :: + + Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API`` + +Semicolon-separated list of base directories of the target's ```` C++ +module set, which has the set type ``CXX_MODULES``. 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:`CXX_MODULE_DIRS` for the list of base directories in the +default C++ module set. See :prop_tgt:`CXX_MODULE_SETS` for the file set names +of all C++ module sets. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_MODULE_SET.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_MODULE_SET.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..f5cd8b2c26bf605356ec699ac467fe70d093b3de --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_MODULE_SET.rst.txt @@ -0,0 +1,20 @@ +CXX_MODULE_SET +-------------- + +.. versionadded:: 3.25 + +.. note :: + + Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API`` + +Semicolon-separated list of files in the target's default C++ module set, +(i.e. the file set with name and type ``CXX_MODULES``). 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:`CXX_MODULE_SET_` for the list of files in other C++ +module sets. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_MODULE_SETS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_MODULE_SETS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0e8945ad09c574b36d6b338293499f826235ff69 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_MODULE_SETS.rst.txt @@ -0,0 +1,18 @@ +CXX_MODULE_SETS +--------------- + +.. versionadded:: 3.25 + +.. note :: + + Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API`` + +Read-only list of the target's ``PRIVATE`` and ``PUBLIC`` C++ module sets (i.e. +all file sets with the type ``CXX_MODULES``). Files listed in these file sets +are treated as source files for the purpose of IDE integration. + +C++ module sets may be defined using the :command:`target_sources` command +``FILE_SET`` option with type ``CXX_MODULES``. + +See also :prop_tgt:`CXX_MODULE_SET_`, :prop_tgt:`CXX_MODULE_SET` and +:prop_tgt:`INTERFACE_CXX_MODULE_SETS`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_SCAN_FOR_MODULES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_SCAN_FOR_MODULES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..93a1b73dbbfa7e626b9f5bb73d67006acec244f2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/CXX_SCAN_FOR_MODULES.rst.txt @@ -0,0 +1,27 @@ +CXX_SCAN_FOR_MODULES +-------------------- + +.. versionadded:: 3.26 + +``CXX_SCAN_FOR_MODULES`` is a boolean specifying whether CMake will scan C++ +sources in the target for module dependencies. See also the +:prop_sf:`CXX_SCAN_FOR_MODULES` for per-source settings which, if set, +overrides the target-wide settings. + +This property is initialized by the value of the +:variable:`CMAKE_CXX_SCAN_FOR_MODULES` variable if it is set when a target is +created. + +When this property is set ``ON`` or unset, CMake will scan the target's +``CXX`` sources at build time and add module dependency information to the +compile line as necessary. When this property is set ``OFF``, CMake will not +scan the target's ``CXX`` sources at build time. + +Note that scanning is only performed if C++20 or higher is enabled for the +target. Scanning for modules in the target's sources belonging to file sets +of type ``CXX_MODULES`` is always performed. + +.. note :: + + This setting is meaningful only when experimental support for C++ modules + has been enabled by the ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API`` gate. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/C_EXTENSIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/C_EXTENSIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a53090c57fd1c5fb9e9585f99b06b711f91bf407 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/C_EXTENSIONS.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/C_STANDARD.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/C_STANDARD.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ecba2a8f1f1609311608d3b4f3b467b41315238b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/C_STANDARD.rst.txt @@ -0,0 +1,55 @@ +C_STANDARD +---------- + +.. versionadded:: 3.1 + +The C standard whose features are requested to build this target. + +This property specifies the C standard whose features are requested +to build this target. For some compilers, this results in adding a +flag such as ``-std=gnu11`` to the compile line. For compilers that +have no notion of a C standard level, such as Microsoft Visual C++ before +VS 16.7, this property has no effect. + +Supported values are: + +``90`` + C89/C90 + +``99`` + C99 + +``11`` + C11 + +``17`` + .. versionadded:: 3.21 + + C17 + +``23`` + .. versionadded:: 3.21 + + C23 + +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 C_STANDARD 11) + +with a compiler which does not support ``-std=gnu11`` or an equivalent +flag will not result in an error or warning, but will instead add the +``-std=gnu99`` or ``-std=gnu90`` flag if supported. This "decay" behavior may +be controlled with the :prop_tgt:`C_STANDARD_REQUIRED` target property. +Additionally, the :prop_tgt:`C_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_C_STANDARD` variable if it is set when a target +is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/DEBUG_POSTFIX.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/DEBUG_POSTFIX.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..eca7cb0966e35b93e1b2ca36ec4d4d261cbea915 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/DEBUG_POSTFIX.rst.txt @@ -0,0 +1,7 @@ +DEBUG_POSTFIX +------------- + +See target property :prop_tgt:`_POSTFIX`. + +This property is a special case of the more-general :prop_tgt:`_POSTFIX` +property for the ``DEBUG`` configuration. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/DEPLOYMENT_ADDITIONAL_FILES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/DEPLOYMENT_ADDITIONAL_FILES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..f11fe7ce2ba5cf013bc4ba467f96fe3979af559b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/DEPLOYMENT_ADDITIONAL_FILES.rst.txt @@ -0,0 +1,20 @@ +DEPLOYMENT_ADDITIONAL_FILES +--------------------------- + +.. versionadded:: 3.13 + +Set the WinCE project ``AdditionalFiles`` in ``DeploymentTool`` in ``.vcproj`` +files generated by the :generator:`Visual Studio 9 2008` generator. +This is useful when you want to debug on remote WinCE device. +Specify additional files that will be copied to the device. +For example: + +.. code-block:: cmake + + set_property(TARGET ${TARGET} PROPERTY + DEPLOYMENT_ADDITIONAL_FILES "english.lng|local_folder|remote_folder|0" + "german.lng|local_folder|remote_folder|0") + +produces:: + + diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/DEPRECATION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/DEPRECATION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2945c98817fb250e47880ae7abf10e8054edbae2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/DEPRECATION.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ENABLE_EXPORTS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ENABLE_EXPORTS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e34c649de1a430803f5bc044fe2c6bf9c33d0f02 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ENABLE_EXPORTS.rst.txt @@ -0,0 +1,59 @@ +ENABLE_EXPORTS +-------------- + +Specify whether an executable or a shared library exports symbols. + +Normally an executable does not export any symbols because it is the +final program. It is possible for an executable to export symbols to +be used by loadable modules. When this property is set to true CMake +will allow other targets to "link" to the executable with the +:command:`target_link_libraries` command. On all platforms a target-level +dependency on the executable is created for targets that link to it. +Handling of the executable on the link lines of the loadable modules +varies by platform: + +* On Windows-based systems (including Cygwin) an "import library" is + created along with the executable to list the exported symbols. + Loadable modules link to the import library to get the symbols. + +* On macOS, loadable modules link to the executable itself using the + ``-bundle_loader`` flag. + +* On AIX, a linker "import file" is created along with the executable + to list the exported symbols for import when linking other targets. + Loadable modules link to the import file to get the symbols. + +* On other platforms, loadable modules are simply linked without + referencing the executable since the dynamic loader will + automatically bind symbols when the module is loaded. + +This property is initialized by the value of the +:variable:`CMAKE_EXECUTABLE_ENABLE_EXPORTS` variable, if it is set when an +executable target is created. If :variable:`CMAKE_EXECUTABLE_ENABLE_EXPORTS` +is not set, the :variable:`CMAKE_ENABLE_EXPORTS` variable is used to initialize +the property instead for backward compatibility reasons. +See below for alternative initialization behavior for shared library targets. + +.. versionadded:: 3.27 + On Apple platforms, to link with a shared library (either a bare library or a + framework), a linker import file can be used instead of the actual shared + library. These linker import files are also known as text-based stubs, and + they have a ``.tbd`` file extension. + + The generation of these linker import files, as well as their consumption, is + controlled by this property. When this property is set to true on a shared + library target, CMake will generate a ``.tbd`` file for the library. + Other targets that link to the shared library target will then use this + ``.tbd`` file when linking rather than linking to the shared library binary. + + .. note:: + + For backward compatibility reasons, this property will be ignored if the + :prop_tgt:`XCODE_ATTRIBUTE_GENERATE_TEXT_BASED_STUBS >` + target property or the + :variable:`CMAKE_XCODE_ATTRIBUTE_GENERATE_TEXT_BASED_STUBS >` + variable is set to false. + + For shared library targets, this property is initialized by the value of the + :variable:`CMAKE_SHARED_LIBRARY_ENABLE_EXPORTS` variable, if it is set when + the target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/EXCLUDE_FROM_DEFAULT_BUILD.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/EXCLUDE_FROM_DEFAULT_BUILD.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..664704bfa773129455817ef2f932fdcd1b08e6a9 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/EXCLUDE_FROM_DEFAULT_BUILD.rst.txt @@ -0,0 +1,8 @@ +EXCLUDE_FROM_DEFAULT_BUILD +-------------------------- + +Exclude target from ``Build Solution``. + +This property is only used by Visual Studio generators. +When set to ``TRUE``, the target will not be built when you press +``Build Solution``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/EXPORT_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/EXPORT_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0e021d0db53e38af5e98cc3cdfa23e7b35759a26 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/EXPORT_NAME.rst.txt @@ -0,0 +1,8 @@ +EXPORT_NAME +----------- + +Exported name for target files. + +This sets the name for the ``IMPORTED`` target generated by the +:command:`install(EXPORT)` and :command:`export` commands. +If not set, the logical target name is used by default. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/EXPORT_PROPERTIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/EXPORT_PROPERTIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2d54f8bf84284d1e3be459509bf7538abdc3c1f7 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/EXPORT_PROPERTIES.rst.txt @@ -0,0 +1,24 @@ +EXPORT_PROPERTIES +----------------- + +.. versionadded:: 3.12 + +List additional properties to export for a target. + +This property contains a list of property names that should be exported by +the :command:`install(EXPORT)` and :command:`export` commands. By default +only a limited number of properties are exported. This property can be used +to additionally export other properties as well. + +Properties starting with ``INTERFACE_`` or ``IMPORTED_`` are not allowed as +they are reserved for internal CMake use. + +Properties containing generator expressions are also not allowed. + +.. note:: + + Since CMake 3.19, :ref:`Interface Libraries` may have arbitrary + target properties. If a project exports an interface library + with custom properties, the resulting package may not work with + dependents configured by older versions of CMake that reject the + custom properties. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/FOLDER.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/FOLDER.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..616b96253d7fe079e0d337bc51f6c0f112f4497d --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/FOLDER.rst.txt @@ -0,0 +1,20 @@ +FOLDER +------ + +For IDEs that present targets using a folder hierarchy, this property +specifies the name of the folder to place the target under. +To nest folders, use ``FOLDER`` values such as ``GUI/Dialogs`` with ``/`` +characters separating folder levels. Targets with no ``FOLDER`` property +will appear as top level entities. Targets with the same ``FOLDER`` +property value will appear in the same folder as siblings. + +Only some CMake generators honor the ``FOLDER`` property +(e.g. :generator:`Xcode` or any of the +:ref:`Visual Studio ` generators). +Those generators that don't will simply ignore it. + +This property is initialized by the value of the variable +:variable:`CMAKE_FOLDER` if it is set when a target is created. + +The global property :prop_gbl:`USE_FOLDERS` must be set to true, otherwise +the ``FOLDER`` property is ignored. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/FRAMEWORK_MULTI_CONFIG_POSTFIX_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/FRAMEWORK_MULTI_CONFIG_POSTFIX_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..84d0c1e257edcffcfe30856adcf5d1073aee5de7 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/FRAMEWORK_MULTI_CONFIG_POSTFIX_CONFIG.rst.txt @@ -0,0 +1,28 @@ +FRAMEWORK_MULTI_CONFIG_POSTFIX_ +--------------------------------------- + +.. versionadded:: 3.18 + +Postfix to append to the framework file name for configuration ````, +when using a multi-config generator (like Xcode and Ninja Multi-Config). + +When building with configuration ```` the value of this property +is appended to the framework file name built on disk. + +For example, given a framework called ``my_fw``, a value of ``_debug`` +for the ``FRAMEWORK_MULTI_CONFIG_POSTFIX_DEBUG`` property, and +``Debug;Release`` in :variable:`CMAKE_CONFIGURATION_TYPES`, the following +relevant files would be created for the ``Debug`` and ``Release`` +configurations: + +- ``Release/my_fw.framework/my_fw`` +- ``Release/my_fw.framework/Versions/A/my_fw`` +- ``Debug/my_fw.framework/my_fw_debug`` +- ``Debug/my_fw.framework/Versions/A/my_fw_debug`` + +For framework targets, this property is initialized by the value of the +:variable:`CMAKE_FRAMEWORK_MULTI_CONFIG_POSTFIX_` variable if it +is set when a target is created. + +This property is ignored for non-framework targets, and when using single +config generators. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/FRAMEWORK_VERSION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/FRAMEWORK_VERSION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..38b81373e27a6ffe02f368cabe1df379d0b51070 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/FRAMEWORK_VERSION.rst.txt @@ -0,0 +1,10 @@ +FRAMEWORK_VERSION +----------------- + +.. versionadded:: 3.4 + +Version of a framework created using the :prop_tgt:`FRAMEWORK` target +property (e.g. ``A``). + +This property only affects macOS, as iOS doesn't have versioned +directory structure. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Fortran_BUILDING_INSTRINSIC_MODULES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Fortran_BUILDING_INSTRINSIC_MODULES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3533ef9c8f1b0309c4f7451106fa05d2636a04fc --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Fortran_BUILDING_INSTRINSIC_MODULES.rst.txt @@ -0,0 +1,16 @@ +Fortran_BUILDING_INSTRINSIC_MODULES +----------------------------------- + +.. versionadded:: 3.22 + +Instructs the CMake Fortran preprocessor that the target is building +Fortran intrinsics for building a Fortran compiler. + +This property is off by default and should be turned only on projects +that build a Fortran compiler. It should not be turned on for projects +that use a Fortran compiler. + +Turning this property on will correctly add dependencies for building +Fortran intrinsic modules whereas turning the property off will ignore +Fortran intrinsic modules in the dependency graph as they are supplied +by the compiler itself. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Fortran_FORMAT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Fortran_FORMAT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..8704e5f42329d1683c3ca8fc06c76dc70a9bd393 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Fortran_FORMAT.rst.txt @@ -0,0 +1,11 @@ +Fortran_FORMAT +-------------- + +Set to ``FIXED`` or ``FREE`` to indicate the Fortran source layout. + +This property tells CMake whether the Fortran source files in a target +use fixed-format or free-format. CMake will pass the corresponding +format flag to the compiler. Use the source-specific ``Fortran_FORMAT`` +property to change the format of a specific source file. If the +variable :variable:`CMAKE_Fortran_FORMAT` is set when a target is created its +value is used to initialize this property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Fortran_MODULE_DIRECTORY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Fortran_MODULE_DIRECTORY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..84029e4290678e4cd23ee6653e8040ce5f448271 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Fortran_MODULE_DIRECTORY.rst.txt @@ -0,0 +1,25 @@ +Fortran_MODULE_DIRECTORY +------------------------ + +Specify output directory for Fortran modules provided by the target. + +If the target contains Fortran source files that provide modules and +the compiler supports a module output directory this specifies the +directory in which the modules will be placed. When this property is +not set the modules will be placed in the build directory +corresponding to the target's source directory. If the variable +:variable:`CMAKE_Fortran_MODULE_DIRECTORY` is set when a target is created its +value is used to initialize this property. + +When using one of the :ref:`Visual Studio Generators` with the Intel Fortran +plugin installed in Visual Studio, a subdirectory named after the +configuration will be appended to the path where modules are created. +For example, if ``Fortran_MODULE_DIRECTORY`` is set to ``C:/some/path``, +modules will end up in ``C:/some/path/Debug`` (or +``C:/some/path/Release`` etc.) when an Intel Fortran ``.vfproj`` file is +generated, and in ``C:/some/path`` when any other generator is used. + +Note that some compilers will automatically search the module output +directory for modules USEd during compilation but others will not. If +your sources USE modules their location must be specified by +:prop_tgt:`INCLUDE_DIRECTORIES` regardless of this property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/GENERATOR_FILE_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/GENERATOR_FILE_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a48610550487d8219c2ce0d6b7783213b93ac9d3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/GENERATOR_FILE_NAME.rst.txt @@ -0,0 +1,9 @@ +GENERATOR_FILE_NAME +------------------- + +Generator's file for this target. + +An internal property used by some generators to record the name of the +project or dsp file associated with this target. Note that at +configure time, this property is only set for targets created by +:command:`include_external_msproject`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/GHS_NO_SOURCE_GROUP_FILE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/GHS_NO_SOURCE_GROUP_FILE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..fe6b8e68ae7f136223b93e3527b9bcba11225565 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/GHS_NO_SOURCE_GROUP_FILE.rst.txt @@ -0,0 +1,15 @@ +GHS_NO_SOURCE_GROUP_FILE +------------------------ + +.. versionadded:: 3.14 + +``ON`` / ``OFF`` boolean to control if the project file for a target should +be one single file or multiple files. + +The default behavior or when the property is ``OFF`` is to generate a project +file for the target and then a sub-project file for each source group. + +When this property is ``ON`` or if :variable:`CMAKE_GHS_NO_SOURCE_GROUP_FILE` +is ``ON`` then only a single project file is generated for the target. + +Supported on :generator:`Green Hills MULTI`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/GNUtoMS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/GNUtoMS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a09ebbfae35889c44f91701961920621c7d5c7d6 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/GNUtoMS.rst.txt @@ -0,0 +1,17 @@ +GNUtoMS +------- + +Convert GNU import library (``.dll.a``) to MS format (``.lib``). + +When linking a shared library or executable that exports symbols using +GNU tools on Windows (MinGW/MSYS) with Visual Studio installed convert +the import library (``.dll.a``) from GNU to MS format (``.lib``). Both import +libraries will be installed by :command:`install(TARGETS)` and exported by +:command:`install(EXPORT)` and :command:`export` to be linked +by applications with either GNU- or MS-compatible tools. + +If the variable ``CMAKE_GNUtoMS`` is set when a target is created its +value is used to initialize this property. The variable must be set +prior to the first command that enables a language such as :command:`project` +or :command:`enable_language`. CMake provides the variable as an option to the +user automatically when configuring on Windows with GNU tools. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HAS_CXX.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HAS_CXX.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..15199b15b1d00f6ead73a254f36a839258b8a01f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HAS_CXX.rst.txt @@ -0,0 +1,7 @@ +HAS_CXX +------- + +Link the target using the C++ linker tool (obsolete). + +This is equivalent to setting the :prop_tgt:`LINKER_LANGUAGE` +property to ``CXX``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HEADER_DIRS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HEADER_DIRS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d095345ce0312169fb712eec94c7e331ccbf0d79 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HEADER_DIRS.rst.txt @@ -0,0 +1,14 @@ +HEADER_DIRS +----------- + +.. versionadded:: 3.23 + +Semicolon-separated list of base directories of the target's default +header set (i.e. the file set with name and type ``HEADERS``). 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_DIRS_` for the list of base directories in +other header sets. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HEADER_SET.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HEADER_SET.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a703fc155a3a8e2bf1846cf1b2aff817819648f2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HEADER_SET.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HEADER_SETS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HEADER_SETS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ceb1df50620f12544245d237d4c6867f05e30a55 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HEADER_SETS.rst.txt @@ -0,0 +1,15 @@ +HEADER_SETS +----------- + +.. versionadded:: 3.23 + +Read-only list of the target's ``PRIVATE`` and ``PUBLIC`` header sets (i.e. +all file sets with the type ``HEADERS``). Files listed in these file sets are +treated as source files for the purpose of IDE integration. The files also +have their :prop_sf:`HEADER_FILE_ONLY` property set to ``TRUE``. + +Header sets may be defined using the :command:`target_sources` command +``FILE_SET`` option with type ``HEADERS``. + +See also :prop_tgt:`HEADER_SET_`, :prop_tgt:`HEADER_SET` and +:prop_tgt:`INTERFACE_HEADER_SETS`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HIP_EXTENSIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HIP_EXTENSIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d1475c96420110b3dc09865a31c2b226499aea08 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HIP_EXTENSIONS.rst.txt @@ -0,0 +1,21 @@ +HIP_EXTENSIONS +-------------- + +.. versionadded:: 3.21 + +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=gnu++11`` instead of ``-std=c++11`` to the compile line. This +property is ``ON`` by default. The basic HIP/C++ standard level is +controlled by the :prop_tgt:`HIP_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_HIP_EXTENSIONS` variable if set when a target is created +and otherwise by the value of +:variable:`CMAKE_HIP_EXTENSIONS_DEFAULT _EXTENSIONS_DEFAULT>` (see +:policy:`CMP0128`). diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HIP_STANDARD.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HIP_STANDARD.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9de873038126d427eabfa3b1229aaf8ad826ec5e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/HIP_STANDARD.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..22d28aaf756b24c727ce076b4f1c020c51fdec72 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED.rst.txt @@ -0,0 +1,8 @@ +IMPORTED +-------- + +Read-only indication of whether a target is ``IMPORTED``. + +The boolean value of this property is ``True`` for targets created with +the ``IMPORTED`` option to :command:`add_executable` or :command:`add_library`. +It is ``False`` for targets built within the project. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_CONFIGURATIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_CONFIGURATIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a4746d3d163a140f8b4255942920e0f884b2d210 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_CONFIGURATIONS.rst.txt @@ -0,0 +1,22 @@ +IMPORTED_CONFIGURATIONS +----------------------- + +Configurations provided for an :ref:`imported target `. + +Set this to the list of configuration names available for an imported +target. For each configuration named, the imported target's artifacts +must be specified in other target properties: + +* :prop_tgt:`IMPORTED_LOCATION_`, or +* :prop_tgt:`IMPORTED_IMPLIB_` (on DLL platforms, on AIX for + :ref:`Executables ` or on Apple for + :ref:`Shared Libraries `), or +* :prop_tgt:`IMPORTED_OBJECTS_` (for :ref:`Object Libraries`), or +* :prop_tgt:`IMPORTED_LIBNAME_` (for :ref:`Interface Libraries`). + +The configuration names correspond to those defined in the project from +which the target is imported. If the importing project uses a different +set of configurations, the names may be mapped using the +:prop_tgt:`MAP_IMPORTED_CONFIG_` target property. + +The ``IMPORTED_CONFIGURATIONS`` property is ignored for non-imported targets. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_GLOBAL.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_GLOBAL.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..176127f43c23dcd9eb40e859dfe63cd4dbf52739 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_GLOBAL.rst.txt @@ -0,0 +1,32 @@ +IMPORTED_GLOBAL +--------------- + +.. versionadded:: 3.11 + +Indication of whether an :ref:`IMPORTED target ` is +globally visible. + +The boolean value of this property is True for targets created with the +``IMPORTED`` ``GLOBAL`` options to :command:`add_executable()` or +:command:`add_library()`. It is always False for targets built within the +project. + +For targets created with the ``IMPORTED`` option to +:command:`add_executable()` or :command:`add_library()` but without the +additional option ``GLOBAL`` this is False, too. However, setting this +property for such a locally ``IMPORTED`` target to True promotes that +target to global scope. This promotion can only be done in the same +directory where that ``IMPORTED`` target was created in the first place. + +.. note:: + + Once an imported target has been made global, it cannot be changed back to + non-global. Therefore, if a project sets this property, it may only + provide a value of True. CMake will issue an error if the project tries to + set the property to a non-True value, even if the value was already False. + +.. note:: + + Local :ref:`ALIAS targets ` created before promoting an + :ref:`IMPORTED target ` from ``LOCAL`` to ``GLOBAL``, keep + their initial scope (see :prop_tgt:`ALIAS_GLOBAL` target property). diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_IMPLIB_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_IMPLIB_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5debabc954e532c3d0ddc1dc431a3c1ffa69806f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_IMPLIB_CONFIG.rst.txt @@ -0,0 +1,7 @@ +IMPORTED_IMPLIB_ +------------------------ + +-specific version of :prop_tgt:`IMPORTED_IMPLIB` property. + +Configuration names correspond to those provided by the project from +which the target is imported. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LINK_DEPENDENT_LIBRARIES_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LINK_DEPENDENT_LIBRARIES_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5b9c51308e0a5e218c9a044835ee94b96b86beb7 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LINK_DEPENDENT_LIBRARIES_CONFIG.rst.txt @@ -0,0 +1,8 @@ +IMPORTED_LINK_DEPENDENT_LIBRARIES_ +------------------------------------------ + +-specific version of :prop_tgt:`IMPORTED_LINK_DEPENDENT_LIBRARIES`. + +Configuration names correspond to those provided by the project from +which the target is imported. If set, this property completely +overrides the generic property for the named configuration. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LINK_INTERFACE_LANGUAGES_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LINK_INTERFACE_LANGUAGES_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..40fcf7fcf353c259abfb60b8f5a1af98d9622755 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LINK_INTERFACE_LANGUAGES_CONFIG.rst.txt @@ -0,0 +1,8 @@ +IMPORTED_LINK_INTERFACE_LANGUAGES_ +------------------------------------------ + +-specific version of :prop_tgt:`IMPORTED_LINK_INTERFACE_LANGUAGES`. + +Configuration names correspond to those provided by the project from +which the target is imported. If set, this property completely +overrides the generic property for the named configuration. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LINK_INTERFACE_LIBRARIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LINK_INTERFACE_LIBRARIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..527cf2ebead01b4ae8999a6c87fdaaf62c40131f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LINK_INTERFACE_LIBRARIES.rst.txt @@ -0,0 +1,16 @@ +IMPORTED_LINK_INTERFACE_LIBRARIES +--------------------------------- + +Transitive link interface of an ``IMPORTED`` target. + +Set this to the list of libraries whose interface is included when an +``IMPORTED`` library target is linked to another target. The libraries +will be included on the link line for the target. Unlike the +:prop_tgt:`LINK_INTERFACE_LIBRARIES` property, this property applies to all +imported target types, including ``STATIC`` libraries. This property is +ignored for non-imported targets. + +This property is ignored if the target also has a non-empty +:prop_tgt:`INTERFACE_LINK_LIBRARIES` property. + +This property is deprecated. Use :prop_tgt:`INTERFACE_LINK_LIBRARIES` instead. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LOCATION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LOCATION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a7207d845bedf61b8cf3e289c5a000de1a783750 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_LOCATION.rst.txt @@ -0,0 +1,31 @@ +IMPORTED_LOCATION +----------------- + +Full path to the main file on disk for an ``IMPORTED`` target. + +Set this to the location of an ``IMPORTED`` target file on disk. For +executables this is the location of the executable file. For ``STATIC`` +libraries and modules this is the location of the library or module. +For ``SHARED`` libraries on non-DLL platforms this is the location of the +shared library. For application bundles on macOS this is the location of +the executable file inside ``Contents/MacOS`` within the bundle folder. +For frameworks on macOS this is the location of the +library file symlink just inside the framework folder. For DLLs this +is the location of the ``.dll`` part of the library. For ``UNKNOWN`` +libraries this is the location of the file to be linked. Ignored for +non-imported targets. + +The ``IMPORTED_LOCATION`` target property may be overridden for a +given configuration ```` by the configuration-specific +:prop_tgt:`IMPORTED_LOCATION_` target property. Furthermore, +the :prop_tgt:`MAP_IMPORTED_CONFIG_` target property may be +used to map between a project's configurations and those of an imported +target. If none of these is set then the name of any other configuration +listed in the :prop_tgt:`IMPORTED_CONFIGURATIONS` target property may be +selected and its :prop_tgt:`IMPORTED_LOCATION_` value used. + +To get the location of an imported target read one of the :prop_tgt:`LOCATION` +or ``LOCATION_`` properties. + +For platforms with import libraries (e.g. Windows, AIX or macOS) see also +:prop_tgt:`IMPORTED_IMPLIB`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_OBJECTS_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_OBJECTS_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..238395a23c617d8d229e2c06a339e5a354e783c4 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORTED_OBJECTS_CONFIG.rst.txt @@ -0,0 +1,20 @@ +IMPORTED_OBJECTS_ +------------------------- + +.. versionadded:: 3.9 + +````-specific version of :prop_tgt:`IMPORTED_OBJECTS` property. + +Configuration names correspond to those provided by the project from +which the target is imported. + + +Xcode Generator Considerations +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Do not use this ````-specific property if you need to use Xcode +variables like ``$(CURRENT_ARCH)`` or ``$(EFFECTIVE_PLATFORM_NAME)`` in +the value. The ````-specific properties will be ignored in such +cases because CMake cannot determine whether a file exists at the +configuration-specific path at configuration time. For such cases, use +:prop_tgt:`IMPORTED_OBJECTS` instead. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORT_PREFIX.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORT_PREFIX.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..17e381be47f155946b1102ed0e4e709bd99466b6 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORT_PREFIX.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORT_SUFFIX.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORT_SUFFIX.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9307115b431e63e0b65165d35550d5696256b851 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IMPORT_SUFFIX.rst.txt @@ -0,0 +1,9 @@ +IMPORT_SUFFIX +------------- + +What comes after the import library name. + +Similar to the target property :prop_tgt:`SUFFIX`, but used +for import libraries (typically corresponding to a ``DLL``) instead of +regular libraries. A target property that can be set to override +the suffix (such as ``.lib``) on an import library name. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INCLUDE_DIRECTORIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INCLUDE_DIRECTORIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b381d1dbdf5a16cd25983dbffd9e461e81728cf7 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INCLUDE_DIRECTORIES.rst.txt @@ -0,0 +1,24 @@ +INCLUDE_DIRECTORIES +------------------- + +List of preprocessor include file search directories. + +This property specifies the list of directories given so far to the +:command:`target_include_directories` command. In addition to accepting +values from that command, values may be set directly on any +target using the :command:`set_property` command. A target gets its +initial value for this property from the value of the +:prop_dir:`INCLUDE_DIRECTORIES` directory property. Both directory and +target property values are adjusted by calls to the +:command:`include_directories` command. + +The value of this property is used by the generators to set the include +paths for the compiler. + +Relative paths should not be added to this property directly. Use one of +the commands above instead to handle relative paths. + +Contents of ``INCLUDE_DIRECTORIES`` may use :manual:`cmake-generator-expressions(7)` 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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INSTALL_REMOVE_ENVIRONMENT_RPATH.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INSTALL_REMOVE_ENVIRONMENT_RPATH.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..f41e41c66ae91ee829930bdcba968875fb36925b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INSTALL_REMOVE_ENVIRONMENT_RPATH.rst.txt @@ -0,0 +1,18 @@ +INSTALL_REMOVE_ENVIRONMENT_RPATH +-------------------------------- + +.. versionadded:: 3.16 + +Controls whether toolchain-defined rpaths should be removed during installation. + +When a target is being installed, CMake may need to rewrite its rpath +information. This occurs when the install rpath (as specified by the +:prop_tgt:`INSTALL_RPATH` target property) has different contents to the rpath +that the target was built with. Some toolchains insert their own rpath +contents into the binary as part of the build. By default, CMake will +preserve those extra inserted contents in the install rpath. For those +scenarios where such toolchain-inserted entries need to be discarded during +install, set the ``INSTALL_REMOVE_ENVIRONMENT_RPATH`` target property to true. + +This property is initialized by the value of +:variable:`CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH` when the target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_AUTOMOC_MACRO_NAMES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_AUTOMOC_MACRO_NAMES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..502775c8e3b4816168b71fc9c800a41c4f8cd241 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_AUTOMOC_MACRO_NAMES.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_AUTOUIC_OPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_AUTOUIC_OPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e97d293180cf06696a0acf9526514ad42b79b066 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_AUTOUIC_OPTIONS.rst.txt @@ -0,0 +1,14 @@ +INTERFACE_AUTOUIC_OPTIONS +------------------------- + +List of interface options to pass to uic. + +Targets may populate this property to publish the options +required to use when invoking ``uic``. Consuming targets can add entries to their +own :prop_tgt:`AUTOUIC_OPTIONS` property such as +``$`` to use the uic options +specified in the interface of ``foo``. This is done automatically by +the :command:`target_link_libraries` command. + +This property supports generator expressions. See the +:manual:`cmake-generator-expressions(7)` manual for available expressions. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_COMPILE_FEATURES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_COMPILE_FEATURES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..50d6161a3acb4544a8d72b8fffedbc44a99b7ea6 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_COMPILE_FEATURES.rst.txt @@ -0,0 +1,13 @@ +INTERFACE_COMPILE_FEATURES +-------------------------- + +.. versionadded:: 3.1 + +.. |property_name| replace:: compile features +.. |command_name| replace:: :command:`target_compile_features` +.. |PROPERTY_INTERFACE_NAME| replace:: ``INTERFACE_COMPILE_FEATURES`` +.. |PROPERTY_LINK| replace:: :prop_tgt:`COMPILE_FEATURES` +.. include:: INTERFACE_BUILD_PROPERTY.txt + +See the :manual:`cmake-compile-features(7)` manual for information on compile +features and a list of supported compilers. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_HEADER_SETS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_HEADER_SETS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2d3bdacfcf08836f77ff52afb546ecd97236346d --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_HEADER_SETS.rst.txt @@ -0,0 +1,14 @@ +INTERFACE_HEADER_SETS +--------------------- + +.. versionadded:: 3.23 + +Read-only list of the target's ``INTERFACE`` and ``PUBLIC`` header sets (i.e. +all file sets with the type ``HEADERS``). Files listed in these header sets +can be installed with :command:`install(TARGETS)` and exported with +:command:`install(EXPORT)` and :command:`export`. + +Header sets may be defined using the :command:`target_sources` command +``FILE_SET`` option with type ``HEADERS``. + +See also :prop_tgt:`HEADER_SETS`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_HEADER_SETS_TO_VERIFY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_HEADER_SETS_TO_VERIFY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b0d63f3cd66d6488e83116528c466eccc87a455e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_HEADER_SETS_TO_VERIFY.rst.txt @@ -0,0 +1,13 @@ +INTERFACE_HEADER_SETS_TO_VERIFY +------------------------------- + +.. versionadded:: 3.24 + +Used to specify which ``PUBLIC`` and ``INTERFACE`` header sets of a target +should be verified. + +This property contains a semicolon-separated list of header sets which +should be verified if :prop_tgt:`VERIFY_INTERFACE_HEADER_SETS` is set to +``TRUE``. If the list is empty, all ``PUBLIC`` and ``INTERFACE`` header sets +are verified. (If the project does not want to verify any header sets on the +target, simply set :prop_tgt:`VERIFY_INTERFACE_HEADER_SETS` to ``FALSE``.) diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_LINK_DEPENDS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_LINK_DEPENDS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9c8275d5f2497fde53a7f0c05cfd2078b47b7881 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_LINK_DEPENDS.rst.txt @@ -0,0 +1,34 @@ +INTERFACE_LINK_DEPENDS +---------------------- + +.. versionadded:: 3.13 + +Additional public interface files on which a target binary depends for linking. + +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. + +When target dependencies are specified using :command:`target_link_libraries`, +CMake will read this property from all target dependencies to determine the +build properties of the consumer. + +Contents of ``INTERFACE_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. + +Link dependency files 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 + + set_property(TARGET mylib PROPERTY INTERFACE_LINK_DEPENDS + $ + $ # /mylinkscript + ) diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_LINK_OPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_LINK_OPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..785b17cfa58717a205c8d779e16e6ad4d9432fe5 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERFACE_LINK_OPTIONS.rst.txt @@ -0,0 +1,10 @@ +INTERFACE_LINK_OPTIONS +---------------------- + +.. versionadded:: 3.13 + +.. |property_name| replace:: link options +.. |command_name| replace:: :command:`target_link_options` +.. |PROPERTY_INTERFACE_NAME| replace:: ``INTERFACE_LINK_OPTIONS`` +.. |PROPERTY_LINK| replace:: :prop_tgt:`LINK_OPTIONS` +.. include:: INTERFACE_BUILD_PROPERTY.txt diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERPROCEDURAL_OPTIMIZATION_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERPROCEDURAL_OPTIMIZATION_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..79d46048b103f0c4fadfe1b46b76b279fa845ee5 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/INTERPROCEDURAL_OPTIMIZATION_CONFIG.rst.txt @@ -0,0 +1,12 @@ +INTERPROCEDURAL_OPTIMIZATION_ +------------------------------------- + +Per-configuration interprocedural optimization for a target. + +This is a per-configuration version of :prop_tgt:`INTERPROCEDURAL_OPTIMIZATION`. +If set, this property overrides the generic property for the named +configuration. + +This property is initialized by the +:variable:`CMAKE_INTERPROCEDURAL_OPTIMIZATION_` variable if it is set +when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IOS_INSTALL_COMBINED.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IOS_INSTALL_COMBINED.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..92d60dcf7057d44656696e8b13b6cd2cc50dd4d9 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/IOS_INSTALL_COMBINED.rst.txt @@ -0,0 +1,19 @@ +IOS_INSTALL_COMBINED +-------------------- + +.. versionadded:: 3.5 + +Build a combined (device and simulator) target when installing. + +When this property is set to set to false (which is the default) then it will +either be built with the device SDK or the simulator SDK depending on the SDK +set. But if this property is set to true then the target will at install time +also be built for the corresponding SDK and combined into one library. + +.. note:: + + If a selected architecture is available for both: device SDK and simulator + SDK it will be built for the SDK selected by :variable:`CMAKE_OSX_SYSROOT` + and removed from the corresponding SDK. + +This feature requires at least Xcode version 6. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ISPC_INSTRUCTION_SETS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ISPC_INSTRUCTION_SETS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..cad116f8f700c427e7b7d761548c1b23c2fe51d3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/ISPC_INSTRUCTION_SETS.rst.txt @@ -0,0 +1,21 @@ +ISPC_INSTRUCTION_SETS +--------------------- + +.. versionadded:: 3.19 + +List of instruction set architectures to generate code for. + +This property is initialized by the value of the :variable:`CMAKE_ISPC_INSTRUCTION_SETS` +variable if it is set when a target is created. + +The ``ISPC_INSTRUCTION_SETS`` target property must be used when generating for multiple +instruction sets so that CMake can track what object files will be generated. + +Examples +^^^^^^^^ + +.. code-block:: cmake + + set_property(TARGET tgt PROPERTY ISPC_INSTRUCTION_SETS avx2-i32x4 avx512skx-i32x835) + +Generates code for avx2 and avx512skx target architectures. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/JOB_POOL_LINK.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/JOB_POOL_LINK.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..653533371cad02ed9a5d58827dd4fc1d4984ee53 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/JOB_POOL_LINK.rst.txt @@ -0,0 +1,16 @@ +JOB_POOL_LINK +------------- + +Ninja only: Pool used for linking. + +The number of parallel link 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_LINK two_jobs) + +This property is initialized by the value of :variable:`CMAKE_JOB_POOL_LINK`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LABELS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LABELS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5e464696dce835b4782593d65064ecdcca0b12a5 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LABELS.rst.txt @@ -0,0 +1,6 @@ +LABELS +------ + +Specify a list of text labels associated with a target. + +Target label semantics are currently unspecified. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_CLANG_TIDY_EXPORT_FIXES_DIR.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_CLANG_TIDY_EXPORT_FIXES_DIR.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..fc88f0f3021d769ce614fc01498ae0451bfb0b04 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_CLANG_TIDY_EXPORT_FIXES_DIR.rst.txt @@ -0,0 +1,29 @@ +_CLANG_TIDY_EXPORT_FIXES_DIR +---------------------------------- + +.. versionadded:: 3.26 + +This property is implemented only when ```` is ``C``, ``CXX``, ``OBJC`` +or ``OBJCXX``, and only has an effect when :prop_tgt:`_CLANG_TIDY` is +set. + +Specify a directory for the ``clang-tidy`` tool to put ``.yaml`` files +containing its suggested changes in. This can be used for automated mass +refactoring by ``clang-tidy``. Each object file that gets compiled will have a +corresponding ``.yaml`` file in this directory. After the build is completed, +you can run ``clang-apply-replacements`` on this directory to simultaneously +apply all suggested changes to the code base. If this property is not an +absolute directory, it is assumed to be relative to the target's binary +directory. This property should be preferred over adding an ``--export-fixes`` +or ``--fix`` argument directly to the :prop_tgt:`_CLANG_TIDY` property. + +When this property is set, CMake takes ownership of the specified directory, +and may create, modify, or delete files and directories within the directory +at any time during configure or build time. Users should use a dedicated +directory for exporting clang-tidy fixes to avoid having files deleted or +overwritten by CMake. Users should not create, modify, or delete files in this +directory. + +This property is initialized by the value of +the :variable:`CMAKE__CLANG_TIDY_EXPORT_FIXES_DIR` variable if it is set +when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_CPPLINT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_CPPLINT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..02610daa3246233a5078aef63bff828cfa068723 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_CPPLINT.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_STANDARD.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_STANDARD.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..c83da0102ffc80f60eedb066b09460303ee07a6a --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_STANDARD.rst.txt @@ -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:`transitive 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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_STANDARD_REQUIRED.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_STANDARD_REQUIRED.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e61125b406006d6b78c819c7df1774bee80cbffa --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_STANDARD_REQUIRED.rst.txt @@ -0,0 +1,32 @@ +_STANDARD_REQUIRED +------------------------ + +The variations are: + +* :prop_tgt:`C_STANDARD_REQUIRED` +* :prop_tgt:`CXX_STANDARD_REQUIRED` +* :prop_tgt:`CUDA_STANDARD_REQUIRED` +* :prop_tgt:`HIP_STANDARD_REQUIRED` +* :prop_tgt:`OBJC_STANDARD_REQUIRED` +* :prop_tgt:`OBJCXX_STANDARD_REQUIRED` + +These properties specify whether the value of :prop_tgt:`_STANDARD` is a +requirement. When false or unset, the :prop_tgt:`_STANDARD` target +property is treated as optional and may "decay" to a previous standard if the +requested standard is not available. When ``_STANDARD_REQUIRED`` is set +to true, :prop_tgt:`_STANDARD` becomes a hard requirement and a fatal +error will be issued if that requirement cannot be met. + +Note that the actual language standard used may be higher than that specified +by :prop_tgt:`_STANDARD`, regardless of the value of +``_STANDARD_REQUIRED``. In particular, +:ref:`transitive usage requirements ` or the use of +:manual:`compile features ` can raise the required +language standard above what :prop_tgt:`_STANDARD` specifies. + +These properties are initialized by the value of the +:variable:`CMAKE__STANDARD_REQUIRED` variable if it is set when a target +is created. + +See the :manual:`cmake-compile-features(7)` manual for information on +compile features and a list of supported compilers. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_VISIBILITY_PRESET.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_VISIBILITY_PRESET.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5d34e207efb2e687a55ef07481120a83db5a847f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LANG_VISIBILITY_PRESET.rst.txt @@ -0,0 +1,13 @@ +_VISIBILITY_PRESET +------------------------ + +Value for symbol visibility compile flags + +The ``_VISIBILITY_PRESET`` property determines the value passed in a +visibility related compile option, such as ``-fvisibility=`` for ````. +This property affects compilation in sources of all types of targets +(subject to policy :policy:`CMP0063`). + +This property is initialized by the value of the +:variable:`CMAKE__VISIBILITY_PRESET` variable if it is set when a +target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LIBRARY_OUTPUT_DIRECTORY_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LIBRARY_OUTPUT_DIRECTORY_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5cefc38bb8bfd681b7a38d237274a8770e897e5b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LIBRARY_OUTPUT_DIRECTORY_CONFIG.rst.txt @@ -0,0 +1,17 @@ +LIBRARY_OUTPUT_DIRECTORY_ +--------------------------------- + +Per-configuration output directory for +:ref:`LIBRARY ` target files. + +This is a per-configuration version of the +:prop_tgt:`LIBRARY_OUTPUT_DIRECTORY` target property, but +multi-configuration generators (:ref:`Visual Studio Generators`, +:generator:`Xcode`) do NOT append a +per-configuration subdirectory to the specified directory. This +property is initialized by the value of the +:variable:`CMAKE_LIBRARY_OUTPUT_DIRECTORY_` variable if +it is set when a target is created. + +Contents of ``LIBRARY_OUTPUT_DIRECTORY_`` may use +:manual:`generator expressions `. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LIBRARY_OUTPUT_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LIBRARY_OUTPUT_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6027f7f73e732d7df7025d7b08749a6eea2dbf69 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LIBRARY_OUTPUT_NAME.rst.txt @@ -0,0 +1,8 @@ +LIBRARY_OUTPUT_NAME +------------------- + +.. |XXX| replace:: :ref:`LIBRARY ` +.. |xxx| replace:: library +.. include:: XXX_OUTPUT_NAME.txt + +See also the :prop_tgt:`LIBRARY_OUTPUT_NAME_` target property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LIBRARY_OUTPUT_NAME_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LIBRARY_OUTPUT_NAME_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..1994c7b1653880d66a1e8e2f2c66329c0f253de4 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LIBRARY_OUTPUT_NAME_CONFIG.rst.txt @@ -0,0 +1,8 @@ +LIBRARY_OUTPUT_NAME_ +---------------------------- + +Per-configuration output name for +:ref:`LIBRARY ` target files. + +This is the configuration-specific version of the +:prop_tgt:`LIBRARY_OUTPUT_NAME` target property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_FLAGS_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_FLAGS_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..68c31293206fba9138ece924a28482dde43f8f65 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_FLAGS_CONFIG.rst.txt @@ -0,0 +1,11 @@ +LINK_FLAGS_ +------------------- + +Per-configuration linker flags for a ``SHARED`` library, ``MODULE`` or +``EXECUTABLE`` target. + +This is the configuration-specific version of :prop_tgt:`LINK_FLAGS`. + +.. note:: + + This property has been superseded by :prop_tgt:`LINK_OPTIONS` property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b5c1d8907c668ca57369f69be570c2e8cb964a9b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARIES.rst.txt @@ -0,0 +1,30 @@ +LINK_LIBRARIES +-------------- + +List of direct link dependencies. + +This property specifies the list of libraries or targets which will be +used for linking. In addition to accepting values from the +:command:`target_link_libraries` command, values may be set directly on +any target using the :command:`set_property` command. + +The value of this property is used by the generators to construct the +link rule for the target. The direct link dependencies are linked first, +followed by indirect dependencies from the transitive closure of the +direct dependencies' :prop_tgt:`INTERFACE_LINK_LIBRARIES` properties. +See policy :policy:`CMP0022`. + +Contents of ``LINK_LIBRARIES`` may use +:manual:`generator expressions ` with the +syntax ``$<...>``. Policy :policy:`CMP0131` affects the behavior of the +:genex:`LINK_ONLY` generator expression for this property. + +See the :manual:`cmake-buildsystem(7)` manual for more on defining +buildsystem properties. + +.. include:: LINK_LIBRARIES_INDIRECTION.txt + +In advanced use cases, the list of direct link dependencies specified +by this property may be updated by usage requirements from dependencies. +See the :prop_tgt:`INTERFACE_LINK_LIBRARIES_DIRECT` and +:prop_tgt:`INTERFACE_LINK_LIBRARIES_DIRECT_EXCLUDE` target properties. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARIES_ONLY_TARGETS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARIES_ONLY_TARGETS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0749c6fb18153440fa1019c771790348b0422139 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARIES_ONLY_TARGETS.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARY_OVERRIDE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARY_OVERRIDE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..916a7c66d5fb0bcb6874f55efdc34c9aae062881 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARY_OVERRIDE.rst.txt @@ -0,0 +1,65 @@ +LINK_LIBRARY_OVERRIDE +--------------------- + +.. versionadded:: 3.24 + +Override the library features associated with libraries from +:genex:`LINK_LIBRARY` generator expressions. This can be used to resolve +incompatible library features that result from specifying different features +for the same library in different :genex:`LINK_LIBRARY` generator expressions. + +This property supports overriding multiple libraries and features. It expects +a :ref:`semicolon-separated list `, where each list item +has the following form:: + + feature[,link-item]* + +For each comma-separated ``link-item``, any existing library feature associated +with it will be ignored for the target this property is set on. The item +will instead be associated with the specified ``feature``. Each ``link-item`` +can be anything that would be accepted as part of a ``library-list`` in a +:genex:`LINK_LIBRARY` generator expression. + +.. code-block:: cmake + + add_library(lib1 ...) + add_library(lib2 ...) + add_library(lib3 ...) + + target_link_libraries(lib1 PUBLIC "$") + target_link_libraries(lib2 PUBLIC "$") + target_link_libraries(lib3 PRIVATE lib1 lib2) + + # lib1 is associated with both feature2 and no feature. Without any override, + # this would result in a fatal error at generation time for lib3. + # Define an override to resolve the incompatible feature associations. + set_property(TARGET lib3 PROPERTY LINK_LIBRARY_OVERRIDE "feature2,lib1,external") + + # lib1 and external will now be associated with feature2 instead when linking lib3 + +It is also possible to override any feature with the pre-defined ``DEFAULT`` +library feature. This effectively discards any feature for that link item, +for that target only (``lib3`` in this example): + +.. code-block:: cmake + + # When linking lib3, discard any library feature for lib1, and use feature2 for external + set_property(TARGET lib3 PROPERTY LINK_LIBRARY_OVERRIDE + "DEFAULT,lib1" + "feature2,external" + ) + +The above example also demonstrates how to specify different feature overrides +for different link items. See the :prop_tgt:`LINK_LIBRARY_OVERRIDE_` +target property for an alternative way of overriding library features for +individual libraries, which may be simpler in some cases. If both properties +are defined and specify an override for the same link item, +:prop_tgt:`LINK_LIBRARY_OVERRIDE_` takes precedence over +``LINK_LIBRARY_OVERRIDE``. + +Contents of ``LINK_LIBRARY_OVERRIDE`` may use +:manual:`generator expressions `. + +For more information about library features, see the +:variable:`CMAKE__LINK_LIBRARY_USING_` and +:variable:`CMAKE_LINK_LIBRARY_USING_` variables. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARY_OVERRIDE_LIBRARY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARY_OVERRIDE_LIBRARY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..4d3dd4f64a4181aaec6fe5032414a1b0fb50f1ea --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_LIBRARY_OVERRIDE_LIBRARY.rst.txt @@ -0,0 +1,51 @@ +LINK_LIBRARY_OVERRIDE_ +------------------------------- + +.. versionadded:: 3.24 + +Override the library feature associated with ```` from +:genex:`LINK_LIBRARY` generator expressions. This can be used to resolve +incompatible library features that result from specifying different features +for ```` in different :genex:`LINK_LIBRARY` generator expressions. + +When set on a target, this property holds a single library feature name, which +will be applied to ```` when linking that target. + +.. code-block:: cmake + + add_library(lib1 ...) + add_library(lib2 ...) + add_library(lib3 ...) + + target_link_libraries(lib1 PUBLIC "$") + target_link_libraries(lib2 PUBLIC "$") + target_link_libraries(lib3 PRIVATE lib1 lib2) + + # lib1 is associated with both feature2 and no feature. Without any override, + # this would result in a fatal error at generation time for lib3. + # Define an override to resolve the incompatible feature associations. + set_property(TARGET lib3 PROPERTY LINK_LIBRARY_OVERRIDE_lib1 feature2) + + # lib1 will now be associated with feature2 instead when linking lib3 + +It is also possible to override any feature with the pre-defined ``DEFAULT`` +library feature. This effectively discards any feature for that link item, +for that target only (``lib3`` in this example): + +.. code-block:: cmake + + # When linking lib3, discard any library feature for lib1 + set_property(TARGET lib3 PROPERTY LINK_LIBRARY_OVERRIDE_lib1 DEFAULT) + +See the :prop_tgt:`LINK_LIBRARY_OVERRIDE` target property for an alternative +way of overriding library features for multiple libraries at once. If both +properties are defined and specify an override for the same link item, +``LINK_LIBRARY_OVERRIDE_`` takes precedence over +:prop_tgt:`LINK_LIBRARY_OVERRIDE`. + +Contents of ``LINK_LIBRARY_OVERRIDE_`` may use +:manual:`generator expressions `. + +For more information about library features, see the +:variable:`CMAKE__LINK_LIBRARY_USING_` and +:variable:`CMAKE_LINK_LIBRARY_USING_` variables. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_OPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_OPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..fcdac59039b48777364d761428a7071f16fd53da --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_OPTIONS.rst.txt @@ -0,0 +1,36 @@ +LINK_OPTIONS +------------ + +.. versionadded:: 3.13 + +List of options to use for the link step of shared library, module +and executable targets as well as the device link step. Targets that are static +libraries need to use the :prop_tgt:`STATIC_LIBRARY_OPTIONS` target property. + +These options are used for both normal linking and device linking +(see policy :policy:`CMP0105`). To control link options for normal and device +link steps, :genex:`$` and :genex:`$` generator +expressions can be used. + +This property holds a :ref:`semicolon-separated list ` of +options specified so far for its target. Use the :command:`target_link_options` +command to append more options. + +This property is initialized by the :prop_dir:`LINK_OPTIONS` directory +property when a target is created, and is used by the generators to set +the options for the compiler. + +Contents of ``LINK_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:`LINK_FLAGS` property. + +.. include:: ../command/DEVICE_LINK_OPTIONS.txt + +.. include:: ../command/OPTIONS_SHELL.txt + +.. include:: ../command/LINK_OPTIONS_LINKER.txt diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_SEARCH_END_STATIC.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_SEARCH_END_STATIC.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..fecbb148049e3543dd15b5de8fb609dec247d655 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_SEARCH_END_STATIC.rst.txt @@ -0,0 +1,19 @@ +LINK_SEARCH_END_STATIC +---------------------- + +End a link line such that static system libraries are used. + +Some linkers support switches such as ``-Bstatic`` and ``-Bdynamic`` to +determine whether to use static or shared libraries for ``-lXXX`` options. +CMake uses these options to set the link type for libraries whose full +paths are not known or (in some cases) are in implicit link +directories for the platform. By default CMake adds an option at the +end of the library list (if necessary) to set the linker search type +back to its starting type. This property switches the final linker +search type to ``-Bstatic`` regardless of how it started. + +This property is initialized by the value of the variable +:variable:`CMAKE_LINK_SEARCH_END_STATIC` if it is set +when a target is created. + +See also :prop_tgt:`LINK_SEARCH_START_STATIC`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_SEARCH_START_STATIC.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_SEARCH_START_STATIC.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..83cf231c5fa49703fc72b06c822776eb39451ba2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_SEARCH_START_STATIC.rst.txt @@ -0,0 +1,20 @@ +LINK_SEARCH_START_STATIC +------------------------ + +Assume the linker looks for static libraries by default. + +Some linkers support switches such as ``-Bstatic`` and ``-Bdynamic`` to +determine whether to use static or shared libraries for ``-lXXX`` options. +CMake uses these options to set the link type for libraries whose full +paths are not known or (in some cases) are in implicit link +directories for the platform. By default the linker search type is +assumed to be ``-Bdynamic`` at the beginning of the library list. This +property switches the assumption to ``-Bstatic``. It is intended for use +when linking an executable statically (e.g. with the GNU ``-static`` +option). + +This property is initialized by the value of the variable + :variable:`CMAKE_LINK_SEARCH_START_STATIC` if it is set + when a target is created. + +See also :prop_tgt:`LINK_SEARCH_END_STATIC`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_WHAT_YOU_USE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_WHAT_YOU_USE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d6de0d49c7577ebb902dcc8a513d547cd456c191 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LINK_WHAT_YOU_USE.rst.txt @@ -0,0 +1,23 @@ +LINK_WHAT_YOU_USE +----------------- + +.. versionadded:: 3.7 + +This is a boolean option that, when set to ``TRUE``, will automatically run +contents of variable :variable:`CMAKE_LINK_WHAT_YOU_USE_CHECK` on the target +after it is linked. In addition, the linker flag specified by variable +:variable:`CMAKE__LINK_WHAT_YOU_USE_FLAG` will be passed to the target +with the link command so that all libraries specified on the command line will +be linked into the target. This will result in the link producing a list of +libraries that provide no symbols used by this target but are being linked to +it. + +.. note:: + + For now, it is only supported for ``ELF`` platforms and is only applicable to + executable and shared or module library targets. This property will be + ignored for any other targets and configurations. + +This property is initialized by the value of +the :variable:`CMAKE_LINK_WHAT_YOU_USE` variable if it is set +when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LOCATION_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LOCATION_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..67de8ed21c574164e96741031ef8abf5c7fe1ad2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/LOCATION_CONFIG.rst.txt @@ -0,0 +1,20 @@ +LOCATION_ +----------------- + +Read-only property providing a target location on disk. + +A read-only property that indicates where a target's main file is +located on disk for the configuration ````. The property is +defined only for library and executable targets. An imported target +may provide a set of configurations different from that of the +importing project. By default CMake looks for an exact-match but +otherwise uses an arbitrary available configuration. Use the +:prop_tgt:`MAP_IMPORTED_CONFIG_` property to map imported +configurations explicitly. + +Do not set properties that affect the location of a target after +reading this property. These include properties whose names match +``(RUNTIME|LIBRARY|ARCHIVE)_OUTPUT_(NAME|DIRECTORY)(_)?``, +``(IMPLIB_)?(PREFIX|SUFFIX)``, or :prop_tgt:`LINKER_LANGUAGE`. +Failure to follow this rule is not diagnosed and leaves +the location of the target undefined. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MACHO_COMPATIBILITY_VERSION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MACHO_COMPATIBILITY_VERSION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a24b25519feb644ccedb6873626da7337f3bb6a4 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MACHO_COMPATIBILITY_VERSION.rst.txt @@ -0,0 +1,27 @@ +MACHO_COMPATIBILITY_VERSION +--------------------------- + +.. versionadded:: 3.17 + +What compatibility version number is this target for Mach-O binaries. + +For shared libraries on Mach-O systems (e.g. macOS, iOS) +the ``MACHO_COMPATIBILITY_VERSION`` property corresponds to the +*compatibility version* and :prop_tgt:`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 :prop_tgt:`MACHO_CURRENT_VERSION` and +``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 :prop_tgt:`MACHO_CURRENT_VERSION` and ``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 :prop_tgt:`MACHO_CURRENT_VERSION` and ``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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MACOSX_BUNDLE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MACOSX_BUNDLE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..92bce53eee6a04b7c3e42f51da647ea8843b3f08 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MACOSX_BUNDLE.rst.txt @@ -0,0 +1,12 @@ +MACOSX_BUNDLE +------------- + +Build an executable as an Application Bundle on macOS or iOS. + +When this property is set to ``TRUE`` the executable when built on macOS +or iOS will be created as an application bundle. This makes it +a GUI executable that can be launched from the Finder. See the +:prop_tgt:`MACOSX_BUNDLE_INFO_PLIST` target property for information about +creation of the ``Info.plist`` file for the application bundle. +This property is initialized by the value of the variable +:variable:`CMAKE_MACOSX_BUNDLE` if it is set when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MACOSX_FRAMEWORK_INFO_PLIST.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MACOSX_FRAMEWORK_INFO_PLIST.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..82fdcc0fb0253fd1d4d170caa4add45d2e4f4cdc --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MACOSX_FRAMEWORK_INFO_PLIST.rst.txt @@ -0,0 +1,27 @@ +MACOSX_FRAMEWORK_INFO_PLIST +--------------------------- + +Specify a custom ``Info.plist`` template for a macOS and iOS Framework. + +A library target with :prop_tgt:`FRAMEWORK` enabled will be built as a +framework on macOS. By default its ``Info.plist`` file is created by +configuring a template called ``MacOSXFrameworkInfo.plist.in`` located in the +:variable:`CMAKE_MODULE_PATH`. This property specifies an alternative template +file name which may be a full path. + +The following target properties may be set to specify content to be +configured into the file: + +``MACOSX_FRAMEWORK_BUNDLE_VERSION`` + Sets ``CFBundleVersion``. +``MACOSX_FRAMEWORK_ICON_FILE`` + Sets ``CFBundleIconFile``. +``MACOSX_FRAMEWORK_IDENTIFIER`` + Sets ``CFBundleIdentifier``. +``MACOSX_FRAMEWORK_SHORT_VERSION_STRING`` + Sets ``CFBundleShortVersionString``. + +CMake variables of the same name may be set to affect all targets in a +directory that do not have each specific property set. If a custom +``Info.plist`` is specified by this property it may of course hard-code +all the settings instead of using the target properties. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MSVC_RUNTIME_LIBRARY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MSVC_RUNTIME_LIBRARY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9f13d38a706231b351bcf7d040227f412ea62e90 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/MSVC_RUNTIME_LIBRARY.rst.txt @@ -0,0 +1,33 @@ +MSVC_RUNTIME_LIBRARY +-------------------- + +.. versionadded:: 3.15 + +Select the MSVC runtime library for use by compilers targeting the MSVC ABI. + +The allowed values are: + +.. include:: MSVC_RUNTIME_LIBRARY-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_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") + +selects for the target ``foo`` a multi-threaded statically-linked runtime +library with or without debug information depending on the configuration. + +The property is initialized from the value of the +:variable:`CMAKE_MSVC_RUNTIME_LIBRARY` variable, if it is set. +If the property is not set, then CMake uses the default value +``MultiThreaded$<$:Debug>DLL`` to select a MSVC runtime library. + +.. note:: + + This property has effect only when policy :policy:`CMP0091` 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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/NO_SONAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/NO_SONAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d381a9c3b7be1044666c064918fe3ae24b337c34 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/NO_SONAME.rst.txt @@ -0,0 +1,14 @@ +NO_SONAME +--------- + +Whether to set ``soname`` when linking a shared library. + +Enable this boolean property if a generated ``SHARED`` library +should not have ``soname`` set. Default is to set ``soname`` on all +shared libraries as long as the platform supports it. +Generally, use this property only for leaf private libraries or +plugins. If you use it on normal shared libraries which other targets +link against, on some platforms a linker will insert a full path to +the library (as specified at link time) into the dynamic section of +the dependent binary. Therefore, once installed, dynamic loader may +eventually fail to locate the library for the binary. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OBJC_EXTENSIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OBJC_EXTENSIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2914045fb4d1f761a206dcb6c703afe4e729a7f0 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OBJC_EXTENSIONS.rst.txt @@ -0,0 +1,24 @@ +OBJC_EXTENSIONS +--------------- + +.. versionadded:: 3.16 + +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 OBJC standard level is +controlled by the :prop_tgt:`OBJC_STANDARD` target property. + +If the property is not set, and the project has set the :prop_tgt:`C_EXTENSIONS`, +the value of :prop_tgt:`C_EXTENSIONS` is set for ``OBJC_EXTENSIONS``. + +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_OBJC_EXTENSIONS` variable if set when a target is created +and otherwise by the value of +:variable:`CMAKE_OBJC_EXTENSIONS_DEFAULT _EXTENSIONS_DEFAULT>` +(see :policy:`CMP0128`). diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OBJC_STANDARD.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OBJC_STANDARD.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0609239f5a173e1af2492f7a90ef0e0d1fee33ab --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OBJC_STANDARD.rst.txt @@ -0,0 +1,46 @@ +OBJC_STANDARD +------------- + +.. versionadded:: 3.16 + +The OBJC standard whose features are requested to build this target. + +This property specifies the OBJC standard whose features are requested +to build this target. For some compilers, this results in adding a +flag such as ``-std=gnu11`` to the compile line. + +Supported values are: + +``90`` + Objective C89/C90 + +``99`` + Objective C99 + +``11`` + Objective C11 + +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 OBJC_STANDARD 11) + +with a compiler which does not support ``-std=gnu11`` or an equivalent +flag will not result in an error or warning, but will instead add the +``-std=gnu99`` or ``-std=gnu90`` flag if supported. This "decay" behavior may +be controlled with the :prop_tgt:`OBJC_STANDARD_REQUIRED` target property. +Additionally, the :prop_tgt:`OBJC_EXTENSIONS` target property may be used to +control whether compiler-specific extensions are enabled on a per-target basis. + +If the property is not set, and the project has set the :prop_tgt:`C_STANDARD`, +the value of :prop_tgt:`C_STANDARD` is set for ``OBJC_STANDARD``. + +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_OBJC_STANDARD` variable if it is set when a target +is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OSX_ARCHITECTURES_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OSX_ARCHITECTURES_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..06da4fb09dbf43e5bd46162bc914353853ff75a7 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OSX_ARCHITECTURES_CONFIG.rst.txt @@ -0,0 +1,7 @@ +OSX_ARCHITECTURES_ +-------------------------- + +Per-configuration macOS and iOS binary architectures for a target. + +This property is the configuration-specific version of +:prop_tgt:`OSX_ARCHITECTURES`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OUTPUT_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OUTPUT_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..4b33b38e06bc2069fa20686b0b795e9fe9ddb2b1 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OUTPUT_NAME.rst.txt @@ -0,0 +1,22 @@ +OUTPUT_NAME +----------- + +Output name for target files. + +This sets the base name for output files created for an executable or +library target. If not set, the logical target name is used by +default during generation. The value is not set by default during +configuration. + +Contents of ``OUTPUT_NAME`` and the variants listed below may use +:manual:`generator expressions `. + +See also the variants: + +* :prop_tgt:`OUTPUT_NAME_` +* :prop_tgt:`ARCHIVE_OUTPUT_NAME_` +* :prop_tgt:`ARCHIVE_OUTPUT_NAME` +* :prop_tgt:`LIBRARY_OUTPUT_NAME_` +* :prop_tgt:`LIBRARY_OUTPUT_NAME` +* :prop_tgt:`RUNTIME_OUTPUT_NAME_` +* :prop_tgt:`RUNTIME_OUTPUT_NAME` diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OUTPUT_NAME_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OUTPUT_NAME_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..41b782f98e0c20cf9512128a851e436c50c6041f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/OUTPUT_NAME_CONFIG.rst.txt @@ -0,0 +1,7 @@ +OUTPUT_NAME_ +-------------------- + +Per-configuration target file base name. + +This is the configuration-specific version of the :prop_tgt:`OUTPUT_NAME` +target property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PCH_INSTANTIATE_TEMPLATES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PCH_INSTANTIATE_TEMPLATES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..7c1af2acd3f64ec6914c212f641eebd30a532e30 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PCH_INSTANTIATE_TEMPLATES.rst.txt @@ -0,0 +1,13 @@ +PCH_INSTANTIATE_TEMPLATES +------------------------- + +.. versionadded:: 3.19 + +When this property is set to true, the precompiled header compiler options +will contain a flag to instantiate templates during the generation of the PCH +if supported. This can significantly improve compile times. Supported in Clang +since version 11. + +This property is initialized by the value of the +:variable:`CMAKE_PCH_INSTANTIATE_TEMPLATES` variable if it is set when a target +is created. If that variable is not set, the property defaults to ``ON``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PCH_WARN_INVALID.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PCH_WARN_INVALID.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2d5ec55caa82d759af0705bf758a317093c898aa --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PCH_WARN_INVALID.rst.txt @@ -0,0 +1,12 @@ +PCH_WARN_INVALID +---------------- + +.. versionadded:: 3.18 + +When this property is set to true, the precompile header compiler options +will contain a compiler flag which should warn about invalid precompiled +headers e.g. ``-Winvalid-pch`` for GNU compiler. + +This property is initialized by the value of the +:variable:`CMAKE_PCH_WARN_INVALID` variable if it is set when a target is +created. If that variable is not set, the property defaults to ``ON``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/POSITION_INDEPENDENT_CODE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/POSITION_INDEPENDENT_CODE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0aaf66bd0ef0c22fca53fce780b0ca72ddd3e29b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/POSITION_INDEPENDENT_CODE.rst.txt @@ -0,0 +1,16 @@ +POSITION_INDEPENDENT_CODE +------------------------- + +Whether to create a position-independent target + +The ``POSITION_INDEPENDENT_CODE`` property determines whether position +independent executables or shared libraries will be created. This +property is ``True`` by default for ``SHARED`` and ``MODULE`` library +targets and ``False`` otherwise. This property is initialized by the value +of the :variable:`CMAKE_POSITION_INDEPENDENT_CODE` variable if it is set +when a target is created. + +.. note:: + + For executable targets, the link step is controlled by the :policy:`CMP0083` + policy and the :module:`CheckPIESupported` module. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/POST_INSTALL_SCRIPT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/POST_INSTALL_SCRIPT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..23935bcdfdcbe9b6446842c2c14a0561545ffabd --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/POST_INSTALL_SCRIPT.rst.txt @@ -0,0 +1,9 @@ +POST_INSTALL_SCRIPT +------------------- + +Deprecated install support. + +The :prop_tgt:`PRE_INSTALL_SCRIPT` and ``POST_INSTALL_SCRIPT`` properties are +the old way to specify CMake scripts to run before and after installing a +target. They are used only when the old ``INSTALL_TARGETS`` command is +used to install the target. Use the :command:`install` command instead. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PRECOMPILE_HEADERS_REUSE_FROM.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PRECOMPILE_HEADERS_REUSE_FROM.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6f5635b4e482f04e6dc29de3b86a039d669e2db2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PRECOMPILE_HEADERS_REUSE_FROM.rst.txt @@ -0,0 +1,9 @@ +PRECOMPILE_HEADERS_REUSE_FROM +----------------------------- + +.. versionadded:: 3.16 + +Target from which to reuse the precompiled headers build artifact. + +See the second signature of :command:`target_precompile_headers` command +for more detailed information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PRIVATE_HEADER.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PRIVATE_HEADER.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..23e1f8e6f3bd30eb142a8eea3937e4e2b4b9ff5e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PRIVATE_HEADER.rst.txt @@ -0,0 +1,11 @@ +PRIVATE_HEADER +-------------- + +Specify private 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 +PrivateHeaders directory inside the framework folder. On non-Apple +platforms these headers may be installed using the ``PRIVATE_HEADER`` +option to the :command:`install(TARGETS)` command. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PROJECT_LABEL.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PROJECT_LABEL.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a1491ee139892c74ac63339415402ca6e11dc714 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/PROJECT_LABEL.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RESOURCE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RESOURCE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e5a1cb677989da86ccb37420140a187b04401cd5 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RESOURCE.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RULE_LAUNCH_COMPILE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RULE_LAUNCH_COMPILE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3f4305f21bb299c8e37f11222fe21e51b2bad0f1 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RULE_LAUNCH_COMPILE.rst.txt @@ -0,0 +1,13 @@ +RULE_LAUNCH_COMPILE +------------------- + +Specify a launcher for compile rules. + +.. note:: + This property is intended for internal use by :manual:`ctest(1)`. Projects + and developers should use the :prop_tgt:`_COMPILER_LAUNCHER` target + properties or the associated :variable:`CMAKE__COMPILER_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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RULE_LAUNCH_CUSTOM.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RULE_LAUNCH_CUSTOM.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2db03177f815b7c02f932bd5bd89fc538bf60409 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RULE_LAUNCH_CUSTOM.rst.txt @@ -0,0 +1,7 @@ +RULE_LAUNCH_CUSTOM +------------------ + +Specify a launcher for custom rules. + +See the global property of the same name for details. This overrides +the global and directory property for a target. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RULE_LAUNCH_LINK.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RULE_LAUNCH_LINK.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..da93be259b8e5a0d02e2019d506663137fa7fbda --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/RULE_LAUNCH_LINK.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/SOVERSION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/SOVERSION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b377f222887bd79fbaa3761a668d16113c65ac28 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/SOVERSION.rst.txt @@ -0,0 +1,37 @@ +SOVERSION +--------- + +What version number is this target. + +For shared libraries :prop_tgt:`VERSION` and ``SOVERSION`` can be used to +specify the build version and API version respectively. When building or +installing appropriate symlinks are created if the platform supports +symlinks and the linker supports so-names. If only one of both is +specified the missing is assumed to have the same version number. +``SOVERSION`` is ignored if :prop_tgt:`NO_SONAME` property is set. + +Windows Versions +^^^^^^^^^^^^^^^^ + +For shared libraries and executables on Windows the :prop_tgt:`VERSION` +attribute is parsed to extract a ``.`` version number. +These numbers are used as the image version of the binary. + +Mach-O Versions +^^^^^^^^^^^^^^^ + +For shared libraries and executables on Mach-O systems (e.g. macOS, iOS), +the ``SOVERSION`` property corresponds to the *compatibility version* and +:prop_tgt:`VERSION` corresponds to the *current version* (unless Mach-O +specific overrides are provided, as discussed below). +See the :prop_tgt:`FRAMEWORK` target property for an example. + +For shared libraries, the :prop_tgt:`MACHO_COMPATIBILITY_VERSION` and +:prop_tgt:`MACHO_CURRENT_VERSION` properties can be used to +override the *compatibility version* and *current version* respectively. +Note that ``SOVERSION`` will still be used to form the ``install_name`` +and both ``SOVERSION`` and :prop_tgt:`VERSION` may also affect the file +and symlink names. + +Versions of Mach-O binaries may be checked with the ``otool -L `` +command. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/STATIC_LIBRARY_FLAGS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/STATIC_LIBRARY_FLAGS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..66e0e8b96a9ebed3b320e447dae936f6651869ad --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/STATIC_LIBRARY_FLAGS.rst.txt @@ -0,0 +1,17 @@ +STATIC_LIBRARY_FLAGS +-------------------- + +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` or :prop_tgt:`LINK_FLAGS` target properties. + +The ``STATIC_LIBRARY_FLAGS`` property, managed as a string, can be used to add +extra flags to the link step of a static library target. +:prop_tgt:`STATIC_LIBRARY_FLAGS_` will add to the configuration +````, for example, ``DEBUG``, ``RELEASE``, ``MINSIZEREL``, +``RELWITHDEBINFO``, ... + +.. note:: + + This property has been superseded by :prop_tgt:`STATIC_LIBRARY_OPTIONS` + property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/STATIC_LIBRARY_OPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/STATIC_LIBRARY_OPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..f5d943723ba9c1dfdd5759490d189930624d07c2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/STATIC_LIBRARY_OPTIONS.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Swift_MODULE_DIRECTORY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Swift_MODULE_DIRECTORY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..619377a11c8a7b4c02fac97565f9d5cf4a79d391 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Swift_MODULE_DIRECTORY.rst.txt @@ -0,0 +1,12 @@ +Swift_MODULE_DIRECTORY +---------------------- + +.. versionadded:: 3.15 + +Specify output directory for Swift modules provided by the target. + +If the target contains Swift source files, this specifies the directory in which +the modules will be placed. When this property is not set, the modules will be +placed in the build directory corresponding to the target's source directory. +If the variable :variable:`CMAKE_Swift_MODULE_DIRECTORY` is set when a target is +created its value is used to initialize this property. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Swift_MODULE_NAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Swift_MODULE_NAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d941b5430440b26f15f10fd96bd2eef291638c68 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/Swift_MODULE_NAME.rst.txt @@ -0,0 +1,7 @@ +Swift_MODULE_NAME +----------------- + +.. versionadded:: 3.15 + +This property specifies the name of the Swift module. It is defaulted to the +name of the target. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/TYPE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/TYPE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3136d119d26d1971d89ed65f664ec7370096e48e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/TYPE.rst.txt @@ -0,0 +1,9 @@ +TYPE +---- + +The type of the target. + +This read-only property can be used to test the type of the given +target. It will be one of ``STATIC_LIBRARY``, ``MODULE_LIBRARY``, +``SHARED_LIBRARY``, ``OBJECT_LIBRARY``, ``INTERFACE_LIBRARY``, ``EXECUTABLE`` +or one of the internal target types. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/UNITY_BUILD_CODE_AFTER_INCLUDE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/UNITY_BUILD_CODE_AFTER_INCLUDE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ac2b19c212a572b006e8962a01b87e575fe26bbb --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/UNITY_BUILD_CODE_AFTER_INCLUDE.rst.txt @@ -0,0 +1,21 @@ +UNITY_BUILD_CODE_AFTER_INCLUDE +------------------------------ + +.. versionadded:: 3.16 + +Code snippet which is included verbatim by the :prop_tgt:`UNITY_BUILD` +feature just after every ``#include`` statement in the generated unity +source files. For example: + +.. code-block:: cmake + + set(after [[ + #if defined(NOMINMAX) + #undef NOMINMAX + #endif + ]]) + set_target_properties(myTarget PROPERTIES + UNITY_BUILD_CODE_AFTER_INCLUDE "${after}" + ) + +See also :prop_tgt:`UNITY_BUILD_CODE_BEFORE_INCLUDE`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VISIBILITY_INLINES_HIDDEN.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VISIBILITY_INLINES_HIDDEN.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..adbbc7103f9ba1d33bc326c4319820f4419af569 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VISIBILITY_INLINES_HIDDEN.rst.txt @@ -0,0 +1,13 @@ +VISIBILITY_INLINES_HIDDEN +------------------------- + +Whether to add a compile flag to hide symbols of inline functions + +The ``VISIBILITY_INLINES_HIDDEN`` property determines whether a flag for +hiding symbols for inline functions, such as ``-fvisibility-inlines-hidden``, +should be used when invoking the compiler. This property affects compilation +in sources of all types of targets (subject to policy :policy:`CMP0063`). + +This property is initialized by +the value of the :variable:`CMAKE_VISIBILITY_INLINES_HIDDEN` variable if it +is set when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_CONFIGURATION_TYPE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_CONFIGURATION_TYPE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..4adffd4f23dc67475710b64376ed75abecdaad7e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_CONFIGURATION_TYPE.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DEBUGGER_COMMAND.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DEBUGGER_COMMAND.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5bf47a38a9bb5f137400738dc03c014a3d8b1262 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DEBUGGER_COMMAND.rst.txt @@ -0,0 +1,15 @@ +VS_DEBUGGER_COMMAND +------------------- + +.. versionadded:: 3.12 + +Sets the local debugger command 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_COMMAND` if it is set when a target is +created. + +This property only works for Visual Studio 11 2012 and above; +it is ignored on other generators. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DEBUGGER_ENVIRONMENT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DEBUGGER_ENVIRONMENT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..8373dbb5c8b8aa41a2cab0b53345773410fbf81e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DEBUGGER_ENVIRONMENT.rst.txt @@ -0,0 +1,15 @@ +VS_DEBUGGER_ENVIRONMENT +----------------------- + +.. versionadded:: 3.13 + +Sets the local debugger environment 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_ENVIRONMENT` if it is set when a target is +created. + +This property only works for Visual Studio 11 2012 and above; +it is ignored on other generators. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DEBUGGER_WORKING_DIRECTORY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DEBUGGER_WORKING_DIRECTORY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..39420475bd5d85c39134c1e5ea76a9275db5212b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DEBUGGER_WORKING_DIRECTORY.rst.txt @@ -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 Visual Studio 11 2012 and above; +it is ignored on other generators. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_DOCUMENTATION_FILE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_DOCUMENTATION_FILE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a3882569e0d4fd40aadcc71f99758e8826330cdc --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_DOCUMENTATION_FILE.rst.txt @@ -0,0 +1,8 @@ +VS_DOTNET_DOCUMENTATION_FILE +---------------------------- + +.. versionadded:: 3.17 + +Visual Studio managed project .NET documentation output + +Sets the target XML documentation file output. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCEPROP_refname_TAG_tagname.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCEPROP_refname_TAG_tagname.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5b9caee08e573baa4299af816f4e60c41607b648 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCEPROP_refname_TAG_tagname.rst.txt @@ -0,0 +1,16 @@ +VS_DOTNET_REFERENCEPROP__TAG_ +----------------------------------------------- + +.. versionadded:: 3.10 + +Defines an XML property ```` for a .NET reference +````. + +Reference properties can be set for .NET references which are +defined by the target properties :prop_tgt:`VS_DOTNET_REFERENCES`, +:prop_tgt:`VS_DOTNET_REFERENCE_` +and also for project references to other C# targets which are +established by :command:`target_link_libraries()`. + +This property is only applicable to C# targets and Visual Studio +generators 2010 and later. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a661ad926a7214a4fa35189d7ea2adedad4887eb --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCES.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCES_COPY_LOCAL.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCES_COPY_LOCAL.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..556fa8acc1001161d737dc5dec5c599e7aebb6be --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCES_COPY_LOCAL.rst.txt @@ -0,0 +1,9 @@ +VS_DOTNET_REFERENCES_COPY_LOCAL +------------------------------- + +.. versionadded:: 3.8 + +Sets the **Copy Local** property for all .NET hint references in the target + +Boolean property to enable/disable copying of .NET hint references to +output directory. The default is ``ON``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCE_refname.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCE_refname.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9c4d34abe9a7744d2439ddfae1e55555378257af --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DOTNET_REFERENCE_refname.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DPI_AWARE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DPI_AWARE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..47ce1ce2a8d80639676002498abf5b5908790d0f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_DPI_AWARE.rst.txt @@ -0,0 +1,16 @@ +VS_DPI_AWARE +------------ + +.. versionadded:: 3.16 + +Set the Manifest Tool -> Input and Output -> DPI Awareness in the Visual Studio +target project properties. + +Valid values are ``PerMonitor``, ``ON``, or ``OFF``. + +For example: + +.. code-block:: cmake + + add_executable(myproject myproject.cpp) + set_property(TARGET myproject PROPERTY VS_DPI_AWARE "PerMonitor") diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_GLOBAL_PROJECT_TYPES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_GLOBAL_PROJECT_TYPES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..f4d9efc8eb2ade5817c307ecdaa870b7d0eac43d --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_GLOBAL_PROJECT_TYPES.rst.txt @@ -0,0 +1,15 @@ +VS_GLOBAL_PROJECT_TYPES +----------------------- + +Visual Studio project type(s). + +Can be set to one or more UUIDs recognized by Visual Studio to +indicate the type of project. This value is copied verbatim into the +generated project file. Example for a managed C++ unit testing +project: + +:: + + {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942} + +UUIDs are semicolon-delimited. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_GLOBAL_ROOTNAMESPACE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_GLOBAL_ROOTNAMESPACE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..a23c54005ee2fc4f90f6b6a9f2511f68a7a028d3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_GLOBAL_ROOTNAMESPACE.rst.txt @@ -0,0 +1,7 @@ +VS_GLOBAL_ROOTNAMESPACE +----------------------- + +Visual Studio project root namespace. + +Sets the "RootNamespace" attribute for a generated Visual Studio +project. The attribute will be generated only if this is set. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_IOT_EXTENSIONS_VERSION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_IOT_EXTENSIONS_VERSION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ca6a3ca0063817d6a9f87f5517d6a18871c930bd --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_IOT_EXTENSIONS_VERSION.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_KEYWORD.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_KEYWORD.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..221b986ac32a8355a22657887ab888ee0ee0a34f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_KEYWORD.rst.txt @@ -0,0 +1,10 @@ +VS_KEYWORD +---------- + +Visual Studio project keyword for VS 9 (2008) and older. + +Can be set to change the visual studio keyword, for example Qt +integration works better if this is set to Qt4VSv1.0. + +Use the :prop_tgt:`VS_GLOBAL_KEYWORD` target property to set the +keyword for Visual Studio 11 (2012) and newer. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_PROJECT_IMPORT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_PROJECT_IMPORT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..f5e9698a3f906b60cde2563a10709d6421c1b9e3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_PROJECT_IMPORT.rst.txt @@ -0,0 +1,10 @@ +VS_PROJECT_IMPORT +----------------- + +.. versionadded:: 3.15 + +Visual Studio managed project imports + +Adds to a generated Visual Studio project one or more semicolon-delimited paths +to .props files needed when building projects from some NuGet packages. +For example, ``my_packages_path/MyPackage.1.0.0/build/MyPackage.props``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_SCC_PROJECTNAME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_SCC_PROJECTNAME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6d7f628d92e1214f2a48a73db0677c033078b232 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_SCC_PROJECTNAME.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_SOLUTION_DEPLOY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_SOLUTION_DEPLOY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e56f411bd71a5fdf68ec6cd14c2d91c59d48c360 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_SOLUTION_DEPLOY.rst.txt @@ -0,0 +1,29 @@ +VS_SOLUTION_DEPLOY +------------------ + +.. versionadded:: 3.18 + +Specify that the target should be marked for deployment when not targeting +Windows CE, Windows Phone or a Windows Store application. + +If the target platform doesn't support deployment, this property won't have +any effect. + +:manual:`Generator expressions ` are supported. + +Examples +^^^^^^^^ + +Always deploy target ``foo``: + +.. code-block:: cmake + + add_executable(foo SHARED foo.cpp) + set_property(TARGET foo PROPERTY VS_SOLUTION_DEPLOY ON) + +Deploy target ``foo`` for all configurations except ``Release``: + +.. code-block:: cmake + + add_executable(foo SHARED foo.cpp) + set_property(TARGET foo PROPERTY VS_SOLUTION_DEPLOY "$>") diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_USER_PROPS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_USER_PROPS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..8f2a105831e718f9491b28c5ad20e5aef2c337a3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_USER_PROPS.rst.txt @@ -0,0 +1,14 @@ +VS_USER_PROPS +------------- + +.. versionadded:: 3.8 + +Sets the user props file to be included in the visual studio +C++ project file. The standard path is +``$(UserRootDir)\\Microsoft.Cpp.$(Platform).user.props``, which is +in most cases the same as +``%LOCALAPPDATA%\\Microsoft\\MSBuild\\v4.0\\Microsoft.Cpp.Win32.user.props`` +or ``%LOCALAPPDATA%\\Microsoft\\MSBuild\\v4.0\\Microsoft.Cpp.x64.user.props``. + +The ``*.user.props`` files can be used for Visual Studio wide +configuration which is independent from cmake. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ef3ceb0f764629143fc50c58096f86556d9a3dc2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION.rst.txt @@ -0,0 +1,17 @@ +VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION +-------------------------------------- + +.. versionadded:: 3.4 + +Visual Studio Windows Target Platform Minimum Version + +For Windows 10. Specifies the minimum version of the OS that is being +targeted. For example ``10.0.10240.0``. If the value is not specified, the +value of the :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` variable +will be used on WindowsStore projects. Otherwise the target platform +minimum version will not be specified for the project. + +.. versionadded:: 3.27 + This property is initialized by the value of the + :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION` variable + if it is set when a target is created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_WINRT_COMPONENT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_WINRT_COMPONENT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b4aaf7ac0b7fcce6f8a63eeece92f9898d2bf45 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_WINRT_COMPONENT.rst.txt @@ -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/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_WINRT_EXTENSIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_WINRT_EXTENSIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d1cba3471f159a575998073305a608a745b376d5 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/VS_WINRT_EXTENSIONS.rst.txt @@ -0,0 +1,5 @@ +VS_WINRT_EXTENSIONS +------------------- + +Deprecated. Use :prop_tgt:`VS_WINRT_COMPONENT` instead. +This property was an experimental partial implementation of that one. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/WATCOM_RUNTIME_LIBRARY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/WATCOM_RUNTIME_LIBRARY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3752862b2e137f541a2c8e6a00dce993668e2143 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/WATCOM_RUNTIME_LIBRARY.rst.txt @@ -0,0 +1,34 @@ +WATCOM_RUNTIME_LIBRARY +---------------------- + +.. versionadded:: 3.24 + +Select the Watcom runtime library for use by compilers targeting the Watcom ABI. + +The allowed values are: + +.. include:: WATCOM_RUNTIME_LIBRARY-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 + WATCOM_RUNTIME_LIBRARY "MultiThreaded") + +selects for the target ``foo`` a multi-threaded statically-linked runtime +library. + +If this property is not set then CMake uses the default value +``MultiThreadedDLL`` on Windows and ``SingleThreaded`` on other +platforms to select a Watcom runtime library. + +.. note:: + + This property has effect only when policy :policy:`CMP0136` is set to ``NEW`` + prior to the first :command:`project` or :command:`enable_language` command + that enables a language using a compiler targeting the Watcom ABI. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/WIN32_EXECUTABLE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/WIN32_EXECUTABLE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..eac28ae3bd3da2e913f1f195a03ae2b2476520a0 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/WIN32_EXECUTABLE.rst.txt @@ -0,0 +1,17 @@ +WIN32_EXECUTABLE +---------------- + +Build an executable with a WinMain entry point on windows. + +When this property is set to true the executable when linked on +Windows will be created with a WinMain() entry point instead of just +main(). This makes it a GUI executable instead of a console application. +See the :variable:`CMAKE_MFC_FLAG` variable documentation to +configure use of the Microsoft Foundation Classes (MFC) for WinMain +executables. This property is initialized by the value of the +:variable:`CMAKE_WIN32_EXECUTABLE` variable if it is set when +a target is created. + +This property supports +:manual:`generator expressions `, except if the +target is managed (contains C# code.) diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_EMBED_type_CODE_SIGN_ON_COPY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_EMBED_type_CODE_SIGN_ON_COPY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..ca35c2551fab37fa14d8a7c5f390dfa38329b477 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_EMBED_type_CODE_SIGN_ON_COPY.rst.txt @@ -0,0 +1,24 @@ +XCODE_EMBED__CODE_SIGN_ON_COPY +------------------------------------ + +.. versionadded:: 3.20 + +Boolean property used only by the :generator:`Xcode` generator. It specifies +whether to perform code signing for the items that are embedded using the +:prop_tgt:`XCODE_EMBED_` property. + +The supported values for ```` are: + +``FRAMEWORKS`` + +``APP_EXTENSIONS`` + .. versionadded:: 3.21 + +``EXTENSIONKIT_EXTENSIONS`` + .. versionadded:: 3.26 + +``PLUGINS`` + .. versionadded:: 3.23 + +If a ``XCODE_EMBED__CODE_SIGN_ON_COPY`` property is not defined on the +target, no code signing on copy will be performed for that ````. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_EMBED_type_PATH.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_EMBED_type_PATH.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5a5c65f30f502c74a60447f2f2177badc24aabf7 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_EMBED_type_PATH.rst.txt @@ -0,0 +1,24 @@ +XCODE_EMBED__PATH +----------------------- + +.. versionadded:: 3.20 + +This property is used only by the :generator:`Xcode` generator. When defined, +it specifies the relative path to use when embedding the items specified by +:prop_tgt:`XCODE_EMBED_`. The path is relative +to the base location of the ``Embed XXX`` build phase associated with +````. See the Xcode documentation for the base location of each +````. + +The supported values for ```` are: + +``FRAMEWORKS`` + +``APP_EXTENSIONS`` + .. versionadded:: 3.21 + +``EXTENSIONKIT_EXTENSIONS`` + .. versionadded:: 3.26 + +``PLUGINS`` + .. versionadded:: 3.23 diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_EXPLICIT_FILE_TYPE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_EXPLICIT_FILE_TYPE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e01a0342b8f43d174e641b15abd95d3e78ce5abb --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_EXPLICIT_FILE_TYPE.rst.txt @@ -0,0 +1,10 @@ +XCODE_EXPLICIT_FILE_TYPE +------------------------ + +.. versionadded:: 3.8 + +Set the Xcode ``explicitFileType`` attribute on its reference to a +target. CMake computes a default based on target type but +can be told explicitly with this property. + +See also :prop_tgt:`XCODE_PRODUCT_TYPE`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_GENERATE_SCHEME.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_GENERATE_SCHEME.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..fa3c5bceedf438d10197d1a10f7b2c200512b6e1 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_GENERATE_SCHEME.rst.txt @@ -0,0 +1,48 @@ +XCODE_GENERATE_SCHEME +--------------------- + +.. versionadded:: 3.15 + +If enabled, the :generator:`Xcode` generator will generate schema files. These +are useful to invoke analyze, archive, build-for-testing and test +actions from the command line. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_GENERATE_SCHEME` if it is set when a target +is created. + +The following target properties overwrite the default of the +corresponding settings on the "Diagnostic" tab for each schema file. +Each of those is initialized by the respective ``CMAKE_`` variable +at target creation time. + +- :prop_tgt:`XCODE_SCHEME_ADDRESS_SANITIZER` +- :prop_tgt:`XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN` +- :prop_tgt:`XCODE_SCHEME_DISABLE_MAIN_THREAD_CHECKER` +- :prop_tgt:`XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS` +- :prop_tgt:`XCODE_SCHEME_DYNAMIC_LINKER_API_USAGE` +- :prop_tgt:`XCODE_SCHEME_GUARD_MALLOC` +- :prop_tgt:`XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP` +- :prop_tgt:`XCODE_SCHEME_MALLOC_GUARD_EDGES` +- :prop_tgt:`XCODE_SCHEME_MALLOC_SCRIBBLE` +- :prop_tgt:`XCODE_SCHEME_MALLOC_STACK` +- :prop_tgt:`XCODE_SCHEME_THREAD_SANITIZER` +- :prop_tgt:`XCODE_SCHEME_THREAD_SANITIZER_STOP` +- :prop_tgt:`XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER` +- :prop_tgt:`XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER_STOP` +- :prop_tgt:`XCODE_SCHEME_LAUNCH_CONFIGURATION` +- :prop_tgt:`XCODE_SCHEME_ENABLE_GPU_API_VALIDATION` +- :prop_tgt:`XCODE_SCHEME_ENABLE_GPU_SHADER_VALIDATION` +- :prop_tgt:`XCODE_SCHEME_ZOMBIE_OBJECTS` + +The following target properties will be applied on the +"Info", "Arguments", and "Options" tab: + +- :prop_tgt:`XCODE_SCHEME_ARGUMENTS` +- :prop_tgt:`XCODE_SCHEME_DEBUG_AS_ROOT` +- :prop_tgt:`XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING` +- :prop_tgt:`XCODE_SCHEME_ENABLE_GPU_FRAME_CAPTURE_MODE` +- :prop_tgt:`XCODE_SCHEME_ENVIRONMENT` +- :prop_tgt:`XCODE_SCHEME_EXECUTABLE` +- :prop_tgt:`XCODE_SCHEME_LAUNCH_MODE` +- :prop_tgt:`XCODE_SCHEME_WORKING_DIRECTORY` diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_PRODUCT_TYPE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_PRODUCT_TYPE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..17a9c3f303ff0e6237b3c95ec49351d1ddd2c92d --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_PRODUCT_TYPE.rst.txt @@ -0,0 +1,10 @@ +XCODE_PRODUCT_TYPE +------------------ + +.. versionadded:: 3.8 + +Set the Xcode ``productType`` attribute on its reference to a +target. CMake computes a default based on target type but +can be told explicitly with this property. + +See also :prop_tgt:`XCODE_EXPLICIT_FILE_TYPE`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ADDRESS_SANITIZER.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ADDRESS_SANITIZER.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..c72ec06888e800b90adb586b422776f315c08d6f --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ADDRESS_SANITIZER.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_ADDRESS_SANITIZER +------------------------------ + +.. versionadded:: 3.13 + +Whether to enable ``Address Sanitizer`` in the Diagnostics +section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_ADDRESS_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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..293b5d4aa49ebd05a53c19c24cc8c675c3e7176c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN +----------------------------------------------- + +.. versionadded:: 3.13 + +Whether to enable ``Detect use of stack after return`` +in the Diagnostics section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN` +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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ARGUMENTS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ARGUMENTS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2bfcb41b372c9c7c9dbf0490f6b21645f8e00bc4 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ARGUMENTS.rst.txt @@ -0,0 +1,12 @@ +XCODE_SCHEME_ARGUMENTS +---------------------- + +.. versionadded:: 3.13 + +Specify command line arguments that should be added to the Arguments +section of the generated Xcode scheme. + +If set to a list of arguments those will be added to the scheme. + +Please refer to the :prop_tgt:`XCODE_GENERATE_SCHEME` target property +documentation to see all Xcode schema related properties. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..bbcae356a99f9b910fb6a3829aa9eda611a11923 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING.rst.txt @@ -0,0 +1,15 @@ +XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING +-------------------------------------- + +.. versionadded:: 3.16 + +Whether to enable +``Allow debugging when using document Versions Browser`` +in the Options section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING` +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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2ca20f72e1b918b87851a07fcf5f407698aca7bd --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS +---------------------------------- + +.. versionadded:: 3.13 + +Whether to enable ``Dynamic Library Loads`` +in the Diagnostics section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS` 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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ENABLE_GPU_API_VALIDATION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ENABLE_GPU_API_VALIDATION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3b801c50362980018de7cc49c9594ac3fc2a09fa --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ENABLE_GPU_API_VALIDATION.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_ENABLE_GPU_API_VALIDATION +-------------------------------------- + +.. versionadded:: 3.25 + +Property value for ``Metal: API Validation`` in the Options section of +the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_ENABLE_GPU_API_VALIDATION` +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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ENABLE_GPU_FRAME_CAPTURE_MODE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ENABLE_GPU_FRAME_CAPTURE_MODE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6ffd6943d8846fd73dcecbfffbf162dbdfe9e233 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ENABLE_GPU_FRAME_CAPTURE_MODE.rst.txt @@ -0,0 +1,15 @@ +XCODE_SCHEME_ENABLE_GPU_FRAME_CAPTURE_MODE +------------------------------------------ + +.. versionadded:: 3.23 + +Property value for ``GPU Frame Capture`` in the Options section of +the generated Xcode scheme. Example values are `Metal` and +`Disabled`. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_ENABLE_GPU_FRAME_CAPTURE_MODE` +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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ENABLE_GPU_SHADER_VALIDATION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ENABLE_GPU_SHADER_VALIDATION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5358087d59941d8056aa2ce6f3eb729bfe26be52 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ENABLE_GPU_SHADER_VALIDATION.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_ENABLE_GPU_SHADER_VALIDATION +----------------------------------------- + +.. versionadded:: 3.25 + +Property value for ``Metal: Shader Validation`` in the Options section of +the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_ENABLE_GPU_SHADER_VALIDATION` +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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_EXECUTABLE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_EXECUTABLE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b453f108d1d26028008337a3e62ec04281bffa77 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_EXECUTABLE.rst.txt @@ -0,0 +1,11 @@ +XCODE_SCHEME_EXECUTABLE +----------------------- + +.. versionadded:: 3.13 + +Specify path to executable in the Info section of the generated +Xcode scheme. If not set the schema generator will select the +current target if it is actually executable. + +Please refer to the :prop_tgt:`XCODE_GENERATE_SCHEME` target property +documentation to see all Xcode schema related properties. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_LAUNCH_MODE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_LAUNCH_MODE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..df5ae07ef8beb33b491a5086b03c6517aebe9b1b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_LAUNCH_MODE.rst.txt @@ -0,0 +1,22 @@ +XCODE_SCHEME_LAUNCH_MODE +------------------------ + +.. versionadded:: 3.25 + +Property value for ``Launch`` in the Info section of the generated Xcode +scheme. + +Possible values are: + +``AUTO`` + Launch automatically. This is the default. + +``WAIT`` + Wait for the executable to be launched. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_LAUNCH_MODE` 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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2a813aaadf700185296b4a7f6b6af14acb5a7f53 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP.rst.txt @@ -0,0 +1,15 @@ +XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP +------------------------------------- + +.. versionadded:: 3.13 + +Whether to enable the ``Main Thread Checker`` option +``Pause on issues`` +in the Diagnostics section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP` 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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MALLOC_GUARD_EDGES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MALLOC_GUARD_EDGES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..750da748c78454f9a898e695f9aa6aacf2741b9c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MALLOC_GUARD_EDGES.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_MALLOC_GUARD_EDGES +------------------------------- + +.. versionadded:: 3.13 + +Whether to enable ``Malloc Guard Edges`` +in the Diagnostics section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_MALLOC_GUARD_EDGES` 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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MALLOC_SCRIBBLE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MALLOC_SCRIBBLE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..4ebd21b350b6ba116ca8c78c19cc9ec3bff12484 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MALLOC_SCRIBBLE.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_MALLOC_SCRIBBLE +------------------------------ + +.. versionadded:: 3.13 + +Whether to enable ``Malloc Scribble`` +in the Diagnostics section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_MALLOC_SCRIBBLE` 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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MALLOC_STACK.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MALLOC_STACK.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5afe34e4f1f356f70adfc69050956bd2fd12f742 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_MALLOC_STACK.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_MALLOC_STACK +------------------------- + +.. versionadded:: 3.13 + +Whether to enable ``Malloc Stack`` in the Diagnostics +section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_MALLOC_STACK` 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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_THREAD_SANITIZER.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_THREAD_SANITIZER.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..cc774c440ed33b1127d282576b5cd6a17c955b1c --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_THREAD_SANITIZER.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_THREAD_SANITIZER +----------------------------- + +.. versionadded:: 3.13 + +Whether to enable ``Thread Sanitizer`` in the Diagnostics +section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_THREAD_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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_THREAD_SANITIZER_STOP.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_THREAD_SANITIZER_STOP.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3bb25964defa0a69a23cba7fa084886eb0aeeba3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_THREAD_SANITIZER_STOP.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_THREAD_SANITIZER_STOP +---------------------------------- + +.. versionadded:: 3.13 + +Whether to enable ``Thread Sanitizer - Pause on issues`` +in the Diagnostics section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_THREAD_SANITIZER_STOP` 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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..1146130ede04a8dc01d25c2435b0d56cae4581a8 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER.rst.txt @@ -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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ZOMBIE_OBJECTS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ZOMBIE_OBJECTS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6030109ce644487b07ddd13b36423071dc00e248 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCODE_SCHEME_ZOMBIE_OBJECTS.rst.txt @@ -0,0 +1,14 @@ +XCODE_SCHEME_ZOMBIE_OBJECTS +------------------------------ + +.. versionadded:: 3.13 + +Whether to enable ``Zombie Objects`` +in the Diagnostics section of the generated Xcode scheme. + +This property is initialized by the value of the variable +:variable:`CMAKE_XCODE_SCHEME_ZOMBIE_OBJECTS` 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. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCTEST.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCTEST.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..67e9a70459628436efbf90ad0dd7d8ba34892ca3 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/prop_tgt/XCTEST.rst.txt @@ -0,0 +1,15 @@ +XCTEST +------ + +.. versionadded:: 3.3 + +This target is a XCTest CFBundle on the Mac. + +This property will usually get set via the :command:`xctest_add_bundle` +macro in :module:`FindXCTest` module. + +If a module library target has this property set to true it will be +built as a CFBundle when built on the Mac. It will have the directory +structure required for a CFBundle. + +This property depends on :prop_tgt:`BUNDLE` to be effective. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/ANDROID.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/ANDROID.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..68dccf2061cba354bb40749ffec11041d9445a58 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/ANDROID.rst.txt @@ -0,0 +1,7 @@ +ANDROID +------- + +.. versionadded:: 3.7 + +Set to ``1`` when the target system (:variable:`CMAKE_SYSTEM_NAME`) is +``Android``. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/APPLE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/APPLE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..810d5fc3a33efab3326fe22d8af07e44ea0f90cc --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/APPLE.rst.txt @@ -0,0 +1,5 @@ +APPLE +----- + +Set to ``True`` when the target system is an Apple platform +(macOS, iOS, tvOS or watchOS). diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/BORLAND.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/BORLAND.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..badb7338e3d0b176cb84a1f88edde264d7054865 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/BORLAND.rst.txt @@ -0,0 +1,6 @@ +BORLAND +------- + +``True`` if the Borland compiler is being used. + +This is set to ``true`` if the Borland compiler is being used. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/BSD.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/BSD.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..fdfe5ec98c83c27ba1437c17206729417f2e84a1 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/BSD.rst.txt @@ -0,0 +1,7 @@ +BSD +--- + +.. versionadded:: 3.25 + +Set to a string value when the target system is BSD. This value can be one of +the following: DragonFlyBSD, FreeBSD, OpenBSD, or NetBSD. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/BUILD_SHARED_LIBS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/BUILD_SHARED_LIBS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..53087b23b96795a193ad11da82f33728c5c9b0f8 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/BUILD_SHARED_LIBS.rst.txt @@ -0,0 +1,10 @@ +BUILD_SHARED_LIBS +----------------- + +Global flag to cause :command:`add_library` to create shared libraries if on. + +If present and true, this will cause all libraries to be built shared +unless the library was explicitly added as a static library. This +variable is often added to projects as an :command:`option` so that each user +of a project can decide if they want to build the project using shared or +static libraries. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CACHE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CACHE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d5489c87c69d6635c13bbb767482adc35ec4c3ed --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CACHE.rst.txt @@ -0,0 +1,20 @@ +CACHE +----- + +.. versionadded:: 3.13 + +Operator to read cache variables. + +Use the syntax ``$CACHE{VAR}`` to read cache entry ``VAR``. +See the :ref:`cmake-language(7) variables ` +documentation for more complete documentation of the interaction of +normal variables and cache entries. + +When evaluating :ref:`Variable References` of the form ``${VAR}``, +CMake first searches for a normal variable with that name, and if not +found CMake will search for a cache entry with that name. +The ``$CACHE{VAR}`` syntax can be used to do direct cache lookup and +ignore any existing normal variable. + +See the :command:`set` and :command:`unset` commands to see how to +write or remove cache variables. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ABSOLUTE_DESTINATION_FILES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ABSOLUTE_DESTINATION_FILES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b6d00543aea5996c65635bab21debf8a89330bd4 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ABSOLUTE_DESTINATION_FILES.rst.txt @@ -0,0 +1,9 @@ +CMAKE_ABSOLUTE_DESTINATION_FILES +-------------------------------- + +List of files which have been installed using an ``ABSOLUTE DESTINATION`` path. + +This variable is defined by CMake-generated ``cmake_install.cmake`` +scripts. It can be used (read-only) by programs or scripts that +source those install scripts. This is used by some CPack generators +(e.g. RPM). diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ADD_CUSTOM_COMMAND_DEPENDS_EXPLICIT_ONLY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ADD_CUSTOM_COMMAND_DEPENDS_EXPLICIT_ONLY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..b6a6233707bae4dcd985fc32eeb2c7521d681467 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ADD_CUSTOM_COMMAND_DEPENDS_EXPLICIT_ONLY.rst.txt @@ -0,0 +1,13 @@ +CMAKE_ADD_CUSTOM_COMMAND_DEPENDS_EXPLICIT_ONLY +---------------------------------------------- + +.. versionadded:: 3.27 + +Whether to enable the ``DEPENDS_EXPLICIT_ONLY`` option by default in +:command:`add_custom_command`. + +This variable affects the default behavior of the :command:`add_custom_command` +command. Setting this variable to ``ON`` is equivalent to using the +``DEPENDS_EXPLICIT_ONLY`` option in all uses of that command. + +See also :variable:`CMAKE_OPTIMIZE_DEPENDENCIES`. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ADSP_ROOT.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ADSP_ROOT.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..f6f3927d65d62235a18bc91091ae526781ce5fac --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ADSP_ROOT.rst.txt @@ -0,0 +1,11 @@ +CMAKE_ADSP_ROOT +--------------- + +.. versionadded:: 3.24 + +When :ref:`Cross Compiling for ADSP SHARC/Blackfin`, +this variable holds the absolute path to the latest CCES or VDSP++ install. +The directory is expected to contain the ``cc21k.exe`` and ``ccblkfn.exe`` compilers. +This will be set automatically if a default install of CCES or VDSP++ can be found. + +See also the :envvar:`ADSP_ROOT` environment variable. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_AIX_EXPORT_ALL_SYMBOLS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_AIX_EXPORT_ALL_SYMBOLS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..699fe0f03b50dadfc4578348d08d94c56ae18e79 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_AIX_EXPORT_ALL_SYMBOLS.rst.txt @@ -0,0 +1,8 @@ +CMAKE_AIX_EXPORT_ALL_SYMBOLS +---------------------------- + +.. versionadded:: 3.17 + +Default value for :prop_tgt:`AIX_EXPORT_ALL_SYMBOLS` target property. +This variable is used to initialize the property on each target as it is +created. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ANT_ADDITIONAL_OPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ANT_ADDITIONAL_OPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..2d6b4b92a01f4d6c8403080639f48357ee519476 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ANT_ADDITIONAL_OPTIONS.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_ANT_ADDITIONAL_OPTIONS +------------------------------------ + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_ANT_ADDITIONAL_OPTIONS` target property. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_API.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_API.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..aba9b6eb6d95f1b8c934d4b8a54bc5aa23922cf6 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_API.rst.txt @@ -0,0 +1,14 @@ +CMAKE_ANDROID_API +----------------- + +.. versionadded:: 3.1 + +When :ref:`Cross Compiling for Android with NVIDIA Nsight Tegra Visual Studio +Edition`, this variable may be set to specify the default value for the +:prop_tgt:`ANDROID_API` target property. See that target property for +additional information. + +When :ref:`Cross Compiling for Android`, the :variable:`CMAKE_SYSTEM_VERSION` +variable represents the Android API version number targeted. For historical +reasons, if a toolchain file sets ``CMAKE_ANDROID_API``, but not +``CMAKE_SYSTEM_VERSION``, the latter will be initialized using the former. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARCH.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARCH.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9f12742917245d2dd644a5a9bae5af4c96d20365 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARCH.rst.txt @@ -0,0 +1,21 @@ +CMAKE_ANDROID_ARCH +------------------ + +.. versionadded:: 3.4 + +When :ref:`Cross Compiling for Android with NVIDIA Nsight Tegra Visual Studio +Edition`, this variable may be set to specify the default value for the +:prop_tgt:`ANDROID_ARCH` target property. See that target property for +additional information. + +Otherwise, when :ref:`Cross Compiling for Android`, this variable provides +the name of the Android architecture corresponding to the value of the +:variable:`CMAKE_ANDROID_ARCH_ABI` variable. The architecture name +may be one of: + +* ``arm`` +* ``arm64`` +* ``mips`` +* ``mips64`` +* ``x86`` +* ``x86_64`` diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARCH_ABI.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARCH_ABI.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5a2e3ecacf7e1fe4aa9bdecb7ac758bdebac08a2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARCH_ABI.rst.txt @@ -0,0 +1,19 @@ +CMAKE_ANDROID_ARCH_ABI +---------------------- + +.. versionadded:: 3.7 + +When :ref:`Cross Compiling for Android`, this variable specifies the +target architecture and ABI to be used. Valid values are: + +* ``arm64-v8a`` +* ``armeabi-v7a`` +* ``armeabi-v6`` +* ``armeabi`` +* ``mips`` +* ``mips64`` +* ``x86`` +* ``x86_64`` + +See also the :variable:`CMAKE_ANDROID_ARM_MODE` and +:variable:`CMAKE_ANDROID_ARM_NEON` variables. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARM_MODE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARM_MODE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..973ff7ef49a45f5f9fd9df05959c677bf650a7b1 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARM_MODE.rst.txt @@ -0,0 +1,9 @@ +CMAKE_ANDROID_ARM_MODE +---------------------- + +.. versionadded:: 3.7 + +When :ref:`Cross Compiling for Android` and :variable:`CMAKE_ANDROID_ARCH_ABI` +is set to one of the ``armeabi`` architectures, set ``CMAKE_ANDROID_ARM_MODE`` +to ``ON`` to target 32-bit ARM processors (``-marm``). Otherwise, the +default is to target the 16-bit Thumb processors (``-mthumb``). diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARM_NEON.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARM_NEON.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6b9cf087d1c9dc06ef70de23eb3232f7e88f9ee4 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ARM_NEON.rst.txt @@ -0,0 +1,8 @@ +CMAKE_ANDROID_ARM_NEON +---------------------- + +.. versionadded:: 3.7 + +When :ref:`Cross Compiling for Android` and :variable:`CMAKE_ANDROID_ARCH_ABI` +is set to ``armeabi-v7a`` set ``CMAKE_ANDROID_ARM_NEON`` to ``ON`` to target +ARM NEON devices. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ASSETS_DIRECTORIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ASSETS_DIRECTORIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3de2be4c9fbd722cbfcef482dcfa37e0d888b4f2 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_ASSETS_DIRECTORIES.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_ASSETS_DIRECTORIES +-------------------------------- + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_ASSETS_DIRECTORIES` target property. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_EXCEPTIONS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_EXCEPTIONS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6dd44f8757286e47e781172e84fbf28ed1414a68 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_EXCEPTIONS.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_EXCEPTIONS +------------------------ + +.. versionadded:: 3.20 + +When :ref:`Cross Compiling for Android with the NDK`, this variable may be set +to specify whether exceptions are enabled. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_GUI.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_GUI.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..821bbee1f5e6ff7505e2d45a24ecbfa8512f373b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_GUI.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_GUI +----------------- + +.. versionadded:: 3.1 + +Default value for the :prop_tgt:`ANDROID_GUI` target property of +executables. See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_JAR_DEPENDENCIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_JAR_DEPENDENCIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..80ab842c6aab3d0884e54daf71187c8b5b288780 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_JAR_DEPENDENCIES.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_JAR_DEPENDENCIES +------------------------------ + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_JAR_DEPENDENCIES` target property. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_JAR_DIRECTORIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_JAR_DIRECTORIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..4d148d81b00faf8845549495d8a26719110f92fe --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_JAR_DIRECTORIES.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_JAR_DIRECTORIES +----------------------------- + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_JAR_DIRECTORIES` target property. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_JAVA_SOURCE_DIR.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_JAVA_SOURCE_DIR.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..021baa080f40b33ef3ffa87bfecf4bb9cfb1fe29 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_JAVA_SOURCE_DIR.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_JAVA_SOURCE_DIR +----------------------------- + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_JAVA_SOURCE_DIR` target property. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NATIVE_LIB_DEPENDENCIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NATIVE_LIB_DEPENDENCIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..41d4cc3930cb6f9828b507318a95869e3f46b4df --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NATIVE_LIB_DEPENDENCIES.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_NATIVE_LIB_DEPENDENCIES +------------------------------------- + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_NATIVE_LIB_DEPENDENCIES` target +property. See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NATIVE_LIB_DIRECTORIES.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NATIVE_LIB_DIRECTORIES.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..e87547de463a174628fa315a6ddc92aeee9025a5 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NATIVE_LIB_DIRECTORIES.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_NATIVE_LIB_DIRECTORIES +------------------------------------ + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_NATIVE_LIB_DIRECTORIES` target +property. See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..72ac99e2acc257f7ac642ec25e66b576a79f9082 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK.rst.txt @@ -0,0 +1,9 @@ +CMAKE_ANDROID_NDK +----------------- + +.. versionadded:: 3.7 + +When :ref:`Cross Compiling for Android with the NDK`, this variable holds +the absolute path to the root directory of the NDK. The directory must +contain a ``platforms`` subdirectory holding the ``android-`` +directories. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_DEPRECATED_HEADERS.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_DEPRECATED_HEADERS.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..40a5c1a69716a77442207bb0972ca566fbbe7d4e --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_DEPRECATED_HEADERS.rst.txt @@ -0,0 +1,11 @@ +CMAKE_ANDROID_NDK_DEPRECATED_HEADERS +------------------------------------ + +.. versionadded:: 3.9 + +When :ref:`Cross Compiling for Android with the NDK`, this variable +may be set to specify whether to use the deprecated per-api-level +headers instead of the unified headers. + +If not specified, the default will be *false* if using a NDK version +that provides the unified headers and *true* otherwise. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9d61fa46a90de92606151ef836a2fe9a05a38296 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG.rst.txt @@ -0,0 +1,8 @@ +CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG +------------------------------------ + +.. versionadded:: 3.7.1 + +When :ref:`Cross Compiling for Android with the NDK`, this variable +provides the NDK's "host tag" used to construct the path to prebuilt +toolchains that run on the host. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..15fe18f9c4af0292c783928a0ca3594a2441cc74 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION.rst.txt @@ -0,0 +1,22 @@ +CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION +----------------------------------- + +.. versionadded:: 3.7 + +When :ref:`Cross Compiling for Android with the NDK`, this variable +may be set to specify the version of the toolchain to be used +as the compiler. + +On NDK r19 or above, this variable must be unset or set to ``clang``. + +On NDK r18 or below, this variable must be set to one of these forms: + +* ``.``: GCC of specified version +* ``clang.``: Clang of specified version +* ``clang``: Clang of most recent available version + +A toolchain of the requested version will be selected automatically to +match the ABI named in the :variable:`CMAKE_ANDROID_ARCH_ABI` variable. + +If not specified, the default will be a value that selects the latest +available GCC toolchain. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_VERSION.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_VERSION.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5428d52bce0b7b30a6c19eb1f2a61af6f71077f0 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_NDK_VERSION.rst.txt @@ -0,0 +1,8 @@ +CMAKE_ANDROID_NDK_VERSION +------------------------- + +.. versionadded:: 3.20 + +When :ref:`Cross Compiling for Android with the NDK` and using an +Android NDK version 11 or higher, this variable is provided by +CMake to report the NDK version number. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_PROCESS_MAX.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_PROCESS_MAX.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..be241c2e71be0ddb56ff7624ed457833602cf259 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_PROCESS_MAX.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_PROCESS_MAX +------------------------- + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_PROCESS_MAX` target property. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_PROGUARD.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_PROGUARD.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..bb001d3abb03bea04e9d53a0f387c4d122eaf864 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_PROGUARD.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_PROGUARD +---------------------- + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_PROGUARD` target property. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_PROGUARD_CONFIG_PATH.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_PROGUARD_CONFIG_PATH.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..6fd4067b800b99916b181a93a46360e089535b94 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_PROGUARD_CONFIG_PATH.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_PROGUARD_CONFIG_PATH +---------------------------------- + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_PROGUARD_CONFIG_PATH` target property. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_RTTI.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_RTTI.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0e982069e2568bd5b006d0bfb91a99eaea72e307 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_RTTI.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_RTTI +------------------ + +.. versionadded:: 3.20 + +When :ref:`Cross Compiling for Android with the NDK`, this variable may be set +to specify whether RTTI is enabled. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_SECURE_PROPS_PATH.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_SECURE_PROPS_PATH.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..9f5743e842aaaf169dd4bcbf53b05bbcc9bd0368 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_SECURE_PROPS_PATH.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_SECURE_PROPS_PATH +------------------------------- + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_SECURE_PROPS_PATH` target property. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_SKIP_ANT_STEP.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_SKIP_ANT_STEP.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..588769bac8aebea035101a25782c448bf59c94b0 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_SKIP_ANT_STEP.rst.txt @@ -0,0 +1,7 @@ +CMAKE_ANDROID_SKIP_ANT_STEP +--------------------------- + +.. versionadded:: 3.4 + +Default value for the :prop_tgt:`ANDROID_SKIP_ANT_STEP` target property. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_STANDALONE_TOOLCHAIN.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_STANDALONE_TOOLCHAIN.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3ca89f5977df362b3d50a408d46bba01476877fe --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_STANDALONE_TOOLCHAIN.rst.txt @@ -0,0 +1,8 @@ +CMAKE_ANDROID_STANDALONE_TOOLCHAIN +---------------------------------- + +.. versionadded:: 3.7 + +When :ref:`Cross Compiling for Android with a Standalone Toolchain`, this +variable holds the absolute path to the root directory of the toolchain. +The specified directory must contain a ``sysroot`` subdirectory. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_STL_TYPE.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_STL_TYPE.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..3778181af4858ca89034f39c631ee6ab73eb0d20 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ANDROID_STL_TYPE.rst.txt @@ -0,0 +1,39 @@ +CMAKE_ANDROID_STL_TYPE +---------------------- + +.. versionadded:: 3.4 + +When :ref:`Cross Compiling for Android with NVIDIA Nsight Tegra Visual Studio +Edition`, this variable may be set to specify the default value for the +:prop_tgt:`ANDROID_STL_TYPE` target property. See that target property +for additional information. + +When :ref:`Cross Compiling for Android with the NDK`, this variable may be +set to specify the STL variant to be used. The value may be one of: + +``none`` + No C++ Support +``system`` + Minimal C++ without STL +``gabi++_static`` + GAbi++ Static +``gabi++_shared`` + GAbi++ Shared +``gnustl_static`` + GNU libstdc++ Static +``gnustl_shared`` + GNU libstdc++ Shared +``c++_static`` + LLVM libc++ Static +``c++_shared`` + LLVM libc++ Shared +``stlport_static`` + STLport Static +``stlport_shared`` + STLport Shared + +The default value is ``gnustl_static`` on NDK versions that provide it +and otherwise ``c++_static``. Note that this default differs from +the native NDK build system because CMake may be used to build projects for +Android that are not natively implemented for it and use the C++ standard +library. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_APPBUNDLE_PATH.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_APPBUNDLE_PATH.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..441ee8ebb2e818e838ea2a79a1a5b2c2854ae5bc --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_APPBUNDLE_PATH.rst.txt @@ -0,0 +1,9 @@ +CMAKE_APPBUNDLE_PATH +-------------------- + +:ref:`Semicolon-separated list ` of directories specifying a search path +for macOS application bundles used by the :command:`find_program`, and +:command:`find_package` commands. + +There is also an environment variable :envvar:`CMAKE_APPBUNDLE_PATH`, which is used +as an additional list of search directories. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_APPLE_SILICON_PROCESSOR.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_APPLE_SILICON_PROCESSOR.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..0d5ccd18313a8022649b9df5d096285ef9d35082 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_APPLE_SILICON_PROCESSOR.rst.txt @@ -0,0 +1,14 @@ +CMAKE_APPLE_SILICON_PROCESSOR +----------------------------- + +.. versionadded:: 3.19.2 + +On Apple Silicon hosts running macOS, set this variable to tell +CMake what architecture to use for :variable:`CMAKE_HOST_SYSTEM_PROCESSOR`. +The value must be either ``arm64`` or ``x86_64``. + +The value of this variable should never be modified by project code. +It is meant to be set as a cache entry provided by the user, +e.g. via ``-DCMAKE_APPLE_SILICON_PROCESSOR=...``. + +See also the :envvar:`CMAKE_APPLE_SILICON_PROCESSOR` environment variable. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_AR.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_AR.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..5893677ff872cd91ee6df8dab2eb5665f4bf394a --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_AR.rst.txt @@ -0,0 +1,7 @@ +CMAKE_AR +-------- + +Name of archiving tool for static libraries. + +This specifies the name of the program that creates archive or static +libraries. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ARCHIVE_OUTPUT_DIRECTORY.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ARCHIVE_OUTPUT_DIRECTORY.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..c88932164a2aa75ed6f021102ad8ebe8de08357b --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ARCHIVE_OUTPUT_DIRECTORY.rst.txt @@ -0,0 +1,9 @@ +CMAKE_ARCHIVE_OUTPUT_DIRECTORY +------------------------------ + +Where to put all the :ref:`ARCHIVE ` +target files when built. + +This variable is used to initialize the :prop_tgt:`ARCHIVE_OUTPUT_DIRECTORY` +property on all the targets. See that target property for additional +information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ARCHIVE_OUTPUT_DIRECTORY_CONFIG.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ARCHIVE_OUTPUT_DIRECTORY_CONFIG.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..d8bd82c6c08f837e278d79110651884d89cb3cce --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ARCHIVE_OUTPUT_DIRECTORY_CONFIG.rst.txt @@ -0,0 +1,11 @@ +CMAKE_ARCHIVE_OUTPUT_DIRECTORY_ +--------------------------------------- + +.. versionadded:: 3.3 + +Where to put all the :ref:`ARCHIVE ` +target files when built for a specific configuration. + +This variable is used to initialize the +:prop_tgt:`ARCHIVE_OUTPUT_DIRECTORY_` property on all the targets. +See that target property for additional information. diff --git a/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ARGC.rst.txt b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ARGC.rst.txt new file mode 100644 index 0000000000000000000000000000000000000000..30db2a2da5a0fcae37cdcb66ed183c5c39fa7248 --- /dev/null +++ b/toolchain/cmake-3.27.9-linux-x86_64/doc/cmake/html/_sources/variable/CMAKE_ARGC.rst.txt @@ -0,0 +1,8 @@ +CMAKE_ARGC +---------- + +Number of command line arguments passed to CMake in script mode. + +When run in :ref:`-P