Commit b225dbbd authored by Brad King's avatar Brad King Committed by Kitware Robot
Browse files

Merge topic 'minor-cleanups'

a55c70de cmTarget: Remove support for <CONFIG>_LOCATION property.
c9f9b3cd cmTarget: Test impliedByUse number-compatible properties.
fbe1fa72 cmTarget: Don't repeat property origin debug information.
01c545c5 cmTarget: Fix debug report for interface-set compatibility types.
c67e1a6a cmTarget: Fix reporting interface-set properties which are FALSE.
07b0f546 Qt Tests: Remove commented and unneeded line.
79db8ef7 cmTarget: Fix the property compatibility error message
43340a9c Help: Reformat Qt autogenerator documentation.
d98ea6c0 Help: Mark some code blocks as containing cmake code.
ea78935f GenerateExportHeader: Reformat docs.
272a20f8 cmTarget: Don't update IMPORTED target compilation properties
03d842a9 Run the add_compile_options command unit test.
cd3d0b61 get_property: Fix testing ALIASED_TARGET target property (#14670)
6a622285 install: Ensure that install(TARGETS) works with no DESTINATION
af3d3b88 export: Only generate and install configuration files if needed.
0de81bba Help: Workaround pygments reporting an error for genexes.
...
parents 1377542d a55c70de
......@@ -131,7 +131,9 @@ It may also provide a CMake package configuration file::
<prefix>/lib/cmake/foo-1.2/FooConfig.cmake
with content defining :prop_tgt:`IMPORTED` targets, or defining variables, such
as::
as:
.. code-block:: cmake
# ...
# (compute PREFIX relative to file location)
......
......@@ -22,7 +22,9 @@ The :command:`cmake_minimum_required` command does more than report an
error if a too-old version of CMake is used to build a project. It
also sets all policies introduced in that CMake version or earlier to
NEW behavior. To manage policies without increasing the minimum required
CMake version, the :command:`if(POLICY)` command may be used::
CMake version, the :command:`if(POLICY)` command may be used:
.. code-block:: cmake
if(POLICY CMP0990)
cmake_policy(SET CMP0990 NEW)
......
......@@ -22,17 +22,23 @@ Languages
Languages are enabled by the :command:`project` command. If no project command
is in the top-level CMakeLists file, one will be implicitly generated. By default
the enabled languages are C and CXX::
the enabled languages are C and CXX:
.. code-block:: cmake
project(C_Only C)
A special value of NONE can also be used with the :command:`project` command
to enable no languages::
to enable no languages:
.. code-block:: cmake
project(MyProject NONE)
The :command:`enable_language` command can be used to enable languages after the
:command:`project` command::
:command:`project` command:
.. code-block:: cmake
enable_language(CXX)
......@@ -86,7 +92,9 @@ Cross Compiling
If :manual:`cmake(1)` is invoked with the command line parameter
``-DCMAKE_TOOLCHAIN_FILE=path/to/file``, the file will be loaded early to set
values for the compilers. A typical cross-compiling toolchain has content such
as::
as:
.. code-block:: cmake
set(CMAKE_SYSTEM_NAME Linux)
......@@ -127,7 +135,9 @@ the ``CMAKE_FIND_ROOT_PATH_MODE_*`` variables.
Some compilers are inherently cross compilers, such as Clang and the QNX QCC
compiler. The :variable:`CMAKE_<LANG>_COMPILER_TARGET` can be set to pass a
value to those supported compilers when compiling::
value to those supported compilers when compiling:
.. code-block:: cmake
set(CMAKE_SYSTEM_NAME Linux)
......@@ -138,7 +148,9 @@ value to those supported compilers when compiling::
set(CMAKE_CXX_COMPILER clang++)
set(CMAKE_CXX_COMPILER_TARGET ${triple})
Or, for QCC::
Or, for QCC:
.. code-block:: cmake
set(CMAKE_SYSTEM_NAME QNX)
......
AUTOGEN_TARGETS_FOLDER
----------------------
Name of FOLDER for ``*_automoc`` targets that are added automatically by CMake for targets for which AUTOMOC is enabled.
Name of :prop_tgt:`FOLDER` for ``*_automoc`` targets that are added automatically by
CMake for targets for which :prop_tgt:`AUTOMOC` is enabled.
If not set, CMake uses the FOLDER property of the parent target as a
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
FOLDER target property and the AUTOMOC target property.
:prop_tgt:`FOLDER` target property and the :prop_tgt:`AUTOMOC` target property.
AUTOMOC_TARGETS_FOLDER
----------------------
Name of FOLDER for ``*_automoc`` targets that are added automatically by CMake for targets for which AUTOMOC is enabled.
Name of :prop_tgt:`FOLDER` for ``*_automoc`` targets that are added automatically by
CMake for targets for which :prop_tgt:`AUTOMOC` is enabled.
This property is obsolete. Use AUTOGEN_TARGETS_FOLDER instead.
This property is obsolete. Use :prop_gbl:`AUTOGEN_TARGETS_FOLDER` instead.
If not set, CMake uses the FOLDER property of the parent target as a
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
FOLDER target property and the AUTOMOC target property.
:prop_tgt:`FOLDER` target property and the :prop_tgt:`AUTOMOC` target property.
AUTORCC_OPTIONS
---------------
Additional options for rcc when using autorcc (see the :prop_tgt:`AUTORCC` target
property)
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 autorcc, i.e. it is equivalent to the
optional OPTIONS argument of the qt4_add_resources() macro.
``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() <FindQt4>` macro.
By default it is empty.
The options set on the .qrc source file may override :prop_tgt:`AUTORCC_OPTIONS` set
The options set on the ``.qrc`` source file may override :prop_tgt:`AUTORCC_OPTIONS` set
on the target.
AUTOUIC_OPTIONS
---------------
Additional options for uic when using autouic (see the :prop_tgt:`AUTOUIC` target property)
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 autouic,
i.e. it is equivalent to the optional OPTIONS argument of the
qt4_wrap_ui() macro.
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()<FindQt4>` macro.
By default it is empty.
The options set on the .ui source file may override :prop_tgt:`AUTOUIC_OPTIONS` set
The options set on the ``.ui`` source file may override :prop_tgt:`AUTOUIC_OPTIONS` set
on the target.
......@@ -3,10 +3,10 @@ AUTOGEN_TARGET_DEPENDS
Target dependencies of the corresponding ``_automoc`` target.
Targets which have their :prop_tgt:`AUTOMOC` target set to true have a
Targets which have their :prop_tgt:`AUTOMOC` target set to ``TRUE`` have a
corresponding ``_automoc`` target which is used to autogenerate generate moc
files. As this ``_automoc`` target is created at generate-time, it is not
possible to define dependencies of it, such as to create inputs for the moc
possible to define dependencies of it, such as to create inputs for the ``moc``
executable.
The ``AUTOGEN_TARGET_DEPENDS`` target can be set instead to a list of dependencies
......
......@@ -3,29 +3,29 @@ AUTOMOC
Should the target be processed with automoc (for Qt projects).
AUTOMOC is a boolean specifying whether CMake will handle the Qt moc
AUTOMOC is a boolean specifying whether CMake will handle the Qt ``moc``
preprocessor automatically, i.e. without having to use the
QT4_WRAP_CPP() or QT5_WRAP_CPP() macro. Currently Qt4 and Qt5 are
supported. When this property is set to TRUE, CMake will scan the
source files at build time and invoke moc accordingly. If an #include
statement like #include "moc_foo.cpp" is found, the Q_OBJECT class
declaration is expected in the header, and moc is run on the header
file. If an #include statement like #include "foo.moc" is found, then
a Q_OBJECT is expected in the current source file and moc is run on
:module:`QT4_WRAP_CPP() <FindQt4>` or QT5_WRAP_CPP() macro. Currently Qt4 and Qt5 are
supported. When this property is set to ``TRUE``, CMake will scan the
source files at build time and invoke moc accordingly. If an ``#include``
statement like ``#include "moc_foo.cpp"`` is found, the ``Q_OBJECT`` class
declaration is expected in the header, and ``moc`` is run on the header
file. If an ``#include`` statement like ``#include "foo.moc"`` is found, then
a ``Q_OBJECT`` is expected in the current source file and ``moc`` is run on
the file itself. Additionally, all header files are parsed for
Q_OBJECT macros, and if found, moc is also executed on those files.
``Q_OBJECT`` macros, and if found, ``moc`` is also executed on those files.
The resulting moc files, which are not included as shown above in any
of the source files are included in a generated
<targetname>_automoc.cpp file, which is compiled as part of the
target.This property is initialized by the value of the variable
CMAKE_AUTOMOC if it is set when a target is created.
``<targetname>_automoc.cpp`` file, which is compiled as part of the
target. This property is initialized by the value of the variable
:variable:`CMAKE_AUTOMOC` if it is set when a target is created.
Additional command line options for moc can be set via the
AUTOMOC_MOC_OPTIONS property.
:prop_tgt:`AUTOMOC_MOC_OPTIONS` property.
By setting the CMAKE_AUTOMOC_RELAXED_MODE variable to TRUE the rules
for searching the files which will be processed by moc can be relaxed.
By setting the :variable:`CMAKE_AUTOMOC_RELAXED_MODE` variable to ``TRUE`` 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 AUTOMOC_TARGETS_FOLDER can be used to group the
The global property :prop_gbl:`AUTOMOC_TARGETS_FOLDER` can be used to group the
automoc targets together in an IDE, e.g. in MSVS.
AUTOMOC_MOC_OPTIONS
-------------------
Additional options for moc when using automoc (see the AUTOMOC property)
Additional options for moc when using :prop_tgt:`AUTOMOC`
This property is only used if the AUTOMOC property is set to TRUE 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 qt4_wrap_cpp()
This property is only used if the :prop_tgt:`AUTOMOC` property is set to ``TRUE``
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() <FindQt4>`
macro.
By default it is empty.
......@@ -4,18 +4,18 @@ AUTORCC
Should the target be processed with autorcc (for Qt projects).
AUTORCC is a boolean specifying whether CMake will handle
the Qt rcc code generator automatically, i.e. without having to use
the QT4_ADD_RESOURCES() or QT5_ADD_RESOURCES() macro. Currently Qt4 and Qt5 are
supported.
``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 set to TRUE, CMake will handle .qrc files added
as target sources at build time and invoke rcc accordingly.
When this property is set to ``TRUE``, 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.
Additional command line options for rcc can be set via the
:prop_sf:`AUTORCC_OPTIONS` source file property on the .qrc file.
:prop_sf:`AUTORCC_OPTIONS` source file property on the ``.qrc`` 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.
AUTORCC_OPTIONS
---------------
Additional options for rcc when using autorcc (see the :prop_tgt:`AUTORCC` target property)
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 autorcc,
i.e. it is equivalent to the optional OPTIONS argument of the
qt4_add_resources() macro.
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() <FindQt4>` macro.
By default it is empty.
......@@ -14,4 +14,4 @@ This property is initialized by the value of the variable
:variable:`CMAKE_AUTORCC` if it is set when a target is created.
The options set on the target may be overridden by :prop_sf:`AUTORCC_OPTIONS` set
on the .qrc source file.
on the ``.qrc`` source file.
......@@ -3,20 +3,20 @@ AUTOUIC
Should the target be processed with autouic (for Qt projects).
AUTOUIC is a boolean specifying whether CMake will handle
the Qt uic code generator automatically, i.e. without having to use
the QT4_WRAP_UI() or QT5_WRAP_UI() macro. Currently Qt4 and Qt5 are
supported.
``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 set to TRUE, 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
foo.cpp, a foo.ui file is expected next to foo.cpp, and uic is
run on the foo.ui file.
When this property is set to ``TRUE``, 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
``foo.cpp``, a ``foo.ui`` file is expected next to ``foo.cpp``, and ``uic`` is
run on the ``foo.ui`` file.
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.
: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.
AUTOUIC_OPTIONS
---------------
Additional options for uic when using autouic (see the :prop_tgt:`AUTOUIC` target property)
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 autouic,
i.e. it is equivalent to the optional OPTIONS argument of the
qt4_wrap_ui() macro.
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() <FindQt4>` macro.
By default it is empty.
......@@ -14,7 +14,7 @@ This property is initialized by the value of the variable
:variable:`CMAKE_AUTOUIC` if it is set when a target is created.
The options set on the target may be overridden by :prop_sf:`AUTOUIC_OPTIONS` set
on the .ui source file.
on the ``.ui`` source file.
This property may use "generator expressions" with the syntax "$<...>".
See the :manual:`cmake-generator-expressions(7)` manual for available
......
CMAKE_AUTOMOC
-------------
Whether to handle moc automatically for Qt targets.
Whether to handle ``moc`` automatically for Qt targets.
This variable is used to initialize the AUTOMOC property on all the
This variable is used to initialize the :prop_tgt:`AUTOMOC` property on all the
targets. See that target property for additional information.
CMAKE_AUTOMOC_MOC_OPTIONS
-------------------------
Additional options for moc when using automoc (see CMAKE_AUTOMOC).
Additional options for ``moc`` when using :variable:`CMAKE_AUTOMOC`.
This variable is used to initialize the AUTOMOC_MOC_OPTIONS property
on all the targets. See that target property for additional
information.
This variable is used to initialize the :prop_tgt:`AUTOMOC_MOC_OPTIONS` property
on all the targets. See that target property for additional information.
......@@ -3,11 +3,11 @@ CMAKE_AUTOMOC_RELAXED_MODE
Switch between strict and relaxed automoc mode.
By default, automoc behaves exactly as described in the documentation
of the AUTOMOC target property. When set to TRUE, it accepts more
input and tries to find the correct input file for moc even if it
By default, :prop_tgt:`AUTOMOC` behaves exactly as described in the documentation
of the :prop_tgt:`AUTOMOC` target property. When set to ``TRUE``, it accepts more
input and tries to find the correct input file for ``moc`` even if it
differs from the documented behaviour. In this mode it e.g. also
checks whether a header file is intended to be processed by moc when a
"foo.moc" file has been included.
``"foo.moc"`` file has been included.
Relaxed mode has to be enabled for KDE4 compatibility.
CMAKE_AUTORCC
-------------
Whether to handle rcc automatically for Qt targets.
Whether to handle ``rcc`` automatically for Qt targets.
This variable is used to initialize the :prop_tgt:`AUTORCC` property on all the targets.
See that target property for additional information.
CMAKE_AUTORCC_OPTIONS
---------------------
Whether to handle rcc automatically for Qt targets.
Whether to handle ``rcc`` automatically for Qt targets.
This variable is used to initialize the :prop_tgt:`AUTORCC_OPTIONS` property on
all the targets. See that target property for additional information.
CMAKE_AUTOUIC
-------------
Whether to handle uic automatically for Qt targets.
Whether to handle ``uic`` automatically for Qt targets.
This variable is used to initialize the :prop_tgt:`AUTOUIC` property on all the targets.
See that target property for additional information.
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment