This removes code that sorts include directories for `AUTOMOC` according to
`CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE`. This is possible because the
included directories passed to `AUTOMOC` are already sorted, also with
respect to `CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE`.
This patch is generated by a python script that uses regular expressions to
search for string concatenation patterns of the kind
```
std::string str = <ARG0>;
str += <ARG1>;
str += <ARG2>;
...
```
and replaces them with a single `cmStrCat` call
```
std::string str = cmStrCat(<ARG0>, <ARG1>, <ARG2>, ...);
```
If any `<ARGX>` is itself a concatenated string of the kind
```
a + b + c + ...;
```
then `<ARGX>` is split into multiple arguments for the `cmStrCat` call.
If there's a sequence of literals in the `<ARGX>`, then all literals in the
sequence are concatenated and merged into a single literal argument for
the `cmStrCat` call.
Single character strings are converted to single char arguments for
the `cmStrCat` call.
`std::to_string(...)` wrappings are removed from `cmStrCat` arguments,
because it supports numeric types as well as string types.
`arg.substr(x)` arguments to `cmStrCat` are replaced with
`cm::string_view(arg).substr(x)`
This replaces invocations of
- `cmSystemTools::IsInternallyOn` with `cmIsInternallyOn`
- `cmSystemTools::IsNOTFOUND` with `cmIsNOTFOUND`
- `cmSystemTools::IsOn` with `cmIsOn`
- `cmSystemTools::IsOff` with `cmIsOff`
This adds the following functions to cmStringAlgorithms:
- `cmStrToLong`: moved from `cmSystemTools::StringToLong`
- `cmStrToULong`: moved from `cmSystemTools::StringToULong`
Overloads of the given functions for `std::string` are added as well.
In the QtAutogen initializer use `cmake::IsHeaderExtension` and
`cmake::IsSourceExtension` instead of `cmSystemTools::GetFileFormat` for file
type detection.
Closes: #13904
When Autogen searches the header for a source files in a target,
the expanded real path is used and not the (possibly symbolic) original path
of the source file. If the source file path contains symbolic links, then the
correct `cmSourceFile` instance of the header won't be found, but a new one
will be generated. This way all header source file properties get lost, which
is problematic especially for the `SKIP_AUTOMOC/UIC/GEN` properties.
This patch changes the header detection in Autogen to use the original source
file path instead of the expanded real source file path.
Fixes: #19346
`CMAKE_AUTOMOC_RELAXED_MODE` was added for backwards compatibility with KDE 4,
which had its last release in 2014. It does not offer additional features
but complicates the `AUTOMOC` code and dependency computation considerably.
Projects that use `CMAKE_AUTOMOC_RELAXED_MODE` functionality always got
extensive warnings during builds and tips on how to convert to regular mode,
which is trivial (see commit e474dcb231, CMake 2.8.7).
It's time to consider this feature deprecated and issue a warning at
configuration time as well.
This adds a configuration time deprecation `AUTHOR_WARNING` for
`CMAKE_AUTOMOC_RELAXED_MODE`.
To speed up the `AUTOGEN` configuration process, evaluate the compiler
features only once. The feature evaluation result is stored in the new class
`cmQtAutoGen::CompilerFeatures`, and the instance is shared by using
`std::shared_ptr`.
The `ADDITIONAL_CLEAN_FILES` target property works on multiple generators
to remove addition files at the clean target. In `AUTOGEN` use it instead of
the deprecated and limited `ADDITIONAL_MAKE_CLEAN_FILES` directory property
to remove `AUTOGEN` generated files.
Fixes: #17074 "Autogen: clean target with ninja generator doesn’t clean
autogen files"
New features
------------
CMake's `AUTOMOC` and `AUTOUIC` now cache information extracted when parsing
source files in `CMakeFiles/<ORIGIN>_autogen.dir/ParseCache.txt`.
This leads to faster `<ORIGIN>_autogen` target rebuilds, because source files
will be parsed again only if they're newer than the `ParseCache.txt` file.
The parse cache will be recomputed if it is older than the CMake executable.
`AUTOMOC` and `AUTOUIC` now check if `moc` or `uic` output files are older
than the `moc` or `uic` executable. If an output file is older than the
compiler, it will be regenerated. Therefore if a new `moc` or `uic` version
is installed, all output files will be regenerated.
`AUTOMOC` and `AUTOUIC` error and warning messages are more detailed.
Internal changes
----------------
`moc` and `uic` output file names are not computed in the `_autogen`
target anymore but in `cmQtAutoGenInitializer`. This makes the available at
the configuration stage for improved dependency computations (to be done).
In `AutogenInfo.cmake`, equally sized lists for "source file names",
"source file flags" and "compiler output file names" are passed to the
`_autogen` target. This replaces the separate file lists for
`AUTOMOC` and `AUTOUIC`.
Files times are read from the file system only once by using `cmFileTime`
instances instead of `cmQtAutoGenerator::FileSystem::FileIsOlderThan` calls.
All calls to not thread safe file system functions are moved to non concurrent
fence jobs (see `cmWorkerPool::JobT::IsFence()`). This renders the
`cmQtAutoGenerator::FileSystem` wrapper class obsolete and it is removed.
Instead of composing a single large settings string that is fed to the
`cmCryptoHash`, now all setting sub strings are fed one by one to the
`cmCryptoHash` and the finalized result is stored.
The `std::mutex` in `cmQtAutoGenerator::Logger` is tagged `mutable` and most
`cmQtAutoGenerator::Logger` methods become `const`.
Outlook
-------
This patch provides the framework required to
- extract dependencies from `.ui` files in `AUTOUIC`.
These will help to address issue
#15420 "AUTOUIC: Track uic external inputs".
- generate adaptive `make` and `ninja` files in the `_autogen` target.
These will help to address issue
#16776 "AUTOUIC: Ninja needs two passes to correctly build Qt project".
- generate (possibly empty) `moc` and `uic` files for all headers instead of a
`mocs_compilation.cpp` file.
This will help to address issue
#17277 "AUTOMOC: Provide a option to allow AUTOMOC to compile individual "
"moc_x.cxx instead of including all in mocs_compilation.cxx"
Both classes `cmQtAutoGenInitializer` and `cmQtAutoGeneratorRcc` had
different implementations for reading the files list from a `.qrc` resources
file. This patch replaces both implementations with the common simple
`cmQtAutoGen::RccLister` implementation.
When building a Qt project, the AUTORCC functionality, by default,
uses the rcc binary to get the contents of a qrc file for
dependency information. This is done at CMake "generate" time.
The problem is that while configuring Qt itself, the rcc binary is
not built yet.
In that case, to get the contents of the qrc file, fall back to
the code branch which uses an ifstream instead of the rcc binary.
The computation of additional source headers and and private headers for
AUTOGEN is moved from the _autogen target to the configuration stage. This
makes them available for _autogen target dependency computations.
Closes: #18949
In AUTOGEN this replaces simple file name lists with two list (for
headers and sources) of structs with file name and file flags.
The file name lists that are passed to the _autogen target via
AutogenInfo.cmake are filtered from these two lists.
In AUTOGEN a common new base class cmQtAutoGenInitializer::GenVarsT for
mo/uic/rcc generator variables allows to generalize variable computation
functions.
In QtAutoGen we used to iterate over all makefile source two times to
extract file parameters for moc and uic respectively. This patch merges both
iterations into one loop. This makes the code easier to understand and likely
faster to execute as well.
Since commit 5990ecb741 (Compute implicit include directories from
compiler output, 2018-12-07) we now have compiler implicit include
directory computation for gcc and clang. It should be safe now to pass
these to `moc`. This patch re-enables passing the compiler implicit
include directories to `moc`, which was disabled due to issue #18669.
Fixes: #18041
Issue: #18669
This patch strips the `stripImplicitDirs` and `appendAllImplicitDirs`
parameters from the `cmLocalGenerator::GetIncludeDirectories` method and makes
it a wrapper into the new `cmLocalGenerator::GetIncludeDirectoriesImplicit`
method. `cmLocalGenerator::GetIncludeDirectoriesImplicit` is the renamed old
implementation of `cmLocalGenerator::GetIncludeDirectories` and still
accepts `stripImplicitDirs` and `appendAllImplicitDirs`.
The motivation is that there's only *one* case where
`cmLocalGenerator::GetIncludeDirectories` is called with the
`stripImplicitDirs` parameter being `false` (QtAutoGen), but many other places
where it is called using the `true` default value.
QtAutoGen is modified to use `cmLocalGenerator::GetIncludeDirectoriesImplicit`
directly. In two use cases of `cmLocalGenerator::GetIncludeDirectories`
the manually set `true` value for `stripImplicitDirs` is removed.
3e867ed400 cmake: inlined files dir constant and removed it from cmake.h
Acked-by: Kitware Robot <kwrobot@kitware.com>
Rejected-by: vvs31415 <vstakhovsky@fastmail.com>
Merge-request: !2655
1ed4d48dcf Autogen: Prepend instead of append `mocs_compilation.cpp` to the sources list
a42b700cc2 cmTarget,cmGeneratorTarget: Add optional `before` parameter to AddSource
Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Peter Wu <peter@lekensteyn.nl>
Merge-request: !2815
`mocs_compilation.cpp` easily takes a long time to compile when it
contains multiple `moc` files. When it was appended like before
we ran into the situation that all smaller sources were already compiled when
`mocs_compilation.cpp` got compiled at last. In that case a single core was
busy but all remaining cores stayed idle.
To optimize CPU core utilization we now prepend `mocs_compilation.cpp`
to the sources list instead of appending it. This allows smaller source files
to get compiled *while* the long lasting `mocs_compilation.cpp` gets compiled.
Closes#18793
Allow to force moc/rcc/uic compiler used for AUTO(MOC|RCC|UIC).
Setting these properties is only necessary if you are going to do
strange things like build these tools as part of your own build system.
Setting these properties will also prevent cmake from testing the
binary: It is user-provided and assumed to be valid.
Handle Qt version > 5 in Qt AutoGen.
This patch does *NOT* include tests and documentation: There is no
Qt 6 yet. I still need this patch to work on a cmake based build
system for Qt 6.
Passing an incomplete list of compiler include directories causes
a regression in the KIO project (and probably others). We need to
disable it until the complete list is available (see #16291).
Fixes: #18669
Issue: #18041
5f0f84c7e0 Autogen: Don't add a WIN32 moc definition if we have a moc_predefs.h file
0814d74548 Autogen: Add QtAutogen.UicNoGui test
2ef640819f Autogen: Tests: Differentiate between Qt core and Qt gui tests
Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !2668
On Windows systems we used to add a "-DWIN32" definition to the ``moc``
defines. This is not necessary anymore when we have a
``moc_predefs.h`` file that provides all compiler predefines.
Closes#18623
In CMake 3.13.0 when a target has ``AUTOUIC`` enabled but doesn't
link against Qt5Widgets, the uic executable string is empty and
an error string "The uic executable \"\" does not exist" is generated.
In CMake 3.12 ``AUTOUIC`` was silently disabled instead.
This patch fixes the regression and restores the behavior of CMake 3.12.
Fixes: #18630
The new ``cmQtAutoGenInitializer::InfoWriter`` class provides an
interface to write strings/vectors/sets/maps in CMake format
into a file. Its use replaces various `cmJoin` calls that
failed to address escaping of semicolons in list elements.
Closes#18554
This teaches CMake the variables
- CMAKE_GLOBAL_AUTOGEN_TARGET
- CMAKE_GLOBAL_AUTOGEN_TARGET_NAME
- CMAKE_GLOBAL_AUTORCC_TARGET
- CMAKE_GLOBAL_AUTORCC_TARGET_NAME
which control the generation of global
``autogen`` and ``autorcc`` targets.
Closes#17721
This adds
- the variable ``CMAKE_AUTOGEN_ORIGIN_DEPENDS`` which initializes
- the target property ``AUTOGEN_ORIGIN_DEPENDS``
which controls whether or not the origin target dependencies
should be forwarded to the corresponding ``_autogen`` target.
The default value of ``CMAKE_AUTOGEN_ORIGIN_DEPENDS`` is ``ON``
which corresponds to the behavior that is in place since CMake 3.9.
Closes: #18493
This method offers the same definitions as `GetTargetDefines` except
that it excludes the "export" macro on shared libraries. Update call
sites to use `GetTargetDefines` instead. Some of them were incorrectly
excluding the export macro.
After changing the ``cmGeneratedFileStream`` methods to accept
``std::string const&`` instead of ``const char*`` we don't
need to call ``std::string::c_str`` anymore when passing
a ``std::string`` to a ``cmGeneratedFileStream`` method.
This patch removes all redundant ``std::string::c_str``
calls when passing a string to a ``cmGeneratedFileStream`` method.
It was generated by building CMake with clang-tidy enabled using
the following options:
-DCMAKE_CXX_CLANG_TIDY=/usr/bin/clang-tidy-4.0;-checks=-*,readability-redundant-string-cstr;-fix;-fix-errors
For Qt4 it was not possible to pass all compiler implicit include
directories to moc because it couldn't handle some system headers.
For reference see commit 753b905ec8,
commit d2536579d5 and
[QTBUG-28045](https://bugreports.qt.io/browse/QTBUG-28045).
For Qt5's moc the problem does not persist anymore so we can
(and should) pass all implicit include directories to moc.
Fixes#18041
cmQtAutoGenInitializer::InitCustomTargets and
cmQtAutoGenInitializer::SetupCustomTargets
now return their success value which gets evaluated
and passed on by the caller (cmGlobalGenerator).
Checks for the existance of the moc/uic/rcc
binaries have been introduces in cmQtAutoGenInitializer.
Additionally they get called once with a "-h"
argument to determine if they're functional.
This way any binary-not-found problem is caught
during the configuration phase.
Run the `clang-format.bash` script to update all our C and C++ code to a
new style defined by `.clang-format`. Use `clang-format` version 6.0.
* If you reached this commit for a line in `git blame`, re-run the blame
operation starting at the parent of this commit to see older history
for the content.
* See the parent commit for instructions to rebase a change across this
style transition commit.
For multi configuration generators let AUTORCC generate
the rcc output for all configurations. This is a workaround
for the incomplete `$<CONFIG>` support in the DEPENDS and OUTPUT
clauses of a custom_command/custom_target. Since we can't depend
on the per-config rcc output file we somehow must ensure the successful
rcc build for one configuration doesn't shadow the need to rcc rebuild
for a second configuration.
Closes#18006
Check if the content of the AUTOMOC/UIC/RCC info file
will change before overwriting it. This avoids unnecessary
AUTORCC rebuilds when AUTORCC unrelated CMake settings change.
For multi configuration generators AUTOMOC generates the
moc files that are included in `mocs_compilation.cpp`
in `AUTOGEN_BUILD_DIR/include_$<CONFIG>/`. By doing so each
configuration reads different moc files when compiling
`mocs_compilation.cpp`. Since we do not (need to) rewrite
`mocs_compilation.cpp` on a configuration change anymore,
the files also does not need to be recompiled anymore.
Not having to rewrite and recompile `mocs_compilation.cpp`
on a configuration change anymore was the main objective of
this patch.
In a similar fashion AUTORCC generates a `qrc_BASE_CMAKE.cpp`
file below `AUTOGEN_BUILD_DIR/include_$<CONFIG>/` and
`qrc_BASE.cpp` becomes a mere wrapper that includes this
actuall rcc output file (when using multi configuration
generators).
The template files `Modules/AutoRccInfo.cmake.in` and
`Modules/AutogenInfo.cmake.in` were removed in favor
of writing the info `.cmake` files manually.
Closes#17230
* Change some functions to take `std::string` instead of
`const char*` in the following classes: `cmMakeFile`, `cmake`,
`cmCoreTryCompile`, `cmSystemTools`, `cmState`, `cmLocalGenerator`
and a few others.
* Greatly reduce using of `const char*` overloads for
`cmSystemTools::MakeDirectory` and `cmSystemTools::RelativePath`.
* Remove many redundant `c_str()` conversions throughout the code.
This commit continues the changes made in CTest to support std::chrono
by
applying it throughout every component where a duration was used.
No functional change intended.
