amass/qt-build-tools
1
0
Fork 0
mirror of https://github.com/crystalidea/qt-build-tools.git synced 2025-02-24 03:44:48 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

cmake 3.16.2 is required

Browse Source
This commit is contained in:
kleuter 2023-10-31 23:20:22 +01:00
parent bc5ac068d8
commit 595eafc085
2806 changed files with 20730 additions and 9028 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
6.5.1/_tools/cmake/bin/cmake-gui.exe
View File

Binary file not shown.

BIN
6.5.1/_tools/cmake/bin/cmake.exe
View File

Binary file not shown.

BIN
6.5.1/_tools/cmake/bin/cmcldeps.exe
View File

Binary file not shown.

BIN
6.5.1/_tools/cmake/bin/cpack.exe
View File

Binary file not shown.

BIN
6.5.1/_tools/cmake/bin/ctest.exe
View File

Binary file not shown.

2
6.5.1/_tools/cmake/share/aclocal/cmake.m4
View File

@ -13,7 +13,7 @@ fi
# $2: language (e.g. C/CXX/Fortran) # $2: language (e.g. C/CXX/Fortran)
# $3: The compiler ID, defaults to GNU. # $3: The compiler ID, defaults to GNU.
# Possible values are: GNU, Intel, Clang, SunPro, HP, XL, VisualAge, PGI, # Possible values are: GNU, Intel, Clang, SunPro, HP, XL, VisualAge, PGI,
# PathScale, Cray, SCO, MIPSpro, MSVC # PathScale, Cray, SCO, MSVC
# $4: optional extra arguments to cmake, e.g. "-DCMAKE_SIZEOF_VOID_P=8" # $4: optional extra arguments to cmake, e.g. "-DCMAKE_SIZEOF_VOID_P=8"
# $5: optional path to cmake binary # $5: optional path to cmake binary
AC_DEFUN([CMAKE_FIND_PACKAGE], [ AC_DEFUN([CMAKE_FIND_PACKAGE], [

22
6.5.1/_tools/cmake/share/cmake-3.14/Help/command/LINK_OPTIONS_LINKER.txt
View File

@ -1,22 +0,0 @@
To pass options to the linker tool, each compiler driver has is own syntax.
The ``LINKER:`` prefix can be used to specify, in a portable way, options
to pass to the linker tool. The ``LINKER:`` prefix is replaced by the required
driver option and the rest of the option string defines linker arguments using
``,`` as separator. These arguments will be formatted according to the
:variable:`CMAKE_<LANG>_LINKER_WRAPPER_FLAG` and
:variable:`CMAKE_<LANG>_LINKER_WRAPPER_FLAG_SEP` variables.
For example, ``"LINKER:-z,defs"`` becomes ``-Xlinker -z -Xlinker defs`` for
``Clang`` and ``-Wl,-z,defs`` for ``GNU GCC``.
The ``LINKER:`` prefix can be specified as part of a ``SHELL:`` prefix
expression.
The ``LINKER:`` prefix supports, as alternate syntax, specification of
arguments using ``SHELL:`` prefix and space as separator. Previous example
becomes ``"LINKER:SHELL:-z defs"``.
.. note::
Specifying ``SHELL:`` prefix elsewhere than at the beginning of the
``LINKER:`` prefix is not supported.

13
6.5.1/_tools/cmake/share/cmake-3.14/Help/command/enable_testing.rst
View File

@ -1,13 +0,0 @@
enable_testing
--------------
Enable testing for current directory and below.
.. code-block:: cmake
enable_testing()
Enables testing for this directory and below. See also the
:command:`add_test` command. Note that ctest expects to find a test file
in the build directory root. Therefore, this command should be in the
source directory root.

33
6.5.1/_tools/cmake/share/cmake-3.14/Help/command/message.rst
View File

@ -1,33 +0,0 @@
message
-------
Display a message to the user.
.. code-block:: cmake
message([<mode>] "message to display" ...)
The optional ``<mode>`` keyword determines the type of message:
::
(none) = Important information
STATUS = Incidental information
WARNING = CMake Warning, continue processing
AUTHOR_WARNING = CMake Warning (dev), continue processing
SEND_ERROR = CMake Error, continue processing,
but skip generation
FATAL_ERROR = CMake Error, stop processing and generation
DEPRECATION = CMake Deprecation Error or Warning if variable
CMAKE_ERROR_DEPRECATED or CMAKE_WARN_DEPRECATED
is enabled, respectively, else no message.
The CMake command-line tool displays STATUS messages on stdout and all
other message types on stderr. The CMake GUI displays all messages in
its log area. The interactive dialogs (ccmake and CMakeSetup) show
STATUS messages one at a time on a status line and other messages in
interactive pop-up boxes.
CMake Warning and Error message text displays using a simple markup
language. Non-indented text is formatted in line-wrapped paragraphs
delimited by newlines. Indented text is considered pre-formatted.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/envvar/DASHBOARD_TEST_FROM_CTEST.rst
View File

@ -1,7 +0,0 @@
DASHBOARD_TEST_FROM_CTEST
-------------------------
.. include:: ENV_VAR.txt
Environment variable that will exist when a test executed by CTest is run
in non-interactive mode. The value will be equal to :variable:`CMAKE_VERSION`.

8
6.5.1/_tools/cmake/share/cmake-3.14/Help/generator/Unix Makefiles.rst
View File

@ -1,8 +0,0 @@
Unix Makefiles
--------------
Generates standard UNIX makefiles.
A hierarchy of UNIX makefiles is generated into the build tree. Any
standard UNIX-style make program can build the project through the
default make target. A "make install" target is also provided.

4
6.5.1/_tools/cmake/share/cmake-3.14/Help/module/CPackWIX.rst
View File

@ -1,4 +0,0 @@
CPackWIX
--------
The documentation for the CPack WIX generator has moved here: :cpack_gen:`CPack WIX Generator`

32
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0000.rst
View File

@ -1,32 +0,0 @@
CMP0000
-------
A minimum required CMake version must be specified.
CMake requires that projects specify the version of CMake to which
they have been written. This policy has been put in place so users
trying to build the project may be told when they need to update their
CMake. Specifying a version also helps the project build with CMake
versions newer than that specified. Use the cmake_minimum_required
command at the top of your main CMakeLists.txt file:
::
cmake_minimum_required(VERSION <major>.<minor>)
where "<major>.<minor>" is the version of CMake you want to support
(such as "2.6"). The command will ensure that at least the given
version of CMake is running and help newer versions be compatible with
the project. See documentation of cmake_minimum_required for details.
Note that the command invocation must appear in the CMakeLists.txt
file itself; a call in an included file is not sufficient. However,
the cmake_policy command may be called to set policy CMP0000 to OLD or
NEW behavior explicitly. The OLD behavior is to silently ignore the
missing invocation. The NEW behavior is to issue an error instead of
a warning. An included file may set CMP0000 explicitly to affect how
this policy is enforced for the main CMakeLists.txt file.
This policy was introduced in CMake version 2.6.0.
.. include:: DEPRECATED.txt

21
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0001.rst
View File

@ -1,21 +0,0 @@
CMP0001
-------
CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.
The OLD behavior is to check CMAKE_BACKWARDS_COMPATIBILITY and present
it to the user. The NEW behavior is to ignore
CMAKE_BACKWARDS_COMPATIBILITY completely.
In CMake 2.4 and below the variable CMAKE_BACKWARDS_COMPATIBILITY was
used to request compatibility with earlier versions of CMake. In
CMake 2.6 and above all compatibility issues are handled by policies
and the cmake_policy command. However, CMake must still check
CMAKE_BACKWARDS_COMPATIBILITY for projects written for CMake 2.4 and
below.
This policy was introduced in CMake version 2.6.0. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

24
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0006.rst
View File

@ -1,24 +0,0 @@
CMP0006
-------
Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.
This policy determines whether the install(TARGETS) command must be
given a BUNDLE DESTINATION when asked to install a target with the
MACOSX_BUNDLE property set. CMake 2.4 and below did not distinguish
application bundles from normal executables when installing targets.
CMake 2.6 provides a BUNDLE option to the install(TARGETS) command
that specifies rules specific to application bundles on the Mac.
Projects should use this option when installing a target with the
MACOSX_BUNDLE property set.
The OLD behavior for this policy is to fall back to the RUNTIME
DESTINATION if a BUNDLE DESTINATION is not given. The NEW behavior
for this policy is to produce an error if a bundle target is installed
without a BUNDLE DESTINATION.
This policy was introduced in CMake version 2.6.0. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

17
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0007.rst
View File

@ -1,17 +0,0 @@
CMP0007
-------
list command no longer ignores empty elements.
This policy determines whether the list command will ignore empty
elements in the list. CMake 2.4 and below list commands ignored all
empty elements in the list. For example, a;b;;c would have length 3
and not 4. The OLD behavior for this policy is to ignore empty list
elements. The NEW behavior for this policy is to correctly count
empty elements in a list.
This policy was introduced in CMake version 2.6.0. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

21
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0009.rst
View File

@ -1,21 +0,0 @@
CMP0009
-------
FILE GLOB_RECURSE calls should not follow symlinks by default.
In CMake 2.6.1 and below, FILE GLOB_RECURSE calls would follow through
symlinks, sometimes coming up with unexpectedly large result sets
because of symlinks to top level directories that contain hundreds of
thousands of files.
This policy determines whether or not to follow symlinks encountered
during a FILE GLOB_RECURSE call. The OLD behavior for this policy is
to follow the symlinks. The NEW behavior for this policy is not to
follow the symlinks by default, but only if FOLLOW_SYMLINKS is given
as an additional argument to the FILE command.
This policy was introduced in CMake version 2.6.2. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

24
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0011.rst
View File

@ -1,24 +0,0 @@
CMP0011
-------
Included scripts do automatic cmake_policy PUSH and POP.
In CMake 2.6.2 and below, CMake Policy settings in scripts loaded by
the include() and find_package() commands would affect the includer.
Explicit invocations of cmake_policy(PUSH) and cmake_policy(POP) were
required to isolate policy changes and protect the includer. While
some scripts intend to affect the policies of their includer, most do
not. In CMake 2.6.3 and above, include() and find_package() by
default PUSH and POP an entry on the policy stack around an included
script, but provide a NO_POLICY_SCOPE option to disable it. This
policy determines whether or not to imply NO_POLICY_SCOPE for
compatibility. The OLD behavior for this policy is to imply
NO_POLICY_SCOPE for include() and find_package() commands. The NEW
behavior for this policy is to allow the commands to do their default
cmake_policy PUSH and POP.
This policy was introduced in CMake version 2.6.3. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

27
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0012.rst
View File

@ -1,27 +0,0 @@
CMP0012
-------
if() recognizes numbers and boolean constants.
In CMake versions 2.6.4 and lower the if() command implicitly
dereferenced arguments corresponding to variables, even those named
like numbers or boolean constants, except for 0 and 1. Numbers and
boolean constants such as true, false, yes, no, on, off, y, n,
notfound, ignore (all case insensitive) were recognized in some cases
but not all. For example, the code "if(TRUE)" might have evaluated as
false. Numbers such as 2 were recognized only in boolean expressions
like "if(NOT 2)" (leading to false) but not as a single-argument like
"if(2)" (also leading to false). Later versions of CMake prefer to
treat numbers and boolean constants literally, so they should not be
used as variable names.
The OLD behavior for this policy is to implicitly dereference
variables named like numbers and boolean constants. The NEW behavior
for this policy is to recognize numbers and boolean constants without
dereferencing variables with such names.
This policy was introduced in CMake version 2.8.0. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

17
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0014.rst
View File

@ -1,17 +0,0 @@
CMP0014
-------
Input directories must have CMakeLists.txt.
CMake versions before 2.8 silently ignored missing CMakeLists.txt
files in directories referenced by add_subdirectory() or subdirs(),
treating them as if present but empty. In CMake 2.8.0 and above this
policy determines whether or not the case is an error. The OLD
behavior for this policy is to silently ignore the problem. The NEW
behavior for this policy is to report an error.
This policy was introduced in CMake version 2.8.0. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

19
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0015.rst
View File

@ -1,19 +0,0 @@
CMP0015
-------
link_directories() treats paths relative to the source dir.
In CMake 2.8.0 and lower the link_directories() command passed
relative paths unchanged to the linker. In CMake 2.8.1 and above the
link_directories() command prefers to interpret relative paths with
respect to CMAKE_CURRENT_SOURCE_DIR, which is consistent with
include_directories() and other commands. The OLD behavior for this
policy is to use relative paths verbatim in the linker command. The
NEW behavior for this policy is to convert relative paths to absolute
paths by appending the relative path to CMAKE_CURRENT_SOURCE_DIR.
This policy was introduced in CMake version 2.8.1. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

15
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0016.rst
View File

@ -1,15 +0,0 @@
CMP0016
-------
target_link_libraries() reports error if its only argument is not a target.
In CMake 2.8.2 and lower the target_link_libraries() command silently
ignored if it was called with only one argument, and this argument
wasn't a valid target. In CMake 2.8.3 and above it reports an error
in this case.
This policy was introduced in CMake version 2.8.3. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

21
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0017.rst
View File

@ -1,21 +0,0 @@
CMP0017
-------
Prefer files from the CMake module directory when including from there.
Starting with CMake 2.8.4, if a cmake-module shipped with CMake (i.e.
located in the CMake module directory) calls include() or
find_package(), the files located in the CMake module directory are
preferred over the files in CMAKE_MODULE_PATH. This makes sure that
the modules belonging to CMake always get those files included which
they expect, and against which they were developed and tested. In all
other cases, the files found in CMAKE_MODULE_PATH still take
precedence over the ones in the CMake module directory. The OLD
behavior is to always prefer files from CMAKE_MODULE_PATH over files
from the CMake modules directory.
This policy was introduced in CMake version 2.8.4. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

34
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0018.rst
View File

@ -1,34 +0,0 @@
CMP0018
-------
Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable.
CMake 2.8.8 and lower compiled sources in SHARED and MODULE libraries
using the value of the undocumented CMAKE_SHARED_LIBRARY_<Lang>_FLAGS
platform variable. The variable contained platform-specific flags
needed to compile objects for shared libraries. Typically it included
a flag such as -fPIC for position independent code but also included
other flags needed on certain platforms. CMake 2.8.9 and higher
prefer instead to use the POSITION_INDEPENDENT_CODE target property to
determine what targets should be position independent, and new
undocumented platform variables to select flags while ignoring
CMAKE_SHARED_LIBRARY_<Lang>_FLAGS completely.
The default for either approach produces identical compilation flags,
but if a project modifies CMAKE_SHARED_LIBRARY_<Lang>_FLAGS from its
original value this policy determines which approach to use.
The OLD behavior for this policy is to ignore the
POSITION_INDEPENDENT_CODE property for all targets and use the
modified value of CMAKE_SHARED_LIBRARY_<Lang>_FLAGS for SHARED and
MODULE libraries.
The NEW behavior for this policy is to ignore
CMAKE_SHARED_LIBRARY_<Lang>_FLAGS whether it is modified or not and
honor the POSITION_INDEPENDENT_CODE target property.
This policy was introduced in CMake version 2.8.9. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

27
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0020.rst
View File

@ -1,27 +0,0 @@
CMP0020
-------
Automatically link Qt executables to qtmain target on Windows.
CMake 2.8.10 and lower required users of Qt to always specify a link
dependency to the qtmain.lib static library manually on Windows.
CMake 2.8.11 gained the ability to evaluate generator expressions
while determining the link dependencies from IMPORTED targets. This
allows CMake itself to automatically link executables which link to Qt
to the qtmain.lib library when using IMPORTED Qt targets. For
applications already linking to qtmain.lib, this should have little
impact. For applications which supply their own alternative WinMain
implementation and for applications which use the QAxServer library,
this automatic linking will need to be disabled as per the
documentation.
The OLD behavior for this policy is not to link executables to
qtmain.lib automatically when they link to the QtCore IMPORTED target.
The NEW behavior for this policy is to link executables to qtmain.lib
automatically when they link to QtCore IMPORTED target.
This policy was introduced in CMake version 2.8.11. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

20
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0021.rst
View File

@ -1,20 +0,0 @@
CMP0021
-------
Fatal error on relative paths in INCLUDE_DIRECTORIES target property.
CMake 2.8.10.2 and lower allowed the INCLUDE_DIRECTORIES target
property to contain relative paths. The base path for such relative
entries is not well defined. CMake 2.8.12 issues a FATAL_ERROR if the
INCLUDE_DIRECTORIES property contains a relative path.
The OLD behavior for this policy is not to warn about relative paths
in the INCLUDE_DIRECTORIES target property. The NEW behavior for this
policy is to issue a FATAL_ERROR if INCLUDE_DIRECTORIES contains a
relative path.
This policy was introduced in CMake version 2.8.12. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

39
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0022.rst
View File

@ -1,39 +0,0 @@
CMP0022
-------
INTERFACE_LINK_LIBRARIES defines the link interface.
CMake 2.8.11 constructed the 'link interface' of a target from
properties matching ``(IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?``.
The modern way to specify config-sensitive content is to use generator
expressions and the ``IMPORTED_`` prefix makes uniform processing of the
link interface with generator expressions impossible. The
INTERFACE_LINK_LIBRARIES target property was introduced as a
replacement in CMake 2.8.12. This new property is named consistently
with the INTERFACE_COMPILE_DEFINITIONS, INTERFACE_INCLUDE_DIRECTORIES
and INTERFACE_COMPILE_OPTIONS properties. For in-build targets, CMake
will use the INTERFACE_LINK_LIBRARIES property as the source of the
link interface only if policy CMP0022 is NEW. When exporting a target
which has this policy set to NEW, only the INTERFACE_LINK_LIBRARIES
property will be processed and generated for the IMPORTED target by
default. A new option to the install(EXPORT) and export commands
allows export of the old-style properties for compatibility with
downstream users of CMake versions older than 2.8.12. The
target_link_libraries command will no longer populate the properties
matching LINK_INTERFACE_LIBRARIES(_<CONFIG>)? if this policy is NEW.
Warning-free future-compatible code which works with CMake 2.8.7 onwards
can be written by using the ``LINK_PRIVATE`` and ``LINK_PUBLIC`` keywords
of :command:`target_link_libraries`.
The OLD behavior for this policy is to ignore the
INTERFACE_LINK_LIBRARIES property for in-build targets. The NEW
behavior for this policy is to use the INTERFACE_LINK_LIBRARIES
property for in-build targets, and ignore the old properties matching
``(IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?``.
This policy was introduced in CMake version 2.8.12. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

35
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0023.rst
View File

@ -1,35 +0,0 @@
CMP0023
-------
Plain and keyword target_link_libraries signatures cannot be mixed.
CMake 2.8.12 introduced the target_link_libraries signature using the
PUBLIC, PRIVATE, and INTERFACE keywords to generalize the LINK_PUBLIC
and LINK_PRIVATE keywords introduced in CMake 2.8.7. Use of
signatures with any of these keywords sets the link interface of a
target explicitly, even if empty. This produces confusing behavior
when used in combination with the historical behavior of the plain
target_link_libraries signature. For example, consider the code:
::
target_link_libraries(mylib A)
target_link_libraries(mylib PRIVATE B)
After the first line the link interface has not been set explicitly so
CMake would use the link implementation, A, as the link interface.
However, the second line sets the link interface to empty. In order
to avoid this subtle behavior CMake now prefers to disallow mixing the
plain and keyword signatures of target_link_libraries for a single
target.
The OLD behavior for this policy is to allow keyword and plain
target_link_libraries signatures to be mixed. The NEW behavior for
this policy is to not to allow mixing of the keyword and plain
signatures.
This policy was introduced in CMake version 2.8.12. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

24
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0024.rst
View File

@ -1,24 +0,0 @@
CMP0024
-------
Disallow include export result.
CMake 2.8.12 and lower allowed use of the include() command with the
result of the export() command. This relies on the assumption that
the export() command has an immediate effect at configure-time during
a cmake run. Certain properties of targets are not fully determined
until later at generate-time, such as the link language and complete
list of link libraries. Future refactoring will change the effect of
the export() command to be executed at generate-time. Use ALIAS
targets instead in cases where the goal is to refer to targets by
another name.
The OLD behavior for this policy is to allow including the result of
an export() command. The NEW behavior for this policy is not to
allow including the result of an export() command.
This policy was introduced in CMake version 3.0. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

28
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0026.rst
View File

@ -1,28 +0,0 @@
CMP0026
-------
Disallow use of the LOCATION property for build targets.
CMake 2.8.12 and lower allowed reading the LOCATION target
property (and configuration-specific variants) to
determine the eventual location of build targets. This relies on the
assumption that all necessary information is available at
configure-time to determine the final location and filename of the
target. However, this property is not fully determined until later at
generate-time. At generate time, the $<TARGET_FILE> generator
expression can be used to determine the eventual LOCATION of a target
output.
Code which reads the LOCATION target property can be ported to use the
$<TARGET_FILE> generator expression together with the file(GENERATE)
subcommand to generate a file containing the target location.
The OLD behavior for this policy is to allow reading the LOCATION
properties from build-targets. The NEW behavior for this policy is to
not to allow reading the LOCATION properties from build-targets.
This policy was introduced in CMake version 3.0. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

27
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0027.rst
View File

@ -1,27 +0,0 @@
CMP0027
-------
Conditionally linked imported targets with missing include directories.
CMake 2.8.11 introduced introduced the concept of
INTERFACE_INCLUDE_DIRECTORIES, and a check at cmake time that the
entries in the INTERFACE_INCLUDE_DIRECTORIES of an IMPORTED target
actually exist. CMake 2.8.11 also introduced generator expression
support in the target_link_libraries command. However, if an imported
target is linked as a result of a generator expression evaluation, the
entries in the INTERFACE_INCLUDE_DIRECTORIES of that target were not
checked for existence as they should be.
The OLD behavior of this policy is to report a warning if an entry in
the INTERFACE_INCLUDE_DIRECTORIES of a generator-expression
conditionally linked IMPORTED target does not exist.
The NEW behavior of this policy is to report an error if an entry in
the INTERFACE_INCLUDE_DIRECTORIES of a generator-expression
conditionally linked IMPORTED target does not exist.
This policy was introduced in CMake version 3.0. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

25
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0028.rst
View File

@ -1,25 +0,0 @@
CMP0028
-------
Double colon in target name means ALIAS or IMPORTED target.
CMake 2.8.12 and lower allowed the use of targets and files with double
colons in target_link_libraries, with some buildsystem generators.
The use of double-colons is a common pattern used to namespace IMPORTED
targets and ALIAS targets. When computing the link dependencies of a target,
the name of each dependency could either be a target, or a file on disk.
Previously, if a target was not found with a matching name, the name was
considered to refer to a file on disk. This can lead to confusing error
messages if there is a typo in what should be a target name.
The OLD behavior for this policy is to search for targets, then files on disk,
even if the search term contains double-colons. The NEW behavior for this
policy is to issue a FATAL_ERROR if a link dependency contains
double-colons but is not an IMPORTED target or an ALIAS target.
This policy was introduced in CMake version 3.0. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

33
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/CMP0037.rst
View File

@ -1,33 +0,0 @@
CMP0037
-------
Target names should not be reserved and should match a validity pattern.
CMake 2.8.12 and lower allowed creating targets using :command:`add_library`,
:command:`add_executable` and :command:`add_custom_target` with unrestricted
choice for the target name. Newer cmake features such
as :manual:`cmake-generator-expressions(7)` and some
diagnostics expect target names to match a restricted pattern.
Target names may contain upper and lower case letters, numbers, the underscore
character (_), dot(.), plus(+) and minus(-). As a special case, ALIAS
targets and IMPORTED targets may contain two consecutive colons.
Target names reserved by one or more CMake generators are not allowed.
Among others these include "all", "clean", "help", and "install".
Target names associated with optional features, such as "test" and "package",
may also be reserved. CMake 3.10 and below always reserve them. CMake 3.11
and above reserve them only when the corresponding feature is enabled
(e.g. by including the :module:`CTest` or :module:`CPack` modules).
The OLD behavior for this policy is to allow creating targets with
reserved names or which do not match the validity pattern.
The NEW behavior for this policy is to report an error
if an add_* command is used with an invalid target name.
This policy was introduced in CMake version 3.0. CMake version
|release| warns when the policy is not set and uses OLD behavior. Use
the cmake_policy command to set it to OLD or NEW explicitly.
.. include:: DEPRECATED.txt

9
6.5.1/_tools/cmake/share/cmake-3.14/Help/policy/DISALLOWED_COMMAND.txt
View File

@ -1,9 +0,0 @@
CMake >= |disallowed_version| prefer that this command never be called.
The OLD behavior for this policy is to allow the command to be called.
The NEW behavior for this policy is to issue a FATAL_ERROR when the
command is called.
This policy was introduced in CMake version |disallowed_version|.
CMake version |release| warns when the policy is not set and uses
OLD behavior. Use the cmake_policy command to set it to OLD or
NEW explicitly.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_dir/ADDITIONAL_MAKE_CLEAN_FILES.rst
View File

@ -1,7 +0,0 @@
ADDITIONAL_MAKE_CLEAN_FILES
---------------------------
Additional files to clean during the make clean stage.
A list of files that will be cleaned as a part of the "make clean"
stage.

15
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_dir/EXCLUDE_FROM_ALL.rst
View File

@ -1,15 +0,0 @@
EXCLUDE_FROM_ALL
----------------
Exclude the directory from the all target of its parent.
A property on a directory that indicates if its targets are excluded
from the default build target. If it is not, then with a Makefile for
example typing make will cause the targets to be built. The same
concept applies to the default build of other generators.
Targets inherit the :prop_tgt:`EXCLUDE_FROM_ALL` property from the directory
that they are created in. When a directory is excluded, all of its targets will
have :prop_tgt:`EXCLUDE_FROM_ALL` set to ``TRUE``. After creating such a target
you can change its :prop_tgt:`EXCLUDE_FROM_ALL` property to ``FALSE``. This
will cause the target to be included in the default build target.

19
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_gbl/ALLOW_DUPLICATE_CUSTOM_TARGETS.rst
View File

@ -1,19 +0,0 @@
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 CMP0002). This is necessary
to generate meaningful project file names in Xcode and VS IDE
generators. It also allows the target names to be referenced
unambiguously.
Makefile generators are capable of supporting duplicate custom target
names. For projects that care only about Makefile generators and do
not wish to support Xcode or VS IDE generators, one may set this
property to true to allow duplicate custom targets. The property
allows multiple 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.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_inst/CPACK_DESKTOP_SHORTCUTS.rst
View File

@ -1,7 +0,0 @@
CPACK_DESKTOP_SHORTCUTS
-----------------------
Species a list of shortcut names that should be created on the Desktop
for this file.
The property is currently only supported by the WIX generator.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_inst/CPACK_STARTUP_SHORTCUTS.rst
View File

@ -1,7 +0,0 @@
CPACK_STARTUP_SHORTCUTS
-----------------------
Species a list of shortcut names that should be created in the Startup folder
for this file.
The property is currently only supported by the WIX generator.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_inst/CPACK_START_MENU_SHORTCUTS.rst
View File

@ -1,7 +0,0 @@
CPACK_START_MENU_SHORTCUTS
--------------------------
Species a list of shortcut names that should be created in the Start Menu
for this file.
The property is currently only supported by the WIX generator.

10
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_sf/COMPILE_DEFINITIONS_CONFIG.rst
View File

@ -1,10 +0,0 @@
COMPILE_DEFINITIONS_<CONFIG>
----------------------------
Ignored. See CMake Policy :policy:`CMP0043`.
Per-configuration preprocessor definitions on a source file.
This is the configuration-specific version of COMPILE_DEFINITIONS.
Note that Xcode does not support per-configuration source file flags
so this property will be ignored by the Xcode generator.

9
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_sf/Fortran_FORMAT.rst
View File

@ -1,9 +0,0 @@
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 Fortran_FORMAT
property if all source files in a target share the same format.

9
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_sf/OBJECT_OUTPUTS.rst
View File

@ -1,9 +0,0 @@
OBJECT_OUTPUTS
--------------
Additional outputs for a Makefile 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 Makefile generators and will be ignored on other
generators.

6
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_sf/VS_INCLUDE_IN_VSIX.rst
View File

@ -1,6 +0,0 @@
VS_INCLUDE_IN_VSIX
------------------
Boolean property to specify if the file should be included within a VSIX
extension package. This is needed for development of Visual Studio
extensions.

4
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_sf/VS_SHADER_FLAGS.rst
View File

@ -1,4 +0,0 @@
VS_SHADER_FLAGS
---------------
Set additional VS shader flags of a ``.hlsl`` source file.

4
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_sf/VS_SHADER_TYPE.rst
View File

@ -1,4 +0,0 @@
VS_SHADER_TYPE
--------------
Set the VS shader type of a ``.hlsl`` source file.

6
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_sf/VS_XAML_TYPE.rst
View File

@ -1,6 +0,0 @@
VS_XAML_TYPE
------------
Mark a 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.

10
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_sf/WRAP_EXCLUDE.rst
View File

@ -1,10 +0,0 @@
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 etc using SWIG etc. If WRAP_EXCLUDE is
set to true (1 etc) that indicates that this source file should not be
wrapped.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_test/COST.rst
View File

@ -1,7 +0,0 @@
COST
----
Set this to a floating point value. Tests in a test set will be run in descending order of cost.
This property describes the cost of a test. You can explicitly set
this value; tests with higher COST values will run first.

15
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_test/DISABLED.rst
View File

@ -1,15 +0,0 @@
DISABLED
--------
If set to true, the test will be skipped and its status will be 'Not Run'. A
DISABLED test will not be counted in the total number of tests and its
completion status will be reported to CDash as 'Disabled'.
A DISABLED test does not participate in test fixture dependency resolution.
If a DISABLED test has fixture requirements defined in its
:prop_test:`FIXTURES_REQUIRED` property, it will not cause setup or cleanup
tests for those fixtures to be added to the test set.
If a test with the :prop_test:`FIXTURES_SETUP` property set is DISABLED, the
fixture behavior will be as though that setup test was passing and any test
case requiring that fixture will still run.

8
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_test/MEASUREMENT.rst
View File

@ -1,8 +0,0 @@
MEASUREMENT
-----------
Specify a CDASH measurement and value to be reported for a test.
If set to a name then that name will be reported to CDASH as a named
measurement with a value of 1. You may also specify a value by
setting MEASUREMENT to "measurement=value".

10
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_test/RESOURCE_LOCK.rst
View File

@ -1,10 +0,0 @@
RESOURCE_LOCK
-------------
Specify a list of resources that are locked by this test.
If multiple tests specify the same resource lock, they are guaranteed
not to run concurrently.
See also :prop_test:`FIXTURES_REQUIRED` if the resource requires any setup or
cleanup steps.

97
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/AUTOMOC.rst
View File

@ -1,97 +0,0 @@
AUTOMOC
-------
Should the target be processed with automoc (for Qt projects).
:prop_tgt:`AUTOMOC` is a boolean specifying whether CMake will handle the Qt
``moc`` preprocessor automatically, i.e. without having to use the
:module:`QT4_WRAP_CPP() <FindQt4>` or QT5_WRAP_CPP() macro.
Currently Qt4 and Qt5 are supported.
When this property is set ``ON``, CMake will scan the header and
source files at build time and invoke moc accordingly.
* If an ``#include`` statement like ``#include "moc_<basename>.cpp"`` is found,
a macro from :prop_tgt:`AUTOMOC_MACRO_NAMES` is expected to appear in the
``<basename>.h(xx)`` header file. ``moc`` is run on the header
file to generate ``moc_<basename>.cpp`` in the
``<AUTOGEN_BUILD_DIR>/include`` directory which is automatically added
to the target's :prop_tgt:`INCLUDE_DIRECTORIES`.
This allows the compiler to find the included ``moc_<basename>.cpp`` file
regardless of the location the original source.
* For :prop_gbl:`multi configuration generators <GENERATOR_IS_MULTI_CONFIG>`,
the include directory is ``<AUTOGEN_BUILD_DIR>/include_<CONFIG>``.
* See :prop_tgt:`AUTOGEN_BUILD_DIR`.
* If an ``#include`` statement like ``#include "<basename>.moc"`` is found,
a macro from :prop_tgt:`AUTOMOC_MACRO_NAMES` is expected to appear in the
source file and ``moc`` is run on the source file itself.
* Header files that are not included by an ``#include "moc_<basename>.cpp"``
statement are nonetheless scanned for a macro out of
:prop_tgt:`AUTOMOC_MACRO_NAMES`.
The resulting ``moc_<basename>.cpp`` files are generated in custom
directories and automatically included in a generated
``<AUTOGEN_BUILD_DIR>/mocs_compilation.cpp`` file,
which is compiled as part of the target.
* The custom directories with checksum
based names help to avoid name collisions for ``moc`` files with the same
``<basename>``.
* See :prop_tgt:`AUTOGEN_BUILD_DIR`.
* Additionally, header files with the same base name as a source file,
(like ``<basename>.h``) or ``_p`` appended to the base name (like
``<basename>_p.h``), are scanned for a macro out of
:prop_tgt:`AUTOMOC_MACRO_NAMES`, and if found, ``moc``
is also executed on those files.
* ``AUTOMOC`` always checks multiple header alternative extensions,
such as ``hpp``, ``hxx``, etc. when searching for headers.
* ``AUTOMOC`` looks for the ``Q_PLUGIN_METADATA`` macro and reruns the
``moc`` when the file addressed by the ``FILE`` argument of the macro changes.
This property is initialized by the value of the :variable:`CMAKE_AUTOMOC`
variable if it is set when a target is created.
The ``moc`` executable will be detected automatically, but can be forced to
a certain binary using the :prop_tgt:`AUTOMOC_EXECUTABLE` property.
Additional command line options for ``moc`` can be set via the
:prop_tgt:`AUTOMOC_MOC_OPTIONS` property.
By enabling the :variable:`CMAKE_AUTOMOC_RELAXED_MODE` variable the
rules for searching the files which will be processed by ``moc`` can be relaxed.
See the documentation for this variable for more details.
The global property :prop_gbl:`AUTOGEN_TARGETS_FOLDER` can be used to group the
automoc targets together in an IDE, e.g. in MSVS.
The global property :prop_gbl:`AUTOGEN_SOURCE_GROUP` can be used to group
files generated by :prop_tgt:`AUTOMOC` together in an IDE, e.g. in MSVS.
Additional macro names to search for can be added to
:prop_tgt:`AUTOMOC_MACRO_NAMES`.
Additional ``moc`` dependency file names can be extracted from source code
by using :prop_tgt:`AUTOMOC_DEPEND_FILTERS`.
Compiler pre definitions for ``moc`` are written to a ``moc_predefs.h`` file
which is controlled by :prop_tgt:`AUTOMOC_COMPILER_PREDEFINES`.
Source C++ files can be excluded from :prop_tgt:`AUTOMOC` processing by
enabling :prop_sf:`SKIP_AUTOMOC` or the broader :prop_sf:`SKIP_AUTOGEN`.
The number of parallel ``moc`` processes to start can be modified by
setting :prop_tgt:`AUTOGEN_PARALLEL`.
A global ``autogen`` target that depends on all :prop_tgt:`AUTOMOC` generated
``<ORIGIN>_autogen`` targets in the project can be generated by enabling
:variable:`CMAKE_GLOBAL_AUTOGEN_TARGET`.
See the :manual:`cmake-qt(7)` manual for more information on using CMake
with Qt.

46
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/AUTORCC.rst
View File

@ -1,46 +0,0 @@
AUTORCC
-------
Should the target be processed with autorcc (for Qt projects).
:prop_tgt:`AUTORCC` is a boolean specifying whether CMake will handle
the Qt ``rcc`` code generator automatically, i.e. without having to use
the :module:`QT4_ADD_RESOURCES() <FindQt4>` or ``QT5_ADD_RESOURCES()``
macro. Currently Qt4 and Qt5 are supported.
When this property is ``ON``, CMake will handle ``.qrc`` files added
as target sources at build time and invoke ``rcc`` accordingly.
This property is initialized by the value of the :variable:`CMAKE_AUTORCC`
variable if it is set when a target is created.
By default :prop_tgt:`AUTORCC` is processed inside a
:command:`custom command <add_custom_command>`.
If the ``.qrc`` file is :prop_sf:`GENERATED` though, a
:command:`custom target <add_custom_target>` is used instead.
Additional command line options for rcc can be set via the
:prop_sf:`AUTORCC_OPTIONS` source file property on the ``.qrc`` file.
The ``rcc`` executable will be detected automatically, but can be forced to
a certain binary using the :prop_tgt:`AUTORCC_EXECUTABLE` property.
The global property :prop_gbl:`AUTOGEN_TARGETS_FOLDER` can be used to group
the autorcc targets together in an IDE, e.g. in MSVS.
The global property :prop_gbl:`AUTOGEN_SOURCE_GROUP` can be used to group
files generated by :prop_tgt:`AUTORCC` together in an IDE, e.g. in MSVS.
When there are multiple ``.qrc`` files with the same name, CMake will
generate unspecified unique names for ``rcc``. Therefore if
``Q_INIT_RESOURCE()`` or ``Q_CLEANUP_RESOURCE()`` need to be used the
``.qrc`` file name must be unique.
Source files can be excluded from :prop_tgt:`AUTORCC` processing by
enabling :prop_sf:`SKIP_AUTORCC` or the broader :prop_sf:`SKIP_AUTOGEN`.
A global ``autorcc`` target that depends on all :prop_tgt:`AUTORCC` targets
in the project can be generated by enabling
:variable:`CMAKE_GLOBAL_AUTORCC_TARGET`.
See the :manual:`cmake-qt(7)` manual for more information on using CMake
with Qt.

47
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/AUTOUIC.rst
View File

@ -1,47 +0,0 @@
AUTOUIC
-------
Should the target be processed with autouic (for Qt projects).
:prop_tgt:`AUTOUIC` is a boolean specifying whether CMake will handle
the Qt ``uic`` code generator automatically, i.e. without having to use
the :module:`QT4_WRAP_UI() <FindQt4>` or ``QT5_WRAP_UI()`` macro. Currently
Qt4 and Qt5 are supported.
When this property is ``ON``, CMake will scan the source files at build time
and invoke ``uic`` accordingly. If an ``#include`` statement like
``#include "ui_foo.h"`` is found in ``source.cpp``, a ``foo.ui`` file is
searched for first in the vicinity of ``source.cpp`` and afterwards in the
optional :prop_tgt:`AUTOUIC_SEARCH_PATHS` of the target.
``uic`` is run on the ``foo.ui`` file to generate ``ui_foo.h`` in the directory
``<AUTOGEN_BUILD_DIR>/include``,
which is automatically added to the target's :prop_tgt:`INCLUDE_DIRECTORIES`.
* For :prop_gbl:`multi configuration generators <GENERATOR_IS_MULTI_CONFIG>`,
the include directory is ``<AUTOGEN_BUILD_DIR>/include_<CONFIG>``.
* See :prop_tgt:`AUTOGEN_BUILD_DIR`.
This property is initialized by the value of the :variable:`CMAKE_AUTOUIC`
variable if it is set when a target is created.
Additional command line options for ``uic`` can be set via the
:prop_sf:`AUTOUIC_OPTIONS` source file property on the ``foo.ui`` file.
The global property :prop_gbl:`AUTOGEN_TARGETS_FOLDER` can be used to group the
autouic targets together in an IDE, e.g. in MSVS.
The ``uic`` executable will be detected automatically, but can be forced to
a certain binary using the :prop_tgt:`AUTOUIC_EXECUTABLE` property.
Source files can be excluded from :prop_tgt:`AUTOUIC` processing by
enabling :prop_sf:`SKIP_AUTOUIC` or the broader :prop_sf:`SKIP_AUTOGEN`.
The number of parallel ``uic`` processes to start can be modified by
setting :prop_tgt:`AUTOGEN_PARALLEL`.
A global ``autogen`` target that depends on all :prop_tgt:`AUTOUIC` generated
``<ORIGIN>_autogen`` targets in the project can be generated by enabling
:variable:`CMAKE_GLOBAL_AUTOGEN_TARGET`.
See the :manual:`cmake-qt(7)` manual for more information on using CMake
with Qt.

21
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/CUDA_RESOLVE_DEVICE_SYMBOLS.rst
View File

@ -1,21 +0,0 @@
CUDA_RESOLVE_DEVICE_SYMBOLS
---------------------------
CUDA only: Enables device linking for the specific library target
If set this will enable device linking on the library target. Normally
device linking is deferred until a shared library or executable is generated,
allowing for multiple static libraries to resolve device symbols at the same
time when they are used by a shared library or executable.
By default static library targets have this property is disabled,
while shared, module, and executable targets have this property enabled.
Note that device linking is not supported for :ref:`Object Libraries`.
For instance:
.. code-block:: cmake
set_property(TARGET mystaticlib PROPERTY CUDA_RESOLVE_DEVICE_SYMBOLS ON)

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/DEBUG_POSTFIX.rst
View File

@ -1,7 +0,0 @@
DEBUG_POSTFIX
-------------
See target property <CONFIG>_POSTFIX.
This property is a special case of the more-general <CONFIG>_POSTFIX
property for the DEBUG configuration.

22
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/ENABLE_EXPORTS.rst
View File

@ -1,22 +0,0 @@
ENABLE_EXPORTS
--------------
Specify whether an executable exports symbols for loadable modules.
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.
For DLL platforms an import library will be created for the exported
symbols and then used for linking. All Windows-based systems
including Cygwin are DLL platforms. For non-DLL platforms that
require all symbols to be resolved at link time, such as macOS, the
module will "link" to the executable using a flag like
``-bundle_loader``. For other non-DLL platforms the link rule is simply
ignored since the dynamic loader will automatically bind symbols when
the module is loaded.
This property is initialized by the value of the variable
:variable:`CMAKE_ENABLE_EXPORTS` if it is set when a target is created.

8
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/EXCLUDE_FROM_DEFAULT_BUILD.rst
View File

@ -1,8 +0,0 @@
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".

9
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/EXCLUDE_FROM_DEFAULT_BUILD_CONFIG.rst
View File

@ -1,9 +0,0 @@
EXCLUDE_FROM_DEFAULT_BUILD_<CONFIG>
-----------------------------------
Per-configuration version of target exclusion from "Build Solution".
This is the configuration-specific version of
EXCLUDE_FROM_DEFAULT_BUILD. If the generic EXCLUDE_FROM_DEFAULT_BUILD
is also set on a target, EXCLUDE_FROM_DEFAULT_BUILD_<CONFIG> takes
precedence in configurations for which it has a value.

8
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/EXPORT_NAME.rst
View File

@ -1,8 +0,0 @@
EXPORT_NAME
-----------
Exported name for target files.
This sets the name for the IMPORTED target generated when it this
target is is exported. If not set, the logical target name is used by
default.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/EchoString.rst
View File

@ -1,7 +0,0 @@
EchoString
----------
A message to be displayed when the target is built.
A message to display on some generators (such as makefiles) when the
target is built.

17
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/GNUtoMS.rst
View File

@ -1,17 +0,0 @@
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 install(TARGETS) and exported by
install(EXPORT) and 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 project()
or enable_language(). CMake provides the variable as an option to the
user automatically when configuring on Windows with GNU tools.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/HAS_CXX.rst
View File

@ -1,7 +0,0 @@
HAS_CXX
-------
Link the target using the C++ linker tool (obsolete).
This is equivalent to setting the LINKER_LANGUAGE property to CXX.
See that property's documentation for details.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/IMPORTED_IMPLIB.rst
View File

@ -1,7 +0,0 @@
IMPORTED_IMPLIB
---------------
Full path to the import library for an IMPORTED target.
Set this to the location of the ".lib" part of a windows DLL. Ignored
for non-imported targets.

16
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/IMPORTED_LINK_INTERFACE_LIBRARIES.rst
View File

@ -1,16 +0,0 @@
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
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
INTERFACE_LINK_LIBRARIES property.
This property is deprecated. Use INTERFACE_LINK_LIBRARIES instead.

6
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/IMPORTED_LINK_INTERFACE_MULTIPLICITY.rst
View File

@ -1,6 +0,0 @@
IMPORTED_LINK_INTERFACE_MULTIPLICITY
------------------------------------
Repetition count for cycles of IMPORTED static libraries.
This is LINK_INTERFACE_MULTIPLICITY for IMPORTED targets.

21
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/IMPORTED_LOCATION.rst
View File

@ -1,21 +0,0 @@
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 bundles
on macOS this is the location of the executable file inside
Contents/MacOS under the application bundle folder. 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 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.
Projects may skip IMPORTED_LOCATION if the configuration-specific
property IMPORTED_LOCATION_<CONFIG> is set. To get the location of an
imported target read one of the LOCATION or LOCATION_<CONFIG>
properties.

9
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/IMPORTED_NO_SONAME.rst
View File

@ -1,9 +0,0 @@
IMPORTED_NO_SONAME
------------------
Specifies that an IMPORTED shared library target has no "soname".
Set this property to true for an imported shared library file that has
no "soname" field. CMake may adjust generated link commands for some
platforms to prevent the linker from using the path to the library in
place of its missing soname. Ignored for non-imported targets.

8
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/IMPORTED_SONAME.rst
View File

@ -1,8 +0,0 @@
IMPORTED_SONAME
---------------
The "soname" of an IMPORTED target of shared library type.
Set this to the "soname" embedded in an imported shared library. This
is meaningful only on platforms supporting the feature. Ignored for
non-imported targets.

9
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/IMPORT_SUFFIX.rst
View File

@ -1,9 +0,0 @@
IMPORT_SUFFIX
-------------
What comes after the import library name.
Similar to the target property 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.

10
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/INSTALL_RPATH_USE_LINK_PATH.rst
View File

@ -1,10 +0,0 @@
INSTALL_RPATH_USE_LINK_PATH
---------------------------
Add paths to linker search and installed rpath.
INSTALL_RPATH_USE_LINK_PATH is a boolean that if set to true will
append directories in the linker search path and outside the project
to the INSTALL_RPATH. This property is initialized by the value of
the variable CMAKE_INSTALL_RPATH_USE_LINK_PATH if it is set when a
target is created.

19
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/LINK_SEARCH_START_STATIC.rst
View File

@ -1,19 +0,0 @@
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
CMAKE_LINK_SEARCH_START_STATIC if it is set when a target is created.
See also LINK_SEARCH_END_STATIC.

9
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/POST_INSTALL_SCRIPT.rst
View File

@ -1,9 +0,0 @@
POST_INSTALL_SCRIPT
-------------------
Deprecated install support.
The 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 INSTALL command instead.

9
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/PRE_INSTALL_SCRIPT.rst
View File

@ -1,9 +0,0 @@
PRE_INSTALL_SCRIPT
------------------
Deprecated install support.
The 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 INSTALL command instead.

9
6.5.1/_tools/cmake/share/cmake-3.14/Help/prop_tgt/TYPE.rst
View File

@ -1,9 +0,0 @@
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.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_CUDA_HOST_COMPILER.rst
View File

@ -1,7 +0,0 @@
CMAKE_CUDA_HOST_COMPILER
------------------------
Executable to use when compiling host code when compiling ``CUDA`` language
files. Maps to the nvcc -ccbin option. Will only be used by CMake on the first
configuration to determine a valid host compiler for ``CUDA``. After a valid
host compiler has been found, this value is read-only.

22
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_ENABLE_EXPORTS.rst
View File

@ -1,22 +0,0 @@
CMAKE_ENABLE_EXPORTS
--------------------
Specify whether an executable exports symbols for loadable modules.
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.
For DLL platforms an import library will be created for the exported
symbols and then used for linking. All Windows-based systems
including Cygwin are DLL platforms. For non-DLL platforms that
require all symbols to be resolved at link time, such as macOS, the
module will ``link`` to the executable using a flag like
``-bundle_loader``. For other non-DLL platforms the link rule is simply
ignored since the dynamic loader will automatically bind symbols when
the module is loaded.
This variable is used to initialize the target property
:prop_tgt:`ENABLE_EXPORTS` for executable targets.

11
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_EXPORT_NO_PACKAGE_REGISTRY.rst
View File

@ -1,11 +0,0 @@
CMAKE_EXPORT_NO_PACKAGE_REGISTRY
--------------------------------
Disable the :command:`export(PACKAGE)` command.
In some cases, for example for packaging and for system wide
installations, it is not desirable to write the user package registry.
If the :variable:`CMAKE_EXPORT_NO_PACKAGE_REGISTRY` variable is enabled,
the :command:`export(PACKAGE)` command will do nothing.
See also :ref:`Disabling the Package Registry`.

13
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY.rst
View File

@ -1,13 +0,0 @@
CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY
--------------------------------------
Skip :ref:`User Package Registry` in :command:`find_package` calls.
In some cases, for example to locate only system wide installations, it
is not desirable to use the :ref:`User Package Registry` when searching
for packages. If the :variable:`CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY`
variable is enabled, all the :command:`find_package` commands will skip
the :ref:`User Package Registry` as if they were called with the
``NO_CMAKE_PACKAGE_REGISTRY`` argument.
See also :ref:`Disabling the Package Registry`.

13
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY.rst
View File

@ -1,13 +0,0 @@
CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY
---------------------------------------------
Skip :ref:`System Package Registry` in :command:`find_package` calls.
In some cases, it is not desirable to use the
:ref:`System Package Registry` when searching for packages. If the
:variable:`CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY` variable is
enabled, all the :command:`find_package` commands will skip
the :ref:`System Package Registry` as if they were called with the
``NO_CMAKE_SYSTEM_PACKAGE_REGISTRY`` argument.
See also :ref:`Disabling the Package Registry`.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_GENERATOR.rst
View File

@ -1,7 +0,0 @@
CMAKE_GENERATOR
---------------
The generator used to build the project. See :manual:`cmake-generators(7)`.
The name of the generator that is being used to generate the build
files. (e.g. ``Unix Makefiles``, ``Ninja``, etc.)

6
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_PROJECT_PROJECT-NAME_INCLUDE.rst
View File

@ -1,6 +0,0 @@
CMAKE_PROJECT_<PROJECT-NAME>_INCLUDE
------------------------------------
A CMake language file or module to be included by the :command:`project`
command. This is intended for injecting custom code into project
builds without modifying their source.

14
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_STAGING_PREFIX.rst
View File

@ -1,14 +0,0 @@
CMAKE_STAGING_PREFIX
--------------------
This variable may be set to a path to install to when cross-compiling. This can
be useful if the path in :variable:`CMAKE_SYSROOT` is read-only, or otherwise
should remain pristine.
The ``CMAKE_STAGING_PREFIX`` location is also used as a search prefix by the
``find_*`` commands. This can be controlled by setting the
:variable:`CMAKE_FIND_NO_INSTALL_PREFIX` variable.
If any RPATH/RUNPATH entries passed to the linker contain the
``CMAKE_STAGING_PREFIX``, the matching path fragments are replaced with the
:variable:`CMAKE_INSTALL_PREFIX`.

6
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_STATIC_LINKER_FLAGS.rst
View File

@ -1,6 +0,0 @@
CMAKE_STATIC_LINKER_FLAGS
-------------------------
Linker flags to be used to create static libraries.
These flags will be used by the linker when creating a static library.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_STATIC_LINKER_FLAGS_CONFIG.rst
View File

@ -1,7 +0,0 @@
CMAKE_STATIC_LINKER_FLAGS_<CONFIG>
----------------------------------
Flags to be used when linking a static library.
Same as ``CMAKE_C_FLAGS_*`` but used by the linker when creating static
libraries.

11
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CMAKE_SUPPRESS_REGENERATION.rst
View File

@ -1,11 +0,0 @@
CMAKE_SUPPRESS_REGENERATION
---------------------------
If CMAKE_SUPPRESS_REGENERATION is ``OFF``, which is default, then CMake adds a
special target on which all other targets depend that checks the build system
and optionally re-runs CMake to regenerate the build system when the target
specification source changes.
If this variable evaluates to ``ON`` at the end of the top-level
``CMakeLists.txt`` file, CMake will not add the regeneration target to the
build system or perform any build system checks.

8
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/CPACK_INSTALL_SCRIPT.rst
View File

@ -1,8 +0,0 @@
CPACK_INSTALL_SCRIPT
--------------------
Extra CMake script provided by the user.
If set this CMake script will be executed by CPack during its local
[CPack-private] installation which is done right before packaging the
files. The script is not called by e.g.: ``make install``.

7
6.5.1/_tools/cmake/share/cmake-3.14/Help/variable/XCODE_VERSION.rst
View File

@ -1,7 +0,0 @@
XCODE_VERSION
-------------
Version of Xcode (:generator:`Xcode` generator only).
Under the Xcode generator, this is the version of Xcode as specified
in ``Xcode.app/Contents/version.plist`` (such as ``3.1.2``).

34
6.5.1/_tools/cmake/share/cmake-3.14/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake
View File

@ -1,34 +0,0 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
# Do NOT include this module directly into any of your code. It is meant as
# a library for Check*CompilerFlag.cmake modules. It's content may change in
# any way between releases.
macro (CHECK_COMPILER_FLAG_COMMON_PATTERNS _VAR)
set(${_VAR}
FAIL_REGEX "[Uu]nrecogni[sz]ed .*option" # GNU, NAG
FAIL_REGEX "unknown .*option" # Clang
FAIL_REGEX "optimization flag .* not supported" # Clang
FAIL_REGEX "unknown argument ignored" # Clang (cl)
FAIL_REGEX "ignoring unknown option" # MSVC, Intel
FAIL_REGEX "warning D9002" # MSVC, any lang
FAIL_REGEX "option.*not supported" # Intel
FAIL_REGEX "invalid argument .*option" # Intel
FAIL_REGEX "ignoring option .*argument required" # Intel
FAIL_REGEX "ignoring option .*argument is of wrong type" # Intel
FAIL_REGEX "[Uu]nknown option" # HP
FAIL_REGEX "[Ww]arning: [Oo]ption" # SunPro
FAIL_REGEX "command option .* is not recognized" # XL
FAIL_REGEX "command option .* contains an incorrect subargument" # XL
FAIL_REGEX "Option .* is not recognized. Option will be ignored." # XL
FAIL_REGEX "not supported in this configuration. ignored" # AIX
FAIL_REGEX "File with unknown suffix passed to linker" # PGI
FAIL_REGEX "[Uu]nknown switch" # PGI
FAIL_REGEX "WARNING: unknown flag:" # Open64
FAIL_REGEX "Incorrect command line option:" # Borland
FAIL_REGEX "Warning: illegal option" # SunStudio 12
FAIL_REGEX "[Ww]arning: Invalid suboption" # Fujitsu
)
endmacro ()

45
6.5.1/_tools/cmake/share/cmake-3.14/Modules/CMakeDetermineSwiftCompiler.cmake
View File

@ -1,45 +0,0 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
if("${CMAKE_GENERATOR}" STREQUAL "Xcode")
if(XCODE_VERSION VERSION_LESS 6.1)
message(FATAL_ERROR "Swift language not supported by Xcode ${XCODE_VERSION}")
endif()
set(CMAKE_Swift_COMPILER_XCODE_TYPE sourcecode.swift)
_cmake_find_compiler_path(Swift)
else()
message(FATAL_ERROR "Swift language not supported by \"${CMAKE_GENERATOR}\" generator")
endif()
# Build a small source file to identify the compiler.
if(NOT CMAKE_Swift_COMPILER_ID_RUN)
set(CMAKE_Swift_COMPILER_ID_RUN 1)
list(APPEND CMAKE_Swift_COMPILER_ID_MATCH_VENDORS Apple)
set(CMAKE_Swift_COMPILER_ID_MATCH_VENDOR_REGEX_Apple "com.apple.xcode.tools.swift.compiler")
set(CMAKE_Swift_COMPILER_ID_TOOL_MATCH_REGEX "\nCompileSwiftSources[^\n]*(\n[ \t]+[^\n]*)*\n[ \t]+([^ \t\r\n]+)[^\r\n]* -c[^\r\n]*CompilerIdSwift/CompilerId/main.swift")
set(CMAKE_Swift_COMPILER_ID_TOOL_MATCH_INDEX 2)
# Try to identify the compiler.
set(CMAKE_Swift_COMPILER_ID)
include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
CMAKE_DETERMINE_COMPILER_ID(Swift "" CompilerId/main.swift)
endif()
if (NOT _CMAKE_TOOLCHAIN_LOCATION)
get_filename_component(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_Swift_COMPILER}" PATH)
endif ()
set(_CMAKE_PROCESSING_LANGUAGE "Swift")
include(CMakeFindBinUtils)
unset(_CMAKE_PROCESSING_LANGUAGE)
# configure variables set in this file for fast reload later on
configure_file(${CMAKE_ROOT}/Modules/CMakeSwiftCompiler.cmake.in
${CMAKE_PLATFORM_INFO_DIR}/CMakeSwiftCompiler.cmake
@ONLY
)

149
6.5.1/_tools/cmake/share/cmake-3.14/Modules/CMakeExpandImportedTargets.cmake
View File

@ -1,149 +0,0 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
#[=======================================================================[.rst:
CMakeExpandImportedTargets
--------------------------
.. deprecated:: 3.4
Do not use.
This module was once needed to expand imported targets to the underlying
libraries they reference on disk for use with the :command:`try_compile`
and :command:`try_run` commands. These commands now support imported
libraries in their ``LINK_LIBRARIES`` options (since CMake 2.8.11
for :command:`try_compile` and since CMake 3.2 for :command:`try_run`).
This module does not support the policy :policy:`CMP0022` ``NEW``
behavior or use of the :prop_tgt:`INTERFACE_LINK_LIBRARIES` property
because :manual:`generator expressions <cmake-generator-expressions(7)>`
cannot be evaluated during configuration.
::
CMAKE_EXPAND_IMPORTED_TARGETS(<var> LIBRARIES lib1 lib2...libN
[CONFIGURATION <config>])
CMAKE_EXPAND_IMPORTED_TARGETS() takes a list of libraries and replaces
all imported targets contained in this list with their actual file
paths of the referenced libraries on disk, including the libraries
from their link interfaces. If a CONFIGURATION is given, it uses the
respective configuration of the imported targets if it exists. If no
CONFIGURATION is given, it uses the first configuration from
${CMAKE_CONFIGURATION_TYPES} if set, otherwise ${CMAKE_BUILD_TYPE}.
::
cmake_expand_imported_targets(expandedLibs
LIBRARIES ${CMAKE_REQUIRED_LIBRARIES}
CONFIGURATION "${CMAKE_TRY_COMPILE_CONFIGURATION}" )
#]=======================================================================]
function(CMAKE_EXPAND_IMPORTED_TARGETS _RESULT )
set(options )
set(oneValueArgs CONFIGURATION )
set(multiValueArgs LIBRARIES )
cmake_parse_arguments(CEIT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
if(CEIT_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "Unknown keywords given to CMAKE_EXPAND_IMPORTED_TARGETS(): \"${CEIT_UNPARSED_ARGUMENTS}\"")
endif()
if(NOT CEIT_CONFIGURATION)
# Would be better to test GENERATOR_IS_MULTI_CONFIG global property,
# but the documented behavior specifically says we check
# CMAKE_CONFIGURATION_TYPES and fall back to CMAKE_BUILD_TYPE if no
# config types are defined.
if(CMAKE_CONFIGURATION_TYPES)
list(GET CMAKE_CONFIGURATION_TYPES 0 CEIT_CONFIGURATION)
else()
set(CEIT_CONFIGURATION ${CMAKE_BUILD_TYPE})
endif()
endif()
# handle imported library targets
set(_CCSR_REQ_LIBS ${CEIT_LIBRARIES})
set(_CHECK_FOR_IMPORTED_TARGETS TRUE)
set(_CCSR_LOOP_COUNTER 0)
while(_CHECK_FOR_IMPORTED_TARGETS)
math(EXPR _CCSR_LOOP_COUNTER "${_CCSR_LOOP_COUNTER} + 1 ")
set(_CCSR_NEW_REQ_LIBS )
set(_CHECK_FOR_IMPORTED_TARGETS FALSE)
foreach(_CURRENT_LIB ${_CCSR_REQ_LIBS})
if(TARGET "${_CURRENT_LIB}")
get_target_property(_importedConfigs "${_CURRENT_LIB}" IMPORTED_CONFIGURATIONS)
else()
set(_importedConfigs "")
endif()
if (_importedConfigs)
# message(STATUS "Detected imported target ${_CURRENT_LIB}")
# Ok, so this is an imported target.
# First we get the imported configurations.
# Then we get the location of the actual library on disk of the first configuration.
# then we'll get its link interface libraries property,
# iterate through it and replace all imported targets we find there
# with there actual location.
# guard against infinite loop: abort after 100 iterations ( 100 is arbitrary chosen)
if ("${_CCSR_LOOP_COUNTER}" LESS 100)
set(_CHECK_FOR_IMPORTED_TARGETS TRUE)
# else ()
# message(STATUS "********* aborting loop, counter : ${_CCSR_LOOP_COUNTER}")
endif ()
# if one of the imported configurations equals ${CMAKE_TRY_COMPILE_CONFIGURATION},
# use it, otherwise simply use the first one:
list(FIND _importedConfigs "${CEIT_CONFIGURATION}" _configIndexToUse)
if("${_configIndexToUse}" EQUAL -1)
set(_configIndexToUse 0)
endif()
list(GET _importedConfigs ${_configIndexToUse} _importedConfigToUse)
get_target_property(_importedLocation "${_CURRENT_LIB}" IMPORTED_LOCATION_${_importedConfigToUse})
get_target_property(_linkInterfaceLibs "${_CURRENT_LIB}" IMPORTED_LINK_INTERFACE_LIBRARIES_${_importedConfigToUse} )
list(APPEND _CCSR_NEW_REQ_LIBS "${_importedLocation}")
# message(STATUS "Appending lib ${_CURRENT_LIB} as ${_importedLocation}")
if(_linkInterfaceLibs)
foreach(_currentLinkInterfaceLib ${_linkInterfaceLibs})
# message(STATUS "Appending link interface lib ${_currentLinkInterfaceLib}")
if(_currentLinkInterfaceLib)
list(APPEND _CCSR_NEW_REQ_LIBS "${_currentLinkInterfaceLib}" )
endif()
endforeach()
endif()
else()
# "Normal" libraries are just used as they are.
list(APPEND _CCSR_NEW_REQ_LIBS "${_CURRENT_LIB}" )
# message(STATUS "Appending lib directly: ${_CURRENT_LIB}")
endif()
endforeach()
set(_CCSR_REQ_LIBS ${_CCSR_NEW_REQ_LIBS} )
endwhile()
# Finally we iterate once more over all libraries. This loop only removes
# all remaining imported target names (there shouldn't be any left anyway).
set(_CCSR_NEW_REQ_LIBS )
foreach(_CURRENT_LIB ${_CCSR_REQ_LIBS})
if(TARGET "${_CURRENT_LIB}")
get_target_property(_importedConfigs "${_CURRENT_LIB}" IMPORTED_CONFIGURATIONS)
else()
set(_importedConfigs "")
endif()
if (NOT _importedConfigs)
list(APPEND _CCSR_NEW_REQ_LIBS "${_CURRENT_LIB}" )
# message(STATUS "final: appending ${_CURRENT_LIB}")
else ()
# message(STATUS "final: skipping ${_CURRENT_LIB}")
endif ()
endforeach()
# message(STATUS "setting -${_RESULT}- to -${_CCSR_NEW_REQ_LIBS}-")
set(${_RESULT} "${_CCSR_NEW_REQ_LIBS}" PARENT_SCOPE)
endfunction()

91
6.5.1/_tools/cmake/share/cmake-3.14/Modules/CMakePushCheckState.cmake
View File

@ -1,91 +0,0 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
#[=======================================================================[.rst:
CMakePushCheckState
-------------------
This module defines three macros: ``CMAKE_PUSH_CHECK_STATE()``
``CMAKE_POP_CHECK_STATE()`` and ``CMAKE_RESET_CHECK_STATE()`` These macros can
be used to save, restore and reset (i.e., clear contents) the state of
the variables ``CMAKE_REQUIRED_FLAGS``, ``CMAKE_REQUIRED_DEFINITIONS``,
``CMAKE_REQUIRED_LINK_OPTIONS``, ``CMAKE_REQUIRED_LIBRARIES``,
``CMAKE_REQUIRED_INCLUDES`` and ``CMAKE_EXTRA_INCLUDE_FILES`` used by the
various Check-files coming with CMake, like e.g. ``check_function_exists()``
etc.
The variable contents are pushed on a stack, pushing multiple times is
supported. This is useful e.g. when executing such tests in a Find-module,
where they have to be set, but after the Find-module has been executed they
should have the same value as they had before.
``CMAKE_PUSH_CHECK_STATE()`` macro receives optional argument ``RESET``.
Whether it's specified, ``CMAKE_PUSH_CHECK_STATE()`` will set all
``CMAKE_REQUIRED_*`` variables to empty values, same as
``CMAKE_RESET_CHECK_STATE()`` call will do.
Usage:
.. code-block:: cmake
cmake_push_check_state(RESET)
set(CMAKE_REQUIRED_DEFINITIONS -DSOME_MORE_DEF)
check_function_exists(...)
cmake_reset_check_state()
set(CMAKE_REQUIRED_DEFINITIONS -DANOTHER_DEF)
check_function_exists(...)
cmake_pop_check_state()
#]=======================================================================]
macro(CMAKE_RESET_CHECK_STATE)
set(CMAKE_EXTRA_INCLUDE_FILES)
set(CMAKE_REQUIRED_INCLUDES)
set(CMAKE_REQUIRED_DEFINITIONS)
set(CMAKE_REQUIRED_LINK_OPTIONS)
set(CMAKE_REQUIRED_LIBRARIES)
set(CMAKE_REQUIRED_FLAGS)
set(CMAKE_REQUIRED_QUIET)
endmacro()
macro(CMAKE_PUSH_CHECK_STATE)
if(NOT DEFINED _CMAKE_PUSH_CHECK_STATE_COUNTER)
set(_CMAKE_PUSH_CHECK_STATE_COUNTER 0)
endif()
math(EXPR _CMAKE_PUSH_CHECK_STATE_COUNTER "${_CMAKE_PUSH_CHECK_STATE_COUNTER}+1")
set(_CMAKE_EXTRA_INCLUDE_FILES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_EXTRA_INCLUDE_FILES})
set(_CMAKE_REQUIRED_INCLUDES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_INCLUDES})
set(_CMAKE_REQUIRED_DEFINITIONS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_DEFINITIONS})
set(_CMAKE_REQUIRED_LINK_OPTIONS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_LINK_OPTIONS})
set(_CMAKE_REQUIRED_LIBRARIES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_LIBRARIES})
set(_CMAKE_REQUIRED_FLAGS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_FLAGS})
set(_CMAKE_REQUIRED_QUIET_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER} ${CMAKE_REQUIRED_QUIET})
if (${ARGC} GREATER 0 AND "${ARGV0}" STREQUAL "RESET")
cmake_reset_check_state()
endif()
endmacro()
macro(CMAKE_POP_CHECK_STATE)
# don't pop more than we pushed
if("${_CMAKE_PUSH_CHECK_STATE_COUNTER}" GREATER "0")
set(CMAKE_EXTRA_INCLUDE_FILES ${_CMAKE_EXTRA_INCLUDE_FILES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}})
set(CMAKE_REQUIRED_INCLUDES ${_CMAKE_REQUIRED_INCLUDES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}})
set(CMAKE_REQUIRED_DEFINITIONS ${_CMAKE_REQUIRED_DEFINITIONS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}})
set(CMAKE_REQUIRED_LINK_OPTIONS ${_CMAKE_REQUIRED_LINK_OPTIONS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}})
set(CMAKE_REQUIRED_LIBRARIES ${_CMAKE_REQUIRED_LIBRARIES_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}})
set(CMAKE_REQUIRED_FLAGS ${_CMAKE_REQUIRED_FLAGS_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}})
set(CMAKE_REQUIRED_QUIET ${_CMAKE_REQUIRED_QUIET_SAVE_${_CMAKE_PUSH_CHECK_STATE_COUNTER}})
math(EXPR _CMAKE_PUSH_CHECK_STATE_COUNTER "${_CMAKE_PUSH_CHECK_STATE_COUNTER}-1")
endif()
endmacro()

5
6.5.1/_tools/cmake/share/cmake-3.14/Modules/CMakeSwiftCompiler.cmake.in
View File

@ -1,5 +0,0 @@
set(CMAKE_Swift_COMPILER "@CMAKE_Swift_COMPILER@")
set(CMAKE_Swift_COMPILER_ID "@CMAKE_Swift_COMPILER_ID@")
set(CMAKE_Swift_COMPILER_ID_RUN 1)
set(CMAKE_Swift_SOURCE_FILE_EXTENSIONS swift)

32
6.5.1/_tools/cmake/share/cmake-3.14/Modules/CMakeSwiftInformation.cmake
View File

@ -1,32 +0,0 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
set(CMAKE_Swift_OUTPUT_EXTENSION .o)
set(CMAKE_INCLUDE_FLAG_Swift "-I")
# Load compiler-specific information.
if(CMAKE_Swift_COMPILER_ID)
include(Compiler/${CMAKE_Swift_COMPILER_ID}-Swift OPTIONAL)
endif()
# load the system- and compiler specific files
if(CMAKE_Swift_COMPILER_ID)
# load a hardware specific file, mostly useful for embedded compilers
if(CMAKE_SYSTEM_PROCESSOR)
include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_Swift_COMPILER_ID}-Swift-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
endif()
include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_Swift_COMPILER_ID}-Swift OPTIONAL)
endif()
# for most systems a module is the same as a shared library
# so unless the variable CMAKE_MODULE_EXISTS is set just
# copy the values from the LIBRARY variables
if(NOT CMAKE_MODULE_EXISTS)
set(CMAKE_SHARED_MODULE_Swift_FLAGS ${CMAKE_SHARED_LIBRARY_Swift_FLAGS})
set(CMAKE_SHARED_MODULE_CREATE_Swift_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_Swift_FLAGS})
endif()
include(CMakeCommonLanguageInclude)
set(CMAKE_Swift_INFORMATION_LOADED 1)

37
6.5.1/_tools/cmake/share/cmake-3.14/Modules/Compiler/CrayPrgEnv.cmake
View File

@ -1,37 +0,0 @@
# Guard against multiple inclusions
if(__craylinux_crayprgenv)
return()
endif()
set(__craylinux_crayprgenv 1)
macro(__CrayPrgEnv_setup lang)
if(DEFINED ENV{CRAYPE_VERSION})
message(STATUS "Cray Programming Environment $ENV{CRAYPE_VERSION} ${lang}")
elseif(DEFINED ENV{ASYNCPE_VERSION})
message(STATUS "Cray XT Programming Environment $ENV{ASYNCPE_VERSION} ${lang}")
else()
message(STATUS "Cray Programming Environment (unknown version) ${lang}")
endif()
# Flags for the Cray wrappers
set(CMAKE_STATIC_LIBRARY_LINK_${lang}_FLAGS "-static")
set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-shared")
set(CMAKE_SHARED_LIBRARY_LINK_${lang}_FLAGS "-dynamic")
# If the link type is not explicitly specified in the environment then
# the Cray wrappers assume that the code will be built statically so
# we check the following condition(s) are NOT met
# Compiler flags are explicitly dynamic
# Env var is dynamic and compiler flags are not explicitly static
if(NOT (((CMAKE_${lang}_FLAGS MATCHES "(^| )-dynamic($| )") OR
(CMAKE_EXE_LINKER_FLAGS MATCHES "(^| )-dynamic($| )"))
OR
(("$ENV{CRAYPE_LINK_TYPE}" STREQUAL "dynamic") AND
NOT ((CMAKE_${lang}_FLAGS MATCHES "(^| )-static($| )") OR
(CMAKE_EXE_LINKER_FLAGS MATCHES "(^| )-static($| )")))))
set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS FALSE)
set(BUILD_SHARED_LIBS FALSE CACHE BOOL "")
set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
set(CMAKE_LINK_SEARCH_START_STATIC TRUE)
endif()
endmacro()

23
6.5.1/_tools/cmake/share/cmake-3.14/Modules/Compiler/IAR-ASM.cmake
View File

@ -1,23 +0,0 @@
# This file is processed when the IAR compiler is used for an assembler file
include(Compiler/IAR)
if("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "ARM")
set(CMAKE_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> -S <SOURCE> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT>")
__compiler_iar_ARM(ASM)
set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;asm;msa)
string(APPEND CMAKE_ASM_FLAGS_INIT " ")
string(APPEND CMAKE_ASM_FLAGS_DEBUG_INIT " -r")
string(APPEND CMAKE_ASM_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
string(APPEND CMAKE_ASM_FLAGS_RELEASE_INIT " -DNDEBUG")
string(APPEND CMAKE_ASM_FLAGS_RELWITHDEBINFO_INIT " -r -DNDEBUG")
elseif("${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}" STREQUAL "AVR")
set(CMAKE_ASM_COMPILE_OBJECT "<CMAKE_ASM_COMPILER> -S <SOURCE> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT>")
__compiler_iar_AVR(ASM)
set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s90;asm;msa)
else()
message(FATAL_ERROR "CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID not detected as \"AVR\" or \"ARM\". This should be automatic.")
endif()

62
6.5.1/_tools/cmake/share/cmake-3.14/Modules/Compiler/IAR-C.cmake
View File

@ -1,62 +0,0 @@
# This file is processed when the IAR compiler is used for a C file
include(Compiler/IAR)
include(Compiler/CMakeCommonCompilerMacros)
# The toolchains for ARM and AVR are quite different:
if("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "ARM")
if(NOT CMAKE_C_COMPILER_VERSION)
message(FATAL_ERROR "CMAKE_C_COMPILER_VERSION not detected. This should be automatic.")
endif()
set(CMAKE_C_EXTENSION_COMPILE_OPTION -e)
set(CMAKE_C90_STANDARD_COMPILE_OPTION "")
set(CMAKE_C90_EXTENSION_COMPILE_OPTION -e)
if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 6.10)
set(CMAKE_C90_STANDARD_COMPILE_OPTION --c89)
set(CMAKE_C90_EXTENSION_COMPILE_OPTION --c89 -e)
set(CMAKE_C99_STANDARD_COMPILE_OPTION "")
set(CMAKE_C99_EXTENSION_COMPILE_OPTION -e)
endif()
if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 8.10)
set(CMAKE_C11_STANDARD_COMPILE_OPTION "")
set(CMAKE_C11_EXTENSION_COMPILE_OPTION -e)
endif()
__compiler_iar_ARM(C)
__compiler_check_default_language_standard(C 1.10 90 6.10 99 8.10 11)
elseif("${CMAKE_C_COMPILER_ARCHITECTURE_ID}" STREQUAL "AVR")
if(NOT CMAKE_C_COMPILER_VERSION)
message(FATAL_ERROR "CMAKE_C_COMPILER_VERSION not detected. This should be automatic.")
endif()
set(CMAKE_C_EXTENSION_COMPILE_OPTION -e)
set(CMAKE_C90_STANDARD_COMPILE_OPTION --c89)
set(CMAKE_C90_EXTENSION_COMPILE_OPTION -e)
set(CMAKE_C99_STANDARD_COMPILE_OPTION "")
set(CMAKE_C99_EXTENSION_COMPILE_OPTION -e)
__compiler_iar_AVR(C)
__compiler_check_default_language_standard(C 7.10 99)
set(CMAKE_C_OUTPUT_EXTENSION ".r90")
if(NOT CMAKE_C_LINK_FLAGS)
set(CMAKE_C_LINK_FLAGS "-Fmotorola")
endif()
set(CMAKE_C_LINK_EXECUTABLE "<CMAKE_LINKER> <OBJECTS> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> -o <TARGET>")
set(CMAKE_C_CREATE_STATIC_LIBRARY "<CMAKE_AR> -o <TARGET> <OBJECTS> ")
# add the target specific include directory:
get_filename_component(_compilerDir "${CMAKE_C_COMPILER}" PATH)
get_filename_component(_compilerDir "${_compilerDir}" PATH)
include_directories("${_compilerDir}/inc" )
include_directories("${_compilerDir}/inc/Atmel" )
else()
message(FATAL_ERROR "CMAKE_C_COMPILER_ARCHITECTURE_ID not detected as \"AVR\" or \"ARM\". This should be automatic.")
endif()

78
6.5.1/_tools/cmake/share/cmake-3.14/Modules/Compiler/IAR-CXX.cmake
View File

@ -1,78 +0,0 @@
# This file is processed when the IAR compiler is used for a C++ file
include(Compiler/IAR)
include(Compiler/CMakeCommonCompilerMacros)
if("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "ARM")
# "(extended) embedded C++" Mode
# old version: --ec++ or --eec++
# since 8.10: --c++ --no_exceptions --no_rtti
#
# --c++ is full C++ and supported since 6.10
if(NOT CMAKE_IAR_CXX_FLAG)
if(NOT CMAKE_CXX_COMPILER_VERSION)
message(FATAL_ERROR "CMAKE_CXX_COMPILER_VERSION not detected. This should be automatic.")
endif()
if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.10)
set(CMAKE_IAR_CXX_FLAG --c++)
else()
set(CMAKE_IAR_CXX_FLAG --eec++)
endif()
endif()
set(CMAKE_CXX_EXTENSION_COMPILE_OPTION -e)
set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "")
set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -e)
if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.10)
set(CMAKE_CXX03_STANDARD_COMPILE_OPTION "")
set(CMAKE_CXX03_EXTENSION_COMPILE_OPTION -e)
set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "")
set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION -e)
set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "")
set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION -e)
endif()
__compiler_iar_ARM(CXX)
__compiler_check_default_language_standard(CXX 6.10 98 8.10 14)
elseif("${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "AVR")
# "embedded C++" --EC++ is probably closest to CXX98 but with no support for:
# Templates, multiple inheritance, virtual inheritance, exceptions, RTTI, C++ style casts,
# Namespaces, the mutable attribute, no STL, any library features related to the above features.
#
# "(extended) embedded C++" --EEC++ Mode but DOES NOT support any normal C++ standard
# probably closest to CXX98 but with no RTTI and no exceptions, and the library
# provided is not in the standard namespace
if(NOT CMAKE_IAR_CXX_FLAG)
if(NOT CMAKE_CXX_COMPILER_VERSION)
message(FATAL_ERROR "CMAKE_CXX_COMPILER_VERSION not detected. This should be automatic.")
endif()
set(CMAKE_IAR_CXX_FLAG --eec++)
endif()
set(CMAKE_CXX_EXTENSION_COMPILE_OPTION -e)
set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "")
set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -e)
__compiler_iar_AVR(CXX)
__compiler_check_default_language_standard(CXX 7.10 98)
set(CMAKE_CXX_OUTPUT_EXTENSION ".r90")
if(NOT CMAKE_CXX_LINK_FLAGS)
set(CMAKE_CXX_LINK_FLAGS "-Fmotorola")
endif()
set(CMAKE_CXX_LINK_EXECUTABLE "<CMAKE_LINKER> <OBJECTS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES> -o <TARGET>")
set(CMAKE_CXX_CREATE_STATIC_LIBRARY "<CMAKE_AR> -o <TARGET> <OBJECTS> ")
# add the target specific include directory:
get_filename_component(_compilerDir "${CMAKE_C_COMPILER}" PATH)
get_filename_component(_compilerDir "${_compilerDir}" PATH)
include_directories("${_compilerDir}/inc")
include_directories("${_compilerDir}/inc/Atmel")
else()
message(FATAL_ERROR "CMAKE_CXX_COMPILER_ARCHITECTURE_ID not detected as \"AVR\" or \"ARM\". This should be automatic." )
endif()

54
6.5.1/_tools/cmake/share/cmake-3.14/Modules/Compiler/IAR-FindBinUtils.cmake
View File

@ -1,54 +0,0 @@
if(NOT DEFINED _CMAKE_PROCESSING_LANGUAGE OR _CMAKE_PROCESSING_LANGUAGE STREQUAL "")
message(FATAL_ERROR "Internal error: _CMAKE_PROCESSING_LANGUAGE is not set")
endif()
# Try to find tools in the same directory as Clang itself
get_filename_component(__iar_hint_1 "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER}" REALPATH)
get_filename_component(__iar_hint_1 "${__iar_hint_1}" DIRECTORY)
get_filename_component(__iar_hint_2 "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER}" DIRECTORY)
set(__iar_hints "${__iar_hint_1}" "${__iar_hint_2}")
if("${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ARCHITECTURE_ID}" STREQUAL "ARM")
# could allow using normal binutils ar, since objects are normal ELF files?
find_program(CMAKE_IAR_LINKARM ilinkarm.exe HINTS ${__iar_hints}
DOC "The IAR ARM linker")
find_program(CMAKE_IAR_ARCHIVE iarchive.exe HINTS ${__iar_hints}
DOC "The IAR archiver")
# find auxiliary tools
find_program(CMAKE_IAR_ELFTOOL ielftool.exe HINTS ${__iar_hints}
DOC "The IAR ELF Tool")
find_program(CMAKE_IAR_ELFDUMP ielfdumparm.exe HINTS ${__iar_hints}
DOC "The IAR ELF Dumper")
find_program(CMAKE_IAR_OBJMANIP iobjmanip.exe HINTS ${__iar_hints}
DOC "The IAR ELF Object Tool")
find_program(CMAKE_IAR_SYMEXPORT isymexport.exe HINTS ${__iar_hints}
DOC "The IAR Absolute Symbol Exporter")
mark_as_advanced(CMAKE_IAR_LINKARM CMAKE_IAR_ARCHIVE CMAKE_IAR_ELFTOOL CMAKE_IAR_ELFDUMP CMAKE_IAR_OBJMANIP CMAKE_IAR_SYMEXPORT)
set(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_CUSTOM_CODE
"set(CMAKE_IAR_LINKARM \"${CMAKE_IAR_LINKARM}\")
set(CMAKE_IAR_ARCHIVE \"${CMAKE_IAR_ARCHIVE}\")
set(CMAKE_IAR_ELFTOOL \"${CMAKE_IAR_ELFTOOL}\")
set(CMAKE_IAR_ELFDUMP \"${CMAKE_IAR_ELFDUMP}\")
set(CMAKE_IAR_OBJMANIP \"${CMAKE_IAR_OBJMANIP}\")
set(CMAKE_IAR_LINKARM \"${CMAKE_IAR_LINKARM}\")
")
elseif("${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ARCHITECTURE_ID}" STREQUAL "AVR")
# For AVR and AVR32, IAR uses the "xlink" linker and the "xar" archiver:
find_program(CMAKE_IAR_LINKER xlink.exe HINTS ${__iar_hints}
DOC "The IAR AVR linker")
find_program(CMAKE_IAR_AR xar.exe HINTS ${__iar_hints}
DOC "The IAR archiver")
mark_as_advanced(CMAKE_IAR_LINKER CMAKE_IAR_AR)
set(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_CUSTOM_CODE
"set(CMAKE_IAR_LINKER \"${CMAKE_IAR_LINKER}\")
set(CMAKE_IAR_AR \"${CMAKE_IAR_AR}\")
")
endif()

Some files were not shown because too many files have changed in this diff Show More