On Apple, the implementation of cmGlobalXCodeGenerator::Open uses
LSOpenCFURLRef from CoreServices. This get's transitively pulled in
from CMake's libuv build but ends up generating a linker error when
using an external libuv. This explicitly adds the appropriate
dependency.
While we already support `VERBOSE` environment variable and
`CMAKE_VERBOSE_MAKEFILE` cached variable, add `-v` and `--verbose`
command line options to be able to activate verbose output directly from
CMake's build tool mode command line.
Also make `msbuild` honor the verbosity setting. `xcodebuild` still
doesn't honor the verbosity setting as it will need a policy added
and reworking of cmGlobalGenerator and cmsys to support
multiple command invocation.
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
Use a dedicated `std::set` for implicit include directories instead
of (ab)using the emitted variable. This in combination with lambdas
makes it easier to comprehend which paths are emitted.
For the implicit include directories we used to omit the
`CMAKE_SYSROOT_COMPILE`/`CMAKE_SYSROOT` prefix. This has been changed and
the implicit paths are returned prefixed. Implicit include directory returning
is only ever used by QtAutoGen which requires prefixed paths. QtAutoGen passes
the (implicit) include paths to the `moc` which isn't aware of
`CMAKE_SYSROOT_COMPILE`/`CMAKE_SYSROOT`.
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.
626c51f47b VS: Update for Visual Studio 2019 Preview 2
fd45cbf40e VS: Fix `/MANIFESTUAC:` link flag mapping for v142
db35e3cfd6 VS: Fix support for '/guard:cf' linker flag for v142
533f95c847 VS: Map the link `/debug` flag for v142
d2fcc6748a VS: Fix `/MANIFESTUAC:NO` link flag mapping for v142
a7973ccb53 VS: Populate `/permissive` flag table entry for v142
049410c0b6 VS: Populate `/JMC-` flag table entry for v142
43aa632f57 VS: Populate `-Qspectre-` flag table entry for v142
...
Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !2856
Currently cmake is only setting CMAKE_Fortran_IMPLICIT_INCLUDE_DIRECTORIES
the first time it runs (the implicit includes parser is only run when
the cache variables are initially populated). It is left unset
during additional runs. This behavior is both confusing and
inconsistent.
Modify CMakeFortranCompiler.cmake.in to preserve the value of
CMAKE_Fortran_IMPLICIT_INCLUDE_DIRECTORIES so that cmake's Fortran
behavior matches C and CXX (i.e. CMAKE_Fortran_IMPLICIT_INCLUDE_DIRECTORIES
retains its value across runs). The implicit includes variable may
not be as useful for Fortran as it is for C and CXX, but we do want
cmake to be consistent in how it is handled.
Adjust CMakeParseImplicitIncludeInfo to parse verbose Fortran output
for Cray and XL compiler IDs (GNU and clang were already ok since
they use the same verbose output format as they do with C/CXX).
Allow Tests/RunCMake/ParseImplicitIncludeInfo/data/CMakeLists.txt
to generate test inputs for Fortran too, and add some sample Fortran
input files for the Tests/RunCMake/ParseImplicitIncludeInfo test.
The logic is that the describe output is readily available using `git
tag --contains` locally. In addition, for a hypothetical commit which
landed in both v3.9.4 and v3.10.1, there is no "better" tag to refer to.
since v3.10.0's relation to such a commit is unclear either way.
Also mention that a `Fixes` trailer is preferred if the mention is just
to indicate a commit which introduced an error rather than writing a
complete sentence about it.
Add parser code for compiler IDs SunPro and XL. For SunPro, /usr/include
appears to be hardwired in and it does not have a -nostdinc-type flag.
For XL, the "xlc" and "xlC" commands determine if you are C or C++
based on input filename. So compiling x.c with "xlC" reverts to C
and compiling x.cc with "xlc" upgrades to CXX. System include paths
are specified by:
-qc_stdinc=[path] and -qgcc_c_stdinc=[path] (for C)
-qcpp_stdinc=[path] and -qgcc_cpp_stdinc=[path] (for CXX)
If you specify "-qnostdinc" then the above flags are ignored.
Specifying an empty path reverts the value to the default
path (e.g. "-qgcc_c_stdinc=" reverts that to the default).
Adjust the code to handle parsing the case where the user specifies
additional compiler include flags via CMAKE_C_FLAGS/CMAKE_CXX_FLAGS.
For example: "-DCMAKE_C_FLAGS=-nostdinc" ... note that gcc and clang
output slightly differ when -nostdinc is specified (clang skips
printing 'search starts here:' with the angle brackets, gcc always
prints it).
Enable sunos-{C,CXX}-SunPro test cases and add XL test cases.
Also add a few -nostdinc style tests.
