diff --git a/Help/command/create_test_sourcelist.rst b/Help/command/create_test_sourcelist.rst index 77e37c50f..5f01a8b02 100644 --- a/Help/command/create_test_sourcelist.rst +++ b/Help/command/create_test_sourcelist.rst @@ -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( + ... + [EXTRA_INCLUDE ] + [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. diff --git a/Help/command/target_link_libraries.rst b/Help/command/target_link_libraries.rst index cc6bc0fdd..68d35988e 100644 --- a/Help/command/target_link_libraries.rst +++ b/Help/command/target_link_libraries.rst @@ -68,9 +68,9 @@ Each ```` 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 diff --git a/Help/prop_tgt/ENABLE_EXPORTS.rst b/Help/prop_tgt/ENABLE_EXPORTS.rst index e34c649de..1902d9480 100644 --- a/Help/prop_tgt/ENABLE_EXPORTS.rst +++ b/Help/prop_tgt/ENABLE_EXPORTS.rst @@ -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. diff --git a/Help/prop_tgt/IMPORTED_IMPLIB.rst b/Help/prop_tgt/IMPORTED_IMPLIB.rst index 27601d2ef..135c31c30 100644 --- a/Help/prop_tgt/IMPORTED_IMPLIB.rst +++ b/Help/prop_tgt/IMPORTED_IMPLIB.rst @@ -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 ```` by the configuration-specific diff --git a/Help/prop_tgt/IMPORTED_LOCATION.rst b/Help/prop_tgt/IMPORTED_LOCATION.rst index 915085b0f..2351374ff 100644 --- a/Help/prop_tgt/IMPORTED_LOCATION.rst +++ b/Help/prop_tgt/IMPORTED_LOCATION.rst @@ -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 ```` by the configuration-specific @@ -38,5 +34,5 @@ selected and its :prop_tgt:`IMPORTED_LOCATION_` value used. To get the location of an imported target read one of the :prop_tgt:`LOCATION` or ``LOCATION_`` 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`. diff --git a/Help/release/3.28.rst b/Help/release/3.28.rst index 200c0a30c..f002cd258 100644 --- a/Help/release/3.28.rst +++ b/Help/release/3.28.rst @@ -201,3 +201,15 @@ Other Changes * The precompiled Linux ``x86_64`` binaries provided on `cmake.org `_ 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. diff --git a/Modules/FetchContent.cmake b/Modules/FetchContent.cmake index f10684cc1..9bbeac0f4 100644 --- a/Modules/FetchContent.cmake +++ b/Modules/FetchContent.cmake @@ -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 diff --git a/Modules/FindCUDAToolkit.cmake b/Modules/FindCUDAToolkit.cmake index 0a22e63c8..b4c596c05 100644 --- a/Modules/FindCUDAToolkit.cmake +++ b/Modules/FindCUDAToolkit.cmake @@ -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) diff --git a/Modules/FindFreetype.cmake b/Modules/FindFreetype.cmake index 583d05600..735276944 100644 --- a/Modules/FindFreetype.cmake +++ b/Modules/FindFreetype.cmake @@ -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 () diff --git a/Modules/FindMatlab.cmake b/Modules/FindMatlab.cmake index 639cc5fdc..b90a45fda 100644 --- a/Modules/FindMatlab.cmake +++ b/Modules/FindMatlab.cmake @@ -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() diff --git a/Modules/FindTIFF.cmake b/Modules/FindTIFF.cmake index 4a93c04f7..58514a4c7 100644 --- a/Modules/FindTIFF.cmake +++ b/Modules/FindTIFF.cmake @@ -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) diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake index 42f354326..4c9d32b7e 100644 --- a/Source/CMakeVersion.cmake +++ b/Source/CMakeVersion.cmake @@ -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]* " diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx index 45073f7ac..8af92e545 100644 --- a/Source/cmGeneratorTarget.cxx +++ b/Source/cmGeneratorTarget.cxx @@ -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> perConfigCompileDefinitions; verifyTarget->FinalizeTargetConfiguration( diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx index ec2550a25..72dba42b0 100644 --- a/Source/cmGlobalXCodeGenerator.cxx +++ b/Source/cmGlobalXCodeGenerator.cxx @@ -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); } } diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index caac5355f..168cd4175 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -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_$>"); diff --git a/Source/cmQtAutoGenInitializer.cxx b/Source/cmQtAutoGenInitializer.cxx index 81752a619..50b0ebeb2 100644 --- a/Source/cmQtAutoGenInitializer.cxx +++ b/Source/cmQtAutoGenInitializer.cxx @@ -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; } diff --git a/Tests/RunCMake/CTestTimeout/TestTimeout.c b/Tests/RunCMake/CTestTimeout/TestTimeout.c index 425548c95..da397f8c8 100644 --- a/Tests/RunCMake/CTestTimeout/TestTimeout.c +++ b/Tests/RunCMake/CTestTimeout/TestTimeout.c @@ -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) diff --git a/Tests/RunCMake/Ninja/RunCMakeTest.cmake b/Tests/RunCMake/Ninja/RunCMakeTest.cmake index 69f2587e2..42ab1d816 100644 --- a/Tests/RunCMake/Ninja/RunCMakeTest.cmake +++ b/Tests/RunCMake/Ninja/RunCMakeTest.cmake @@ -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() diff --git a/Tests/RunCMake/try_compile/ISPCDuplicateTargetNinja-stderr.txt b/Tests/RunCMake/try_compile/ISPCDuplicateTargetNinja-stderr.txt index 99248bfea..155aff96b 100644 --- a/Tests/RunCMake/try_compile/ISPCDuplicateTargetNinja-stderr.txt +++ b/Tests/RunCMake/try_compile/ISPCDuplicateTargetNinja-stderr.txt @@ -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)