[Cmake-commits] CMake branch, next, updated. v3.8.0-rc1-409-g1376688
Brad King
brad.king at kitware.com
Tue Feb 21 10:13:52 EST 2017
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMake".
The branch, next has been updated
via 1376688a01bfcf28d31d6a9a79703502d5027ca9 (commit)
via 401700852e368569ea4f641ccceafbda9306b744 (commit)
via 52708851a885d32f0b523cb20fc30a482956edeb (commit)
via d056533bb56b6cd46bd9aab72463239e035a52cf (commit)
via bdab9b52b752085cc6f48d089f13760ec246fe29 (commit)
via 7b950873b245a70509c792aacaee5b2b56d05767 (commit)
via 1f7f92b83efbaf8685b5db71c073f6e3779893f4 (commit)
via 8dad7d6a668c14cf0395872b22ee533961d3facf (commit)
via 4f4cdccdd4c59a7af1e87e88b783bcbf42923fc8 (commit)
via c7c1ac85de53a1fce5c0b1bdded27598109cc4be (commit)
via 50805693ba987fbf86bb5e8263d7b427cd4da0c2 (commit)
via c23206b6c17a5c70580355904fc12fd64c26ef79 (commit)
via 347572cf5ea2c653cba6150b5e6d6fa083a68cb0 (commit)
via 03df033bfa551e83c2a265cc22f6f5278c80528b (commit)
via 3ec230de1f45f48a8bbb8eca49674f0e0c99dfa1 (commit)
via 41fb64e719817ce877565e6e11198df2f7e7e63d (commit)
via 175c89004425cdbb151d4e85876e2a2076432f28 (commit)
via 80a007534f6287cd2e88c1b8fd72b68fc688da4e (commit)
via f379fdbb9ee17b62ac8b4a8d4b9fab562ba37253 (commit)
via ddf940725e8af095b1c02606aeea64cc9baaf572 (commit)
via 71c5ae253cb5498da319e36bcf49869509b6603c (commit)
via 5308f954c9ad13cfc6cc84f1f1255fb5faff48c6 (commit)
via 887e40034161589b63fdb14bfaee7f66374b9b83 (commit)
via 4c60099fea2b06229900cc16fed907185c4fe2ef (commit)
via 815a05cf12499b42acea70b5a9534e10e1701417 (commit)
via 3270091210c0cfdddb133209b232a1d0a1fa48da (commit)
via 793c9a7925dfa3aaa2b15212f4ba0246d1fbf83c (commit)
via 25dbfbc2a937379ca78328dfabdf54043340dbd3 (commit)
via 3cc42863a43cd4256efdeb2eda2d235d5533bad9 (commit)
from 061f28d1f29a84f6d5b479e504bad89f63d565f7 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=1376688a01bfcf28d31d6a9a79703502d5027ca9
commit 1376688a01bfcf28d31d6a9a79703502d5027ca9
Merge: 061f28d 4017008
Author: Brad King <brad.king at kitware.com>
AuthorDate: Tue Feb 21 10:13:50 2017 -0500
Commit: CMake Topic Stage <kwrobot at kitware.com>
CommitDate: Tue Feb 21 10:13:50 2017 -0500
Merge topic 'autogen_json' into next
40170085 Autogen: Don't use .moc include in Q_PLUGIN_METADATA test
52708851 Autogen: Documentation update
d056533b Autogen: Add release notes for Q_PLUGIN_METADATA support
bdab9b52 Autogen: Tests: Set different compression levels in rcc test
7b950873 Autogen: Overhaul and simplify AutogenInfo.cmake file generation
1f7f92b8 Autogen: Optimize GetCompileDefinitionsAndDirectories function
8dad7d6a Autogen: Sort AutogenInfo.cmake.in
4f4cdccd Autogen: Tests: Add Q_PLUGIN_METADATA test
c7c1ac85 Autogen: Tests: Add moc include tests
50805693 Autogen: Tests: Clean comments
c23206b6 Autogen: Log simplifications
347572cf Autogen: Only touch an unchanged moc_compilation.cpp
03df033b Autogen: Rebuild moc when Q_PLUGIN_METADATA json file changes
3ec230de Autogen: Use GetRealPath in central places only
41fb64e7 Autogen: Search moc includes in include directories
175c8900 Autogen: Sort includes before composing include options
...
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=401700852e368569ea4f641ccceafbda9306b744
commit 401700852e368569ea4f641ccceafbda9306b744
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Tue Feb 21 11:27:02 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:58 2017 -0500
Autogen: Don't use .moc include in Q_PLUGIN_METADATA test
diff --git a/Tests/QtAutogen/mocPlugin/StyleD.cpp b/Tests/QtAutogen/mocPlugin/StyleD.cpp
index 48398bb..7e4b121 100644
--- a/Tests/QtAutogen/mocPlugin/StyleD.cpp
+++ b/Tests/QtAutogen/mocPlugin/StyleD.cpp
@@ -1,17 +1,6 @@
#include "StyleD.hpp"
-class StyleD : public QStylePlugin
-{
- Q_OBJECT
- // Json file in global sub director
- Q_PLUGIN_METADATA(IID "org.styles.D" FILE "sub/StyleD.json")
-public:
- QStyle* create(const QString& key);
-};
-
QStyle* StyleD::create(const QString& key)
{
return 0;
}
-
-#include "StyleD.moc"
diff --git a/Tests/QtAutogen/mocPlugin/StyleD.hpp b/Tests/QtAutogen/mocPlugin/StyleD.hpp
index 2afe055..e58444d 100644
--- a/Tests/QtAutogen/mocPlugin/StyleD.hpp
+++ b/Tests/QtAutogen/mocPlugin/StyleD.hpp
@@ -3,6 +3,13 @@
#include <QStylePlugin>
-class StyleD;
+class StyleD : public QStylePlugin
+{
+ Q_OBJECT
+ // Json file in global sub director
+ Q_PLUGIN_METADATA(IID "org.styles.D" FILE "sub/StyleD.json")
+public:
+ QStyle* create(const QString& key);
+};
#endif
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=52708851a885d32f0b523cb20fc30a482956edeb
commit 52708851a885d32f0b523cb20fc30a482956edeb
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Sun Feb 19 20:11:18 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:58 2017 -0500
Autogen: Documentation update
Closes #15254
diff --git a/Help/manual/cmake-qt.7.rst b/Help/manual/cmake-qt.7.rst
index 56d4ca7..e9da396 100644
--- a/Help/manual/cmake-qt.7.rst
+++ b/Help/manual/cmake-qt.7.rst
@@ -63,20 +63,24 @@ If a ``Q_OBJECT`` or ``Q_GADGET`` macro is found in a header file, ``moc``
will be run on the file. The result will be put into a file named according
to ``moc_<basename>.cpp``. If the macro is found in a C++ implementation
file, the moc output will be put into a file named according to
-``<basename>.moc``, following the Qt conventions. The ``moc file`` may be
-included by the user in the C++ implementation file with a preprocessor
-``#include``. If it is not so included, it will be added to a separate file
-which is compiled into the target.
+``<basename>.moc``, following the Qt conventions. The ``<basename>.moc`` must
+be included by the user in the C++ implementation file with a preprocessor
+``#include``.
-The ``moc`` command line will consume the :prop_tgt:`COMPILE_DEFINITIONS` and
-:prop_tgt:`INCLUDE_DIRECTORIES` target properties from the target it is being
-invoked for, and for the appropriate build configuration.
-
-The generated ``moc_*.cpp`` and ``*.moc`` files are placed in the
+Included ``moc_*.cpp`` and ``*.moc`` files will be generated in the
``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/include`` directory which is
automatically added to the target's :prop_tgt:`INCLUDE_DIRECTORIES`.
(This differs from CMake 3.7 and below; see their documentation for details.)
+Not included ``moc_<basename>.cpp`` files will be generated in custom
+folders to avoid name collisions and included in a separate
+``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/moc_compilation.cpp``
+file which is compiled into the target.
+
+The ``moc`` command line will consume the :prop_tgt:`COMPILE_DEFINITIONS` and
+:prop_tgt:`INCLUDE_DIRECTORIES` target properties from the target it is being
+invoked for, and for the appropriate build configuration.
+
The :prop_tgt:`AUTOMOC` target property may be pre-set for all
following targets by setting the :variable:`CMAKE_AUTOMOC` variable. The
:prop_tgt:`AUTOMOC_MOC_OPTIONS` target property may be populated to set
diff --git a/Help/prop_tgt/AUTOMOC.rst b/Help/prop_tgt/AUTOMOC.rst
index b42643f..4ac9b6e 100644
--- a/Help/prop_tgt/AUTOMOC.rst
+++ b/Help/prop_tgt/AUTOMOC.rst
@@ -8,31 +8,41 @@ 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
+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_foo.cpp"`` is found,
- the ``Q_OBJECT`` class declaration is expected in the header, and
- ``moc`` is run on the header file. A ``moc_foo.cpp`` file will be
- generated from the source's header into the
- ``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/include``
- directory which is automatically added to the target's
+* If an ``#include`` statement like ``#include "moc_<basename>.cpp"`` is found,
+ the ``Q_OBJECT`` or ``Q_GADGET`` macros are expected in an otherwise empty
+ line of the ``<basename>.h(xx)`` header file. ``moc`` is run on the header file to
+ generate ``moc_<basename>.cpp`` in the
+ ``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/include`` directory
+ which is automatically added to the target's
:prop_tgt:`INCLUDE_DIRECTORIES`. This allows the compiler to find the
- included ``moc_foo.cpp`` file regardless of the location the original source.
- However, if multiple source files in different directories do this then their
- generated moc files would collide. In this case a diagnostic will be issued.
-
-* 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, header files with the same
- base name (like ``foo.h``) or ``_p`` appended to the base name (like
- ``foo_p.h``) are parsed for ``Q_OBJECT`` macros, and if found, ``moc``
- is also executed on those files. ``AUTOMOC`` checks multiple header
- alternative extensions, such as ``hpp``, ``hxx`` etc when searching
- for headers. The resulting moc files, which are not included as shown
- above in any of the source files are included in a generated
- ``moc_compilation.cpp`` file, which is compiled as part of the
- target.
+ included ``moc_<basename>.cpp`` file regardless of the location the
+ original source.
+
+* If an ``#include`` statement like ``#include "<basename>.moc"`` is found,
+ then ``Q_OBJECT`` or ``Q_GADGET`` macros are expected in the current 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 ``Q_OBJECT`` or ``Q_GADGET`` macros.
+ The resulting ``moc_<basename>.cpp`` files are generated in custom
+ directories and automatically included in the generated
+ ``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/moc_compilation.cpp`` file,
+ which is compiled as part of the target. The custom directories help to
+ avoid name collisions for moc files with the same ``<basename>``.
+
+* 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 parsed for ``Q_OBJECT`` or ``Q_GADGET`` macros,
+ 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.
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=d056533bb56b6cd46bd9aab72463239e035a52cf
commit d056533bb56b6cd46bd9aab72463239e035a52cf
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Sun Feb 19 18:35:40 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:57 2017 -0500
Autogen: Add release notes for Q_PLUGIN_METADATA support
diff --git a/Help/release/dev/Autogen_json.rst b/Help/release/dev/Autogen_json.rst
new file mode 100644
index 0000000..73bbdf1
--- /dev/null
+++ b/Help/release/dev/Autogen_json.rst
@@ -0,0 +1,10 @@
+AutoGen json
+------------
+
+* When using :prop_tgt:`AUTOMOC`, CMake scans for the presence of the
+ ``Q_PLUGIN_METADATA`` macro and reruns moc when the file from the
+ macro's ``FILE`` argument changes.
+
+* When :prop_tgt:`AUTOMOC` detects an include statement of the form
+ ``#include "moc_<basename>.cpp"`` the respective header file is searched
+ for in the :prop_tgt:`INCLUDE_DIRECTORIES` of the target as well.
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=bdab9b52b752085cc6f48d089f13760ec246fe29
commit bdab9b52b752085cc6f48d089f13760ec246fe29
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Sun Feb 19 17:24:30 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:57 2017 -0500
Autogen: Tests: Set different compression levels in rcc test
diff --git a/Tests/QtAutogen/sameName/CMakeLists.txt b/Tests/QtAutogen/sameName/CMakeLists.txt
index 9e47a3e..4d2dcd9 100644
--- a/Tests/QtAutogen/sameName/CMakeLists.txt
+++ b/Tests/QtAutogen/sameName/CMakeLists.txt
@@ -18,3 +18,14 @@ add_executable(sameName
)
target_link_libraries(sameName ${QT_LIBRARIES})
set_target_properties(sameName PROPERTIES AUTOMOC TRUE AUTORCC TRUE)
+
+# Set different compression levels
+if (QT_TEST_VERSION STREQUAL 4)
+ set(rccCompress "-compress")
+else()
+ set(rccCompress "--compress")
+endif()
+set_target_properties(sameName PROPERTIES AUTORCC_OPTIONS "${rccCompress};0" )
+set_source_files_properties(aaa/data.qrc PROPERTIES AUTORCC_OPTIONS "${rccCompress};1" )
+set_source_files_properties(bbb/data.qrc PROPERTIES AUTORCC_OPTIONS "${rccCompress};2" )
+set_source_files_properties(ccc/data.qrc PROPERTIES AUTORCC_OPTIONS "${rccCompress};3" )
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=7b950873b245a70509c792aacaee5b2b56d05767
commit 7b950873b245a70509c792aacaee5b2b56d05767
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Sun Feb 19 16:46:47 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:57 2017 -0500
Autogen: Overhaul and simplify AutogenInfo.cmake file generation
diff --git a/Modules/AutogenInfo.cmake.in b/Modules/AutogenInfo.cmake.in
index 3135909..b647ecf 100644
--- a/Modules/AutogenInfo.cmake.in
+++ b/Modules/AutogenInfo.cmake.in
@@ -1,5 +1,5 @@
# Target names
-set(AM_TARGET_NAME @_moc_target_name@)
+set(AM_TARGET_NAME @_autogen_target_name@)
set(AM_ORIGIN_TARGET_NAME @_origin_target_name@)
# Directories and files
set(AM_CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@/")
@@ -10,16 +10,16 @@ set(AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE "@CMAKE_INCLUDE_DIRECTORIES_PROJ
set(AM_SOURCES @_sources@)
set(AM_HEADERS @_headers@)
# Qt environment
-set(AM_QT_VERSION_MAJOR "@_target_qt_version@")
-set(AM_QT_MOC_EXECUTABLE "@_qt_moc_executable@")
-set(AM_QT_UIC_EXECUTABLE "@_qt_uic_executable@")
-set(AM_QT_RCC_EXECUTABLE "@_qt_rcc_executable@")
+set(AM_QT_VERSION_MAJOR @_qt_version_major@)
+set(AM_QT_MOC_EXECUTABLE @_qt_moc_executable@)
+set(AM_QT_UIC_EXECUTABLE @_qt_uic_executable@)
+set(AM_QT_RCC_EXECUTABLE @_qt_rcc_executable@)
# MOC settings
set(AM_MOC_SKIP @_moc_skip@)
set(AM_MOC_COMPILE_DEFINITIONS @_moc_compile_defs@)
set(AM_MOC_INCLUDES @_moc_incs@)
set(AM_MOC_OPTIONS @_moc_options@)
-set(AM_MOC_RELAXED_MODE "@_moc_relaxed_mode@")
+set(AM_MOC_RELAXED_MODE @_moc_relaxed_mode@)
# UIC settings
set(AM_UIC_SKIP @_uic_skip@)
set(AM_UIC_TARGET_OPTIONS @_uic_target_options@)
diff --git a/Source/cmQtAutoGeneratorInitializer.cxx b/Source/cmQtAutoGeneratorInitializer.cxx
index c201023..52112ff 100644
--- a/Source/cmQtAutoGeneratorInitializer.cxx
+++ b/Source/cmQtAutoGeneratorInitializer.cxx
@@ -22,7 +22,6 @@
#endif
#include <algorithm>
-#include <assert.h>
#include <cmConfigure.h>
#include <cmsys/FStream.hxx>
#include <cmsys/RegularExpression.hxx>
@@ -55,6 +54,13 @@ static std::string utilStripCR(std::string const& line)
return line;
}
+static std::string GetSafeProperty(cmGeneratorTarget const* target,
+ const char* key)
+{
+ const char* tmp = target->GetProperty(key);
+ return std::string((tmp != CM_NULLPTR) ? tmp : "");
+}
+
static std::string GetAutogenTargetName(cmGeneratorTarget const* target)
{
std::string autogenTargetName = target->GetName();
@@ -118,19 +124,33 @@ static void GetCompileDefinitionsAndDirectories(
}
}
+static void AddDefinitionEscaped(cmMakefile* makefile, const char* key,
+ const std::string& value)
+{
+ makefile->AddDefinition(key,
+ cmOutputConverter::EscapeForCMake(value).c_str());
+}
+
+static void AddDefinitionEscaped(cmMakefile* makefile, const char* key,
+ const std::vector<std::string>& values)
+{
+ makefile->AddDefinition(
+ key, cmOutputConverter::EscapeForCMake(cmJoin(values, ";")).c_str());
+}
+
static void SetupSourceFiles(cmGeneratorTarget const* target,
std::vector<std::string>& mocUicSources,
std::vector<std::string>& mocUicHeaders,
- std::vector<std::string>& skipMocList,
- std::vector<std::string>& skipUicList)
+ std::vector<std::string>& mocSkipList,
+ std::vector<std::string>& uicSkipList)
{
cmMakefile* makefile = target->Target->GetMakefile();
std::vector<cmSourceFile*> srcFiles;
target->GetConfigCommonSourceFiles(srcFiles);
- const bool targetMoc = target->GetPropertyAsBool("AUTOMOC");
- const bool targetUic = target->GetPropertyAsBool("AUTOUIC");
+ const bool mocTarget = target->GetPropertyAsBool("AUTOMOC");
+ const bool uicTarget = target->GetPropertyAsBool("AUTOUIC");
cmFilePathChecksum fpathCheckSum(makefile);
for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
@@ -151,22 +171,22 @@ static void SetupSourceFiles(cmGeneratorTarget const* target,
// Skip flags
const bool skipAll =
cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOGEN"));
- const bool skipMoc =
+ const bool mocSkip =
skipAll || cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC"));
- const bool skipUic =
+ const bool uicSkip =
skipAll || cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC"));
// Add file name to skip lists.
// Do this even when the file is not added to the sources/headers lists
// because the file name may be extracted from an other file when
// processing
- if (skipMoc) {
- skipMocList.push_back(absFile);
+ if (mocSkip) {
+ mocSkipList.push_back(absFile);
}
- if (skipUic) {
- skipUicList.push_back(absFile);
+ if (uicSkip) {
+ uicSkipList.push_back(absFile);
}
- if ((targetMoc && !skipMoc) || (targetUic && !skipUic)) {
+ if ((mocTarget && !mocSkip) || (uicTarget && !uicSkip)) {
// Add file name to sources or headers list
switch (fileType) {
case cmSystemTools::CXX_FILE_FORMAT:
@@ -184,80 +204,85 @@ static void SetupSourceFiles(cmGeneratorTarget const* target,
static void MocSetupAutoTarget(
cmGeneratorTarget const* target, const std::string& autogenTargetName,
- std::vector<std::string> const& skipMoc,
+ const std::string& qtMajorVersion,
+ std::vector<std::string> const& mocSkipList,
std::map<std::string, std::string>& configIncludes,
std::map<std::string, std::string>& configDefines)
{
cmLocalGenerator* lg = target->GetLocalGenerator();
cmMakefile* makefile = target->Target->GetMakefile();
- const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS");
- std::string _moc_options = (tmp != CM_NULLPTR ? tmp : "");
- makefile->AddDefinition(
- "_moc_options", cmOutputConverter::EscapeForCMake(_moc_options).c_str());
- makefile->AddDefinition(
- "_moc_skip",
- cmOutputConverter::EscapeForCMake(cmJoin(skipMoc, ";")).c_str());
- bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE");
- makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE");
-
- std::string _moc_incs;
- std::string _moc_compile_defs;
- std::vector<std::string> configs;
- const std::string& config = makefile->GetConfigurations(configs);
- GetCompileDefinitionsAndDirectories(target, config, _moc_incs,
- _moc_compile_defs);
+ AddDefinitionEscaped(makefile, "_moc_options",
+ GetSafeProperty(target, "AUTOMOC_MOC_OPTIONS"));
+ AddDefinitionEscaped(makefile, "_moc_skip", mocSkipList);
+ AddDefinitionEscaped(makefile, "_moc_relaxed_mode",
+ makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE") ? "TRUE"
+ : "FALSE");
- makefile->AddDefinition(
- "_moc_incs", cmOutputConverter::EscapeForCMake(_moc_incs).c_str());
- makefile->AddDefinition(
- "_moc_compile_defs",
- cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str());
-
- for (std::vector<std::string>::const_iterator li = configs.begin();
- li != configs.end(); ++li) {
- std::string config_moc_incs;
- std::string config_moc_compile_defs;
- GetCompileDefinitionsAndDirectories(target, *li, config_moc_incs,
- config_moc_compile_defs);
- if (config_moc_incs != _moc_incs) {
- configIncludes[*li] = cmOutputConverter::EscapeForCMake(config_moc_incs);
- if (_moc_incs.empty()) {
- _moc_incs = config_moc_incs;
+ // Moc includes and compile definitions
+ {
+ std::string _moc_incs;
+ std::string _moc_compile_defs;
+ std::vector<std::string> configs;
+ {
+ const std::string& config = makefile->GetConfigurations(configs);
+ GetCompileDefinitionsAndDirectories(target, config, _moc_incs,
+ _moc_compile_defs);
+ AddDefinitionEscaped(makefile, "_moc_incs", _moc_incs);
+ AddDefinitionEscaped(makefile, "_moc_compile_defs", _moc_compile_defs);
+ }
+ for (std::vector<std::string>::const_iterator li = configs.begin();
+ li != configs.end(); ++li) {
+ std::string config_moc_incs;
+ std::string config_moc_compile_defs;
+ GetCompileDefinitionsAndDirectories(target, *li, config_moc_incs,
+ config_moc_compile_defs);
+ if (config_moc_incs != _moc_incs) {
+ configIncludes[*li] =
+ cmOutputConverter::EscapeForCMake(config_moc_incs);
+ if (_moc_incs.empty()) {
+ _moc_incs = config_moc_incs;
+ }
}
- }
- if (config_moc_compile_defs != _moc_compile_defs) {
- configDefines[*li] =
- cmOutputConverter::EscapeForCMake(config_moc_compile_defs);
- if (_moc_compile_defs.empty()) {
- _moc_compile_defs = config_moc_compile_defs;
+ if (config_moc_compile_defs != _moc_compile_defs) {
+ configDefines[*li] =
+ cmOutputConverter::EscapeForCMake(config_moc_compile_defs);
+ if (_moc_compile_defs.empty()) {
+ _moc_compile_defs = config_moc_compile_defs;
+ }
}
}
}
- const char* qtVersion = makefile->GetDefinition("_target_qt_version");
- if (strcmp(qtVersion, "5") == 0) {
- cmGeneratorTarget* qt5Moc = lg->FindGeneratorTargetToUse("Qt5::moc");
- if (!qt5Moc) {
- cmSystemTools::Error("Qt5::moc target not found ",
- autogenTargetName.c_str());
- return;
+ // Moc executable
+ {
+ std::string err;
+ const char* mocExec = CM_NULLPTR;
+ if (qtMajorVersion == "5") {
+ cmGeneratorTarget* qt5Moc = lg->FindGeneratorTargetToUse("Qt5::moc");
+ if (qt5Moc != CM_NULLPTR) {
+ mocExec = qt5Moc->ImportedGetLocation("");
+ } else {
+ err = "Qt5::moc target not found " + autogenTargetName;
+ }
+ } else if (qtMajorVersion == "4") {
+ cmGeneratorTarget* qt4Moc = lg->FindGeneratorTargetToUse("Qt4::moc");
+ if (qt4Moc != CM_NULLPTR) {
+ mocExec = qt4Moc->ImportedGetLocation("");
+ } else {
+ err = "Qt4::moc target not found " + autogenTargetName;
+ }
+ } else {
+ err = "The CMAKE_AUTOMOC feature supports only Qt 4 and Qt 5 ";
+ err += autogenTargetName;
}
- makefile->AddDefinition("_qt_moc_executable",
- qt5Moc->ImportedGetLocation(""));
- } else if (strcmp(qtVersion, "4") == 0) {
- cmGeneratorTarget* qt4Moc = lg->FindGeneratorTargetToUse("Qt4::moc");
- if (!qt4Moc) {
- cmSystemTools::Error("Qt4::moc target not found ",
- autogenTargetName.c_str());
- return;
+ // Add definition or error
+ if (err.empty()) {
+ AddDefinitionEscaped(makefile, "_qt_moc_executable",
+ mocExec ? mocExec : "");
+ } else {
+ cmSystemTools::Error(err.c_str());
}
- makefile->AddDefinition("_qt_moc_executable",
- qt4Moc->ImportedGetLocation(""));
- } else {
- cmSystemTools::Error("The CMAKE_AUTOMOC feature supports only Qt 4 and "
- "Qt 5 ",
- autogenTargetName.c_str());
}
}
@@ -270,126 +295,126 @@ static void UicGetOpts(cmGeneratorTarget const* target,
}
static void UicSetupAutoTarget(
- cmGeneratorTarget const* target, std::vector<std::string> const& skipUic,
+ cmGeneratorTarget const* target, const std::string& qtMajorVersion,
+ std::vector<std::string> const& uicSkipList,
std::map<std::string, std::string>& configUicOptions)
{
cmLocalGenerator* lg = target->GetLocalGenerator();
cmMakefile* makefile = target->Target->GetMakefile();
- std::set<std::string> skipped;
- skipped.insert(skipUic.begin(), skipUic.end());
+ AddDefinitionEscaped(makefile, "_uic_skip", uicSkipList);
- makefile->AddDefinition(
- "_uic_skip",
- cmOutputConverter::EscapeForCMake(cmJoin(skipUic, ";")).c_str());
-
- std::vector<cmSourceFile*> uiFilesWithOptions =
- makefile->GetQtUiFilesWithOptions();
-
- const char* qtVersion = makefile->GetDefinition("_target_qt_version");
-
- std::string _uic_opts;
- std::vector<std::string> configs;
- const std::string& config = makefile->GetConfigurations(configs);
- UicGetOpts(target, config, _uic_opts);
-
- if (!_uic_opts.empty()) {
- _uic_opts = cmOutputConverter::EscapeForCMake(_uic_opts);
- makefile->AddDefinition("_uic_target_options", _uic_opts.c_str());
- }
- for (std::vector<std::string>::const_iterator li = configs.begin();
- li != configs.end(); ++li) {
- std::string config_uic_opts;
- UicGetOpts(target, *li, config_uic_opts);
- if (config_uic_opts != _uic_opts) {
- configUicOptions[*li] =
- cmOutputConverter::EscapeForCMake(config_uic_opts);
- if (_uic_opts.empty()) {
- _uic_opts = config_uic_opts;
+ // Uic target options
+ {
+ std::string _uic_opts;
+ std::vector<std::string> configs;
+ UicGetOpts(target, makefile->GetConfigurations(configs), _uic_opts);
+
+ AddDefinitionEscaped(makefile, "_uic_target_options", _uic_opts);
+
+ for (std::vector<std::string>::const_iterator li = configs.begin();
+ li != configs.end(); ++li) {
+ std::string config_uic_opts;
+ UicGetOpts(target, *li, config_uic_opts);
+ if (config_uic_opts != _uic_opts) {
+ configUicOptions[*li] =
+ cmOutputConverter::EscapeForCMake(config_uic_opts);
+ if (_uic_opts.empty()) {
+ _uic_opts = config_uic_opts;
+ }
}
}
}
-
- std::string uiFileFiles;
- std::string uiFileOptions;
- const char* sep = "";
-
- for (std::vector<cmSourceFile*>::const_iterator fileIt =
- uiFilesWithOptions.begin();
- fileIt != uiFilesWithOptions.end(); ++fileIt) {
- cmSourceFile* sf = *fileIt;
- std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
-
- if (!skipped.insert(absFile).second) {
- continue;
+ // Uic files options
+ {
+ std::vector<std::string> uiFileFiles;
+ std::vector<std::string> uiFileOptions;
+ {
+ std::set<std::string> skipped;
+ skipped.insert(uicSkipList.begin(), uicSkipList.end());
+
+ const std::vector<cmSourceFile*> uiFilesWithOptions =
+ makefile->GetQtUiFilesWithOptions();
+ for (std::vector<cmSourceFile*>::const_iterator fileIt =
+ uiFilesWithOptions.begin();
+ fileIt != uiFilesWithOptions.end(); ++fileIt) {
+ cmSourceFile* sf = *fileIt;
+ const std::string absFile =
+ cmsys::SystemTools::GetRealPath(sf->GetFullPath());
+ if (skipped.insert(absFile).second) {
+ // The file wasn't skipped
+ uiFileFiles.push_back(absFile);
+ {
+ std::string opts = sf->GetProperty("AUTOUIC_OPTIONS");
+ cmSystemTools::ReplaceString(opts, ";", "@list_sep@");
+ uiFileOptions.push_back(opts);
+ }
+ }
+ }
}
- uiFileFiles += sep;
- uiFileFiles += absFile;
- uiFileOptions += sep;
- std::string opts = sf->GetProperty("AUTOUIC_OPTIONS");
- cmSystemTools::ReplaceString(opts, ";", "@list_sep@");
- uiFileOptions += opts;
- sep = ";";
+ AddDefinitionEscaped(makefile, "_qt_uic_options_files", uiFileFiles);
+ AddDefinitionEscaped(makefile, "_qt_uic_options_options", uiFileOptions);
}
- makefile->AddDefinition(
- "_qt_uic_options_files",
- cmOutputConverter::EscapeForCMake(uiFileFiles).c_str());
- makefile->AddDefinition(
- "_qt_uic_options_options",
- cmOutputConverter::EscapeForCMake(uiFileOptions).c_str());
-
- std::string targetName = target->GetName();
- if (strcmp(qtVersion, "5") == 0) {
- cmGeneratorTarget* qt5Uic = lg->FindGeneratorTargetToUse("Qt5::uic");
- if (!qt5Uic) {
- // Project does not use Qt5Widgets, but has AUTOUIC ON anyway
+ // Uic executable
+ {
+ std::string err;
+ const char* uicExec = CM_NULLPTR;
+ if (qtMajorVersion == "5") {
+ cmGeneratorTarget* qt5Uic = lg->FindGeneratorTargetToUse("Qt5::uic");
+ if (qt5Uic != CM_NULLPTR) {
+ uicExec = qt5Uic->ImportedGetLocation("");
+ } else {
+ // Project does not use Qt5Widgets, but has AUTOUIC ON anyway
+ }
+ } else if (qtMajorVersion == "4") {
+ cmGeneratorTarget* qt4Uic = lg->FindGeneratorTargetToUse("Qt4::uic");
+ if (qt4Uic != CM_NULLPTR) {
+ uicExec = qt4Uic->ImportedGetLocation("");
+ } else {
+ err = "Qt4::uic target not found " + target->GetName();
+ }
} else {
- makefile->AddDefinition("_qt_uic_executable",
- qt5Uic->ImportedGetLocation(""));
+ err = "The CMAKE_AUTOUIC feature supports only Qt 4 and Qt 5 ";
+ err += target->GetName();
}
- } else if (strcmp(qtVersion, "4") == 0) {
- cmGeneratorTarget* qt4Uic = lg->FindGeneratorTargetToUse("Qt4::uic");
- if (!qt4Uic) {
- cmSystemTools::Error("Qt4::uic target not found ", targetName.c_str());
- return;
+ // Add definition or error
+ if (err.empty()) {
+ AddDefinitionEscaped(makefile, "_qt_uic_executable",
+ uicExec ? uicExec : "");
+ } else {
+ cmSystemTools::Error(err.c_str());
}
- makefile->AddDefinition("_qt_uic_executable",
- qt4Uic->ImportedGetLocation(""));
- } else {
- cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and "
- "Qt 5 ",
- targetName.c_str());
}
}
static std::string RccGetExecutable(cmGeneratorTarget const* target,
const std::string& qtMajorVersion)
{
+ std::string rccExec;
cmLocalGenerator* lg = target->GetLocalGenerator();
-
- std::string const& targetName = target->GetName();
if (qtMajorVersion == "5") {
cmGeneratorTarget* qt5Rcc = lg->FindGeneratorTargetToUse("Qt5::rcc");
- if (!qt5Rcc) {
- cmSystemTools::Error("Qt5::rcc target not found ", targetName.c_str());
- return std::string();
+ if (qt5Rcc != CM_NULLPTR) {
+ rccExec = qt5Rcc->ImportedGetLocation("");
+ } else {
+ cmSystemTools::Error("Qt5::rcc target not found ",
+ target->GetName().c_str());
}
- return qt5Rcc->ImportedGetLocation("");
- }
- if (qtMajorVersion == "4") {
+ } else if (qtMajorVersion == "4") {
cmGeneratorTarget* qt4Rcc = lg->FindGeneratorTargetToUse("Qt4::rcc");
- if (!qt4Rcc) {
- cmSystemTools::Error("Qt4::rcc target not found ", targetName.c_str());
- return std::string();
+ if (qt4Rcc != CM_NULLPTR) {
+ rccExec = qt4Rcc->ImportedGetLocation("");
+ } else {
+ cmSystemTools::Error("Qt4::rcc target not found ",
+ target->GetName().c_str());
}
- return qt4Rcc->ImportedGetLocation("");
+ } else {
+ cmSystemTools::Error(
+ "The CMAKE_AUTORCC feature supports only Qt 4 and Qt 5 ",
+ target->GetName().c_str());
}
-
- cmSystemTools::Error("The CMAKE_AUTORCC feature supports only Qt 4 and "
- "Qt 5 ",
- targetName.c_str());
- return std::string();
+ return rccExec;
}
static void RccMergeOptions(std::vector<std::string>& opts,
@@ -399,26 +424,31 @@ static void RccMergeOptions(std::vector<std::string>& opts,
static const char* valueOptions[] = { "name", "root", "compress",
"threshold" };
std::vector<std::string> extraOpts;
- for (std::vector<std::string>::const_iterator it = fileOpts.begin();
- it != fileOpts.end(); ++it) {
+ for (std::vector<std::string>::const_iterator fit = fileOpts.begin();
+ fit != fileOpts.end(); ++fit) {
std::vector<std::string>::iterator existingIt =
- std::find(opts.begin(), opts.end(), *it);
+ std::find(opts.begin(), opts.end(), *fit);
if (existingIt != opts.end()) {
- const char* o = it->c_str();
- if (*o == '-') {
- ++o;
- }
- if (isQt5 && *o == '-') {
- ++o;
+ const char* optName = fit->c_str();
+ if (*optName == '-') {
+ ++optName;
+ if (isQt5 && *optName == '-') {
+ ++optName;
+ }
}
- if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
- cmStrCmp(*it)) != cmArrayEnd(valueOptions)) {
- assert(existingIt + 1 != opts.end());
- *(existingIt + 1) = *(it + 1);
- ++it;
+ // Test if this is a value option and change the existing value
+ if ((optName != fit->c_str()) &&
+ std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
+ cmStrCmp(optName)) != cmArrayEnd(valueOptions)) {
+ const std::vector<std::string>::iterator existValueIt(existingIt + 1);
+ const std::vector<std::string>::const_iterator fileValueIt(fit + 1);
+ if ((existValueIt != opts.end()) && (fileValueIt != fileOpts.end())) {
+ *existValueIt = *fileValueIt;
+ ++fit;
+ }
}
} else {
- extraOpts.push_back(*it);
+ extraOpts.push_back(*fit);
}
}
opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
@@ -528,23 +558,20 @@ static bool RccListInputsQt4(cmSourceFile* sf,
}
cmsys::RegularExpression fileMatchRegex("(<file[^<]+)");
+ cmsys::RegularExpression fileReplaceRegex("(^<file[^>]*>)");
size_t offset = 0;
while (fileMatchRegex.find(qrcContents.c_str() + offset)) {
std::string qrcEntry = fileMatchRegex.match(1);
-
offset += qrcEntry.size();
-
- cmsys::RegularExpression fileReplaceRegex("(^<file[^>]*>)");
- fileReplaceRegex.find(qrcEntry);
- std::string tag = fileReplaceRegex.match(1);
-
- qrcEntry = qrcEntry.substr(tag.size());
-
+ {
+ fileReplaceRegex.find(qrcEntry);
+ std::string tag = fileReplaceRegex.match(1);
+ qrcEntry = qrcEntry.substr(tag.size());
+ }
if (!cmSystemTools::FileIsFullPath(qrcEntry.c_str())) {
qrcEntry = sf->GetLocation().GetDirectory() + "/" + qrcEntry;
}
-
depends.push_back(qrcEntry);
}
return true;
@@ -565,89 +592,69 @@ static bool RccListInputs(const std::string& qtMajorVersion, cmSourceFile* sf,
static void RccSetupAutoTarget(cmGeneratorTarget const* target,
const std::string& qtMajorVersion)
{
- std::string _rcc_files;
- const char* sepRccFiles = "";
cmMakefile* makefile = target->Target->GetMakefile();
-
- std::vector<cmSourceFile*> srcFiles;
- target->GetConfigCommonSourceFiles(srcFiles);
-
- std::string qrcInputs;
- const char* qrcInputsSep = "";
-
- std::string rccFileFiles;
- std::string rccFileOptions;
- const char* optionSep = "";
-
const bool qtMajorVersion5 = (qtMajorVersion == "5");
-
- std::vector<std::string> rccOptions;
+ std::vector<std::string> _rcc_files;
+ std::vector<std::string> _rcc_inputs;
+ std::vector<std::string> rccFileFiles;
+ std::vector<std::string> rccFileOptions;
+ std::vector<std::string> rccOptionsTarget;
if (const char* opts = target->GetProperty("AUTORCC_OPTIONS")) {
- cmSystemTools::ExpandListArgument(opts, rccOptions);
+ cmSystemTools::ExpandListArgument(opts, rccOptionsTarget);
}
+ std::vector<cmSourceFile*> srcFiles;
+ target->GetConfigCommonSourceFiles(srcFiles);
for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
fileIt != srcFiles.end(); ++fileIt) {
cmSourceFile* sf = *fileIt;
- std::string ext = sf->GetExtension();
- if (ext == "qrc") {
- std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
+ if (sf->GetExtension() == "qrc") {
const bool skip =
cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOGEN")) ||
cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"));
-
if (!skip) {
- _rcc_files += sepRccFiles;
- _rcc_files += absFile;
- sepRccFiles = ";";
-
- if (const char* prop = sf->GetProperty("AUTORCC_OPTIONS")) {
- std::vector<std::string> optsVec;
- cmSystemTools::ExpandListArgument(prop, optsVec);
- RccMergeOptions(rccOptions, optsVec, qtMajorVersion5);
- }
-
- if (!rccOptions.empty()) {
- rccFileFiles += optionSep;
- rccFileFiles += absFile;
- rccFileOptions += optionSep;
- }
- const char* listSep = "";
- for (std::vector<std::string>::const_iterator it = rccOptions.begin();
- it != rccOptions.end(); ++it) {
- rccFileOptions += listSep;
- rccFileOptions += *it;
- listSep = "@list_sep@";
+ const std::string absFile =
+ cmsys::SystemTools::GetRealPath(sf->GetFullPath());
+ // qrc file
+ _rcc_files.push_back(absFile);
+ // qrc file entries
+ {
+ std::string entriesList;
+ if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) {
+ std::vector<std::string> depends;
+ if (RccListInputs(qtMajorVersion, sf, target, depends)) {
+ entriesList = cmJoin(depends, "@list_sep@");
+ } else {
+ return;
+ }
+ }
+ _rcc_inputs.push_back(entriesList);
}
- optionSep = ";";
-
- std::string entriesList;
- if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) {
- std::vector<std::string> depends;
- if (RccListInputs(qtMajorVersion, sf, target, depends)) {
- entriesList = cmJoin(depends, "@list_sep@");
- } else {
- return;
+ // rcc options for this qrc file
+ {
+ // Merged target and file options
+ std::vector<std::string> rccOptions(rccOptionsTarget);
+ if (const char* prop = sf->GetProperty("AUTORCC_OPTIONS")) {
+ std::vector<std::string> optsVec;
+ cmSystemTools::ExpandListArgument(prop, optsVec);
+ RccMergeOptions(rccOptions, optsVec, qtMajorVersion5);
+ }
+ // Only store non empty options lists
+ if (!rccOptions.empty()) {
+ rccFileFiles.push_back(absFile);
+ rccFileOptions.push_back(cmJoin(rccOptions, "@list_sep@"));
}
}
- qrcInputs += qrcInputsSep;
- qrcInputs += entriesList;
- qrcInputsSep = ";";
}
}
}
- makefile->AddDefinition(
- "_rcc_inputs", cmOutputConverter::EscapeForCMake(qrcInputs).c_str());
- makefile->AddDefinition(
- "_rcc_files", cmOutputConverter::EscapeForCMake(_rcc_files).c_str());
- makefile->AddDefinition(
- "_rcc_options_files",
- cmOutputConverter::EscapeForCMake(rccFileFiles).c_str());
- makefile->AddDefinition(
- "_rcc_options_options",
- cmOutputConverter::EscapeForCMake(rccFileOptions).c_str());
- makefile->AddDefinition("_qt_rcc_executable",
- RccGetExecutable(target, qtMajorVersion).c_str());
+
+ AddDefinitionEscaped(makefile, "_rcc_files", _rcc_files);
+ AddDefinitionEscaped(makefile, "_rcc_inputs", _rcc_inputs);
+ AddDefinitionEscaped(makefile, "_rcc_options_files", rccFileFiles);
+ AddDefinitionEscaped(makefile, "_rcc_options_options", rccFileOptions);
+ AddDefinitionEscaped(makefile, "_qt_rcc_executable",
+ RccGetExecutable(target, qtMajorVersion));
}
void cmQtAutoGeneratorInitializer::InitializeAutogenSources(
@@ -874,47 +881,42 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
cmMakefile::ScopePushPop varScope(makefile);
static_cast<void>(varScope);
- // create a custom target for running generators at buildtime:
- const std::string autogenTargetName = GetAutogenTargetName(target);
- const std::string qtMajorVersion = GetQtMajorVersion(target);
-
- makefile->AddDefinition(
- "_moc_target_name",
- cmOutputConverter::EscapeForCMake(autogenTargetName).c_str());
- makefile->AddDefinition(
- "_origin_target_name",
- cmOutputConverter::EscapeForCMake(target->GetName()).c_str());
- makefile->AddDefinition("_target_qt_version", qtMajorVersion.c_str());
-
- std::vector<std::string> mocUicSources;
- std::vector<std::string> mocUicHeaders;
- std::vector<std::string> skipMoc;
- std::vector<std::string> skipUic;
std::map<std::string, std::string> configMocIncludes;
std::map<std::string, std::string> configMocDefines;
std::map<std::string, std::string> configUicOptions;
+ {
+ // create a custom target for running generators at buildtime:
+ const std::string autogenTargetName = GetAutogenTargetName(target);
+ const std::string qtMajorVersion = GetQtMajorVersion(target);
- if (target->GetPropertyAsBool("AUTOMOC") ||
- target->GetPropertyAsBool("AUTOUIC") ||
- target->GetPropertyAsBool("AUTORCC")) {
- SetupSourceFiles(target, mocUicSources, mocUicHeaders, skipMoc, skipUic);
- }
- makefile->AddDefinition(
- "_sources",
- cmOutputConverter::EscapeForCMake(cmJoin(mocUicSources, ";")).c_str());
- makefile->AddDefinition(
- "_headers",
- cmOutputConverter::EscapeForCMake(cmJoin(mocUicHeaders, ";")).c_str());
+ AddDefinitionEscaped(makefile, "_autogen_target_name", autogenTargetName);
+ AddDefinitionEscaped(makefile, "_origin_target_name", target->GetName());
+ AddDefinitionEscaped(makefile, "_qt_version_major", qtMajorVersion);
- if (target->GetPropertyAsBool("AUTOMOC")) {
- MocSetupAutoTarget(target, autogenTargetName, skipMoc, configMocIncludes,
- configMocDefines);
- }
- if (target->GetPropertyAsBool("AUTOUIC")) {
- UicSetupAutoTarget(target, skipUic, configUicOptions);
- }
- if (target->GetPropertyAsBool("AUTORCC")) {
- RccSetupAutoTarget(target, qtMajorVersion);
+ std::vector<std::string> _sources;
+ std::vector<std::string> _headers;
+ std::vector<std::string> mocSkipList;
+ std::vector<std::string> uicSkipList;
+
+ if (target->GetPropertyAsBool("AUTOMOC") ||
+ target->GetPropertyAsBool("AUTOUIC") ||
+ target->GetPropertyAsBool("AUTORCC")) {
+ SetupSourceFiles(target, _sources, _headers, mocSkipList, uicSkipList);
+ }
+ AddDefinitionEscaped(makefile, "_sources", _sources);
+ AddDefinitionEscaped(makefile, "_headers", _headers);
+
+ if (target->GetPropertyAsBool("AUTOMOC")) {
+ MocSetupAutoTarget(target, autogenTargetName, qtMajorVersion,
+ mocSkipList, configMocIncludes, configMocDefines);
+ }
+ if (target->GetPropertyAsBool("AUTOUIC")) {
+ UicSetupAutoTarget(target, qtMajorVersion, uicSkipList,
+ configUicOptions);
+ }
+ if (target->GetPropertyAsBool("AUTORCC")) {
+ RccSetupAutoTarget(target, qtMajorVersion);
+ }
}
// Generate config file
@@ -926,7 +928,7 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
makefile->ConfigureFile(inputFile.c_str(), outputFile.c_str(), false, true,
false);
- // Append custom definitions to config file
+ // Append custom config definitions to info file
if (!configMocDefines.empty() || !configMocIncludes.empty() ||
!configUicOptions.empty()) {
@@ -948,33 +950,34 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
error += outputFile;
error += " for writing.";
cmSystemTools::Error(error.c_str());
- return;
- }
- if (!configMocDefines.empty()) {
- for (std::map<std::string, std::string>::iterator
- it = configMocDefines.begin(),
- end = configMocDefines.end();
- it != end; ++it) {
- infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first << " "
- << it->second << ")\n";
+ } else {
+ infoFile << "# Configuration specific options\n";
+ if (!configMocDefines.empty()) {
+ for (std::map<std::string, std::string>::iterator
+ it = configMocDefines.begin(),
+ end = configMocDefines.end();
+ it != end; ++it) {
+ infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first << " "
+ << it->second << ")\n";
+ }
}
- }
- if (!configMocIncludes.empty()) {
- for (std::map<std::string, std::string>::iterator
- it = configMocIncludes.begin(),
- end = configMocIncludes.end();
- it != end; ++it) {
- infoFile << "set(AM_MOC_INCLUDES_" << it->first << " " << it->second
- << ")\n";
+ if (!configMocIncludes.empty()) {
+ for (std::map<std::string, std::string>::iterator
+ it = configMocIncludes.begin(),
+ end = configMocIncludes.end();
+ it != end; ++it) {
+ infoFile << "set(AM_MOC_INCLUDES_" << it->first << " " << it->second
+ << ")\n";
+ }
}
- }
- if (!configUicOptions.empty()) {
- for (std::map<std::string, std::string>::iterator
- it = configUicOptions.begin(),
- end = configUicOptions.end();
- it != end; ++it) {
- infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " "
- << it->second << ")\n";
+ if (!configUicOptions.empty()) {
+ for (std::map<std::string, std::string>::iterator
+ it = configUicOptions.begin(),
+ end = configUicOptions.end();
+ it != end; ++it) {
+ infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " "
+ << it->second << ")\n";
+ }
}
}
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=1f7f92b83efbaf8685b5db71c073f6e3779893f4
commit 1f7f92b83efbaf8685b5db71c073f6e3779893f4
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Sun Feb 19 13:17:42 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:57 2017 -0500
Autogen: Optimize GetCompileDefinitionsAndDirectories function
diff --git a/Source/cmQtAutoGeneratorInitializer.cxx b/Source/cmQtAutoGeneratorInitializer.cxx
index d17faf6..c201023 100644
--- a/Source/cmQtAutoGeneratorInitializer.cxx
+++ b/Source/cmQtAutoGeneratorInitializer.cxx
@@ -98,6 +98,26 @@ static std::string GetQtMajorVersion(cmGeneratorTarget const* target)
return qtMajorVersion;
}
+static void GetCompileDefinitionsAndDirectories(
+ cmGeneratorTarget const* target, const std::string& config,
+ std::string& incs, std::string& defs)
+{
+ cmLocalGenerator* localGen = target->GetLocalGenerator();
+ {
+ std::vector<std::string> includeDirs;
+ // Get the include dirs for this target, without stripping the implicit
+ // include dirs off, see
+ // https://gitlab.kitware.com/cmake/cmake/issues/13667
+ localGen->GetIncludeDirectories(includeDirs, target, "CXX", config, false);
+ incs = cmJoin(includeDirs, ";");
+ }
+ {
+ std::set<std::string> defines;
+ localGen->AddCompileDefinitions(defines, target, config, "CXX");
+ defs += cmJoin(defines, ";");
+ }
+}
+
static void SetupSourceFiles(cmGeneratorTarget const* target,
std::vector<std::string>& mocUicSources,
std::vector<std::string>& mocUicHeaders,
@@ -162,24 +182,6 @@ static void SetupSourceFiles(cmGeneratorTarget const* target,
}
}
-static void GetCompileDefinitionsAndDirectories(
- cmGeneratorTarget const* target, const std::string& config,
- std::string& incs, std::string& defs)
-{
- std::vector<std::string> includeDirs;
- cmLocalGenerator* localGen = target->GetLocalGenerator();
- // Get the include dirs for this target, without stripping the implicit
- // include dirs off, see https://gitlab.kitware.com/cmake/cmake/issues/13667
- localGen->GetIncludeDirectories(includeDirs, target, "CXX", config, false);
-
- incs = cmJoin(includeDirs, ";");
-
- std::set<std::string> defines;
- localGen->AddCompileDefinitions(defines, target, config, "CXX");
-
- defs += cmJoin(defines, ";");
-}
-
static void MocSetupAutoTarget(
cmGeneratorTarget const* target, const std::string& autogenTargetName,
std::vector<std::string> const& skipMoc,
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=8dad7d6a668c14cf0395872b22ee533961d3facf
commit 8dad7d6a668c14cf0395872b22ee533961d3facf
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Sun Feb 19 12:57:47 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:56 2017 -0500
Autogen: Sort AutogenInfo.cmake.in
Also rename AM_SKIP_MOC to AM_MOC_SKIP
and AM_SKIP_UIC to AM_UIC_SKIP
diff --git a/Modules/AutogenInfo.cmake.in b/Modules/AutogenInfo.cmake.in
index 3fafaff..3135909 100644
--- a/Modules/AutogenInfo.cmake.in
+++ b/Modules/AutogenInfo.cmake.in
@@ -1,25 +1,31 @@
-set(AM_SOURCES @_moc_uic_sources@)
-set(AM_HEADERS @_moc_uic_headers@)
-set(AM_SKIP_MOC @_skip_moc@)
-set(AM_SKIP_UIC @_skip_uic@)
-set(AM_MOC_COMPILE_DEFINITIONS @_moc_compile_defs@)
-set(AM_MOC_INCLUDES @_moc_incs@)
-set(AM_MOC_OPTIONS @_moc_options@)
-set(AM_MOC_RELAXED_MODE "@_moc_relaxed_mode@")
-set(AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE "@CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE@")
+# Target names
+set(AM_TARGET_NAME @_moc_target_name@)
+set(AM_ORIGIN_TARGET_NAME @_origin_target_name@)
+# Directories and files
set(AM_CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@/")
set(AM_CMAKE_SOURCE_DIR "@CMAKE_SOURCE_DIR@/")
-set(AM_QT_MOC_EXECUTABLE "@_qt_moc_executable@")
-set(AM_QT_UIC_EXECUTABLE "@_qt_uic_executable@")
-set(AM_QT_RCC_EXECUTABLE "@_qt_rcc_executable@")
set(AM_CMAKE_CURRENT_SOURCE_DIR "@CMAKE_CURRENT_SOURCE_DIR@/")
set(AM_CMAKE_CURRENT_BINARY_DIR "@CMAKE_CURRENT_BINARY_DIR@/")
+set(AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE "@CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE@")
+set(AM_SOURCES @_sources@)
+set(AM_HEADERS @_headers@)
+# Qt environment
set(AM_QT_VERSION_MAJOR "@_target_qt_version@")
-set(AM_TARGET_NAME @_moc_target_name@)
-set(AM_ORIGIN_TARGET_NAME @_origin_target_name@)
+set(AM_QT_MOC_EXECUTABLE "@_qt_moc_executable@")
+set(AM_QT_UIC_EXECUTABLE "@_qt_uic_executable@")
+set(AM_QT_RCC_EXECUTABLE "@_qt_rcc_executable@")
+# MOC settings
+set(AM_MOC_SKIP @_moc_skip@)
+set(AM_MOC_COMPILE_DEFINITIONS @_moc_compile_defs@)
+set(AM_MOC_INCLUDES @_moc_incs@)
+set(AM_MOC_OPTIONS @_moc_options@)
+set(AM_MOC_RELAXED_MODE "@_moc_relaxed_mode@")
+# UIC settings
+set(AM_UIC_SKIP @_uic_skip@)
set(AM_UIC_TARGET_OPTIONS @_uic_target_options@)
set(AM_UIC_OPTIONS_FILES @_qt_uic_options_files@)
set(AM_UIC_OPTIONS_OPTIONS @_qt_uic_options_options@)
+# RCC settings
set(AM_RCC_SOURCES @_rcc_files@ )
set(AM_RCC_INPUTS @_rcc_inputs@)
set(AM_RCC_OPTIONS_FILES @_rcc_options_files@)
diff --git a/Source/cmQtAutoGeneratorInitializer.cxx b/Source/cmQtAutoGeneratorInitializer.cxx
index 825eba0..d17faf6 100644
--- a/Source/cmQtAutoGeneratorInitializer.cxx
+++ b/Source/cmQtAutoGeneratorInitializer.cxx
@@ -194,7 +194,7 @@ static void MocSetupAutoTarget(
makefile->AddDefinition(
"_moc_options", cmOutputConverter::EscapeForCMake(_moc_options).c_str());
makefile->AddDefinition(
- "_skip_moc",
+ "_moc_skip",
cmOutputConverter::EscapeForCMake(cmJoin(skipMoc, ";")).c_str());
bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE");
makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE");
@@ -278,7 +278,7 @@ static void UicSetupAutoTarget(
skipped.insert(skipUic.begin(), skipUic.end());
makefile->AddDefinition(
- "_skip_uic",
+ "_uic_skip",
cmOutputConverter::EscapeForCMake(cmJoin(skipUic, ";")).c_str());
std::vector<cmSourceFile*> uiFilesWithOptions =
@@ -898,10 +898,10 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
SetupSourceFiles(target, mocUicSources, mocUicHeaders, skipMoc, skipUic);
}
makefile->AddDefinition(
- "_moc_uic_sources",
+ "_sources",
cmOutputConverter::EscapeForCMake(cmJoin(mocUicSources, ";")).c_str());
makefile->AddDefinition(
- "_moc_uic_headers",
+ "_headers",
cmOutputConverter::EscapeForCMake(cmJoin(mocUicHeaders, ";")).c_str());
if (target->GetPropertyAsBool("AUTOMOC")) {
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index ccdebbb..4149e55 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -307,7 +307,7 @@ bool cmQtAutoGenerators::ReadAutogenInfoFile(
this->Headers);
// - Moc
- cmSystemTools::ExpandListArgument(makefile->GetSafeDefinition("AM_SKIP_MOC"),
+ cmSystemTools::ExpandListArgument(makefile->GetSafeDefinition("AM_MOC_SKIP"),
this->MocSkipList);
cmSystemTools::ExpandListArgument(
GetConfigDefinition(makefile, "AM_MOC_COMPILE_DEFINITIONS", config),
@@ -319,7 +319,7 @@ bool cmQtAutoGenerators::ReadAutogenInfoFile(
makefile->GetSafeDefinition("AM_MOC_OPTIONS"), this->MocOptions);
// - Uic
- cmSystemTools::ExpandListArgument(makefile->GetSafeDefinition("AM_SKIP_UIC"),
+ cmSystemTools::ExpandListArgument(makefile->GetSafeDefinition("AM_UIC_SKIP"),
this->UicSkipList);
cmSystemTools::ExpandListArgument(
GetConfigDefinition(makefile, "AM_UIC_TARGET_OPTIONS", config),
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=4f4cdccdd4c59a7af1e87e88b783bcbf42923fc8
commit 4f4cdccdd4c59a7af1e87e88b783bcbf42923fc8
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Fri Feb 17 13:50:33 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:56 2017 -0500
Autogen: Tests: Add Q_PLUGIN_METADATA test
diff --git a/Tests/QtAutogen/CMakeLists.txt b/Tests/QtAutogen/CMakeLists.txt
index 40c23fa..260331b 100644
--- a/Tests/QtAutogen/CMakeLists.txt
+++ b/Tests/QtAutogen/CMakeLists.txt
@@ -86,7 +86,8 @@ try_compile(RCC_DEPENDS
"${CMAKE_CURRENT_BINARY_DIR}/autorcc_depends"
"${CMAKE_CURRENT_SOURCE_DIR}/autorcc_depends"
autorcc_depends
- CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}" "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
+ CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}"
+ "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
"-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
OUTPUT_VARIABLE output
)
@@ -121,7 +122,8 @@ try_compile(MOC_RERUN
"${CMAKE_CURRENT_BINARY_DIR}/automoc_rerun"
"${CMAKE_CURRENT_SOURCE_DIR}/automoc_rerun"
automoc_rerun
- CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}" "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
+ CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}"
+ "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
"-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
OUTPUT_VARIABLE output
)
@@ -215,5 +217,60 @@ add_subdirectory(mocIncludeStrict)
add_subdirectory(mocIncludeRelaxed)
# -- Test
+# Tests Q_PLUGIN_METADATA json file change detection
+if (NOT QT_TEST_VERSION STREQUAL 4)
+ try_compile(MOC_PLUGIN
+ "${CMAKE_CURRENT_BINARY_DIR}/mocPlugin"
+ "${CMAKE_CURRENT_SOURCE_DIR}/mocPlugin"
+ mocPlugin
+ CMAKE_FLAGS "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
+ "-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
+ OUTPUT_VARIABLE output
+ )
+ if (NOT MOC_PLUGIN)
+ message(SEND_ERROR "Initial build of mocPlugin failed. Output: ${output}")
+ endif()
+
+ set(timeformat "%Y%j%H%M%S")
+ set(mocPluginBinDir "${CMAKE_CURRENT_BINARY_DIR}/mocPlugin")
+ find_library(style_a_file "PluginStyleA" "${mocPluginBinDir}")
+ find_library(style_b_file "PluginStyleB" "${mocPluginBinDir}")
+ find_library(style_c_file "PluginStyleC" "${mocPluginBinDir}")
+ find_library(style_d_file "PluginStyleD" "${mocPluginBinDir}")
+
+ file(TIMESTAMP "${style_a_file}" style_a_before "${timeformat}")
+ file(TIMESTAMP "${style_b_file}" style_b_before "${timeformat}")
+ file(TIMESTAMP "${style_c_file}" style_c_before "${timeformat}")
+ file(TIMESTAMP "${style_d_file}" style_d_before "${timeformat}")
+
+ # Ensure that the timestamp will change and touch the json files
+ execute_process(COMMAND "${CMAKE_COMMAND}" -E sleep 1)
+ execute_process(COMMAND "${CMAKE_COMMAND}" -E touch "${mocPluginBinDir}/jsonFiles/StyleC.json")
+ execute_process(COMMAND "${CMAKE_COMMAND}" -E touch "${mocPluginBinDir}/jsonFiles/sub/StyleD.json")
+
+ execute_process(COMMAND "${CMAKE_COMMAND}" --build .
+ WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/mocPlugin"
+ )
+
+ file(TIMESTAMP "${style_a_file}" style_a_after "${timeformat}")
+ file(TIMESTAMP "${style_b_file}" style_b_after "${timeformat}")
+ file(TIMESTAMP "${style_c_file}" style_c_after "${timeformat}")
+ file(TIMESTAMP "${style_d_file}" style_d_after "${timeformat}")
+
+ if (style_a_after GREATER style_a_before)
+ message(SEND_ERROR "file (${style_a_file}) should not have changed!")
+ endif()
+ if (style_b_after GREATER style_b_before)
+ message(SEND_ERROR "file (${style_b_file}) should not have changed!")
+ endif()
+ if (NOT style_c_after GREATER style_c_before)
+ message(SEND_ERROR "file (${style_c_file}) should have changed!")
+ endif()
+ if (NOT style_d_after GREATER style_d_before)
+ message(SEND_ERROR "file (${style_d_file}) should have changed!")
+ endif()
+endif()
+
+# -- Test
# Complex test case
add_subdirectory(complex)
diff --git a/Tests/QtAutogen/mocPlugin/CMakeLists.txt b/Tests/QtAutogen/mocPlugin/CMakeLists.txt
new file mode 100644
index 0000000..eed7d39
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/CMakeLists.txt
@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.8)
+
+if (NOT QT_TEST_VERSION STREQUAL 5)
+ message(SEND_ERROR "Invalid Qt version specified.")
+endif()
+find_package(Qt5Widgets REQUIRED)
+
+if(Qt5_POSITION_INDEPENDENT_CODE AND CMAKE_CXX_COMPILE_OPTIONS_PIC)
+ add_definitions(${CMAKE_CXX_COMPILE_OPTIONS_PIC})
+endif()
+
+configure_file(jsonIn/StyleC.json jsonFiles/StyleC.json @ONLY)
+configure_file(jsonIn/StyleD.json jsonFiles/sub/StyleD.json @ONLY)
+
+# Enable automoc
+set(CMAKE_AUTOMOC TRUE)
+
+include_directories("${CMAKE_CURRENT_BINARY_DIR}/jsonFiles")
+link_libraries(Qt5::Widgets)
+
+add_library(PluginStyleA MODULE StyleA.cpp)
+add_library(PluginStyleB MODULE StyleB.cpp)
+add_library(PluginStyleC MODULE StyleC.cpp)
+add_library(PluginStyleD MODULE StyleD.cpp)
+add_library(PluginStyleE MODULE StyleE.cpp)
diff --git a/Tests/QtAutogen/mocPlugin/StyleA.cpp b/Tests/QtAutogen/mocPlugin/StyleA.cpp
new file mode 100644
index 0000000..b5e8753
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleA.cpp
@@ -0,0 +1,6 @@
+#include "StyleA.hpp"
+
+QStyle* StyleA::create(const QString& key)
+{
+ return 0;
+}
diff --git a/Tests/QtAutogen/mocPlugin/StyleA.hpp b/Tests/QtAutogen/mocPlugin/StyleA.hpp
new file mode 100644
index 0000000..b105b02
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleA.hpp
@@ -0,0 +1,15 @@
+#ifndef STYLEA_HPP
+#define STYLEA_HPP
+
+#include <QStylePlugin>
+
+class StyleA : public QStylePlugin
+{
+ Q_OBJECT
+ // Json file in local directory
+ Q_PLUGIN_METADATA(IID "org.styles.A" FILE "StyleA.json")
+public:
+ QStyle* create(const QString& key);
+};
+
+#endif
diff --git a/Tests/QtAutogen/mocPlugin/StyleA.json b/Tests/QtAutogen/mocPlugin/StyleA.json
new file mode 100644
index 0000000..cc33953
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleA.json
@@ -0,0 +1 @@
+{ "Keys": [ "Rocket", "Starbuster" ] }
diff --git a/Tests/QtAutogen/mocPlugin/StyleB.cpp b/Tests/QtAutogen/mocPlugin/StyleB.cpp
new file mode 100644
index 0000000..17d4400
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleB.cpp
@@ -0,0 +1,6 @@
+#include "StyleB.hpp"
+
+QStyle* StyleB::create(const QString& key)
+{
+ return 0;
+}
diff --git a/Tests/QtAutogen/mocPlugin/StyleB.hpp b/Tests/QtAutogen/mocPlugin/StyleB.hpp
new file mode 100644
index 0000000..ba89127
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleB.hpp
@@ -0,0 +1,15 @@
+#ifndef STYLEB_HPP
+#define STYLEB_HPP
+
+#include <QStylePlugin>
+
+class StyleB : public QStylePlugin
+{
+ Q_OBJECT
+ // Json file in local subdirectory
+ Q_PLUGIN_METADATA(IID "org.styles.B" FILE "jsonIn/StyleB.json")
+public:
+ QStyle* create(const QString& key);
+};
+
+#endif
diff --git a/Tests/QtAutogen/mocPlugin/StyleC.cpp b/Tests/QtAutogen/mocPlugin/StyleC.cpp
new file mode 100644
index 0000000..37e7564
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleC.cpp
@@ -0,0 +1,6 @@
+#include "StyleC.hpp"
+
+QStyle* StyleC::create(const QString& key)
+{
+ return 0;
+}
diff --git a/Tests/QtAutogen/mocPlugin/StyleC.hpp b/Tests/QtAutogen/mocPlugin/StyleC.hpp
new file mode 100644
index 0000000..9f71d75
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleC.hpp
@@ -0,0 +1,15 @@
+#ifndef STYLEC_HPP
+#define STYLEC_HPP
+
+#include <QStylePlugin>
+
+class StyleC : public QStylePlugin
+{
+ Q_OBJECT
+ // Json file in global root directory
+ Q_PLUGIN_METADATA(IID "org.styles.C" FILE "StyleC.json")
+public:
+ QStyle* create(const QString& key);
+};
+
+#endif
diff --git a/Tests/QtAutogen/mocPlugin/StyleD.cpp b/Tests/QtAutogen/mocPlugin/StyleD.cpp
new file mode 100644
index 0000000..48398bb
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleD.cpp
@@ -0,0 +1,17 @@
+#include "StyleD.hpp"
+
+class StyleD : public QStylePlugin
+{
+ Q_OBJECT
+ // Json file in global sub director
+ Q_PLUGIN_METADATA(IID "org.styles.D" FILE "sub/StyleD.json")
+public:
+ QStyle* create(const QString& key);
+};
+
+QStyle* StyleD::create(const QString& key)
+{
+ return 0;
+}
+
+#include "StyleD.moc"
diff --git a/Tests/QtAutogen/mocPlugin/StyleD.hpp b/Tests/QtAutogen/mocPlugin/StyleD.hpp
new file mode 100644
index 0000000..2afe055
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleD.hpp
@@ -0,0 +1,8 @@
+#ifndef STYLED_HPP
+#define STYLED_HPP
+
+#include <QStylePlugin>
+
+class StyleD;
+
+#endif
diff --git a/Tests/QtAutogen/mocPlugin/StyleE.cpp b/Tests/QtAutogen/mocPlugin/StyleE.cpp
new file mode 100644
index 0000000..8fc9a7f
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleE.cpp
@@ -0,0 +1,6 @@
+#include "StyleE.hpp"
+
+QStyle* StyleE::create(const QString& key)
+{
+ return 0;
+}
diff --git a/Tests/QtAutogen/mocPlugin/StyleE.hpp b/Tests/QtAutogen/mocPlugin/StyleE.hpp
new file mode 100644
index 0000000..80e0b79
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/StyleE.hpp
@@ -0,0 +1,15 @@
+#ifndef STYLEE_HPP
+#define STYLEE_HPP
+
+#include <QStylePlugin>
+
+class StyleE : public QStylePlugin
+{
+ Q_OBJECT
+ // No Json file
+ Q_PLUGIN_METADATA(IID "org.styles.E")
+public:
+ QStyle* create(const QString& key);
+};
+
+#endif
diff --git a/Tests/QtAutogen/mocPlugin/jsonIn/StyleB.json b/Tests/QtAutogen/mocPlugin/jsonIn/StyleB.json
new file mode 100644
index 0000000..129cac4
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/jsonIn/StyleB.json
@@ -0,0 +1 @@
+{ "Keys": [ "Rocket", "StarbusterB" ] }
diff --git a/Tests/QtAutogen/mocPlugin/jsonIn/StyleC.json b/Tests/QtAutogen/mocPlugin/jsonIn/StyleC.json
new file mode 100644
index 0000000..bf17580
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/jsonIn/StyleC.json
@@ -0,0 +1 @@
+{ "Keys": [ "Rocket", "StarbusterC" ] }
diff --git a/Tests/QtAutogen/mocPlugin/jsonIn/StyleD.json b/Tests/QtAutogen/mocPlugin/jsonIn/StyleD.json
new file mode 100644
index 0000000..f7fcc19
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/jsonIn/StyleD.json
@@ -0,0 +1 @@
+{ "Keys": [ "Rocket", "StarbusterD" ] }
diff --git a/Tests/QtAutogen/mocPlugin/main.cpp b/Tests/QtAutogen/mocPlugin/main.cpp
new file mode 100644
index 0000000..3ba2ddc
--- /dev/null
+++ b/Tests/QtAutogen/mocPlugin/main.cpp
@@ -0,0 +1,6 @@
+#include "StyleA.hpp"
+
+int main(int argv, char** args)
+{
+ return 0;
+}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=c7c1ac85de53a1fce5c0b1bdded27598109cc4be
commit c7c1ac85de53a1fce5c0b1bdded27598109cc4be
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Thu Feb 16 15:59:56 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:56 2017 -0500
Autogen: Tests: Add moc include tests
diff --git a/Tests/QtAutogen/CMakeLists.txt b/Tests/QtAutogen/CMakeLists.txt
index c1cdee2..40c23fa 100644
--- a/Tests/QtAutogen/CMakeLists.txt
+++ b/Tests/QtAutogen/CMakeLists.txt
@@ -207,5 +207,13 @@ target_link_libraries(skipRccB ${QT_LIBRARIES})
add_subdirectory(sameName)
# -- Test
+# Tests various include moc patterns
+add_subdirectory(mocIncludeStrict)
+
+# -- Test
+# Tests various include moc patterns
+add_subdirectory(mocIncludeRelaxed)
+
+# -- Test
# Complex test case
add_subdirectory(complex)
diff --git a/Tests/QtAutogen/mocInclude/ObjA.cpp b/Tests/QtAutogen/mocInclude/ObjA.cpp
new file mode 100644
index 0000000..2ee47ec
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/ObjA.cpp
@@ -0,0 +1,24 @@
+#include "ObjA.hpp"
+
+class SubObjA : public QObject
+{
+ Q_OBJECT
+
+public:
+ SubObjA() = default;
+ ~SubObjA() = default;
+
+ Q_SLOT
+ void aSlot();
+};
+
+void SubObjA::aSlot()
+{
+}
+
+void ObjA::go()
+{
+ SubObjA subObj;
+}
+
+#include "ObjA.moc"
diff --git a/Tests/QtAutogen/mocInclude/ObjA.hpp b/Tests/QtAutogen/mocInclude/ObjA.hpp
new file mode 100644
index 0000000..281e90d
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/ObjA.hpp
@@ -0,0 +1,13 @@
+#ifndef OBJA_HPP
+#define OBJA_HPP
+
+#include <QObject>
+
+class ObjA : public QObject
+{
+ Q_OBJECT
+ Q_SLOT
+ void go();
+};
+
+#endif
diff --git a/Tests/QtAutogen/mocInclude/ObjB.cpp b/Tests/QtAutogen/mocInclude/ObjB.cpp
new file mode 100644
index 0000000..abec06a
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/ObjB.cpp
@@ -0,0 +1,25 @@
+#include "ObjB.hpp"
+
+class SubObjB : public QObject
+{
+ Q_OBJECT
+
+public:
+ SubObjB() = default;
+ ~SubObjB() = default;
+
+ Q_SLOT
+ void aSlot();
+};
+
+void SubObjB::aSlot()
+{
+}
+
+void ObjB::go()
+{
+ SubObjB subObj;
+}
+
+#include "ObjB.moc"
+#include "moc_ObjB.cpp"
diff --git a/Tests/QtAutogen/mocInclude/ObjB.hpp b/Tests/QtAutogen/mocInclude/ObjB.hpp
new file mode 100644
index 0000000..94f3d49
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/ObjB.hpp
@@ -0,0 +1,13 @@
+#ifndef OBJB_HPP
+#define OBJB_HPP
+
+#include <QObject>
+
+class ObjB : public QObject
+{
+ Q_OBJECT
+ Q_SLOT
+ void go();
+};
+
+#endif
diff --git a/Tests/QtAutogen/mocInclude/ObjC.cpp b/Tests/QtAutogen/mocInclude/ObjC.cpp
new file mode 100644
index 0000000..bdcdb13
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/ObjC.cpp
@@ -0,0 +1,26 @@
+#include "ObjC.hpp"
+
+class SubObjC : public QObject
+{
+ Q_OBJECT
+
+public:
+ SubObjC() = default;
+ ~SubObjC() = default;
+
+ Q_SLOT
+ void aSlot();
+};
+
+void SubObjC::aSlot()
+{
+}
+
+void ObjC::go()
+{
+ SubObjC subObj;
+}
+
+#include "ObjC.moc"
+// Not the own header
+#include "moc_ObjD.cpp"
diff --git a/Tests/QtAutogen/mocInclude/ObjC.hpp b/Tests/QtAutogen/mocInclude/ObjC.hpp
new file mode 100644
index 0000000..a8e98eb
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/ObjC.hpp
@@ -0,0 +1,13 @@
+#ifndef OBJC_HPP
+#define OBJC_HPP
+
+#include <QObject>
+
+class ObjC : public QObject
+{
+ Q_OBJECT
+ Q_SLOT
+ void go();
+};
+
+#endif
diff --git a/Tests/QtAutogen/mocInclude/ObjD.cpp b/Tests/QtAutogen/mocInclude/ObjD.cpp
new file mode 100644
index 0000000..9145ba3
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/ObjD.cpp
@@ -0,0 +1,26 @@
+#include "ObjD.hpp"
+
+class SubObjD : public QObject
+{
+ Q_OBJECT
+
+public:
+ SubObjD() = default;
+ ~SubObjD() = default;
+
+ Q_SLOT
+ void aSlot();
+};
+
+void SubObjD::aSlot()
+{
+}
+
+void ObjD::go()
+{
+ SubObjD subObj;
+}
+
+#include "ObjD.moc"
+// Header in subdirectory
+#include "subA/moc_SubObjA.cpp"
diff --git a/Tests/QtAutogen/mocInclude/ObjD.hpp b/Tests/QtAutogen/mocInclude/ObjD.hpp
new file mode 100644
index 0000000..b6ee098
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/ObjD.hpp
@@ -0,0 +1,13 @@
+#ifndef OBJD_HPP
+#define OBJD_HPP
+
+#include <QObject>
+
+class ObjD : public QObject
+{
+ Q_OBJECT
+ Q_SLOT
+ void go();
+};
+
+#endif
diff --git a/Tests/QtAutogen/mocInclude/subA/SubObjA.cpp b/Tests/QtAutogen/mocInclude/subA/SubObjA.cpp
new file mode 100644
index 0000000..d780942
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/subA/SubObjA.cpp
@@ -0,0 +1,27 @@
+#include "SubObjA.hpp"
+
+namespace subA {
+
+class SubObjA : public QObject
+{
+ Q_OBJECT
+
+public:
+ SubObjA() = default;
+ ~SubObjA() = default;
+
+ Q_SLOT
+ void aSlot();
+};
+
+void SubObjA::aSlot()
+{
+}
+
+void ObjA::go()
+{
+ SubObjA subObj;
+}
+}
+
+#include "SubObjA.moc"
diff --git a/Tests/QtAutogen/mocInclude/subA/SubObjA.hpp b/Tests/QtAutogen/mocInclude/subA/SubObjA.hpp
new file mode 100644
index 0000000..31a18b6
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/subA/SubObjA.hpp
@@ -0,0 +1,16 @@
+#ifndef SUBOBJA_HPP
+#define SUBOBJA_HPP
+
+#include <QObject>
+
+namespace subA {
+
+class ObjA : public QObject
+{
+ Q_OBJECT
+ Q_SLOT
+ void go();
+};
+}
+
+#endif
diff --git a/Tests/QtAutogen/mocInclude/subB/SubObjB.cpp b/Tests/QtAutogen/mocInclude/subB/SubObjB.cpp
new file mode 100644
index 0000000..e602e06
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/subB/SubObjB.cpp
@@ -0,0 +1,27 @@
+#include "SubObjB.hpp"
+
+namespace subB {
+
+class SubObjB : public QObject
+{
+ Q_OBJECT
+
+public:
+ SubObjB() = default;
+ ~SubObjB() = default;
+
+ Q_SLOT
+ void aSlot();
+};
+
+void SubObjB::aSlot()
+{
+}
+
+void ObjB::go()
+{
+ SubObjB subObj;
+}
+}
+
+#include "SubObjB.moc"
diff --git a/Tests/QtAutogen/mocInclude/subB/SubObjB.hpp b/Tests/QtAutogen/mocInclude/subB/SubObjB.hpp
new file mode 100644
index 0000000..3f29fa2
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/subB/SubObjB.hpp
@@ -0,0 +1,16 @@
+#ifndef SUBOBJB_HPP
+#define SUBOBJB_HPP
+
+#include <QObject>
+
+namespace subB {
+
+class ObjB : public QObject
+{
+ Q_OBJECT
+ Q_SLOT
+ void go();
+};
+}
+
+#endif
diff --git a/Tests/QtAutogen/mocInclude/subC/SubObjC.cpp b/Tests/QtAutogen/mocInclude/subC/SubObjC.cpp
new file mode 100644
index 0000000..fb2d1ec
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/subC/SubObjC.cpp
@@ -0,0 +1,27 @@
+#include "SubObjC.hpp"
+
+namespace subC {
+
+class SubObjC : public QObject
+{
+ Q_OBJECT
+
+public:
+ SubObjC() = default;
+ ~SubObjC() = default;
+
+ Q_SLOT
+ void aSlot();
+};
+
+void SubObjC::aSlot()
+{
+}
+
+void ObjC::go()
+{
+ SubObjC subObj;
+}
+}
+
+#include "SubObjC.moc"
diff --git a/Tests/QtAutogen/mocInclude/subC/SubObjC.hpp b/Tests/QtAutogen/mocInclude/subC/SubObjC.hpp
new file mode 100644
index 0000000..dc251fd
--- /dev/null
+++ b/Tests/QtAutogen/mocInclude/subC/SubObjC.hpp
@@ -0,0 +1,16 @@
+#ifndef SUBOBJC_HPP
+#define SUBOBJC_HPP
+
+#include <QObject>
+
+namespace subC {
+
+class ObjC : public QObject
+{
+ Q_OBJECT
+ Q_SLOT
+ void go();
+};
+}
+
+#endif
diff --git a/Tests/QtAutogen/mocIncludeRelaxed/CMakeLists.txt b/Tests/QtAutogen/mocIncludeRelaxed/CMakeLists.txt
new file mode 100644
index 0000000..6a0829d
--- /dev/null
+++ b/Tests/QtAutogen/mocIncludeRelaxed/CMakeLists.txt
@@ -0,0 +1,18 @@
+# Test moc include patterns
+
+set(CMAKE_AUTOMOC_RELAXED_MODE TRUE)
+
+include_directories("../mocInclude")
+
+add_executable(mocIncludeRelaxed
+ ../mocInclude/ObjA.cpp
+ ../mocInclude/ObjB.cpp
+ ../mocInclude/ObjC.cpp
+ ../mocInclude/ObjD.cpp
+ ../mocInclude/subA/SubObjA.cpp
+ ../mocInclude/subB/SubObjB.cpp
+ ../mocInclude/subC/SubObjC.cpp
+ main.cpp
+)
+target_link_libraries(mocIncludeRelaxed ${QT_LIBRARIES})
+set_target_properties(mocIncludeRelaxed PROPERTIES AUTOMOC ON)
diff --git a/Tests/QtAutogen/mocIncludeRelaxed/main.cpp b/Tests/QtAutogen/mocIncludeRelaxed/main.cpp
new file mode 100644
index 0000000..142d59e
--- /dev/null
+++ b/Tests/QtAutogen/mocIncludeRelaxed/main.cpp
@@ -0,0 +1,14 @@
+#include "ObjA.hpp"
+#include "ObjB.hpp"
+#include "ObjC.hpp"
+
+int main(int argv, char** args)
+{
+ ObjA objA;
+ ObjB objB;
+ ObjC objC;
+ return 0;
+}
+
+// Header in global subdirectory
+#include "subB/moc_SubObjB.cpp"
diff --git a/Tests/QtAutogen/mocIncludeStrict/CMakeLists.txt b/Tests/QtAutogen/mocIncludeStrict/CMakeLists.txt
new file mode 100644
index 0000000..22e93a8
--- /dev/null
+++ b/Tests/QtAutogen/mocIncludeStrict/CMakeLists.txt
@@ -0,0 +1,18 @@
+# Test moc include patterns
+
+set(CMAKE_AUTOMOC_RELAXED_MODE FALSE)
+
+include_directories("../mocInclude")
+
+add_executable(mocIncludeStrict
+ ../mocInclude/ObjA.cpp
+ ../mocInclude/ObjB.cpp
+ ../mocInclude/ObjC.cpp
+ ../mocInclude/ObjD.cpp
+ ../mocInclude/subA/SubObjA.cpp
+ ../mocInclude/subB/SubObjB.cpp
+ ../mocInclude/subC/SubObjC.cpp
+ main.cpp
+)
+target_link_libraries(mocIncludeStrict ${QT_LIBRARIES})
+set_target_properties(mocIncludeStrict PROPERTIES AUTOMOC ON)
diff --git a/Tests/QtAutogen/mocIncludeStrict/main.cpp b/Tests/QtAutogen/mocIncludeStrict/main.cpp
new file mode 100644
index 0000000..142d59e
--- /dev/null
+++ b/Tests/QtAutogen/mocIncludeStrict/main.cpp
@@ -0,0 +1,14 @@
+#include "ObjA.hpp"
+#include "ObjB.hpp"
+#include "ObjC.hpp"
+
+int main(int argv, char** args)
+{
+ ObjA objA;
+ ObjB objB;
+ ObjC objC;
+ return 0;
+}
+
+// Header in global subdirectory
+#include "subB/moc_SubObjB.cpp"
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=50805693ba987fbf86bb5e8263d7b427cd4da0c2
commit 50805693ba987fbf86bb5e8263d7b427cd4da0c2
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Thu Feb 16 15:05:11 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:55 2017 -0500
Autogen: Tests: Clean comments
diff --git a/Tests/QtAutogen/CMakeLists.txt b/Tests/QtAutogen/CMakeLists.txt
index 4b90ad8..c1cdee2 100644
--- a/Tests/QtAutogen/CMakeLists.txt
+++ b/Tests/QtAutogen/CMakeLists.txt
@@ -46,26 +46,26 @@ endif()
get_property(QT_COMPILE_FEATURES TARGET ${QT_QTCORE_TARGET} PROPERTY INTERFACE_COMPILE_FEATURES)
-# -- Test: AUTORCC
+# -- Test
# RCC only
add_executable(rccOnly rccOnly.cpp rccOnlyRes.qrc)
set_property(TARGET rccOnly PROPERTY AUTORCC ON)
target_link_libraries(rccOnly ${QT_QTCORE_TARGET})
-# -- Test: AUTORCC
+# -- Test
# RCC empty
add_executable(rccEmpty rccEmpty.cpp rccEmptyRes.qrc)
set_property(TARGET rccEmpty PROPERTY AUTORCC ON)
target_link_libraries(rccEmpty ${QT_QTCORE_TARGET})
-# -- Test: AUTOUIC
+# -- Test
# UIC only
qtx_wrap_cpp(uicOnlyMoc uicOnlySource/uiconly.h)
add_executable(uicOnly uicOnlySource/uiconly.cpp ${uicOnlyMoc})
set_property(TARGET uicOnly PROPERTY AUTOUIC ON)
target_link_libraries(uicOnly ${QT_LIBRARIES})
-# -- Test: AUTOMOC, AUTORCC
+# -- Test
# Add not_generated_file.qrc to the source list to get the file-level
# dependency, but don't generate a c++ file from it. Disable the AUTORCC
# feature for this target. This tests that qrc files in the sources don't
@@ -80,7 +80,7 @@ set_target_properties(no_link_language PROPERTIES AUTOMOC TRUE)
target_compile_features(no_link_language PRIVATE ${QT_COMPILE_FEATURES})
target_compile_features(empty PRIVATE ${QT_COMPILE_FEATURES})
-# -- Test: AUTORCC
+# -- Test
# When a file listed in a .qrc file changes the target must be rebuilt
try_compile(RCC_DEPENDS
"${CMAKE_CURRENT_BINARY_DIR}/autorcc_depends"
@@ -115,7 +115,7 @@ if (NOT file1_step1 GREATER file1_before)
message(SEND_ERROR "file1 (${qrc_file1}) should have changed in the first step!")
endif()
-# -- Test: AUTOMOC
+# -- Test
# Ensure a repeated build succeeds when a header containing a QObject changes
try_compile(MOC_RERUN
"${CMAKE_CURRENT_BINARY_DIR}/automoc_rerun"
@@ -139,7 +139,7 @@ if (automoc_rerun_result)
message(SEND_ERROR "Second build of automoc_rerun failed.")
endif()
-# -- Test: AUTOMOC, SKIP_AUTOMOC
+# -- Test
# Test for SKIP_AUTOMOC and SKIP_AUTOGEN on an AUTOMOC enabled target
qtx_wrap_cpp(skipMocWrapMoc
skipSource/qItemA.hpp
@@ -161,7 +161,7 @@ set_property(TARGET skipMocB PROPERTY AUTOMOC ON)
set_property(TARGET skipMocB PROPERTY AUTOUIC ON)
target_link_libraries(skipMocB ${QT_LIBRARIES})
-# -- Test: AUTOUIC, SKIP_AUTOUIC
+# -- Test
# Test for SKIP_AUTOUIC and SKIP_AUTOGEN on an AUTOUIC enabled target
set(skipUicSources
skipUic.cpp
@@ -181,7 +181,7 @@ set_property(TARGET skipUicB PROPERTY AUTOUIC ON)
set_property(TARGET skipUicB PROPERTY AUTOMOC ON)
target_link_libraries(skipUicB ${QT_LIBRARIES})
-# -- Test: AUTORCC, SKIP_AUTORCC
+# -- Test
# Test for SKIP_AUTORCC and SKIP_AUTOGEN on an AUTORCC enabled target
set(skipRccSources
skipRcc.cpp
@@ -202,10 +202,10 @@ set_property(TARGET skipRccB PROPERTY AUTOUIC ON)
set_property(TARGET skipRccB PROPERTY AUTOMOC ON)
target_link_libraries(skipRccB ${QT_LIBRARIES})
-# -- Test: AUTOMOC AUTORCC
+# -- Test
# Source files with the same basename in different subdirectories
add_subdirectory(sameName)
-# -- Test: AUTOMOC AUTORCC AUTOUIC
+# -- Test
# Complex test case
add_subdirectory(complex)
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=c23206b6c17a5c70580355904fc12fd64c26ef79
commit c23206b6c17a5c70580355904fc12fd64c26ef79
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Fri Feb 17 18:44:10 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:55 2017 -0500
Autogen: Log simplifications
The logging methods now automatically add an end-of-line
to the message if it is missing.
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index cd39984..ccdebbb 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -465,9 +465,7 @@ bool cmQtAutoGenerators::SettingsFileWrite(const std::string& targetDirectory)
if (this->GenerateAllAny()) {
const std::string filename = SettingsFile(targetDirectory);
if (this->Verbose) {
- std::ostringstream err;
- err << "AutoGen: Writing settings file " << filename << "\n";
- this->LogInfo(err.str());
+ this->LogInfo("AutoGen: Writing settings file " + filename);
}
cmsys::ofstream outfile;
outfile.open(filename.c_str(), std::ios::trunc);
@@ -483,8 +481,8 @@ bool cmQtAutoGenerators::SettingsFileWrite(const std::string& targetDirectory)
cmSystemTools::RemoveFile(filename);
{
std::ostringstream err;
- err << "AutoGen: Error: Writing old settings file failed: " << filename
- << std::endl;
+ err << "AutoGen: Error: Writing old settings file failed: "
+ << filename;
this->LogError(err.str());
}
}
@@ -686,12 +684,12 @@ void cmQtAutoGenerators::MocFindDepends(
mocDepends[absFilename].insert(incFile);
if (this->Verbose) {
this->LogInfo("AutoMoc: Found dependency:\n \"" + absFilename +
- "\"\n \"" + incFile + "\"\n");
+ "\"\n \"" + incFile + "\"");
}
} else {
this->LogWarning("AutoMoc: Warning: \"" + absFilename + "\"\n" +
"Could not find dependency file \"" + match +
- "\"\n");
+ "\"");
}
}
contentChars += filter.regExp.end();
@@ -741,10 +739,10 @@ bool cmQtAutoGenerators::ParseSourceFile(
bool success = true;
const std::string contentText = ReadAll(absFilename);
if (contentText.empty()) {
- std::ostringstream err;
- err << "AutoGen: Warning: " << absFilename << "\n"
+ std::ostringstream ost;
+ ost << "AutoGen: Warning: " << absFilename << "\n"
<< "The file is empty\n";
- this->LogWarning(err.str());
+ this->LogWarning(ost.str());
} else {
// Parse source contents for MOC
if (success && !this->MocSkip(absFilename)) {
@@ -764,9 +762,7 @@ void cmQtAutoGenerators::UicParseContent(
std::map<std::string, std::vector<std::string> >& uisIncluded)
{
if (this->Verbose) {
- std::ostringstream err;
- err << "AutoUic: Checking " << absFilename << "\n";
- this->LogInfo(err.str());
+ this->LogInfo("AutoUic: Checking " + absFilename);
}
const char* contentChars = contentText.c_str();
@@ -792,9 +788,7 @@ bool cmQtAutoGenerators::MocParseSourceContent(
std::map<std::string, std::set<std::string> >& mocDepends, bool relaxed)
{
if (this->Verbose) {
- std::ostringstream err;
- err << "AutoMoc: Checking " << absFilename << "\n";
- this->LogInfo(err.str());
+ this->LogInfo("AutoMoc: Checking " + absFilename);
}
const std::string scannedFileAbsPath =
@@ -846,12 +840,12 @@ bool cmQtAutoGenerators::MocParseSourceContent(
ownMocUnderscoreHeader = headerToMoc;
}
} else {
- std::ostringstream err;
- err << "AutoMoc: Error: " << absFilename << "\n"
+ std::ostringstream ost;
+ ost << "AutoMoc: Error: " << absFilename << "\n"
<< "The file includes the moc file \"" << incString
<< "\", but could not find header \"" << incRealBasename << '{'
<< JoinExts(this->HeaderExtensions) << "}\"\n";
- this->LogError(err.str());
+ this->LogError(ost.str());
return false;
}
} else {
@@ -871,34 +865,34 @@ bool cmQtAutoGenerators::MocParseSourceContent(
// This is for KDE4 compatibility:
fileToMoc = headerToMoc;
if (!requiresMoc && (incBasename == scannedFileBasename)) {
- std::ostringstream err;
- err << "AutoMoc: Warning: " << absFilename << "\n"
+ std::ostringstream ost;
+ ost << "AutoMoc: Warning: " << absFilename << "\n"
<< "The file includes the moc file \"" << incString << "\""
<< ", but does not contain a Q_OBJECT or Q_GADGET macro.\n"
<< "Running moc on \"" << headerToMoc << "\"!\n"
<< "Include \"moc_" << incBasename
<< ".cpp\" for a compatibility with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n";
- this->LogWarning(err.str());
+ this->LogWarning(ost.str());
} else {
- std::ostringstream err;
- err << "AutoMoc: Warning: " << absFilename << "\n"
+ std::ostringstream ost;
+ ost << "AutoMoc: Warning: " << absFilename << "\n"
<< "The file includes the moc file \"" << incString
<< "\" instead of \"moc_" << incBasename << ".cpp\".\n"
<< "Running moc on \"" << headerToMoc << "\"!\n"
<< "Include \"moc_" << incBasename
<< ".cpp\" for compatibility with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n";
- this->LogWarning(err.str());
+ this->LogWarning(ost.str());
}
} else {
- std::ostringstream err;
- err << "AutoMoc: Error: " << absFilename << "\n"
+ std::ostringstream ost;
+ ost << "AutoMoc: Error: " << absFilename << "\n"
<< "The file includes the moc file \"" << incString
<< "\", which seems to be the moc file from a different "
"source file. CMake also could not find a matching "
"header.\n";
- this->LogError(err.str());
+ this->LogError(ost.str());
return false;
}
}
@@ -910,23 +904,23 @@ bool cmQtAutoGenerators::MocParseSourceContent(
ownDotMocIncluded = true;
// Accept but issue a warning if moc isn't required
if (!requiresMoc) {
- std::ostringstream err;
- err << "AutoMoc: Error: " << absFilename << "\n"
+ std::ostringstream ost;
+ ost << "AutoMoc: Error: " << absFilename << "\n"
<< "The file includes the moc file \"" << incString << "\""
<< ", but does not contain a Q_OBJECT or Q_GADGET "
"macro.\n";
- this->LogWarning(err.str());
+ this->LogWarning(ost.str());
}
} else {
// Don't allow FOO.moc include other than self in strict mode
- std::ostringstream err;
- err << "AutoMoc: Error: " << absFilename << "\n"
+ std::ostringstream ost;
+ ost << "AutoMoc: Error: " << absFilename << "\n"
<< "The file includes the moc file \"" << incString
<< "\", which seems to be the moc file from a different "
"source file. This is not supported. Include \""
<< scannedFileBasename
<< ".moc\" to run moc on this source file.\n";
- this->LogError(err.str());
+ this->LogError(ost.str());
return false;
}
}
@@ -947,8 +941,8 @@ bool cmQtAutoGenerators::MocParseSourceContent(
// But warn, since this is not how it is supposed to be used.
if (relaxed && !ownMocUnderscoreInclude.empty()) {
// This is for KDE4 compatibility:
- std::ostringstream err;
- err << "AutoMoc: Warning: " << absFilename << "\n"
+ std::ostringstream ost;
+ ost << "AutoMoc: Warning: " << absFilename << "\n"
<< "The file contains a " << macroName
<< " macro, but does not include "
<< "\"" << scannedFileBasename << ".moc\", but instead includes "
@@ -957,7 +951,7 @@ bool cmQtAutoGenerators::MocParseSourceContent(
<< "Better include \"" << scannedFileBasename
<< ".moc\" for compatibility with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n";
- this->LogWarning(err.str());
+ this->LogWarning(ost.str());
// Use scanned source file instead of scanned header file as moc source
mocsIncluded[absFilename] = ownMocUnderscoreInclude;
@@ -966,12 +960,12 @@ bool cmQtAutoGenerators::MocParseSourceContent(
mocsIncluded.erase(ownMocUnderscoreHeader);
} else {
// Otherwise always error out since it will not compile:
- std::ostringstream err;
- err << "AutoMoc: Error: " << absFilename << "\n"
+ std::ostringstream ost;
+ ost << "AutoMoc: Error: " << absFilename << "\n"
<< "The file contains a " << macroName
<< " macro, but does not include "
<< "\"" << scannedFileBasename << ".moc\"!\n";
- this->LogError(err.str());
+ this->LogError(ost.str());
return false;
}
}
@@ -986,9 +980,7 @@ void cmQtAutoGenerators::MocParseHeaderContent(
{
// Log
if (this->Verbose) {
- std::ostringstream err;
- err << "AutoMoc: Checking " << absFilename << "\n";
- this->LogInfo(err.str());
+ this->LogInfo("AutoMoc: Checking " + absFilename);
}
if (this->MocRequired(contentText)) {
// Register moc job
@@ -1080,15 +1072,14 @@ bool cmQtAutoGenerators::MocGenerateAll(
std::map<std::string, std::string> mergedMocs(mocsIncluded);
mergedMocs.insert(mocsNotIncluded.begin(), mocsNotIncluded.end());
if (this->NameCollisionTest(mergedMocs, collisions)) {
- std::ostringstream err;
- err << "AutoMoc: Error: "
+ std::ostringstream ost;
+ ost << "AutoMoc: Error: "
"The same moc file will be generated "
- "from different sources."
- << std::endl
- << "To avoid this error either" << std::endl
- << "- rename the source files or" << std::endl
- << "- do not include the (moc_NAME.cpp|NAME.moc) file" << std::endl;
- this->LogErrorNameCollision(err.str(), collisions);
+ "from different sources.\n"
+ "To avoid this error either\n"
+ "- rename the source files or\n"
+ "- do not include the (moc_NAME.cpp|NAME.moc) file";
+ this->LogErrorNameCollision(ost.str(), collisions);
return false;
}
}
@@ -1124,21 +1115,20 @@ bool cmQtAutoGenerators::MocGenerateAll(
// Compose moc_compilation.cpp content
std::string automocSource;
{
- std::ostringstream outStream;
- outStream << "/* This file is autogenerated, do not edit*/\n";
+ std::ostringstream ost;
+ ost << "/* This file is autogenerated, do not edit*/\n";
if (mocsNotIncluded.empty()) {
// Dummy content
- outStream << "enum some_compilers { need_more_than_nothing };\n";
+ ost << "enum some_compilers { need_more_than_nothing };\n";
} else {
// Valid content
for (std::map<std::string, std::string>::const_iterator it =
mocsNotIncluded.begin();
it != mocsNotIncluded.end(); ++it) {
- outStream << "#include \"" << it->second << "\"\n";
+ ost << "#include \"" << it->second << "\"\n";
}
}
- outStream.flush();
- automocSource = outStream.str();
+ automocSource = ost.str();
}
// Check if the content of moc_compilation.cpp changed
@@ -1159,25 +1149,20 @@ bool cmQtAutoGenerators::MocGenerateAll(
outfile.open(this->MocCppFilenameAbs.c_str(), std::ios::trunc);
if (!outfile) {
success = false;
- std::ostringstream err;
- err << "AutoMoc: error opening " << this->MocCppFilenameAbs << "\n";
- this->LogError(err.str());
+ this->LogError("AutoMoc: error opening " + this->MocCppFilenameAbs);
} else {
outfile << automocSource;
// Check for write errors
if (!outfile.good()) {
success = false;
- std::ostringstream err;
- err << "AutoMoc: error writing " << this->MocCppFilenameAbs << "\n";
- this->LogError(err.str());
+ this->LogError("AutoMoc: error writing " + this->MocCppFilenameAbs);
}
}
}
} else if (mocCompFileGenerated) {
// Only touch moc_compilation.cpp
if (this->Verbose) {
- this->LogInfo("Touching MOC compilation " + this->MocCppFilenameRel +
- "\n");
+ this->LogInfo("Touching MOC compilation " + this->MocCppFilenameRel);
}
cmSystemTools::Touch(this->MocCppFilenameAbs, false);
}
@@ -1257,12 +1242,12 @@ bool cmQtAutoGenerators::MocGenerateFile(
if (!res || (retVal != 0)) {
// Command failed
{
- std::ostringstream err;
- err << "AutoMoc: Error: moc process failed for\n";
- err << "\"" << mocFileRel << "\"\n";
- err << "AutoMoc: Command:\n" << cmJoin(cmd, " ") << "\n";
- err << "AutoMoc: Command output:\n" << output << "\n";
- this->LogError(err.str());
+ std::ostringstream ost;
+ ost << "AutoMoc: Error: moc process failed for\n";
+ ost << "\"" << mocFileRel << "\"\n";
+ ost << "AutoMoc: Command:\n" << cmJoin(cmd, " ") << "\n";
+ ost << "AutoMoc: Command output:\n" << output << "\n";
+ this->LogError(ost.str());
}
cmSystemTools::RemoveFile(mocFileAbs);
this->RunMocFailed = true;
@@ -1311,12 +1296,11 @@ bool cmQtAutoGenerators::UicGenerateAll(
{
std::multimap<std::string, std::string> collisions;
if (this->NameCollisionTest(testMap, collisions)) {
- std::ostringstream err;
- err << "AutoUic: Error: The same ui_NAME.h file will be generated "
- "from different sources."
- << std::endl
- << "To avoid this error rename the source files." << std::endl;
- this->LogErrorNameCollision(err.str(), collisions);
+ std::ostringstream ost;
+ ost << "AutoUic: Error: The same ui_NAME.h file will be generated "
+ "from different sources.\n"
+ "To avoid this error rename the source files.\n";
+ this->LogErrorNameCollision(ost.str(), collisions);
return false;
}
}
@@ -1397,13 +1381,13 @@ bool cmQtAutoGenerators::UicGenerateFile(const std::string& realName,
if (!res || (retVal != 0)) {
// Command failed
{
- std::ostringstream err;
- err << "AutoUic: Error: uic process failed for\n";
- err << "\"" << uicFileRel << "\" needed by\n";
- err << "\"" << realName << "\"\n";
- err << "AutoUic: Command:\n" << cmJoin(cmd, " ") << "\n";
- err << "AutoUic: Command output:\n" << output << "\n";
- this->LogError(err.str());
+ std::ostringstream ost;
+ ost << "AutoUic: Error: uic process failed for\n";
+ ost << "\"" << uicFileRel << "\" needed by\n";
+ ost << "\"" << realName << "\"\n";
+ ost << "AutoUic: Command:\n" << cmJoin(cmd, " ") << "\n";
+ ost << "AutoUic: Command output:\n" << output << "\n";
+ this->LogError(ost.str());
}
cmSystemTools::RemoveFile(uicFileAbs);
this->RunUicFailed = true;
@@ -1440,12 +1424,11 @@ bool cmQtAutoGenerators::RccGenerateAll()
{
std::multimap<std::string, std::string> collisions;
if (this->NameCollisionTest(qrcGenMap, collisions)) {
- std::ostringstream err;
- err << "AutoRcc: Error: The same qrc_NAME.cpp file"
- " will be generated from different sources."
- << std::endl
- << "To avoid this error rename the source .qrc files." << std::endl;
- this->LogErrorNameCollision(err.str(), collisions);
+ std::ostringstream ost;
+ ost << "AutoRcc: Error: The same qrc_NAME.cpp file"
+ " will be generated from different sources.\n"
+ "To avoid this error rename the source .qrc files.\n";
+ this->LogErrorNameCollision(ost.str(), collisions);
return false;
}
}
@@ -1537,12 +1520,12 @@ bool cmQtAutoGenerators::RccGenerateFile(const std::string& rccInputFile,
if (!res || (retVal != 0)) {
// Command failed
{
- std::ostringstream err;
- err << "AutoRcc: Error: rcc process failed for\n";
- err << "\"" << rccOutputFile << "\"\n";
- err << "AutoRcc: Command:\n" << cmJoin(cmd, " ") << "\n";
- err << "AutoRcc: Command output:\n" << output << "\n";
- this->LogError(err.str());
+ std::ostringstream ost;
+ ost << "AutoRcc: Error: rcc process failed for\n";
+ ost << "\"" << rccOutputFile << "\"\n";
+ ost << "AutoRcc: Command:\n" << cmJoin(cmd, " ") << "\n";
+ ost << "AutoRcc: Command output:\n" << output << "\n";
+ this->LogError(ost.str());
}
cmSystemTools::RemoveFile(rccBuildFile);
this->RunRccFailed = true;
@@ -1560,18 +1543,23 @@ bool cmQtAutoGenerators::RccGenerateFile(const std::string& rccInputFile,
void cmQtAutoGenerators::LogErrorNameCollision(
const std::string& message,
- const std::multimap<std::string, std::string>& collisions)
+ const std::multimap<std::string, std::string>& collisions) const
{
typedef std::multimap<std::string, std::string>::const_iterator Iter;
- std::ostringstream err;
+ std::ostringstream ost;
// Add message
- err << message;
+ if (!message.empty()) {
+ ost << message;
+ if (message[message.size() - 1] != '\n') {
+ ost << '\n';
+ }
+ }
// Append collision list
for (Iter it = collisions.begin(); it != collisions.end(); ++it) {
- err << it->first << " : " << it->second << std::endl;
+ ost << it->first << " : " << it->second << '\n';
}
- this->LogError(err.str());
+ this->LogError(ost.str());
}
void cmQtAutoGenerators::LogBold(const std::string& message) const
@@ -1583,38 +1571,45 @@ void cmQtAutoGenerators::LogBold(const std::string& message) const
void cmQtAutoGenerators::LogInfo(const std::string& message) const
{
- cmSystemTools::Stdout(message.c_str(), message.size());
+ std::string msg(message);
+ if (!msg.empty()) {
+ if (msg[msg.size() - 1] != '\n') {
+ msg.push_back('\n');
+ }
+ cmSystemTools::Stdout(msg.c_str(), msg.size());
+ }
}
void cmQtAutoGenerators::LogWarning(const std::string& message) const
{
std::string msg(message);
- msg += "\n";
- cmSystemTools::Stdout(msg.c_str(), msg.size());
+ if (!msg.empty()) {
+ if (msg[msg.size() - 1] != '\n') {
+ msg.push_back('\n');
+ }
+ // Append empty line
+ msg.push_back('\n');
+ cmSystemTools::Stdout(msg.c_str(), msg.size());
+ }
}
void cmQtAutoGenerators::LogError(const std::string& message) const
{
std::string msg(message);
- msg += "\n";
- cmSystemTools::Stderr(msg.c_str(), msg.size());
+ if (!msg.empty()) {
+ if (msg[msg.size() - 1] != '\n') {
+ msg.push_back('\n');
+ }
+ // Append empty line
+ msg.push_back('\n');
+ cmSystemTools::Stderr(msg.c_str(), msg.size());
+ }
}
void cmQtAutoGenerators::LogCommand(
const std::vector<std::string>& command) const
{
- std::ostringstream sbuf;
- for (std::vector<std::string>::const_iterator cmdIt = command.begin();
- cmdIt != command.end(); ++cmdIt) {
- if (cmdIt != command.begin()) {
- sbuf << " ";
- }
- sbuf << *cmdIt;
- }
- if (!sbuf.str().empty()) {
- sbuf << std::endl;
- this->LogInfo(sbuf.str());
- }
+ this->LogInfo(cmJoin(command, " "));
}
/**
@@ -1737,7 +1732,7 @@ std::string cmQtAutoGenerators::FindIncludedFile(
return cmsys::SystemTools::GetRealPath(testPath);
}
}
- // Search globaly
+ // Search globally
return FindInIncludeDirectories(includeString);
}
@@ -1765,16 +1760,14 @@ std::string cmQtAutoGenerators::FindInIncludeDirectories(
* @brief Generates the parent directory of the given file on demand
* @return True on success
*/
-bool cmQtAutoGenerators::MakeParentDirectory(const std::string& filename)
+bool cmQtAutoGenerators::MakeParentDirectory(const std::string& filename) const
{
bool success = true;
const std::string dirName = cmSystemTools::GetFilenamePath(filename);
if (!dirName.empty()) {
success = cmsys::SystemTools::MakeDirectory(dirName);
if (!success) {
- std::ostringstream err;
- err << "AutoGen: Directory creation failed: " << dirName << std::endl;
- this->LogError(err.str());
+ this->LogError("AutoGen: Directory creation failed: " + dirName);
}
}
return success;
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index 2242e13..c20b83c 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -124,7 +124,7 @@ private:
// - Logging
void LogErrorNameCollision(
const std::string& message,
- const std::multimap<std::string, std::string>& collisions);
+ const std::multimap<std::string, std::string>& collisions) const;
void LogBold(const std::string& message) const;
void LogInfo(const std::string& message) const;
void LogWarning(const std::string& message) const;
@@ -138,7 +138,7 @@ private:
std::string ChecksumedPath(const std::string& sourceFile,
const char* basePrefix,
const char* baseSuffix) const;
- bool MakeParentDirectory(const std::string& filename);
+ bool MakeParentDirectory(const std::string& filename) const;
bool FindHeader(std::string& header, const std::string& testBasePath) const;
bool FindHeaderGlobal(std::string& header,
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=347572cf5ea2c653cba6150b5e6d6fa083a68cb0
commit 347572cf5ea2c653cba6150b5e6d6fa083a68cb0
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Fri Feb 17 14:47:20 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:55 2017 -0500
Autogen: Only touch an unchanged moc_compilation.cpp
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index 3965503..cd39984 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -1070,6 +1070,9 @@ bool cmQtAutoGenerators::MocGenerateAll(
return true;
}
+ bool mocCompFileGenerated = false;
+ bool mocCompChanged = false;
+
// look for name collisions
{
std::multimap<std::string, std::string> collisions;
@@ -1089,8 +1092,7 @@ bool cmQtAutoGenerators::MocGenerateAll(
return false;
}
}
-
- // generate moc files that are included by source files.
+ // Generate moc files that are included by source files.
{
const std::string subDir = "include/";
for (std::map<std::string, std::string>::const_iterator it =
@@ -1103,16 +1105,14 @@ bool cmQtAutoGenerators::MocGenerateAll(
}
}
}
-
- // generate moc files that are _not_ included by source files.
- bool automocCppChanged = false;
+ // Generate moc files that are _not_ included by source files.
{
const std::string subDir;
for (std::map<std::string, std::string>::const_iterator it =
mocsNotIncluded.begin();
it != mocsNotIncluded.end(); ++it) {
if (this->MocGenerateFile(it->first, it->second, subDir, mocDepends)) {
- automocCppChanged = true;
+ mocCompFileGenerated = true;
} else {
if (this->RunMocFailed) {
return false;
@@ -1141,46 +1141,47 @@ bool cmQtAutoGenerators::MocGenerateAll(
automocSource = outStream.str();
}
- // Check if we even need to update moc_compilation.cpp
- if (!automocCppChanged) {
- // compare contents of the moc_compilation.cpp file
+ // Check if the content of moc_compilation.cpp changed
+ {
const std::string oldContents = ReadAll(this->MocCppFilenameAbs);
- if (oldContents == automocSource) {
- // nothing changed: don't touch the moc_compilation.cpp file
- if (this->Verbose) {
- std::ostringstream err;
- err << "AutoMoc: " << this->MocCppFilenameRel << " still up to date"
- << std::endl;
- this->LogInfo(err.str());
- }
- return true;
- }
+ mocCompChanged = (oldContents != automocSource);
}
- // Actually write moc_compilation.cpp
- this->LogBold("Generating MOC compilation " + this->MocCppFilenameRel);
+ bool success = true;
+ if (mocCompChanged) {
+ // Actually write moc_compilation.cpp
+ this->LogBold("Generating MOC compilation " + this->MocCppFilenameRel);
- // Make sure the parent directory exists
- bool success = this->MakeParentDirectory(this->MocCppFilenameAbs);
- if (success) {
- cmsys::ofstream outfile;
- outfile.open(this->MocCppFilenameAbs.c_str(), std::ios::trunc);
- if (!outfile) {
- success = false;
- std::ostringstream err;
- err << "AutoMoc: error opening " << this->MocCppFilenameAbs << "\n";
- this->LogError(err.str());
- } else {
- outfile << automocSource;
- // Check for write errors
- if (!outfile.good()) {
+ // Make sure the parent directory exists
+ success = this->MakeParentDirectory(this->MocCppFilenameAbs);
+ if (success) {
+ cmsys::ofstream outfile;
+ outfile.open(this->MocCppFilenameAbs.c_str(), std::ios::trunc);
+ if (!outfile) {
success = false;
std::ostringstream err;
- err << "AutoMoc: error writing " << this->MocCppFilenameAbs << "\n";
+ err << "AutoMoc: error opening " << this->MocCppFilenameAbs << "\n";
this->LogError(err.str());
+ } else {
+ outfile << automocSource;
+ // Check for write errors
+ if (!outfile.good()) {
+ success = false;
+ std::ostringstream err;
+ err << "AutoMoc: error writing " << this->MocCppFilenameAbs << "\n";
+ this->LogError(err.str());
+ }
}
}
+ } else if (mocCompFileGenerated) {
+ // Only touch moc_compilation.cpp
+ if (this->Verbose) {
+ this->LogInfo("Touching MOC compilation " + this->MocCppFilenameRel +
+ "\n");
+ }
+ cmSystemTools::Touch(this->MocCppFilenameAbs, false);
}
+
return success;
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=03df033bfa551e83c2a265cc22f6f5278c80528b
commit 03df033bfa551e83c2a265cc22f6f5278c80528b
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Fri Feb 17 11:56:02 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:54 2017 -0500
Autogen: Rebuild moc when Q_PLUGIN_METADATA json file changes
Closes #15419
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index 25a0f87..3965503 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -565,6 +565,16 @@ void cmQtAutoGenerators::Init(cmMakefile* makefile)
this->MocIncludes.push_back(*it);
}
}
+
+ // Insert MocDependFilter for Q_PLUGIN_METADATA
+ if (QtMajorVersion != "4") {
+ MocDependFilter filter;
+ filter.key = "Q_PLUGIN_METADATA";
+ filter.regExp.compile("[\n][ \t]*"
+ "Q_PLUGIN_METADATA[ \t]*\\("
+ "[^\\)]*FILE[ \t]*\"([^\"]+)\"");
+ this->MocDependFilters.push_back(filter);
+ }
}
bool cmQtAutoGenerators::RunAutogen()
@@ -580,6 +590,7 @@ bool cmQtAutoGenerators::RunAutogen()
// key = moc source filepath, value = moc output filepath
std::map<std::string, std::string> mocsIncluded;
std::map<std::string, std::string> mocsNotIncluded;
+ std::map<std::string, std::set<std::string> > mocDepends;
std::map<std::string, std::vector<std::string> > uisIncluded;
// collects all headers which may need to be mocced
std::set<std::string> mocHeaderFiles;
@@ -590,8 +601,8 @@ bool cmQtAutoGenerators::RunAutogen()
it != this->Sources.end(); ++it) {
const std::string& absFilename = cmsys::SystemTools::GetRealPath(*it);
// Parse source file for MOC/UIC
- if (!this->ParseSourceFile(absFilename, mocsIncluded, uisIncluded,
- this->MocRelaxedMode)) {
+ if (!this->ParseSourceFile(absFilename, mocsIncluded, mocDepends,
+ uisIncluded, this->MocRelaxedMode)) {
return false;
}
// Find additional headers
@@ -611,10 +622,10 @@ bool cmQtAutoGenerators::RunAutogen()
}
}
this->ParseHeaders(mocHeaderFiles, uicHeaderFiles, mocsIncluded,
- mocsNotIncluded, uisIncluded);
+ mocsNotIncluded, mocDepends, uisIncluded);
// Generate files
- if (!this->MocGenerateAll(mocsIncluded, mocsNotIncluded)) {
+ if (!this->MocGenerateAll(mocsIncluded, mocsNotIncluded, mocDepends)) {
return false;
}
if (!this->UicGenerateAll(uisIncluded)) {
@@ -631,17 +642,18 @@ bool cmQtAutoGenerators::RunAutogen()
* @brief Tests if the C++ content requires moc processing
* @return True if moc is required
*/
-bool cmQtAutoGenerators::MocRequired(const std::string& text,
+bool cmQtAutoGenerators::MocRequired(const std::string& contentText,
std::string* macroName)
{
for (unsigned int ii = 0; ii != cmArraySize(this->MacroFilters); ++ii) {
- MacroFilter& macroFilter = this->MacroFilters[ii];
- // Run a simple check before an expensive regular expression check
- if (text.find(macroFilter.first) != std::string::npos) {
- if (macroFilter.second.find(text)) {
+ MacroFilter& filter = this->MacroFilters[ii];
+ // Run a simple find string operation before the expensive
+ // regular expression check
+ if (contentText.find(filter.first) != std::string::npos) {
+ if (filter.second.find(contentText)) {
// Return macro name on demand
if (macroName != CM_NULLPTR) {
- *macroName = macroFilter.first;
+ *macroName = filter.first;
}
return true;
}
@@ -650,6 +662,44 @@ bool cmQtAutoGenerators::MocRequired(const std::string& text,
return false;
}
+void cmQtAutoGenerators::MocFindDepends(
+ const std::string& absFilename, const std::string& contentText,
+ std::map<std::string, std::set<std::string> >& mocDepends)
+{
+ for (std::vector<MocDependFilter>::iterator fit =
+ this->MocDependFilters.begin();
+ fit != this->MocDependFilters.end(); ++fit) {
+ MocDependFilter& filter = *fit;
+ // Run a simple find string operation before the expensive
+ // regular expression check
+ if (contentText.find(filter.key) != std::string::npos) {
+ // Run regular expression check loop
+ const char* contentChars = contentText.c_str();
+ while (filter.regExp.find(contentChars)) {
+ // Evaluate match
+ const std::string match = filter.regExp.match(1);
+ if (!match.empty()) {
+ // Find the dependency file
+ const std::string incFile =
+ this->FindIncludedFile(absFilename, match);
+ if (!incFile.empty()) {
+ mocDepends[absFilename].insert(incFile);
+ if (this->Verbose) {
+ this->LogInfo("AutoMoc: Found dependency:\n \"" + absFilename +
+ "\"\n \"" + incFile + "\"\n");
+ }
+ } else {
+ this->LogWarning("AutoMoc: Warning: \"" + absFilename + "\"\n" +
+ "Could not find dependency file \"" + match +
+ "\"\n");
+ }
+ }
+ contentChars += filter.regExp.end();
+ }
+ }
+ }
+}
+
/**
* @brief Tests if the file should be ignored for moc scanning
* @return True if the file should be ignored
@@ -685,11 +735,12 @@ bool cmQtAutoGenerators::UicSkip(const std::string& absFilename) const
bool cmQtAutoGenerators::ParseSourceFile(
const std::string& absFilename,
std::map<std::string, std::string>& mocsIncluded,
+ std::map<std::string, std::set<std::string> >& mocDepends,
std::map<std::string, std::vector<std::string> >& uisIncluded, bool relaxed)
{
bool success = true;
- const std::string contentsString = ReadAll(absFilename);
- if (contentsString.empty()) {
+ const std::string contentText = ReadAll(absFilename);
+ if (contentText.empty()) {
std::ostringstream err;
err << "AutoGen: Warning: " << absFilename << "\n"
<< "The file is empty\n";
@@ -697,19 +748,19 @@ bool cmQtAutoGenerators::ParseSourceFile(
} else {
// Parse source contents for MOC
if (success && !this->MocSkip(absFilename)) {
- success = this->ParseContentForMoc(absFilename, contentsString,
- mocsIncluded, relaxed);
+ success = this->MocParseSourceContent(absFilename, contentText,
+ mocsIncluded, mocDepends, relaxed);
}
// Parse source contents for UIC
if (success && !this->UicSkip(absFilename)) {
- this->ParseContentForUic(absFilename, contentsString, uisIncluded);
+ this->UicParseContent(absFilename, contentText, uisIncluded);
}
}
return success;
}
-void cmQtAutoGenerators::ParseContentForUic(
- const std::string& absFilename, const std::string& contentsString,
+void cmQtAutoGenerators::UicParseContent(
+ const std::string& absFilename, const std::string& contentText,
std::map<std::string, std::vector<std::string> >& uisIncluded)
{
if (this->Verbose) {
@@ -718,7 +769,7 @@ void cmQtAutoGenerators::ParseContentForUic(
this->LogInfo(err.str());
}
- const char* contentChars = contentsString.c_str();
+ const char* contentChars = contentText.c_str();
if (strstr(contentChars, "ui_") != CM_NULLPTR) {
while (this->RegExpUicInclude.find(contentChars)) {
const std::string currentUi = this->RegExpUicInclude.match(1);
@@ -735,9 +786,10 @@ void cmQtAutoGenerators::ParseContentForUic(
/**
* @return True on success
*/
-bool cmQtAutoGenerators::ParseContentForMoc(
- const std::string& absFilename, const std::string& contentsString,
- std::map<std::string, std::string>& mocsIncluded, bool relaxed)
+bool cmQtAutoGenerators::MocParseSourceContent(
+ const std::string& absFilename, const std::string& contentText,
+ std::map<std::string, std::string>& mocsIncluded,
+ std::map<std::string, std::set<std::string> >& mocDepends, bool relaxed)
{
if (this->Verbose) {
std::ostringstream err;
@@ -751,16 +803,15 @@ bool cmQtAutoGenerators::ParseContentForMoc(
cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
std::string macroName;
- const bool requiresMoc = this->MocRequired(contentsString, ¯oName);
+ const bool requiresMoc = this->MocRequired(contentText, ¯oName);
bool ownDotMocIncluded = false;
- bool ownMocUnderscoreIncluded = false;
- std::string ownMocUnderscoreFile;
- std::string ownMocHeaderFile;
+ std::string ownMocUnderscoreInclude;
+ std::string ownMocUnderscoreHeader;
// first a simple string check for "moc" is *much* faster than the regexp,
// and if the string search already fails, we don't have to try the
// expensive regexp
- const char* contentChars = contentsString.c_str();
+ const char* contentChars = contentText.c_str();
if (strstr(contentChars, "moc") != CM_NULLPTR) {
// Iterate over all included moc files
while (this->RegExpMocInclude.find(contentChars)) {
@@ -786,11 +837,13 @@ bool cmQtAutoGenerators::ParseContentForMoc(
const std::string headerToMoc =
this->FindMocHeader(scannedFileAbsPath, incRealBasename, incSubDir);
if (!headerToMoc.empty()) {
+ // Register moc job
mocsIncluded[headerToMoc] = incString;
+ this->MocFindDepends(headerToMoc, contentText, mocDepends);
+ // Store meta information for relaxed mode
if (relaxed && (incRealBasename == scannedFileBasename)) {
- ownMocUnderscoreIncluded = true;
- ownMocUnderscoreFile = incString;
- ownMocHeaderFile = headerToMoc;
+ ownMocUnderscoreInclude = incString;
+ ownMocUnderscoreHeader = headerToMoc;
}
} else {
std::ostringstream err;
@@ -879,6 +932,7 @@ bool cmQtAutoGenerators::ParseContentForMoc(
}
if (!fileToMoc.empty()) {
mocsIncluded[fileToMoc] = incString;
+ this->MocFindDepends(fileToMoc, contentText, mocDepends);
}
}
// Forward content pointer
@@ -891,14 +945,14 @@ bool cmQtAutoGenerators::ParseContentForMoc(
// If this is the case, the moc_foo.cpp should probably be generated from
// foo.cpp instead of foo.h, because otherwise it won't build.
// But warn, since this is not how it is supposed to be used.
- if (relaxed && ownMocUnderscoreIncluded) {
+ if (relaxed && !ownMocUnderscoreInclude.empty()) {
// This is for KDE4 compatibility:
std::ostringstream err;
err << "AutoMoc: Warning: " << absFilename << "\n"
<< "The file contains a " << macroName
<< " macro, but does not include "
<< "\"" << scannedFileBasename << ".moc\", but instead includes "
- << "\"" << ownMocUnderscoreFile << "\".\n"
+ << "\"" << ownMocUnderscoreInclude << "\".\n"
<< "Running moc on \"" << absFilename << "\"!\n"
<< "Better include \"" << scannedFileBasename
<< ".moc\" for compatibility with "
@@ -906,8 +960,10 @@ bool cmQtAutoGenerators::ParseContentForMoc(
this->LogWarning(err.str());
// Use scanned source file instead of scanned header file as moc source
- mocsIncluded[absFilename] = ownMocUnderscoreFile;
- mocsIncluded.erase(ownMocHeaderFile);
+ mocsIncluded[absFilename] = ownMocUnderscoreInclude;
+ this->MocFindDepends(absFilename, contentText, mocDepends);
+ // Remove
+ mocsIncluded.erase(ownMocUnderscoreHeader);
} else {
// Otherwise always error out since it will not compile:
std::ostringstream err;
@@ -923,6 +979,25 @@ bool cmQtAutoGenerators::ParseContentForMoc(
return true;
}
+void cmQtAutoGenerators::MocParseHeaderContent(
+ const std::string& absFilename, const std::string& contentText,
+ std::map<std::string, std::string>& mocsNotIncluded,
+ std::map<std::string, std::set<std::string> >& mocDepends)
+{
+ // Log
+ if (this->Verbose) {
+ std::ostringstream err;
+ err << "AutoMoc: Checking " << absFilename << "\n";
+ this->LogInfo(err.str());
+ }
+ if (this->MocRequired(contentText)) {
+ // Register moc job
+ mocsNotIncluded[absFilename] =
+ this->ChecksumedPath(absFilename, "moc_", ".cpp");
+ this->MocFindDepends(absFilename, contentText, mocDepends);
+ }
+}
+
void cmQtAutoGenerators::SearchHeadersForSourceFile(
const std::string& absFilename, std::set<std::string>& mocHeaderFiles,
std::set<std::string>& uicHeaderFiles) const
@@ -959,6 +1034,7 @@ void cmQtAutoGenerators::ParseHeaders(
const std::set<std::string>& uicHeaderFiles,
const std::map<std::string, std::string>& mocsIncluded,
std::map<std::string, std::string>& mocsNotIncluded,
+ std::map<std::string, std::set<std::string> >& mocDepends,
std::map<std::string, std::vector<std::string> >& uisIncluded)
{
// Merged header files list to read files only once
@@ -969,33 +1045,26 @@ void cmQtAutoGenerators::ParseHeaders(
for (std::set<std::string>::const_iterator hIt = headerFiles.begin();
hIt != headerFiles.end(); ++hIt) {
const std::string& headerName = *hIt;
- const std::string contents = ReadAll(headerName);
+ const std::string contentText = ReadAll(headerName);
// Parse header content for MOC
if ((mocHeaderFiles.find(headerName) != mocHeaderFiles.end()) &&
(mocsIncluded.find(headerName) == mocsIncluded.end())) {
- // Log
- if (this->Verbose) {
- std::ostringstream err;
- err << "AutoMoc: Checking " << headerName << "\n";
- this->LogInfo(err.str());
- }
- if (this->MocRequired(contents)) {
- mocsNotIncluded[headerName] =
- this->ChecksumedPath(headerName, "moc_", ".cpp");
- }
+ this->MocParseHeaderContent(headerName, contentText, mocsNotIncluded,
+ mocDepends);
}
// Parse header content for UIC
if (uicHeaderFiles.find(headerName) != uicHeaderFiles.end()) {
- this->ParseContentForUic(headerName, contents, uisIncluded);
+ this->UicParseContent(headerName, contentText, uisIncluded);
}
}
}
bool cmQtAutoGenerators::MocGenerateAll(
const std::map<std::string, std::string>& mocsIncluded,
- const std::map<std::string, std::string>& mocsNotIncluded)
+ const std::map<std::string, std::string>& mocsNotIncluded,
+ const std::map<std::string, std::set<std::string> >& mocDepends)
{
if (!this->MocEnabled()) {
return true;
@@ -1023,11 +1092,11 @@ bool cmQtAutoGenerators::MocGenerateAll(
// generate moc files that are included by source files.
{
- const std::string subDirPrefix = "include/";
+ const std::string subDir = "include/";
for (std::map<std::string, std::string>::const_iterator it =
mocsIncluded.begin();
it != mocsIncluded.end(); ++it) {
- if (!this->MocGenerateFile(it->first, it->second, subDirPrefix)) {
+ if (!this->MocGenerateFile(it->first, it->second, subDir, mocDepends)) {
if (this->RunMocFailed) {
return false;
}
@@ -1038,11 +1107,11 @@ bool cmQtAutoGenerators::MocGenerateAll(
// generate moc files that are _not_ included by source files.
bool automocCppChanged = false;
{
- const std::string subDirPrefix;
+ const std::string subDir;
for (std::map<std::string, std::string>::const_iterator it =
mocsNotIncluded.begin();
it != mocsNotIncluded.end(); ++it) {
- if (this->MocGenerateFile(it->first, it->second, subDirPrefix)) {
+ if (this->MocGenerateFile(it->first, it->second, subDir, mocDepends)) {
automocCppChanged = true;
} else {
if (this->RunMocFailed) {
@@ -1118,9 +1187,10 @@ bool cmQtAutoGenerators::MocGenerateAll(
/**
* @return True if a moc file was created. False may indicate an error.
*/
-bool cmQtAutoGenerators::MocGenerateFile(const std::string& sourceFile,
- const std::string& mocFileName,
- const std::string& subDirPrefix)
+bool cmQtAutoGenerators::MocGenerateFile(
+ const std::string& sourceFile, const std::string& mocFileName,
+ const std::string& subDirPrefix,
+ const std::map<std::string, std::set<std::string> >& mocDepends)
{
bool mocGenerated = false;
bool generateMoc = this->GenerateAllMoc;
@@ -1132,6 +1202,20 @@ bool cmQtAutoGenerators::MocGenerateFile(const std::string& sourceFile,
if (!generateMoc) {
// Test if the source file is newer that the build file
generateMoc = FileAbsentOrOlder(mocFileAbs, sourceFile);
+ if (!generateMoc) {
+ // Test if a dependency file changed
+ std::map<std::string, std::set<std::string> >::const_iterator dit =
+ mocDepends.find(sourceFile);
+ if (dit != mocDepends.end()) {
+ for (std::set<std::string>::const_iterator fit = dit->second.begin();
+ fit != dit->second.end(); ++fit) {
+ if (FileAbsentOrOlder(mocFileAbs, *fit)) {
+ generateMoc = true;
+ break;
+ }
+ }
+ }
+ }
}
if (generateMoc) {
// Log
@@ -1489,33 +1573,34 @@ void cmQtAutoGenerators::LogErrorNameCollision(
this->LogError(err.str());
}
-void cmQtAutoGenerators::LogBold(const std::string& message)
+void cmQtAutoGenerators::LogBold(const std::string& message) const
{
cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue |
cmsysTerminal_Color_ForegroundBold,
message.c_str(), true, this->ColorOutput);
}
-void cmQtAutoGenerators::LogInfo(const std::string& message)
+void cmQtAutoGenerators::LogInfo(const std::string& message) const
{
cmSystemTools::Stdout(message.c_str(), message.size());
}
-void cmQtAutoGenerators::LogWarning(const std::string& message)
+void cmQtAutoGenerators::LogWarning(const std::string& message) const
{
std::string msg(message);
msg += "\n";
cmSystemTools::Stdout(msg.c_str(), msg.size());
}
-void cmQtAutoGenerators::LogError(const std::string& message)
+void cmQtAutoGenerators::LogError(const std::string& message) const
{
std::string msg(message);
msg += "\n";
cmSystemTools::Stderr(msg.c_str(), msg.size());
}
-void cmQtAutoGenerators::LogCommand(const std::vector<std::string>& command)
+void cmQtAutoGenerators::LogCommand(
+ const std::vector<std::string>& command) const
{
std::ostringstream sbuf;
for (std::vector<std::string>::const_iterator cmdIt = command.begin();
@@ -1639,23 +1724,40 @@ std::string cmQtAutoGenerators::FindMocHeader(const std::string& basePath,
return header;
}
+std::string cmQtAutoGenerators::FindIncludedFile(
+ const std::string& sourceFile, const std::string& includeString) const
+{
+ // Search in vicinity of the source
+ {
+ std::string testPath = cmSystemTools::GetFilenamePath(sourceFile);
+ testPath += '/';
+ testPath += includeString;
+ if (cmsys::SystemTools::FileExists(testPath.c_str())) {
+ return cmsys::SystemTools::GetRealPath(testPath);
+ }
+ }
+ // Search globaly
+ return FindInIncludeDirectories(includeString);
+}
+
/**
* @brief Tries to find a file in the include directories
* @return True on success
*/
-bool cmQtAutoGenerators::FindInIncludeDirectories(
- std::string& file_n, const std::string& searchString) const
+std::string cmQtAutoGenerators::FindInIncludeDirectories(
+ const std::string& includeString) const
{
+ std::string res;
for (std::vector<std::string>::const_iterator iit =
this->MocIncludePaths.begin();
iit != this->MocIncludePaths.end(); ++iit) {
- const std::string fullPath = ((*iit) + '/' + searchString);
+ const std::string fullPath = ((*iit) + '/' + includeString);
if (cmsys::SystemTools::FileExists(fullPath.c_str())) {
- file_n = fullPath;
- return true;
+ res = cmsys::SystemTools::GetRealPath(fullPath);
+ break;
}
}
- return false;
+ return res;
}
/**
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index 6c9c3a8..2242e13 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -22,6 +22,16 @@ public:
bool Run(const std::string& targetDirectory, const std::string& config);
private:
+ // - Types
+
+ /// @brief Used to extract additional dependencies from content text
+ struct MocDependFilter
+ {
+ std::string key;
+ cmsys::RegularExpression regExp;
+ };
+ typedef std::pair<std::string, cmsys::RegularExpression> MacroFilter;
+
// - Configuration
bool ReadAutogenInfoFile(cmMakefile* makefile,
const std::string& targetDirectory,
@@ -47,14 +57,19 @@ private:
bool RunAutogen();
// - Content analysis
- bool MocRequired(const std::string& text,
+ bool MocRequired(const std::string& contentText,
std::string* macroName = CM_NULLPTR);
+ void MocFindDepends(
+ const std::string& absFilename, const std::string& contentText,
+ std::map<std::string, std::set<std::string> >& mocDepends);
+
bool MocSkip(const std::string& absFilename) const;
bool UicSkip(const std::string& absFilename) const;
bool ParseSourceFile(
const std::string& absFilename,
std::map<std::string, std::string>& mocsIncluded,
+ std::map<std::string, std::set<std::string> >& mocDepends,
std::map<std::string, std::vector<std::string> >& includedUis,
bool relaxed);
@@ -67,24 +82,32 @@ private:
const std::set<std::string>& uicHeaderFiles,
const std::map<std::string, std::string>& mocsIncluded,
std::map<std::string, std::string>& mocsNotIncluded,
+ std::map<std::string, std::set<std::string> >& mocDepends,
std::map<std::string, std::vector<std::string> >& includedUis);
- void ParseContentForUic(
- const std::string& fileName, const std::string& contentsString,
+ void UicParseContent(
+ const std::string& fileName, const std::string& contentText,
std::map<std::string, std::vector<std::string> >& includedUis);
- bool ParseContentForMoc(const std::string& absFilename,
- const std::string& contentsString,
- std::map<std::string, std::string>& mocsIncluded,
- bool relaxed);
+ bool MocParseSourceContent(
+ const std::string& absFilename, const std::string& contentText,
+ std::map<std::string, std::string>& mocsIncluded,
+ std::map<std::string, std::set<std::string> >& mocDepends, bool relaxed);
+
+ void MocParseHeaderContent(
+ const std::string& absFilename, const std::string& contentText,
+ std::map<std::string, std::string>& mocsNotIncluded,
+ std::map<std::string, std::set<std::string> >& mocDepends);
// - Moc file generation
bool MocGenerateAll(
const std::map<std::string, std::string>& mocsIncluded,
- const std::map<std::string, std::string>& mocsNotIncluded);
- bool MocGenerateFile(const std::string& sourceFile,
- const std::string& mocFileName,
- const std::string& subDirPrefix);
+ const std::map<std::string, std::string>& mocsNotIncluded,
+ const std::map<std::string, std::set<std::string> >& mocDepends);
+ bool MocGenerateFile(
+ const std::string& sourceFile, const std::string& mocFileName,
+ const std::string& subDirPrefix,
+ const std::map<std::string, std::set<std::string> >& mocDepends);
// - Uic file generation
bool UicGenerateAll(
@@ -102,11 +125,11 @@ private:
void LogErrorNameCollision(
const std::string& message,
const std::multimap<std::string, std::string>& collisions);
- void LogBold(const std::string& message);
- void LogInfo(const std::string& message);
- void LogWarning(const std::string& message);
- void LogError(const std::string& message);
- void LogCommand(const std::vector<std::string>& command);
+ void LogBold(const std::string& message) const;
+ void LogInfo(const std::string& message) const;
+ void LogWarning(const std::string& message) const;
+ void LogError(const std::string& message) const;
+ void LogCommand(const std::vector<std::string>& command) const;
// - Utility
bool NameCollisionTest(
@@ -123,8 +146,9 @@ private:
std::string FindMocHeader(const std::string& basePath,
const std::string& baseName,
const std::string& subDir) const;
- bool FindInIncludeDirectories(std::string& file_n,
- const std::string& searchString) const;
+ std::string FindIncludedFile(const std::string& sourceFile,
+ const std::string& includeString) const;
+ std::string FindInIncludeDirectories(const std::string& includeString) const;
// - Target names
std::string OriginTargetName;
@@ -155,6 +179,7 @@ private:
std::vector<std::string> MocIncludes;
std::vector<std::string> MocDefinitions;
std::vector<std::string> MocOptions;
+ std::vector<MocDependFilter> MocDependFilters;
// - Uic
std::vector<std::string> UicSkipList;
std::vector<std::string> UicTargetOptions;
@@ -166,7 +191,6 @@ private:
// - Utility
cmFilePathChecksum fpathCheckSum;
std::vector<std::string> HeaderExtensions;
- typedef std::pair<std::string, cmsys::RegularExpression> MacroFilter;
MacroFilter MacroFilters[2];
cmsys::RegularExpression RegExpMocInclude;
cmsys::RegularExpression RegExpUicInclude;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=3ec230de1f45f48a8bbb8eca49674f0e0c99dfa1
commit 3ec230de1f45f48a8bbb8eca49674f0e0c99dfa1
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Thu Feb 16 23:55:59 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:54 2017 -0500
Autogen: Use GetRealPath in central places only
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index fcc49d4..25a0f87 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -588,7 +588,7 @@ bool cmQtAutoGenerators::RunAutogen()
// Parse sources
for (std::vector<std::string>::const_iterator it = this->Sources.begin();
it != this->Sources.end(); ++it) {
- const std::string& absFilename = *it;
+ const std::string& absFilename = cmsys::SystemTools::GetRealPath(*it);
// Parse source file for MOC/UIC
if (!this->ParseSourceFile(absFilename, mocsIncluded, uisIncluded,
this->MocRelaxedMode)) {
@@ -602,7 +602,7 @@ bool cmQtAutoGenerators::RunAutogen()
// Parse headers
for (std::vector<std::string>::const_iterator it = this->Headers.begin();
it != this->Headers.end(); ++it) {
- const std::string& headerName = *it;
+ const std::string& headerName = cmsys::SystemTools::GetRealPath(*it);
if (!this->MocSkip(headerName)) {
mocHeaderFiles.insert(headerName);
}
@@ -718,7 +718,6 @@ void cmQtAutoGenerators::ParseContentForUic(
this->LogInfo(err.str());
}
- const std::string realName = cmsys::SystemTools::GetRealPath(absFilename);
const char* contentChars = contentsString.c_str();
if (strstr(contentChars, "ui_") != CM_NULLPTR) {
while (this->RegExpUicInclude.find(contentChars)) {
@@ -727,7 +726,7 @@ void cmQtAutoGenerators::ParseContentForUic(
cmsys::SystemTools::GetFilenameWithoutLastExtension(currentUi);
// basename should be the part of the ui filename used for
// finding the correct header, so we need to remove the ui_ part
- uisIncluded[realName].push_back(basename.substr(3));
+ uisIncluded[absFilename].push_back(basename.substr(3));
contentChars += this->RegExpUicInclude.end();
}
}
@@ -747,9 +746,7 @@ bool cmQtAutoGenerators::ParseContentForMoc(
}
const std::string scannedFileAbsPath =
- cmsys::SystemTools::GetFilenamePath(
- cmsys::SystemTools::GetRealPath(absFilename)) +
- '/';
+ cmsys::SystemTools::GetFilenamePath(absFilename) + '/';
const std::string scannedFileBasename =
cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
@@ -932,33 +929,27 @@ void cmQtAutoGenerators::SearchHeadersForSourceFile(
{
std::string basepaths[2];
{
- std::string bpath = cmsys::SystemTools::GetFilenamePath(
- cmsys::SystemTools::GetRealPath(absFilename));
+ std::string bpath = cmsys::SystemTools::GetFilenamePath(absFilename);
bpath += '/';
bpath += cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
-
// search for default header files and private header files
- basepaths[0] = (bpath + ".");
- basepaths[1] = (bpath + "_p.");
+ basepaths[0] = bpath;
+ basepaths[1] = bpath + "_p";
}
for (const std::string* bpit = cmArrayBegin(basepaths);
bpit != cmArrayEnd(basepaths); ++bpit) {
- for (std::vector<std::string>::const_iterator heit =
- this->HeaderExtensions.begin();
- heit != this->HeaderExtensions.end(); ++heit) {
- const std::string hname = (*bpit) + (*heit);
- if (cmsys::SystemTools::FileExists(hname.c_str())) {
- // Moc headers
- if (!this->MocSkip(absFilename) && !this->MocSkip(hname)) {
- mocHeaderFiles.insert(hname);
- }
- // Uic headers
- if (!this->UicSkip(absFilename) && !this->UicSkip(hname)) {
- uicHeaderFiles.insert(hname);
- }
- break;
+ std::string headerName;
+ if (this->FindHeader(headerName, *bpit)) {
+ // Moc headers
+ if (!this->MocSkip(absFilename) && !this->MocSkip(headerName)) {
+ mocHeaderFiles.insert(headerName);
+ }
+ // Uic headers
+ if (!this->UicSkip(absFilename) && !this->UicSkip(headerName)) {
+ uicHeaderFiles.insert(headerName);
}
+ break;
}
}
}
@@ -1643,7 +1634,7 @@ std::string cmQtAutoGenerators::FindMocHeader(const std::string& basePath,
} while (false);
// Sanitize
if (!header.empty()) {
- header = cmSystemTools::CollapseFullPath(header);
+ header = cmsys::SystemTools::GetRealPath(header);
}
return header;
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=41fb64e719817ce877565e6e11198df2f7e7e63d
commit 41fb64e719817ce877565e6e11198df2f7e7e63d
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Thu Feb 16 22:03:43 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:54 2017 -0500
Autogen: Search moc includes in include directories
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index 0eda4bc..fcc49d4 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -773,7 +773,8 @@ bool cmQtAutoGenerators::ParseContentForMoc(
cmsys::SystemTools::GetFilenameWithoutLastExtension(incString);
std::string incSubDir;
if (incString.find_first_of('/') != std::string::npos) {
- incSubDir = cmsys::SystemTools::GetFilenamePath(incString) + '/';
+ incSubDir = cmsys::SystemTools::GetFilenamePath(incString);
+ incSubDir += '/';
}
// If the moc include is of the moc_foo.cpp style we expect
@@ -785,8 +786,8 @@ bool cmQtAutoGenerators::ParseContentForMoc(
// Include: moc_FOO.cxx
// Remove the moc_ part
const std::string incRealBasename = incBasename.substr(4);
- const std::string headerToMoc = this->FindMatchingHeader(
- scannedFileAbsPath, incRealBasename, incSubDir);
+ const std::string headerToMoc =
+ this->FindMocHeader(scannedFileAbsPath, incRealBasename, incSubDir);
if (!headerToMoc.empty()) {
mocsIncluded[headerToMoc] = incString;
if (relaxed && (incRealBasename == scannedFileBasename)) {
@@ -814,8 +815,8 @@ bool cmQtAutoGenerators::ParseContentForMoc(
ownDotMocIncluded = true;
} else {
// In relaxed mode try to find a header instead but issue a warning
- const std::string headerToMoc = this->FindMatchingHeader(
- scannedFileAbsPath, incBasename, incSubDir);
+ const std::string headerToMoc =
+ this->FindMocHeader(scannedFileAbsPath, incBasename, incSubDir);
if (!headerToMoc.empty()) {
// This is for KDE4 compatibility:
fileToMoc = headerToMoc;
@@ -1607,9 +1608,23 @@ bool cmQtAutoGenerators::FindHeader(std::string& header,
return false;
}
-std::string cmQtAutoGenerators::FindMatchingHeader(
- const std::string& basePath, const std::string& baseName,
- const std::string& subDir) const
+bool cmQtAutoGenerators::FindHeaderGlobal(
+ std::string& header, const std::string& testBasePath) const
+{
+ for (std::vector<std::string>::const_iterator iit =
+ this->MocIncludePaths.begin();
+ iit != this->MocIncludePaths.end(); ++iit) {
+ const std::string fullPath = ((*iit) + '/' + testBasePath);
+ if (FindHeader(header, fullPath)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+std::string cmQtAutoGenerators::FindMocHeader(const std::string& basePath,
+ const std::string& baseName,
+ const std::string& subDir) const
{
std::string header;
do {
@@ -1621,7 +1636,15 @@ std::string cmQtAutoGenerators::FindMatchingHeader(
if (this->FindHeader(header, basePath + baseName)) {
break;
}
+ // Try include directories
+ if (this->FindHeaderGlobal(header, subDir + baseName)) {
+ break;
+ }
} while (false);
+ // Sanitize
+ if (!header.empty()) {
+ header = cmSystemTools::CollapseFullPath(header);
+ }
return header;
}
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index b3c7a3c..6c9c3a8 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -118,9 +118,11 @@ private:
bool MakeParentDirectory(const std::string& filename);
bool FindHeader(std::string& header, const std::string& testBasePath) const;
- std::string FindMatchingHeader(const std::string& basePath,
- const std::string& baseName,
- const std::string& subDir) const;
+ bool FindHeaderGlobal(std::string& header,
+ const std::string& testBasePath) const;
+ std::string FindMocHeader(const std::string& basePath,
+ const std::string& baseName,
+ const std::string& subDir) const;
bool FindInIncludeDirectories(std::string& file_n,
const std::string& searchString) const;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=175c89004425cdbb151d4e85876e2a2076432f28
commit 175c89004425cdbb151d4e85876e2a2076432f28
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Thu Feb 16 21:09:04 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:53 2017 -0500
Autogen: Sort includes before composing include options
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index 62fbe18..0eda4bc 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -510,15 +510,44 @@ void cmQtAutoGenerators::Init(cmMakefile* makefile)
// Acquire header extensions
this->HeaderExtensions = makefile->GetCMakeInstance()->GetHeaderExtensions();
+ // Sort include directories on demand
+ if (this->IncludeProjectDirsBefore) {
+ // Move strings to temporary list
+ std::list<std::string> includes;
+ includes.insert(includes.end(), this->MocIncludePaths.begin(),
+ this->MocIncludePaths.end());
+ this->MocIncludePaths.clear();
+ this->MocIncludePaths.reserve(includes.size());
+ // Append project directories only
+ {
+ const char* movePaths[2] = { this->ProjectBinaryDir.c_str(),
+ this->ProjectSourceDir.c_str() };
+ for (const char* const* mpit = cmArrayBegin(movePaths);
+ mpit != cmArrayEnd(movePaths); ++mpit) {
+ std::list<std::string>::iterator it = includes.begin();
+ while (it != includes.end()) {
+ const std::string& path = *it;
+ if (cmsys::SystemTools::StringStartsWith(path, *mpit)) {
+ this->MocIncludePaths.push_back(path);
+ it = includes.erase(it);
+ } else {
+ ++it;
+ }
+ }
+ }
+ }
+ // Append remaining directories
+ this->MocIncludePaths.insert(this->MocIncludePaths.end(), includes.begin(),
+ includes.end());
+ }
// Compose moc includes list
- std::list<std::string> mocIncludes;
{
std::set<std::string> frameworkPaths;
for (std::vector<std::string>::const_iterator it =
this->MocIncludePaths.begin();
it != this->MocIncludePaths.end(); ++it) {
const std::string& path = *it;
- mocIncludes.push_back("-I" + path);
+ this->MocIncludes.push_back("-I" + path);
// Extract framework path
if (cmHasLiteralSuffix(path, ".framework/Headers")) {
// Go up twice to get to the framework root
@@ -532,40 +561,10 @@ void cmQtAutoGenerators::Init(cmMakefile* makefile)
// Append framework includes
for (std::set<std::string>::const_iterator it = frameworkPaths.begin();
it != frameworkPaths.end(); ++it) {
- mocIncludes.push_back("-F");
- mocIncludes.push_back(*it);
+ this->MocIncludes.push_back("-F");
+ this->MocIncludes.push_back(*it);
}
}
- if (this->IncludeProjectDirsBefore) {
- // Extract project includes
- std::vector<std::string> mocSortedIncludes;
- {
- std::vector<std::string> movePaths;
- movePaths.push_back("-I" + this->ProjectBinaryDir);
- movePaths.push_back("-I" + this->ProjectSourceDir);
-
- for (std::vector<std::string>::const_iterator mpit = movePaths.begin();
- mpit != movePaths.end(); ++mpit) {
- std::list<std::string>::iterator it = mocIncludes.begin();
- while (it != mocIncludes.end()) {
- const std::string& path = *it;
- if (cmsys::SystemTools::StringStartsWith(path, mpit->c_str())) {
- mocSortedIncludes.push_back(path);
- it = mocIncludes.erase(it);
- } else {
- ++it;
- }
- }
- }
- }
- // Place extracted includes at the begin
- this->MocIncludes.insert(this->MocIncludes.end(),
- mocSortedIncludes.begin(),
- mocSortedIncludes.end());
- }
- // Append remaining includes
- this->MocIncludes.insert(this->MocIncludes.end(), mocIncludes.begin(),
- mocIncludes.end());
}
bool cmQtAutoGenerators::RunAutogen()
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=80a007534f6287cd2e88c1b8fd72b68fc688da4e
commit 80a007534f6287cd2e88c1b8fd72b68fc688da4e
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Thu Feb 16 19:47:40 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:53 2017 -0500
Autogen: Add FindInIncludeDirectories method
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index e3d20cf..62fbe18 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -1627,6 +1627,25 @@ std::string cmQtAutoGenerators::FindMatchingHeader(
}
/**
+ * @brief Tries to find a file in the include directories
+ * @return True on success
+ */
+bool cmQtAutoGenerators::FindInIncludeDirectories(
+ std::string& file_n, const std::string& searchString) const
+{
+ for (std::vector<std::string>::const_iterator iit =
+ this->MocIncludePaths.begin();
+ iit != this->MocIncludePaths.end(); ++iit) {
+ const std::string fullPath = ((*iit) + '/' + searchString);
+ if (cmsys::SystemTools::FileExists(fullPath.c_str())) {
+ file_n = fullPath;
+ return true;
+ }
+ }
+ return false;
+}
+
+/**
* @brief Generates the parent directory of the given file on demand
* @return True on success
*/
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index 895c50a..b3c7a3c 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -121,6 +121,8 @@ private:
std::string FindMatchingHeader(const std::string& basePath,
const std::string& baseName,
const std::string& subDir) const;
+ bool FindInIncludeDirectories(std::string& file_n,
+ const std::string& searchString) const;
// - Target names
std::string OriginTargetName;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=f379fdbb9ee17b62ac8b4a8d4b9fab562ba37253
commit f379fdbb9ee17b62ac8b4a8d4b9fab562ba37253
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Thu Feb 16 17:53:19 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:53 2017 -0500
Autogen: Synchronize header/source argument names
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index 8206f23..895c50a 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -54,19 +54,19 @@ private:
bool ParseSourceFile(
const std::string& absFilename,
- std::map<std::string, std::string>& includedMocs,
+ std::map<std::string, std::string>& mocsIncluded,
std::map<std::string, std::vector<std::string> >& includedUis,
bool relaxed);
void SearchHeadersForSourceFile(const std::string& absFilename,
- std::set<std::string>& absHeadersMoc,
- std::set<std::string>& absHeadersUic) const;
+ std::set<std::string>& mocHeaderFiles,
+ std::set<std::string>& uicHeaderFiles) const;
void ParseHeaders(
- const std::set<std::string>& absHeadersMoc,
- const std::set<std::string>& absHeadersUic,
- const std::map<std::string, std::string>& includedMocs,
- std::map<std::string, std::string>& notIncludedMocs,
+ const std::set<std::string>& mocHeaderFiles,
+ const std::set<std::string>& uicHeaderFiles,
+ const std::map<std::string, std::string>& mocsIncluded,
+ std::map<std::string, std::string>& mocsNotIncluded,
std::map<std::string, std::vector<std::string> >& includedUis);
void ParseContentForUic(
@@ -75,13 +75,13 @@ private:
bool ParseContentForMoc(const std::string& absFilename,
const std::string& contentsString,
- std::map<std::string, std::string>& includedMocs,
+ std::map<std::string, std::string>& mocsIncluded,
bool relaxed);
// - Moc file generation
bool MocGenerateAll(
- const std::map<std::string, std::string>& includedMocs,
- const std::map<std::string, std::string>& notIncludedMocs);
+ const std::map<std::string, std::string>& mocsIncluded,
+ const std::map<std::string, std::string>& mocsNotIncluded);
bool MocGenerateFile(const std::string& sourceFile,
const std::string& mocFileName,
const std::string& subDirPrefix);
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=ddf940725e8af095b1c02606aeea64cc9baaf572
commit ddf940725e8af095b1c02606aeea64cc9baaf572
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Thu Feb 16 11:10:46 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:53 2017 -0500
Autogen: Split moc include paths on info reading
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index 8bf41f8..e3d20cf 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -312,8 +312,9 @@ bool cmQtAutoGenerators::ReadAutogenInfoFile(
cmSystemTools::ExpandListArgument(
GetConfigDefinition(makefile, "AM_MOC_COMPILE_DEFINITIONS", config),
this->MocDefinitions);
- this->MocInfoIncludes =
- GetConfigDefinition(makefile, "AM_MOC_INCLUDES", config);
+ cmSystemTools::ExpandListArgument(
+ GetConfigDefinition(makefile, "AM_MOC_INCLUDES", config),
+ this->MocIncludePaths);
cmSystemTools::ExpandListArgument(
makefile->GetSafeDefinition("AM_MOC_OPTIONS"), this->MocOptions);
@@ -411,7 +412,7 @@ void cmQtAutoGenerators::SettingsFileRead(cmMakefile* makefile,
std::string& str = this->SettingsStringMoc;
str += JoinOptionsList(this->MocDefinitions);
str += " ~~~ ";
- str += this->MocInfoIncludes;
+ str += JoinOptionsList(this->MocIncludePaths);
str += " ~~~ ";
str += JoinOptionsList(this->MocOptions);
str += " ~~~ ";
@@ -513,22 +514,19 @@ void cmQtAutoGenerators::Init(cmMakefile* makefile)
std::list<std::string> mocIncludes;
{
std::set<std::string> frameworkPaths;
- {
- std::vector<std::string> incPaths;
- cmSystemTools::ExpandListArgument(this->MocInfoIncludes, incPaths);
- for (std::vector<std::string>::const_iterator it = incPaths.begin();
- it != incPaths.end(); ++it) {
- const std::string& path = *it;
- mocIncludes.push_back("-I" + path);
- // Extract framework path
- if (cmHasLiteralSuffix(path, ".framework/Headers")) {
- // Go up twice to get to the framework root
- std::vector<std::string> pathComponents;
- cmsys::SystemTools::SplitPath(path, pathComponents);
- std::string frameworkPath = cmsys::SystemTools::JoinPath(
- pathComponents.begin(), pathComponents.end() - 2);
- frameworkPaths.insert(frameworkPath);
- }
+ for (std::vector<std::string>::const_iterator it =
+ this->MocIncludePaths.begin();
+ it != this->MocIncludePaths.end(); ++it) {
+ const std::string& path = *it;
+ mocIncludes.push_back("-I" + path);
+ // Extract framework path
+ if (cmHasLiteralSuffix(path, ".framework/Headers")) {
+ // Go up twice to get to the framework root
+ std::vector<std::string> pathComponents;
+ cmsys::SystemTools::SplitPath(path, pathComponents);
+ std::string frameworkPath = cmsys::SystemTools::JoinPath(
+ pathComponents.begin(), pathComponents.end() - 2);
+ frameworkPaths.insert(frameworkPath);
}
}
// Append framework includes
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index 2842660..8206f23 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -144,10 +144,10 @@ private:
std::string SettingsStringUic;
std::string SettingsStringRcc;
// - Moc
- std::string MocInfoIncludes;
std::string MocCppFilenameRel;
std::string MocCppFilenameAbs;
std::vector<std::string> MocSkipList;
+ std::vector<std::string> MocIncludePaths;
std::vector<std::string> MocIncludes;
std::vector<std::string> MocDefinitions;
std::vector<std::string> MocOptions;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=71c5ae253cb5498da319e36bcf49869509b6603c
commit 71c5ae253cb5498da319e36bcf49869509b6603c
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Thu Feb 16 10:31:03 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:52 2017 -0500
Autogen: Loop based macro detection instead of code duplication
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index 4e4ab30..8bf41f8 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -214,9 +214,12 @@ cmQtAutoGenerators::cmQtAutoGenerators()
}
}
+ this->MacroFilters[0].first = "Q_OBJECT";
+ this->MacroFilters[0].second.compile("[\n][ \t]*Q_OBJECT[^a-zA-Z0-9_]");
+ this->MacroFilters[1].first = "Q_GADGET";
+ this->MacroFilters[1].second.compile("[\n][ \t]*Q_GADGET[^a-zA-Z0-9_]");
+
// Precompile regular expressions
- this->RegExpQObject.compile("[\n][ \t]*Q_OBJECT[^a-zA-Z0-9_]");
- this->RegExpQGadget.compile("[\n][ \t]*Q_GADGET[^a-zA-Z0-9_]");
this->RegExpMocInclude.compile(
"[\n][ \t]*#[ \t]*include[ \t]+"
"[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
@@ -632,19 +635,19 @@ bool cmQtAutoGenerators::RunAutogen()
* @return True if moc is required
*/
bool cmQtAutoGenerators::MocRequired(const std::string& text,
- std::string& macroName)
+ std::string* macroName)
{
- // Run a simple check before an expensive regular expression check
- if (strstr(text.c_str(), "Q_OBJECT") != CM_NULLPTR) {
- if (this->RegExpQObject.find(text)) {
- macroName = "Q_OBJECT";
- return true;
- }
- }
- if (strstr(text.c_str(), "Q_GADGET") != CM_NULLPTR) {
- if (this->RegExpQGadget.find(text)) {
- macroName = "Q_GADGET";
- return true;
+ for (unsigned int ii = 0; ii != cmArraySize(this->MacroFilters); ++ii) {
+ MacroFilter& macroFilter = this->MacroFilters[ii];
+ // Run a simple check before an expensive regular expression check
+ if (text.find(macroFilter.first) != std::string::npos) {
+ if (macroFilter.second.find(text)) {
+ // Return macro name on demand
+ if (macroName != CM_NULLPTR) {
+ *macroName = macroFilter.first;
+ }
+ return true;
+ }
}
}
return false;
@@ -754,7 +757,7 @@ bool cmQtAutoGenerators::ParseContentForMoc(
cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
std::string macroName;
- const bool requiresMoc = this->MocRequired(contentsString, macroName);
+ const bool requiresMoc = this->MocRequired(contentsString, ¯oName);
bool ownDotMocIncluded = false;
bool ownMocUnderscoreIncluded = false;
std::string ownMocUnderscoreFile;
@@ -988,8 +991,7 @@ void cmQtAutoGenerators::ParseHeaders(
err << "AutoMoc: Checking " << headerName << "\n";
this->LogInfo(err.str());
}
- std::string macroName;
- if (this->MocRequired(contents, macroName)) {
+ if (this->MocRequired(contents)) {
mocsNotIncluded[headerName] =
this->ChecksumedPath(headerName, "moc_", ".cpp");
}
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index e6f9160..2842660 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -10,6 +10,7 @@
#include <map>
#include <set>
#include <string>
+#include <utility>
#include <vector>
class cmMakefile;
@@ -46,7 +47,8 @@ private:
bool RunAutogen();
// - Content analysis
- bool MocRequired(const std::string& text, std::string& macroName);
+ bool MocRequired(const std::string& text,
+ std::string* macroName = CM_NULLPTR);
bool MocSkip(const std::string& absFilename) const;
bool UicSkip(const std::string& absFilename) const;
@@ -160,8 +162,8 @@ private:
// - Utility
cmFilePathChecksum fpathCheckSum;
std::vector<std::string> HeaderExtensions;
- cmsys::RegularExpression RegExpQObject;
- cmsys::RegularExpression RegExpQGadget;
+ typedef std::pair<std::string, cmsys::RegularExpression> MacroFilter;
+ MacroFilter MacroFilters[2];
cmsys::RegularExpression RegExpMocInclude;
cmsys::RegularExpression RegExpUicInclude;
// - Flags
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=5308f954c9ad13cfc6cc84f1f1255fb5faff48c6
commit 5308f954c9ad13cfc6cc84f1f1255fb5faff48c6
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Wed Feb 15 20:47:58 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:52 2017 -0500
Autogen: Issue a warning if moc isn't required in strict mode
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index 859b2de..4e4ab30 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -857,6 +857,15 @@ bool cmQtAutoGenerators::ParseContentForMoc(
// Include self
fileToMoc = absFilename;
ownDotMocIncluded = true;
+ // Accept but issue a warning if moc isn't required
+ if (!requiresMoc) {
+ std::ostringstream err;
+ err << "AutoMoc: Error: " << absFilename << "\n"
+ << "The file includes the moc file \"" << incString << "\""
+ << ", but does not contain a Q_OBJECT or Q_GADGET "
+ "macro.\n";
+ this->LogWarning(err.str());
+ }
} else {
// Don't allow FOO.moc include other than self in strict mode
std::ostringstream err;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=887e40034161589b63fdb14bfaee7f66374b9b83
commit 887e40034161589b63fdb14bfaee7f66374b9b83
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Wed Feb 15 20:36:39 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:51 2017 -0500
Autogen: Error message tweaks
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index e84b04d..859b2de 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -808,7 +808,12 @@ bool cmQtAutoGenerators::ParseContentForMoc(
std::string fileToMoc;
if (relaxed) {
// Mode: Relaxed
- if (!requiresMoc || (incBasename != scannedFileBasename)) {
+ if (requiresMoc && (incBasename == scannedFileBasename)) {
+ // Include self
+ fileToMoc = absFilename;
+ ownDotMocIncluded = true;
+ } else {
+ // In relaxed mode try to find a header instead but issue a warning
const std::string headerToMoc = this->FindMatchingHeader(
scannedFileAbsPath, incBasename, incSubDir);
if (!headerToMoc.empty()) {
@@ -817,11 +822,10 @@ bool cmQtAutoGenerators::ParseContentForMoc(
if (!requiresMoc && (incBasename == scannedFileBasename)) {
std::ostringstream err;
err << "AutoMoc: Warning: " << absFilename << "\n"
- << "The file includes the moc file \"" << incString
- << "\", but does not contain a " << macroName
- << " macro. Running moc on "
- << "\"" << headerToMoc << "\" ! Include \"moc_"
- << incBasename
+ << "The file includes the moc file \"" << incString << "\""
+ << ", but does not contain a Q_OBJECT or Q_GADGET macro.\n"
+ << "Running moc on \"" << headerToMoc << "\"!\n"
+ << "Include \"moc_" << incBasename
<< ".cpp\" for a compatibility with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n";
this->LogWarning(err.str());
@@ -829,10 +833,9 @@ bool cmQtAutoGenerators::ParseContentForMoc(
std::ostringstream err;
err << "AutoMoc: Warning: " << absFilename << "\n"
<< "The file includes the moc file \"" << incString
- << "\" instead of \"moc_" << incBasename
- << ".cpp\". Running moc on "
- << "\"" << headerToMoc << "\" ! Include \"moc_"
- << incBasename
+ << "\" instead of \"moc_" << incBasename << ".cpp\".\n"
+ << "Running moc on \"" << headerToMoc << "\"!\n"
+ << "Include \"moc_" << incBasename
<< ".cpp\" for compatibility with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n";
this->LogWarning(err.str());
@@ -847,10 +850,6 @@ bool cmQtAutoGenerators::ParseContentForMoc(
this->LogError(err.str());
return false;
}
- } else {
- // Include self
- fileToMoc = absFilename;
- ownDotMocIncluded = true;
}
} else {
// Mode: Strict
@@ -892,9 +891,9 @@ bool cmQtAutoGenerators::ParseContentForMoc(
<< "The file contains a " << macroName
<< " macro, but does not include "
<< "\"" << scannedFileBasename << ".moc\", but instead includes "
- << "\"" << ownMocUnderscoreFile << "\". Running moc on "
- << "\"" << absFilename << "\" ! Better include \""
- << scannedFileBasename
+ << "\"" << ownMocUnderscoreFile << "\".\n"
+ << "Running moc on \"" << absFilename << "\"!\n"
+ << "Better include \"" << scannedFileBasename
<< ".moc\" for compatibility with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n";
this->LogWarning(err.str());
@@ -908,7 +907,7 @@ bool cmQtAutoGenerators::ParseContentForMoc(
err << "AutoMoc: Error: " << absFilename << "\n"
<< "The file contains a " << macroName
<< " macro, but does not include "
- << "\"" << scannedFileBasename << ".moc\" !\n";
+ << "\"" << scannedFileBasename << ".moc\"!\n";
this->LogError(err.str());
return false;
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=4c60099fea2b06229900cc16fed907185c4fe2ef
commit 4c60099fea2b06229900cc16fed907185c4fe2ef
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Wed Feb 15 19:30:08 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:51 2017 -0500
Autogen: Acquire and store header extensions in Init()
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index 97d1299..e84b04d 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -246,9 +246,9 @@ bool cmQtAutoGenerators::Run(const std::string& targetDirectory,
// Read old settings
this->SettingsFileRead(mf.get(), targetDirectory);
// Init and run
- this->Init();
+ this->Init(mf.get());
if (this->QtMajorVersion == "4" || this->QtMajorVersion == "5") {
- if (!this->RunAutogen(mf.get())) {
+ if (!this->RunAutogen()) {
return false;
}
}
@@ -488,7 +488,7 @@ bool cmQtAutoGenerators::SettingsFileWrite(const std::string& targetDirectory)
return success;
}
-void cmQtAutoGenerators::Init()
+void cmQtAutoGenerators::Init(cmMakefile* makefile)
{
this->AutogenBuildSubDir = this->AutogenTargetName;
this->AutogenBuildSubDir += "/";
@@ -503,6 +503,9 @@ void cmQtAutoGenerators::Init()
this->ProjectSourceDir,
this->ProjectBinaryDir);
+ // Acquire header extensions
+ this->HeaderExtensions = makefile->GetCMakeInstance()->GetHeaderExtensions();
+
// Compose moc includes list
std::list<std::string> mocIncludes;
{
@@ -564,7 +567,7 @@ void cmQtAutoGenerators::Init()
mocIncludes.end());
}
-bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
+bool cmQtAutoGenerators::RunAutogen()
{
// the program goes through all .cpp files to see which moc files are
// included. It is not really interesting how the moc file is named, but
@@ -583,22 +586,17 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
std::set<std::string> uicHeaderFiles;
// Parse sources
- {
- const std::vector<std::string>& headerExtensions =
- makefile->GetCMakeInstance()->GetHeaderExtensions();
-
- for (std::vector<std::string>::const_iterator it = this->Sources.begin();
- it != this->Sources.end(); ++it) {
- const std::string& absFilename = *it;
- // Parse source file for MOC/UIC
- if (!this->ParseSourceFile(absFilename, headerExtensions, mocsIncluded,
- uisIncluded, this->MocRelaxedMode)) {
- return false;
- }
- // Find additional headers
- this->SearchHeadersForSourceFile(absFilename, headerExtensions,
- mocHeaderFiles, uicHeaderFiles);
+ for (std::vector<std::string>::const_iterator it = this->Sources.begin();
+ it != this->Sources.end(); ++it) {
+ const std::string& absFilename = *it;
+ // Parse source file for MOC/UIC
+ if (!this->ParseSourceFile(absFilename, mocsIncluded, uisIncluded,
+ this->MocRelaxedMode)) {
+ return false;
}
+ // Find additional headers
+ this->SearchHeadersForSourceFile(absFilename, mocHeaderFiles,
+ uicHeaderFiles);
}
// Parse headers
@@ -656,7 +654,7 @@ bool cmQtAutoGenerators::MocRequired(const std::string& text,
* @brief Tests if the file should be ignored for moc scanning
* @return True if the file should be ignored
*/
-bool cmQtAutoGenerators::MocSkip(const std::string& absFilename)
+bool cmQtAutoGenerators::MocSkip(const std::string& absFilename) const
{
if (this->MocEnabled()) {
// Test if the file name is on the skip list
@@ -670,7 +668,7 @@ bool cmQtAutoGenerators::MocSkip(const std::string& absFilename)
/**
* @brief Tests if the file name is in the skip list
*/
-bool cmQtAutoGenerators::UicSkip(const std::string& absFilename)
+bool cmQtAutoGenerators::UicSkip(const std::string& absFilename) const
{
if (this->UicEnabled()) {
// Test if the file name is on the skip list
@@ -686,7 +684,6 @@ bool cmQtAutoGenerators::UicSkip(const std::string& absFilename)
*/
bool cmQtAutoGenerators::ParseSourceFile(
const std::string& absFilename,
- const std::vector<std::string>& headerExtensions,
std::map<std::string, std::string>& mocsIncluded,
std::map<std::string, std::vector<std::string> >& uisIncluded, bool relaxed)
{
@@ -700,8 +697,8 @@ bool cmQtAutoGenerators::ParseSourceFile(
} else {
// Parse source contents for MOC
if (success && !this->MocSkip(absFilename)) {
- success = this->ParseContentForMoc(
- absFilename, contentsString, headerExtensions, mocsIncluded, relaxed);
+ success = this->ParseContentForMoc(absFilename, contentsString,
+ mocsIncluded, relaxed);
}
// Parse source contents for UIC
if (success && !this->UicSkip(absFilename)) {
@@ -741,7 +738,6 @@ void cmQtAutoGenerators::ParseContentForUic(
*/
bool cmQtAutoGenerators::ParseContentForMoc(
const std::string& absFilename, const std::string& contentsString,
- const std::vector<std::string>& headerExtensions,
std::map<std::string, std::string>& mocsIncluded, bool relaxed)
{
if (this->Verbose) {
@@ -789,8 +785,8 @@ bool cmQtAutoGenerators::ParseContentForMoc(
// Include: moc_FOO.cxx
// Remove the moc_ part
const std::string incRealBasename = incBasename.substr(4);
- const std::string headerToMoc = FindMatchingHeader(
- scannedFileAbsPath, incRealBasename, incSubDir, headerExtensions);
+ const std::string headerToMoc = this->FindMatchingHeader(
+ scannedFileAbsPath, incRealBasename, incSubDir);
if (!headerToMoc.empty()) {
mocsIncluded[headerToMoc] = incString;
if (relaxed && (incRealBasename == scannedFileBasename)) {
@@ -803,7 +799,7 @@ bool cmQtAutoGenerators::ParseContentForMoc(
err << "AutoMoc: Error: " << absFilename << "\n"
<< "The file includes the moc file \"" << incString
<< "\", but could not find header \"" << incRealBasename << '{'
- << JoinExts(headerExtensions) << "}\"\n";
+ << JoinExts(this->HeaderExtensions) << "}\"\n";
this->LogError(err.str());
return false;
}
@@ -813,8 +809,8 @@ bool cmQtAutoGenerators::ParseContentForMoc(
if (relaxed) {
// Mode: Relaxed
if (!requiresMoc || (incBasename != scannedFileBasename)) {
- const std::string headerToMoc = FindMatchingHeader(
- scannedFileAbsPath, incBasename, incSubDir, headerExtensions);
+ const std::string headerToMoc = this->FindMatchingHeader(
+ scannedFileAbsPath, incBasename, incSubDir);
if (!headerToMoc.empty()) {
// This is for KDE4 compatibility:
fileToMoc = headerToMoc;
@@ -922,9 +918,8 @@ bool cmQtAutoGenerators::ParseContentForMoc(
}
void cmQtAutoGenerators::SearchHeadersForSourceFile(
- const std::string& absFilename,
- const std::vector<std::string>& headerExtensions,
- std::set<std::string>& mocHeaderFiles, std::set<std::string>& uicHeaderFiles)
+ const std::string& absFilename, std::set<std::string>& mocHeaderFiles,
+ std::set<std::string>& uicHeaderFiles) const
{
std::string basepaths[2];
{
@@ -941,8 +936,8 @@ void cmQtAutoGenerators::SearchHeadersForSourceFile(
for (const std::string* bpit = cmArrayBegin(basepaths);
bpit != cmArrayEnd(basepaths); ++bpit) {
for (std::vector<std::string>::const_iterator heit =
- headerExtensions.begin();
- heit != headerExtensions.end(); ++heit) {
+ this->HeaderExtensions.begin();
+ heit != this->HeaderExtensions.end(); ++heit) {
const std::string hname = (*bpit) + (*heit);
if (cmsys::SystemTools::FileExists(hname.c_str())) {
// Moc headers
@@ -1588,12 +1583,12 @@ std::string cmQtAutoGenerators::ChecksumedPath(const std::string& sourceFile,
* appending different header extensions
* @return True on success
*/
-bool cmQtAutoGenerators::FindHeader(
- std::string& header, const std::string& testBasePath,
- const std::vector<std::string>& headerExtensions) const
+bool cmQtAutoGenerators::FindHeader(std::string& header,
+ const std::string& testBasePath) const
{
- for (std::vector<std::string>::const_iterator ext = headerExtensions.begin();
- ext != headerExtensions.end(); ++ext) {
+ for (std::vector<std::string>::const_iterator ext =
+ this->HeaderExtensions.begin();
+ ext != this->HeaderExtensions.end(); ++ext) {
std::string testFilePath(testBasePath);
testFilePath += '.';
testFilePath += (*ext);
@@ -1607,17 +1602,16 @@ bool cmQtAutoGenerators::FindHeader(
std::string cmQtAutoGenerators::FindMatchingHeader(
const std::string& basePath, const std::string& baseName,
- const std::string& subDir,
- const std::vector<std::string>& headerExtensions) const
+ const std::string& subDir) const
{
std::string header;
do {
if (!subDir.empty()) {
- if (FindHeader(header, basePath + subDir + baseName, headerExtensions)) {
+ if (this->FindHeader(header, basePath + subDir + baseName)) {
break;
}
}
- if (FindHeader(header, basePath + baseName, headerExtensions)) {
+ if (this->FindHeader(header, basePath + baseName)) {
break;
}
} while (false);
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index 50df9f8..e6f9160 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -42,26 +42,23 @@ private:
}
// - Init and run
- void Init();
- bool RunAutogen(cmMakefile* makefile);
+ void Init(cmMakefile* makefile);
+ bool RunAutogen();
// - Content analysis
bool MocRequired(const std::string& text, std::string& macroName);
- bool MocSkip(const std::string& absFilename);
- bool UicSkip(const std::string& absFilename);
+ bool MocSkip(const std::string& absFilename) const;
+ bool UicSkip(const std::string& absFilename) const;
bool ParseSourceFile(
const std::string& absFilename,
- const std::vector<std::string>& headerExtensions,
std::map<std::string, std::string>& includedMocs,
std::map<std::string, std::vector<std::string> >& includedUis,
bool relaxed);
- void SearchHeadersForSourceFile(
- const std::string& absFilename,
- const std::vector<std::string>& headerExtensions,
- std::set<std::string>& absHeadersMoc,
- std::set<std::string>& absHeadersUic);
+ void SearchHeadersForSourceFile(const std::string& absFilename,
+ std::set<std::string>& absHeadersMoc,
+ std::set<std::string>& absHeadersUic) const;
void ParseHeaders(
const std::set<std::string>& absHeadersMoc,
@@ -76,7 +73,6 @@ private:
bool ParseContentForMoc(const std::string& absFilename,
const std::string& contentsString,
- const std::vector<std::string>& headerExtensions,
std::map<std::string, std::string>& includedMocs,
bool relaxed);
@@ -119,12 +115,10 @@ private:
const char* baseSuffix) const;
bool MakeParentDirectory(const std::string& filename);
- bool FindHeader(std::string& header, const std::string& testBasePath,
- const std::vector<std::string>& headerExtensions) const;
- std::string FindMatchingHeader(
- const std::string& basePath, const std::string& baseName,
- const std::string& subDir,
- const std::vector<std::string>& headerExtensions) const;
+ bool FindHeader(std::string& header, const std::string& testBasePath) const;
+ std::string FindMatchingHeader(const std::string& basePath,
+ const std::string& baseName,
+ const std::string& subDir) const;
// - Target names
std::string OriginTargetName;
@@ -165,6 +159,7 @@ private:
std::map<std::string, std::vector<std::string> > RccInputs;
// - Utility
cmFilePathChecksum fpathCheckSum;
+ std::vector<std::string> HeaderExtensions;
cmsys::RegularExpression RegExpQObject;
cmsys::RegularExpression RegExpQGadget;
cmsys::RegularExpression RegExpMocInclude;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=815a05cf12499b42acea70b5a9534e10e1701417
commit 815a05cf12499b42acea70b5a9534e10e1701417
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Wed Feb 15 19:19:37 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:51 2017 -0500
Autogen: Overhaul FindMatchingHeader function
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index 580265b..97d1299 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -74,42 +74,6 @@ static void SettingWrite(std::ostream& ostr, const char* key,
}
}
-static std::string FindMatchingHeader(
- const std::string& absPath, const std::string& mocSubDir,
- const std::string& basename,
- const std::vector<std::string>& headerExtensions)
-{
- std::string header;
- for (std::vector<std::string>::const_iterator ext = headerExtensions.begin();
- ext != headerExtensions.end(); ++ext) {
- std::string sourceFilePath = absPath + basename + "." + (*ext);
- if (cmsys::SystemTools::FileExists(sourceFilePath.c_str())) {
- header = sourceFilePath;
- break;
- }
- // Try subdirectory instead
- if (!mocSubDir.empty()) {
- sourceFilePath = mocSubDir + basename + "." + (*ext);
- if (cmsys::SystemTools::FileExists(sourceFilePath.c_str())) {
- header = sourceFilePath;
- break;
- }
- }
- }
-
- return header;
-}
-
-static std::string ExtractSubDir(const std::string& absPath,
- const std::string& currentMoc)
-{
- std::string subDir;
- if (currentMoc.find_first_of('/') != std::string::npos) {
- subDir = absPath + cmsys::SystemTools::GetFilenamePath(currentMoc) + '/';
- }
- return subDir;
-}
-
static bool FileNameIsUnique(const std::string& filePath,
const std::map<std::string, std::string>& fileMap)
{
@@ -807,38 +771,38 @@ bool cmQtAutoGenerators::ParseContentForMoc(
if (strstr(contentChars, "moc") != CM_NULLPTR) {
// Iterate over all included moc files
while (this->RegExpMocInclude.find(contentChars)) {
- const std::string currentMoc = this->RegExpMocInclude.match(1);
- // Basename of the current moc include
- std::string basename =
- cmsys::SystemTools::GetFilenameWithoutLastExtension(currentMoc);
+ const std::string incString = this->RegExpMocInclude.match(1);
+ // Basename of the moc include
+ const std::string incBasename =
+ cmsys::SystemTools::GetFilenameWithoutLastExtension(incString);
+ std::string incSubDir;
+ if (incString.find_first_of('/') != std::string::npos) {
+ incSubDir = cmsys::SystemTools::GetFilenamePath(incString) + '/';
+ }
// If the moc include is of the moc_foo.cpp style we expect
// the Q_OBJECT class declaration in a header file.
// If the moc include is of the foo.moc style we need to look for
// a Q_OBJECT macro in the current source file, if it contains the
// macro we generate the moc file from the source file.
- if (cmHasLiteralPrefix(basename, "moc_")) {
+ if (cmHasLiteralPrefix(incBasename, "moc_")) {
// Include: moc_FOO.cxx
- // basename should be the part of the moc filename used for
- // finding the correct header, so we need to remove the moc_ part
- basename = basename.substr(4);
- const std::string mocSubDir =
- ExtractSubDir(scannedFileAbsPath, currentMoc);
+ // Remove the moc_ part
+ const std::string incRealBasename = incBasename.substr(4);
const std::string headerToMoc = FindMatchingHeader(
- scannedFileAbsPath, mocSubDir, basename, headerExtensions);
-
+ scannedFileAbsPath, incRealBasename, incSubDir, headerExtensions);
if (!headerToMoc.empty()) {
- mocsIncluded[headerToMoc] = currentMoc;
- if (relaxed && (basename == scannedFileBasename)) {
+ mocsIncluded[headerToMoc] = incString;
+ if (relaxed && (incRealBasename == scannedFileBasename)) {
ownMocUnderscoreIncluded = true;
- ownMocUnderscoreFile = currentMoc;
+ ownMocUnderscoreFile = incString;
ownMocHeaderFile = headerToMoc;
}
} else {
std::ostringstream err;
err << "AutoMoc: Error: " << absFilename << "\n"
- << "The file includes the moc file \"" << currentMoc
- << "\", but could not find header \"" << basename << '{'
+ << "The file includes the moc file \"" << incString
+ << "\", but could not find header \"" << incRealBasename << '{'
<< JoinExts(headerExtensions) << "}\"\n";
this->LogError(err.str());
return false;
@@ -848,31 +812,31 @@ bool cmQtAutoGenerators::ParseContentForMoc(
std::string fileToMoc;
if (relaxed) {
// Mode: Relaxed
- if (!requiresMoc || basename != scannedFileBasename) {
- const std::string mocSubDir =
- ExtractSubDir(scannedFileAbsPath, currentMoc);
+ if (!requiresMoc || (incBasename != scannedFileBasename)) {
const std::string headerToMoc = FindMatchingHeader(
- scannedFileAbsPath, mocSubDir, basename, headerExtensions);
+ scannedFileAbsPath, incBasename, incSubDir, headerExtensions);
if (!headerToMoc.empty()) {
// This is for KDE4 compatibility:
fileToMoc = headerToMoc;
- if (!requiresMoc && basename == scannedFileBasename) {
+ if (!requiresMoc && (incBasename == scannedFileBasename)) {
std::ostringstream err;
err << "AutoMoc: Warning: " << absFilename << "\n"
- << "The file includes the moc file \"" << currentMoc
+ << "The file includes the moc file \"" << incString
<< "\", but does not contain a " << macroName
<< " macro. Running moc on "
- << "\"" << headerToMoc << "\" ! Include \"moc_" << basename
+ << "\"" << headerToMoc << "\" ! Include \"moc_"
+ << incBasename
<< ".cpp\" for a compatibility with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n";
this->LogWarning(err.str());
} else {
std::ostringstream err;
err << "AutoMoc: Warning: " << absFilename << "\n"
- << "The file includes the moc file \"" << currentMoc
- << "\" instead of \"moc_" << basename
+ << "The file includes the moc file \"" << incString
+ << "\" instead of \"moc_" << incBasename
<< ".cpp\". Running moc on "
- << "\"" << headerToMoc << "\" ! Include \"moc_" << basename
+ << "\"" << headerToMoc << "\" ! Include \"moc_"
+ << incBasename
<< ".cpp\" for compatibility with "
"strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n";
this->LogWarning(err.str());
@@ -880,7 +844,7 @@ bool cmQtAutoGenerators::ParseContentForMoc(
} else {
std::ostringstream err;
err << "AutoMoc: Error: " << absFilename << "\n"
- << "The file includes the moc file \"" << currentMoc
+ << "The file includes the moc file \"" << incString
<< "\", which seems to be the moc file from a different "
"source file. CMake also could not find a matching "
"header.\n";
@@ -894,7 +858,7 @@ bool cmQtAutoGenerators::ParseContentForMoc(
}
} else {
// Mode: Strict
- if (basename == scannedFileBasename) {
+ if (incBasename == scannedFileBasename) {
// Include self
fileToMoc = absFilename;
ownDotMocIncluded = true;
@@ -902,7 +866,7 @@ bool cmQtAutoGenerators::ParseContentForMoc(
// Don't allow FOO.moc include other than self in strict mode
std::ostringstream err;
err << "AutoMoc: Error: " << absFilename << "\n"
- << "The file includes the moc file \"" << currentMoc
+ << "The file includes the moc file \"" << incString
<< "\", which seems to be the moc file from a different "
"source file. This is not supported. Include \""
<< scannedFileBasename
@@ -912,7 +876,7 @@ bool cmQtAutoGenerators::ParseContentForMoc(
}
}
if (!fileToMoc.empty()) {
- mocsIncluded[fileToMoc] = currentMoc;
+ mocsIncluded[fileToMoc] = incString;
}
}
// Forward content pointer
@@ -920,11 +884,11 @@ bool cmQtAutoGenerators::ParseContentForMoc(
}
}
- // In this case, check whether the scanned file itself contains a Q_OBJECT.
- // If this is the case, the moc_foo.cpp should probably be generated from
- // foo.cpp instead of foo.h, because otherwise it won't build.
- // But warn, since this is not how it is supposed to be used.
if (requiresMoc && !ownDotMocIncluded) {
+ // In this case, check whether the scanned file itself contains a Q_OBJECT.
+ // If this is the case, the moc_foo.cpp should probably be generated from
+ // foo.cpp instead of foo.h, because otherwise it won't build.
+ // But warn, since this is not how it is supposed to be used.
if (relaxed && ownMocUnderscoreIncluded) {
// This is for KDE4 compatibility:
std::ostringstream err;
@@ -1620,6 +1584,47 @@ std::string cmQtAutoGenerators::ChecksumedPath(const std::string& sourceFile,
}
/**
+ * @brief Tries to find the header file to the given file base path by
+ * appending different header extensions
+ * @return True on success
+ */
+bool cmQtAutoGenerators::FindHeader(
+ std::string& header, const std::string& testBasePath,
+ const std::vector<std::string>& headerExtensions) const
+{
+ for (std::vector<std::string>::const_iterator ext = headerExtensions.begin();
+ ext != headerExtensions.end(); ++ext) {
+ std::string testFilePath(testBasePath);
+ testFilePath += '.';
+ testFilePath += (*ext);
+ if (cmsys::SystemTools::FileExists(testFilePath.c_str())) {
+ header = testFilePath;
+ return true;
+ }
+ }
+ return false;
+}
+
+std::string cmQtAutoGenerators::FindMatchingHeader(
+ const std::string& basePath, const std::string& baseName,
+ const std::string& subDir,
+ const std::vector<std::string>& headerExtensions) const
+{
+ std::string header;
+ do {
+ if (!subDir.empty()) {
+ if (FindHeader(header, basePath + subDir + baseName, headerExtensions)) {
+ break;
+ }
+ }
+ if (FindHeader(header, basePath + baseName, headerExtensions)) {
+ break;
+ }
+ } while (false);
+ return header;
+}
+
+/**
* @brief Generates the parent directory of the given file on demand
* @return True on success
*/
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index a466b77..50df9f8 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -119,6 +119,13 @@ private:
const char* baseSuffix) const;
bool MakeParentDirectory(const std::string& filename);
+ bool FindHeader(std::string& header, const std::string& testBasePath,
+ const std::vector<std::string>& headerExtensions) const;
+ std::string FindMatchingHeader(
+ const std::string& basePath, const std::string& baseName,
+ const std::string& subDir,
+ const std::vector<std::string>& headerExtensions) const;
+
// - Target names
std::string OriginTargetName;
std::string AutogenTargetName;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=3270091210c0cfdddb133209b232a1d0a1fa48da
commit 3270091210c0cfdddb133209b232a1d0a1fa48da
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Wed Feb 15 17:36:58 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:50 2017 -0500
Autogen: Don't list all search paths in error message
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index ddf8bf1..580265b 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -839,13 +839,7 @@ bool cmQtAutoGenerators::ParseContentForMoc(
err << "AutoMoc: Error: " << absFilename << "\n"
<< "The file includes the moc file \"" << currentMoc
<< "\", but could not find header \"" << basename << '{'
- << JoinExts(headerExtensions) << "}\" ";
- if (mocSubDir.empty()) {
- err << "in " << scannedFileAbsPath << "\n";
- } else {
- err << "neither in " << scannedFileAbsPath << " nor in "
- << mocSubDir << "\n";
- }
+ << JoinExts(headerExtensions) << "}\"\n";
this->LogError(err.str());
return false;
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=793c9a7925dfa3aaa2b15212f4ba0246d1fbf83c
commit 793c9a7925dfa3aaa2b15212f4ba0246d1fbf83c
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Wed Feb 15 13:43:19 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:50 2017 -0500
Autogen: Indentation fix
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index ee3dc10..ddf8bf1 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -608,8 +608,7 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
// may not be included in the moc_compilation.cpp file anymore. OTOH if
// there's a header containing Q_OBJECT where no corresponding moc file
// is included anywhere a moc_<filename>.cpp file is created and included
- // in
- // the moc_compilation.cpp file.
+ // in the moc_compilation.cpp file.
// key = moc source filepath, value = moc output filepath
std::map<std::string, std::string> mocsIncluded;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=25dbfbc2a937379ca78328dfabdf54043340dbd3
commit 25dbfbc2a937379ca78328dfabdf54043340dbd3
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Wed Feb 15 13:23:27 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:50 2017 -0500
Autogen: Rename moc related variables
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index f67543f..ee3dc10 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -529,11 +529,10 @@ void cmQtAutoGenerators::Init()
this->AutogenBuildSubDir = this->AutogenTargetName;
this->AutogenBuildSubDir += "/";
- this->OutMocCppFilenameRel = this->AutogenBuildSubDir;
- this->OutMocCppFilenameRel += "moc_compilation.cpp";
+ this->MocCppFilenameRel = this->AutogenBuildSubDir;
+ this->MocCppFilenameRel += "moc_compilation.cpp";
- this->OutMocCppFilenameAbs =
- this->CurrentBinaryDir + this->OutMocCppFilenameRel;
+ this->MocCppFilenameAbs = this->CurrentBinaryDir + this->MocCppFilenameRel;
// Init file path checksum generator
fpathCheckSum.setupParentDirs(this->CurrentSourceDir, this->CurrentBinaryDir,
@@ -1125,12 +1124,12 @@ bool cmQtAutoGenerators::MocGenerateAll(
// Check if we even need to update moc_compilation.cpp
if (!automocCppChanged) {
// compare contents of the moc_compilation.cpp file
- const std::string oldContents = ReadAll(this->OutMocCppFilenameAbs);
+ const std::string oldContents = ReadAll(this->MocCppFilenameAbs);
if (oldContents == automocSource) {
// nothing changed: don't touch the moc_compilation.cpp file
if (this->Verbose) {
std::ostringstream err;
- err << "AutoMoc: " << this->OutMocCppFilenameRel << " still up to date"
+ err << "AutoMoc: " << this->MocCppFilenameRel << " still up to date"
<< std::endl;
this->LogInfo(err.str());
}
@@ -1139,17 +1138,17 @@ bool cmQtAutoGenerators::MocGenerateAll(
}
// Actually write moc_compilation.cpp
- this->LogBold("Generating MOC compilation " + this->OutMocCppFilenameRel);
+ this->LogBold("Generating MOC compilation " + this->MocCppFilenameRel);
// Make sure the parent directory exists
- bool success = this->MakeParentDirectory(this->OutMocCppFilenameAbs);
+ bool success = this->MakeParentDirectory(this->MocCppFilenameAbs);
if (success) {
cmsys::ofstream outfile;
- outfile.open(this->OutMocCppFilenameAbs.c_str(), std::ios::trunc);
+ outfile.open(this->MocCppFilenameAbs.c_str(), std::ios::trunc);
if (!outfile) {
success = false;
std::ostringstream err;
- err << "AutoMoc: error opening " << this->OutMocCppFilenameAbs << "\n";
+ err << "AutoMoc: error opening " << this->MocCppFilenameAbs << "\n";
this->LogError(err.str());
} else {
outfile << automocSource;
@@ -1157,7 +1156,7 @@ bool cmQtAutoGenerators::MocGenerateAll(
if (!outfile.good()) {
success = false;
std::ostringstream err;
- err << "AutoMoc: error writing " << this->OutMocCppFilenameAbs << "\n";
+ err << "AutoMoc: error writing " << this->MocCppFilenameAbs << "\n";
this->LogError(err.str());
}
}
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index f6caed9..a466b77 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -141,10 +141,10 @@ private:
std::string SettingsStringUic;
std::string SettingsStringRcc;
// - Moc
- std::vector<std::string> MocSkipList;
std::string MocInfoIncludes;
- std::string OutMocCppFilenameRel;
- std::string OutMocCppFilenameAbs;
+ std::string MocCppFilenameRel;
+ std::string MocCppFilenameAbs;
+ std::vector<std::string> MocSkipList;
std::vector<std::string> MocIncludes;
std::vector<std::string> MocDefinitions;
std::vector<std::string> MocOptions;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=3cc42863a43cd4256efdeb2eda2d235d5533bad9
commit 3cc42863a43cd4256efdeb2eda2d235d5533bad9
Author: Sebastian Holtermann <sebholt at xwmw.org>
AuthorDate: Wed Feb 15 12:53:39 2017 +0100
Commit: Brad King <brad.king at kitware.com>
CommitDate: Tue Feb 21 10:12:49 2017 -0500
Autogen: Overhaul moc include list generation
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index a167705..f67543f 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -7,6 +7,7 @@
#include <cmConfigure.h>
#include <cmsys/FStream.hxx>
#include <cmsys/Terminal.h>
+#include <list>
#include <sstream>
#include <stdlib.h>
#include <string.h>
@@ -539,58 +540,65 @@ void cmQtAutoGenerators::Init()
this->ProjectSourceDir,
this->ProjectBinaryDir);
- std::vector<std::string> incPaths;
- cmSystemTools::ExpandListArgument(this->MocInfoIncludes, incPaths);
-
- std::set<std::string> frameworkPaths;
- for (std::vector<std::string>::const_iterator it = incPaths.begin();
- it != incPaths.end(); ++it) {
- const std::string& path = *it;
- this->MocIncludes.push_back("-I" + path);
- if (cmHasLiteralSuffix(path, ".framework/Headers")) {
- // Go up twice to get to the framework root
- std::vector<std::string> pathComponents;
- cmsys::SystemTools::SplitPath(path, pathComponents);
- std::string frameworkPath = cmsys::SystemTools::JoinPath(
- pathComponents.begin(), pathComponents.end() - 2);
- frameworkPaths.insert(frameworkPath);
+ // Compose moc includes list
+ std::list<std::string> mocIncludes;
+ {
+ std::set<std::string> frameworkPaths;
+ {
+ std::vector<std::string> incPaths;
+ cmSystemTools::ExpandListArgument(this->MocInfoIncludes, incPaths);
+ for (std::vector<std::string>::const_iterator it = incPaths.begin();
+ it != incPaths.end(); ++it) {
+ const std::string& path = *it;
+ mocIncludes.push_back("-I" + path);
+ // Extract framework path
+ if (cmHasLiteralSuffix(path, ".framework/Headers")) {
+ // Go up twice to get to the framework root
+ std::vector<std::string> pathComponents;
+ cmsys::SystemTools::SplitPath(path, pathComponents);
+ std::string frameworkPath = cmsys::SystemTools::JoinPath(
+ pathComponents.begin(), pathComponents.end() - 2);
+ frameworkPaths.insert(frameworkPath);
+ }
+ }
+ }
+ // Append framework includes
+ for (std::set<std::string>::const_iterator it = frameworkPaths.begin();
+ it != frameworkPaths.end(); ++it) {
+ mocIncludes.push_back("-F");
+ mocIncludes.push_back(*it);
}
}
-
- for (std::set<std::string>::const_iterator it = frameworkPaths.begin();
- it != frameworkPaths.end(); ++it) {
- this->MocIncludes.push_back("-F");
- this->MocIncludes.push_back(*it);
- }
-
if (this->IncludeProjectDirsBefore) {
- const std::string binDir = "-I" + this->ProjectBinaryDir;
- const std::string srcDir = "-I" + this->ProjectSourceDir;
-
- std::list<std::string> sortedMocIncludes;
- std::list<std::string>::iterator it = this->MocIncludes.begin();
- while (it != this->MocIncludes.end()) {
- if (cmsys::SystemTools::StringStartsWith(*it, binDir.c_str())) {
- sortedMocIncludes.push_back(*it);
- it = this->MocIncludes.erase(it);
- } else {
- ++it;
- }
- }
- it = this->MocIncludes.begin();
- while (it != this->MocIncludes.end()) {
- if (cmsys::SystemTools::StringStartsWith(*it, srcDir.c_str())) {
- sortedMocIncludes.push_back(*it);
- it = this->MocIncludes.erase(it);
- } else {
- ++it;
+ // Extract project includes
+ std::vector<std::string> mocSortedIncludes;
+ {
+ std::vector<std::string> movePaths;
+ movePaths.push_back("-I" + this->ProjectBinaryDir);
+ movePaths.push_back("-I" + this->ProjectSourceDir);
+
+ for (std::vector<std::string>::const_iterator mpit = movePaths.begin();
+ mpit != movePaths.end(); ++mpit) {
+ std::list<std::string>::iterator it = mocIncludes.begin();
+ while (it != mocIncludes.end()) {
+ const std::string& path = *it;
+ if (cmsys::SystemTools::StringStartsWith(path, mpit->c_str())) {
+ mocSortedIncludes.push_back(path);
+ it = mocIncludes.erase(it);
+ } else {
+ ++it;
+ }
+ }
}
}
- sortedMocIncludes.insert(sortedMocIncludes.end(),
- this->MocIncludes.begin(),
- this->MocIncludes.end());
- this->MocIncludes = sortedMocIncludes;
- }
+ // Place extracted includes at the begin
+ this->MocIncludes.insert(this->MocIncludes.end(),
+ mocSortedIncludes.begin(),
+ mocSortedIncludes.end());
+ }
+ // Append remaining includes
+ this->MocIncludes.insert(this->MocIncludes.end(), mocIncludes.begin(),
+ mocIncludes.end());
}
bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index e60320b..f6caed9 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -7,7 +7,6 @@
#include <cmFilePathChecksum.h>
#include <cmsys/RegularExpression.hxx>
-#include <list>
#include <map>
#include <set>
#include <string>
@@ -146,7 +145,7 @@ private:
std::string MocInfoIncludes;
std::string OutMocCppFilenameRel;
std::string OutMocCppFilenameAbs;
- std::list<std::string> MocIncludes;
+ std::vector<std::string> MocIncludes;
std::vector<std::string> MocDefinitions;
std::vector<std::string> MocOptions;
// - Uic
-----------------------------------------------------------------------
Summary of changes:
hooks/post-receive
--
CMake
More information about the Cmake-commits
mailing list