Lubuntu/cmake
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

New upstream version 3.28.1

Browse Source
This commit is contained in:
Timo Röhling 2023-12-23 22:40:16 +01:00
parent cf677c087a
commit a9633ce77d
19 changed files with 195 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
Help/command/create_test_sourcelist.rst
View File

@ -5,26 +5,25 @@ Create a test driver and source list for building test programs.
.. code-block:: cmake
create_test_sourcelist(sourceListName driverName
test1 test2 test3
EXTRA_INCLUDE include.h
FUNCTION function)
create_test_sourcelist(<sourceListName> <driverName>
<tests> ...
[EXTRA_INCLUDE <include>]
[FUNCTION <function>])
A test driver is a program that links together many small tests into a
single executable. This is useful when building static executables
with large libraries to shrink the total required size. The list of
source files needed to build the test driver will be in
``sourceListName``. ``driverName`` is the name of the test driver program.
The rest of the arguments consist of a list of test source files, can
be semicolon separated. Each test source file should have a function
in it that is the same name as the file with no extension (foo.cxx
should have int foo(int, char*[]);) ``driverName`` will be able to call
each of the tests by name on the command line. If ``EXTRA_INCLUDE`` is
specified, then the next argument is included into the generated file.
If ``FUNCTION`` is specified, then the next argument is taken as a
function name that is passed a pointer to ac and av. This can be used
to add extra command line processing to each test. The
``CMAKE_TESTDRIVER_BEFORE_TESTMAIN`` cmake variable can be set to
have code that will be placed directly before calling the test main function.
``CMAKE_TESTDRIVER_AFTER_TESTMAIN`` can be set to have code that
will be placed directly after the call to the test main function.
A test driver is a program that links together many small tests into a single
executable. This is useful when building static executables with large
libraries to shrink the total required size. The list of source files needed
to build the test driver will be in ``sourceListName``. ``driverName`` is the
name of the test driver program. The rest of the arguments consist of a list
of test source files and can be semicolon separated. Each test source file
should have a function in it that is the same name as the file with no
extension (``foo.cxx`` should have ``int foo(int, char*[]);``). ``driverName``
will be able to call each of the tests by name on the command line. If
``EXTRA_INCLUDE`` is specified, then the next argument is included into the
generated file. If ``FUNCTION`` is specified, then the next argument is taken
as a function name that is passed pointers to ``argc`` and ``argv``. This can
be used to add extra command line processing to each test. The
``CMAKE_TESTDRIVER_BEFORE_TESTMAIN`` cmake variable can be set to have code
that will be placed directly before calling the test ``main`` function.
``CMAKE_TESTDRIVER_AFTER_TESTMAIN`` can be set to have code that will be
placed directly after the call to the test ``main`` function.

6
Help/command/target_link_libraries.rst
View File

@ -68,9 +68,9 @@ Each ``<item>`` may be:
.. versionadded:: 3.28
The library file may point to a ``.xcframework`` folder on macOS. If it
does, the target will get the selected library's ``Headers`` directory as
a usage requirement.
The library file may point to a ``.xcframework`` folder on Apple platforms.
If it does, the target will get the selected library's ``Headers``
directory as a usage requirement.
.. versionadded:: 3.8
On :ref:`Visual Studio Generators` for VS 2010 and above, library files

4
Help/prop_tgt/ENABLE_EXPORTS.rst
View File

@ -35,8 +35,8 @@ the property instead for backward compatibility reasons.
See below for alternative initialization behavior for shared library targets.
.. versionadded:: 3.27
On Apple platforms, to link with a shared library (either a bare library or a
framework), a linker import file can be used instead of the actual shared
To link with a shared library on macOS, or to a shared framework on any Apple
platform, a linker import file can be used instead of the actual shared
library. These linker import files are also known as text-based stubs, and
they have a ``.tbd`` file extension.

19
Help/prop_tgt/IMPORTED_IMPLIB.rst
View File

@ -6,17 +6,26 @@ Full path to the import library for an ``IMPORTED`` target.
This property may be set:
* On DLL platforms, to the location of the ``.lib`` part of the DLL.
* On AIX, to an import file (e.g. ``.imp``) created for executables that export
symbols (see the :prop_tgt:`ENABLE_EXPORTS` target property).
* On macOS, to an import file (e.g. ``.tbd``) created for shared libraries (see
the :prop_tgt:`ENABLE_EXPORTS` target property). For frameworks this is the
location of the ``.tbd`` file symlink just inside the framework folder.
* .. versionadded:: 3.16
On AIX, to an import file (e.g. ``.imp``) created for executables that
export symbols (see the :prop_tgt:`ENABLE_EXPORTS` target property).
* .. versionadded:: 3.27
On Apple platforms, to an import file (e.g. ``.tbd``) created for shared
libraries or frameworks (see the :prop_tgt:`ENABLE_EXPORTS` target
property). For frameworks, this is the location of the ``.tbd`` file
symlink just inside the framework folder.
* .. versionadded:: 3.28
On non-DLL platforms, to the location of a shared library.
When set without also specifying an :prop_tgt:`IMPORTED_LOCATION`,
the library is considered to be a stub, and its location will not
be added as a runtime search path to dependents that link it.
.. versionchanged:: 3.28
If an imported target is an Apple framework or XCFramework, the preferred
arrangement is to set :prop_tgt:`IMPORTED_LOCATION` to the ``.framework``
or ``.xcframework`` directory. CMake will then find the relevant ``.tbd``
file inside that framework or XCFramework automatically without requiring
``IMPORTED_IMPLIB`` to be set.
The ``IMPORTED_IMPLIB`` target property may be overridden for a
given configuration ``<CONFIG>`` by the configuration-specific

14
Help/prop_tgt/IMPORTED_LOCATION.rst
View File

@ -17,14 +17,10 @@ non-imported targets.
.. versionadded:: 3.28
For frameworks on macOS, this may be the location of the framework folder
itself.
.. versionadded:: 3.28
This may be the location of a ``.xcframework`` folder on macOS. If it is,
any target that links against it will get the selected library's ``Headers``
directory as a usage requirement.
For ordinary frameworks on Apple platforms, this may be the location of the
``.framework`` folder itself. For XCFrameworks, it may be the location of
the ``.xcframework`` folder, in which case any target that links against it
will get the selected library's ``Headers`` directory as a usage requirement.
The ``IMPORTED_LOCATION`` target property may be overridden for a
given configuration ``<CONFIG>`` by the configuration-specific
@ -38,5 +34,5 @@ selected and its :prop_tgt:`IMPORTED_LOCATION_<CONFIG>` value used.
To get the location of an imported target read one of the :prop_tgt:`LOCATION`
or ``LOCATION_<CONFIG>`` properties.
For platforms with import libraries (e.g. Windows, AIX or macOS) see also
For platforms with import libraries (e.g. Windows, AIX or Apple) see also
:prop_tgt:`IMPORTED_IMPLIB`.

12
Help/release/3.28.rst
View File

@ -201,3 +201,15 @@ Other Changes
* The precompiled Linux ``x86_64`` binaries provided on
`cmake.org <https://cmake.org/download/>`_ now require GLIBC 2.17 or higher.
Updates
=======
Changes made since CMake 3.28.0 include the following.
3.28.1
------
* This version made no changes to documented features or interfaces.
Some implementation updates were made to support ecosystem changes
and/or fix regressions.

2
Modules/FetchContent.cmake
View File

@ -247,7 +247,7 @@ Commands
If the ``EXCLUDE_FROM_ALL`` argument is provided, then targets in the
subdirectory added by :command:`FetchContent_MakeAvailable` will not be
included in the ``ALL`` target by default, and may be excluded from IDE
project files. See the `:command:`add_subdirectory` `EXCLUDE_FROM_ALL``
project files. See the :command:`add_subdirectory` ``EXCLUDE_FROM_ALL``
argument documentation for a more detailed discussion of the effects.
.. command:: FetchContent_MakeAvailable

17
Modules/FindCUDAToolkit.cmake
View File

@ -1096,11 +1096,13 @@ if(CUDAToolkit_FOUND)
ENV CUDA_PATH
PATH_SUFFIXES lib64/stubs lib/x64/stubs lib/stubs stubs
)
if(CUDA_${lib_name}_LIBRARY AND NOT WIN32)
# Use `IMPORTED_IMPLIB` so that we don't add a `-rpath` entry for stub directories
set(CUDA_IMPORT_PROPERTY IMPORTED_IMPLIB)
set(CUDA_IMPORT_TYPE SHARED)
endif()
endif()
if(CUDA_${lib_name}_LIBRARY MATCHES "/stubs/" AND NOT WIN32)
# Use a SHARED library with IMPORTED_IMPLIB, but not IMPORTED_LOCATION,
# to indicate that the stub is for linkers but not dynamic loaders.
# It will not contribute any RPATH entry.
set(CUDA_IMPORT_PROPERTY IMPORTED_IMPLIB)
set(CUDA_IMPORT_TYPE SHARED)
endif()
mark_as_advanced(CUDA_${lib_name}_LIBRARY)
@ -1244,8 +1246,9 @@ if(CUDAToolkit_FOUND)
find_path(CUDAToolkit_CUPTI_INCLUDE_DIR cupti.h PATHS
"${CUDAToolkit_ROOT_DIR}/extras/CUPTI/include"
"${CUDAToolkit_INCLUDE_DIR}/../extras/CUPTI/include"
"${CUDAToolkit_INCLUDE_DIR}"
"${CUDAToolkit_INCLUDE_DIRS}"
PATH_SUFFIXES "../extras/CUPTI/include"
"../../../extras/CUPTI/include"
NO_DEFAULT_PATH)
mark_as_advanced(CUDAToolkit_CUPTI_INCLUDE_DIR)

20
Modules/FindFreetype.cmake
View File

@ -66,10 +66,6 @@ directory of a Freetype installation.
# everything still works.
set(_Freetype_args)
if (Freetype_FIND_QUIETLY)
list(APPEND _Freetype_args
QUIET)
endif ()
if (Freetype_FIND_VERSION)
list(APPEND _Freetype_args
"${Freetype_FIND_VERSION}")
@ -100,7 +96,8 @@ if (_Freetype_component_opt)
OPTIONAL_COMPONENTS "${_Freetype_component_opt}")
endif ()
unset(_Freetype_component_opt)
find_package(freetype CONFIG ${_Freetype_args})
# Always find with QUIET to avoid noise when it is not found.
find_package(freetype CONFIG QUIET ${_Freetype_args})
unset(_Freetype_args)
if (freetype_FOUND)
if (NOT TARGET Freetype::Freetype)
@ -113,6 +110,9 @@ if (freetype_FOUND)
get_property(_Freetype_location TARGET freetype PROPERTY IMPORTED_IMPLIB)
if (NOT _Freetype_location)
get_property(_Freetype_location_release TARGET freetype PROPERTY IMPORTED_IMPLIB_RELEASE)
if (NOT _Freetype_location_release)
get_property(_Freetype_location_release TARGET freetype PROPERTY IMPORTED_IMPLIB_RELWITHDEBINFO)
endif ()
get_property(_Freetype_location_debug TARGET freetype PROPERTY IMPORTED_IMPLIB_DEBUG)
if (_Freetype_location_release AND _Freetype_location_debug)
set(_Freetype_location
@ -124,6 +124,9 @@ if (freetype_FOUND)
set(_Freetype_location "${_Freetype_location_debug}")
else ()
get_property(_Freetype_location_release TARGET freetype PROPERTY LOCATION_RELEASE)
if (NOT _Freetype_location_release)
get_property(_Freetype_location_release TARGET freetype PROPERTY LOCATION_RELWITHDEBINFO)
endif ()
get_property(_Freetype_location_debug TARGET freetype PROPERTY LOCATION_DEBUG)
if (_Freetype_location_release AND _Freetype_location_debug)
set(_Freetype_location
@ -150,6 +153,13 @@ if (freetype_FOUND)
set(Freetype_${_Freetype_component}_FOUND "${freetype_${_Freetype_component}_FOUND}")
endforeach ()
unset(_Freetype_component)
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
find_package_handle_standard_args(Freetype
HANDLE_COMPONENTS
VERSION_VAR FREETYPE_VERSION_STRING
)
return ()
endif ()

12
Modules/FindMatlab.cmake
View File

@ -486,10 +486,10 @@ function(matlab_extract_all_installed_versions_from_registry win64 matlab_versio
if(_reg)
string(REGEX MATCHALL "([0-9]+\\.[0-9]+)" _versions_regex ${_reg})
string(REGEX MATCHALL "([0-9]+\\.[0-9]+)" _versions_regex "${_reg}")
foreach(match IN LISTS _versions_regex)
string(REGEX MATCH "([0-9]+\\.[0-9]+)" current_match ${match})
string(REGEX MATCH "([0-9]+\\.[0-9]+)" current_match "${match}")
if(NOT CMAKE_MATCH_1)
continue()
@ -500,7 +500,7 @@ function(matlab_extract_all_installed_versions_from_registry win64 matlab_versio
VALUE "MATLABROOT"
)
_Matlab_VersionInfoXML(${_reg} _matlab_version_tmp)
_Matlab_VersionInfoXML("${_reg}" _matlab_version_tmp)
if(NOT "${_matlab_version_tmp}" STREQUAL "unknown")
list(APPEND matlabs_from_registry ${_matlab_version_tmp})
endif()
@ -1364,7 +1364,7 @@ function(_Matlab_get_version_from_root matlab_root matlab_or_mcr matlab_known_ve
${_matlab_main_real_path_tmp}
CACHE INTERNAL "internal matlab location for the discovered version")
_Matlab_VersionInfoXML(${matlab_root} _matlab_version_tmp)
_Matlab_VersionInfoXML("${matlab_root}" _matlab_version_tmp)
if(NOT "${_matlab_version_tmp}" STREQUAL "unknown")
# at least back to R2016 VersionInfo.xml exists
set(matlab_list_of_all_versions ${_matlab_version_tmp})
@ -1392,7 +1392,7 @@ function(_Matlab_get_version_from_root matlab_root matlab_or_mcr matlab_known_ve
# MCR
# we cannot run anything in order to extract the version. We assume that the file
# VersionInfo.xml exists under the MatlabRoot, we look for it and extract the version from there
_Matlab_VersionInfoXML(${matlab_root} _matlab_version_tmp)
_Matlab_VersionInfoXML("${matlab_root}" _matlab_version_tmp)
if(NOT "${_matlab_version_tmp}" STREQUAL "unknown")
set(Matlab_VERSION_STRING_INTERNAL ${_matlab_version_tmp} CACHE INTERNAL "Matlab version (automatically determined)")
endif()
@ -1481,7 +1481,7 @@ function(_Matlab_find_instances_macos matlab_roots)
string(REPLACE "." "" _matlab_current_version_without_dot "${_matlab_current_version}")
set(_matlab_base_path "/Applications/MATLAB_${_matlab_current_release}.app")
_Matlab_VersionInfoXML(${_matlab_base_path} _matlab_version_tmp)
_Matlab_VersionInfoXML("${_matlab_base_path}" _matlab_version_tmp)
if(NOT "${_matlab_version_tmp}" STREQUAL "unknown")
set(_matlab_current_version ${_matlab_version_tmp})
endif()

99
Modules/FindTIFF.cmake
View File

@ -65,11 +65,10 @@ The following cache variables may also be set:
Debug and Release variants are found separately.
#]=======================================================================]
cmake_policy(PUSH)
cmake_policy(SET CMP0057 NEW) # if IN_LIST
set(_TIFF_args)
if (TIFF_FIND_QUIETLY)
list(APPEND _TIFF_args
QUIET)
endif ()
if (TIFF_FIND_VERSION)
list(APPEND _TIFF_args
"${TIFF_FIND_VERSION}")
@ -100,7 +99,8 @@ if (_TIFF_component_opt)
OPTIONAL_COMPONENTS "${_TIFF_component_opt}")
endif ()
unset(_TIFF_component_opt)
find_package(tiff CONFIG ${_TIFF_args})
# Always find with QUIET to avoid noise when it is not found.
find_package(tiff CONFIG QUIET ${_TIFF_args})
unset(_TIFF_args)
if (tiff_FOUND)
if (NOT TARGET TIFF::TIFF)
@ -110,15 +110,86 @@ if (tiff_FOUND)
endif ()
get_property(TIFF_INCLUDE_DIRS TARGET TIFF::tiff PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
get_property(TIFF_LIBRARIES TARGET TIFF::tiff PROPERTY INTERFACE_LINK_LIBRARIES)
get_property(_TIFF_location TARGET TIFF::tiff PROPERTY LOCATION)
list(APPEND TIFF_LIBRARIES
get_property(_TIFF_location TARGET TIFF::tiff PROPERTY IMPORTED_IMPLIB)
if (NOT _TIFF_location)
get_property(_TIFF_location_release TARGET TIFF::tiff PROPERTY IMPORTED_IMPLIB_RELEASE)
if (NOT _TIFF_location_release)
get_property(_TIFF_location_release TARGET TIFF::tiff PROPERTY IMPORTED_IMPLIB_RELWITHDEBINFO)
endif ()
get_property(_TIFF_location_debug TARGET TIFF::tiff PROPERTY IMPORTED_IMPLIB_DEBUG)
if (_TIFF_location_release AND _TIFF_location_debug)
set(_TIFF_location
optimized "${_TIFF_location_release}"
debug "${_TIFF_location_debug}")
elseif (_TIFF_location_release)
set(_TIFF_location "${_TIFF_location_release}")
elseif (_TIFF_location_debug)
set(_TIFF_location "${_TIFF_location_debug}")
else ()
get_property(_TIFF_location_release TARGET TIFF::tiff PROPERTY LOCATION_RELEASE)
if (NOT _TIFF_location_release)
get_property(_TIFF_location_release TARGET TIFF::tiff PROPERTY LOCATION_RELWITHDEBINFO)
endif ()
get_property(_TIFF_location_debug TARGET TIFF::tiff PROPERTY LOCATION_DEBUG)
if (_TIFF_location_release AND _TIFF_location_debug)
set(_TIFF_location
optimized "${_TIFF_location_release}"
debug "${_TIFF_location_debug}")
elseif (_TIFF_location_release)
set(_TIFF_location "${_TIFF_location_release}")
elseif (_TIFF_location_debug)
set(_TIFF_location "${_TIFF_location_debug}")
else ()
get_property(_TIFF_location TARGET TIFF::tiff PROPERTY LOCATION)
endif ()
endif ()
unset(_TIFF_location_release)
unset(_TIFF_location_debug)
endif ()
list(INSERT TIFF_LIBRARIES 0
"${_TIFF_location}")
unset(_TIFF_location)
set(TIFF_FOUND 1)
if("CXX" IN_LIST TIFF_FIND_COMPONENTS)
if (TARGET TIFF::CXX)
get_property(_TIFF_CXX_location TARGET TIFF::CXX PROPERTY LOCATION)
list(APPEND TIFF_LIBRARIES ${_TIFF_CXX_location})
get_property(_TIFF_CXX_location TARGET TIFF::CXX PROPERTY IMPORTED_IMPLIB)
if (NOT _TIFF_CXX_location)
get_property(_TIFF_CXX_location_release TARGET TIFF::CXX PROPERTY IMPORTED_IMPLIB_RELEASE)
if (NOT _TIFF_CXX_location_release)
get_property(_TIFF_CXX_location_release TARGET TIFF::CXX PROPERTY IMPORTED_IMPLIB_RELWITHDEBINFO)
endif ()
get_property(_TIFF_CXX_location_debug TARGET TIFF::CXX PROPERTY IMPORTED_IMPLIB_DEBUG)
if (_TIFF_CXX_location_release AND _TIFF_CXX_location_debug)
set(_TIFF_CXX_location
optimized "${_TIFF_CXX_location_release}"
debug "${_TIFF_CXX_location_debug}")
elseif (_TIFF_CXX_location_release)
set(_TIFF_CXX_location "${_TIFF_CXX_location_release}")
elseif (_TIFF_CXX_location_debug)
set(_TIFF_CXX_location "${_TIFF_CXX_location_debug}")
else ()
get_property(_TIFF_CXX_location_release TARGET TIFF::CXX PROPERTY LOCATION_RELEASE)
if (NOT _TIFF_CXX_location_release)
get_property(_TIFF_CXX_location_release TARGET TIFF::CXX PROPERTY LOCATION_RELWITHDEBINFO)
endif ()
get_property(_TIFF_CXX_location_debug TARGET TIFF::CXX PROPERTY LOCATION_DEBUG)
if (_TIFF_CXX_location_release AND _TIFF_CXX_location_debug)
set(_TIFF_CXX_location
optimized "${_TIFF_CXX_location_release}"
debug "${_TIFF_CXX_location_debug}")
elseif (_TIFF_CXX_location_release)
set(_TIFF_CXX_location "${_TIFF_CXX_location_release}")
elseif (_TIFF_CXX_location_debug)
set(_TIFF_CXX_location "${_TIFF_CXX_location_debug}")
else ()
get_property(_TIFF_CXX_location TARGET TIFF::CXX PROPERTY LOCATION)
endif ()
endif ()
unset(_TIFF_CXX_location_release)
unset(_TIFF_CXX_location_debug)
endif ()
list(INSERT TIFF_LIBRARIES 0
"${_TIFF_CXX_location}")
unset(_TIFF_CXX_location)
set(TIFF_CXX_FOUND 1)
else ()
@ -135,12 +206,16 @@ if (tiff_FOUND)
set(TIFF_${_TIFF_component}_FOUND "${tiff_${_TIFF_component}_FOUND}")
endforeach ()
unset(_TIFF_component)
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
find_package_handle_standard_args(TIFF
HANDLE_COMPONENTS
VERSION_VAR TIFF_VERSION_STRING)
cmake_policy(POP)
return ()
endif ()
cmake_policy(PUSH)
cmake_policy(SET CMP0057 NEW)
find_path(TIFF_INCLUDE_DIR tiff.h)
set(TIFF_NAMES ${TIFF_NAMES} tiff libtiff tiff3 libtiff3)

4
Source/CMakeVersion.cmake
View File

@ -1,7 +1,7 @@
# CMake version number components.
set(CMake_VERSION_MAJOR 3)
set(CMake_VERSION_MINOR 28)
set(CMake_VERSION_PATCH 0)
set(CMake_VERSION_PATCH 1)
#set(CMake_VERSION_RC 0)
set(CMake_VERSION_IS_DIRTY 0)
@ -21,7 +21,7 @@ endif()
if(NOT CMake_VERSION_NO_GIT)
# If this source was exported by 'git archive', use its commit info.
set(git_info [==[618fdc1c42 CMake 3.28.0]==])
set(git_info [==[1eed682d7c CMake 3.28.1]==])
# Otherwise, try to identify the current development source version.
if(NOT git_info MATCHES "^([0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]?[0-9a-f]?)[0-9a-f]* "

1
Source/cmGeneratorTarget.cxx
View File

@ -8948,6 +8948,7 @@ bool cmGeneratorTarget::AddHeaderSetVerification()
verifyTarget->SetProperty("AUTOUIC", "OFF");
verifyTarget->SetProperty("DISABLE_PRECOMPILE_HEADERS", "ON");
verifyTarget->SetProperty("UNITY_BUILD", "OFF");
verifyTarget->SetProperty("CXX_SCAN_FOR_MODULES", "OFF");
cm::optional<std::map<std::string, cmValue>>
perConfigCompileDefinitions;
verifyTarget->FinalizeTargetConfiguration(

1
Source/cmGlobalXCodeGenerator.cxx
View File

@ -1697,6 +1697,7 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmGeneratorTarget* gtgt)
}
if (cmSourceFile* sf = mf->GetOrCreateSource(fname)) {
sf->SetProperty("LANGUAGE", llang);
sf->SetProperty("CXX_SCAN_FOR_MODULES", "0");
gtgt->AddSource(fname);
}
}

2
Source/cmLocalGenerator.cxx
View File

@ -2928,6 +2928,7 @@ void cmLocalGenerator::CopyPchCompilePdb(
} else {
cc->SetOutputs(outputs);
cmSourceFile* copy_rule = this->AddCustomCommandToOutput(std::move(cc));
copy_rule->SetProperty("CXX_SCAN_FOR_MODULES", "0");
if (copy_rule) {
target->AddSource(copy_rule->ResolveFullPath());
@ -3195,6 +3196,7 @@ void cmLocalGenerator::AddUnityBuild(cmGeneratorTarget* target)
target->AddSource(file.Path, true);
unity->SetProperty("SKIP_UNITY_BUILD_INCLUSION", "ON");
unity->SetProperty("UNITY_SOURCE_FILE", file.Path);
unity->SetProperty("CXX_SCAN_FOR_MODULES", "0");
if (file.PerConfig) {
unity->SetProperty("COMPILE_DEFINITIONS",
"CMAKE_UNITY_CONFIG_$<UPPER_CASE:$<CONFIG>>");

1
Source/cmQtAutoGenInitializer.cxx
View File

@ -1878,6 +1878,7 @@ cmSourceFile* cmQtAutoGenInitializer::RegisterGeneratedSource(
gFile->MarkAsGenerated();
gFile->SetProperty("SKIP_AUTOGEN", "1");
gFile->SetProperty("SKIP_LINTING", "ON");
gFile->SetProperty("CXX_SCAN_FOR_MODULES", "0");
return gFile;
}

2
Tests/RunCMake/CTestTimeout/TestTimeout.c
View File

@ -45,7 +45,7 @@ int main(void)
#if defined(_WIN32)
Sleep((TIMEOUT + 4) * 1000);
#elif defined(SIGNAL_IGNORE)
# if defined(__CYGWIN__) || defined(__sun__)
# if defined(__CYGWIN__) || defined(__sun__) || defined(__GNU__)
# define ERRNO_IS_EINTR (errno == EINTR || errno == 0)
# else
# define ERRNO_IS_EINTR (errno == EINTR)

9
Tests/RunCMake/Ninja/RunCMakeTest.cmake
View File

@ -347,6 +347,9 @@ if("${ninja_version}" VERSION_LESS 1.6)
message(WARNING "Ninja is too old; skipping rest of test.")
return()
endif()
if("${ninja_version}" VERSION_LESS 1.12)
set(maybe_w_dupbuild_err -w dupbuild=err)
endif()
set(ninja_output_path_prefixes "sub")
if(NOT CMAKE_C_COMPILER_ID STREQUAL "OrangeC")
@ -364,14 +367,14 @@ endforeach(ninja_output_path_prefix)
function (run_PreventTargetAliasesDupBuildRule)
set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/PreventTargetAliasesDupBuildRule-build)
run_cmake(PreventTargetAliasesDupBuildRule)
run_ninja("${RunCMake_TEST_BINARY_DIR}" -w dupbuild=err)
run_ninja("${RunCMake_TEST_BINARY_DIR}" ${maybe_w_dupbuild_err})
endfunction ()
run_PreventTargetAliasesDupBuildRule()
function (run_PreventConfigureFileDupBuildRule)
set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/PreventConfigureFileDupBuildRule-build)
run_cmake(PreventConfigureFileDupBuildRule)
run_ninja("${RunCMake_TEST_BINARY_DIR}" -w dupbuild=err)
run_ninja("${RunCMake_TEST_BINARY_DIR}" ${maybe_w_dupbuild_err})
endfunction()
run_PreventConfigureFileDupBuildRule()
@ -380,7 +383,7 @@ function (run_ChangeBuildType)
set(RunCMake_TEST_OPTIONS "-DCMAKE_BUILD_TYPE:STRING=Debug")
run_cmake(ChangeBuildType)
unset(RunCMake_TEST_OPTIONS)
run_ninja("${RunCMake_TEST_BINARY_DIR}" -w dupbuild=err)
run_ninja("${RunCMake_TEST_BINARY_DIR}" ${maybe_w_dupbuild_err})
endfunction()
run_ChangeBuildType()

6
Tests/RunCMake/try_compile/ISPCDuplicateTargetNinja-stderr.txt
View File

@ -1 +1,5 @@
.*ninja: error: .* multiple rules generate.*src.ispc_avx512skx.o.*
ninja: error:([^
]+multiple rules generate[^
]+src\.ispc_avx512skx\.o|[^
]+src\.ispc_avx512skx\.o[^
]+is defined as an output multiple times)