New upstream version 3.27.2

ci/unstable
Timo Röhling 1 year ago
parent 354615eb8f
commit 913341068d

@ -362,7 +362,7 @@ The options are:
.. versionadded:: 3.27 .. versionadded:: 3.27
Indicate that the command's ``DEPENDS`` argument represents all files Indicates that the command's ``DEPENDS`` argument represents all files
required by the command and implicit dependencies are not required. required by the command and implicit dependencies are not required.
Without this option, if any target uses the output of the custom command, Without this option, if any target uses the output of the custom command,
@ -376,6 +376,10 @@ The options are:
Only the :ref:`Ninja Generators` actually use this information to remove Only the :ref:`Ninja Generators` actually use this information to remove
unnecessary implicit dependencies. unnecessary implicit dependencies.
See also the :prop_tgt:`OPTIMIZE_DEPENDENCIES` target property, which may
provide another way for reducing the impact of target dependencies in some
scenarios.
Examples: Generating Files Examples: Generating Files
^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^

@ -170,9 +170,9 @@ File Operations
.. signature:: if(EXISTS <path-to-file-or-directory>) .. signature:: if(EXISTS <path-to-file-or-directory>)
True if the named file or directory exists. Behavior is well-defined True if the named file or directory exists and is readable. Behavior
only for explicit full paths (a leading ``~/`` is not expanded as is well-defined only for explicit full paths (a leading ``~/`` is not
a home directory and is considered a relative path). expanded as a home directory and is considered a relative path).
Resolves symbolic links, i.e. if the named file or directory is a Resolves symbolic links, i.e. if the named file or directory is a
symbolic link, returns true if the target of the symbolic link exists. symbolic link, returns true if the target of the symbolic link exists.

@ -322,10 +322,10 @@ were built in its own tree. For example:
add_executable(myexe src1.c src2.c ) add_executable(myexe src1.c src2.c )
target_link_libraries(myexe PRIVATE MathFunctions::MathFunctions) target_link_libraries(myexe PRIVATE MathFunctions::MathFunctions)
Line 1 loads the target CMake file. Although we only exported a single Line 2 loads the target CMake file. Although we only exported a single
target, this file may import any number of targets. Their locations are target, this file may import any number of targets. Their locations are
computed relative to the file location so that the install tree may be computed relative to the file location so that the install tree may be
easily moved. Line 3 references the imported ``MathFunctions`` library. The easily moved. Line 4 references the imported ``MathFunctions`` library. The
resulting build system will link to the library from its installed location. resulting build system will link to the library from its installed location.
Executables may also be exported and imported using the same process. Executables may also be exported and imported using the same process.

@ -27,30 +27,33 @@ varies by platform:
referencing the executable since the dynamic loader will referencing the executable since the dynamic loader will
automatically bind symbols when the module is loaded. automatically bind symbols when the module is loaded.
This property is initialized by the value of the variable This property is initialized by the value of the
:variable:`CMAKE_EXECUTABLE_ENABLE_EXPORTS` if it is set when an executable :variable:`CMAKE_EXECUTABLE_ENABLE_EXPORTS` variable, if it is set when an
target is created. executable target is created. If :variable:`CMAKE_EXECUTABLE_ENABLE_EXPORTS`
is not set, the :variable:`CMAKE_ENABLE_EXPORTS` variable is used to initialize
the property instead for backward compatibility reasons.
See below for alternative initialization behavior for shared library targets.
.. versionadded:: 3.27 .. versionadded:: 3.27
On macOS, to link with a shared library (standard one as well as framework), On Apple platforms, to link with a shared library (either a bare library or a
a linker import file (e.g. a text-based stubs file, with ``.tbd`` extension) framework), a linker import file can be used instead of the actual shared
can be used instead of the shared library itself. library. These linker import files are also known as text-based stubs, and
they have a ``.tbd`` file extension.
The generation of these linker import files, as well as the consumption, is The generation of these linker import files, as well as their consumption, is
controlled by this property. When this property is set to true, CMake will controlled by this property. When this property is set to true on a shared
generate a ``.tbd`` file for each shared library created by library target, CMake will generate a ``.tbd`` file for the library.
:command:`add_library` command. This allow other targets to use this ``.tbd`` Other targets that link to the shared library target will then use this
file to link to the library with the :command:`target_link_libraries` ``.tbd`` file when linking rather than linking to the shared library binary.
command.
.. note:: .. note::
For compatibility purpose, this property will be ignored if For backward compatibility reasons, this property will be ignored if the
:prop_tgt:`XCODE_ATTRIBUTE_GENERATE_TEXT_BASED_STUBS <XCODE_ATTRIBUTE_<an-attribute>>` :prop_tgt:`XCODE_ATTRIBUTE_GENERATE_TEXT_BASED_STUBS <XCODE_ATTRIBUTE_<an-attribute>>`
target property or the target property or the
:variable:`CMAKE_XCODE_ATTRIBUTE_GENERATE_TEXT_BASED_STUBS <CMAKE_XCODE_ATTRIBUTE_<an-attribute>>` :variable:`CMAKE_XCODE_ATTRIBUTE_GENERATE_TEXT_BASED_STUBS <CMAKE_XCODE_ATTRIBUTE_<an-attribute>>`
variable is set to ``NO``. variable is set to false.
This property is initialized by the value of the variable For shared library targets, this property is initialized by the value of the
:variable:`CMAKE_SHARED_LIBRARY_ENABLE_EXPORTS` if it is set when a shared :variable:`CMAKE_SHARED_LIBRARY_ENABLE_EXPORTS` variable, if it is set when
library target is created. the target is created.

@ -33,7 +33,7 @@ Generators
linker will cause a relink if they change (typically modified timestamps). linker will cause a relink if they change (typically modified timestamps).
See the :variable:`CMAKE_LINK_DEPENDS_USE_LINKER` variable. See the :variable:`CMAKE_LINK_DEPENDS_USE_LINKER` variable.
* The :ref:`Visual Studio Generators` for VS 2015 and above learned to * The :ref:`Visual Studio Generators` for VS 14 (2015) and above learned to
select the Windows SDK version explicitly using a ``version=`` field select the Windows SDK version explicitly using a ``version=`` field
in the :variable:`CMAKE_GENERATOR_PLATFORM` variable. in the :variable:`CMAKE_GENERATOR_PLATFORM` variable.
See :ref:`Visual Studio Platform Selection`. See :ref:`Visual Studio Platform Selection`.
@ -257,6 +257,9 @@ Other Changes
* :ref:`Visual Studio Generators`, for VS 15.8 (2017) and newer, now * :ref:`Visual Studio Generators`, for VS 15.8 (2017) and newer, now
build custom commands in parallel. See policy :policy:`CMP0147`. build custom commands in parallel. See policy :policy:`CMP0147`.
* :ref:`Visual Studio Generators` for VS 14 (2015) and above now prefer
to select the latest Windows SDK version. See policy :policy:`CMP0149`.
Updates Updates
======= =======
@ -268,3 +271,16 @@ Changes made since CMake 3.27.0 include the following.
* This version made no changes to documented features or interfaces. * This version made no changes to documented features or interfaces.
Some implementation updates were made to support ecosystem changes Some implementation updates were made to support ecosystem changes
and/or fix regressions. and/or fix regressions.
3.27.2
------
* :ref:`Visual Studio Generators` for VS 14 (2015) and above now prefer to
select the latest Windows SDK, as documented by policy :policy:`CMP0149`,
when targeting any version of Windows. In CMake 3.27.[0-1] the
preference was limited to targeting Windows 10 and above.
* :ref:`Visual Studio Generators` for VS 14 (2015) and above now support
using ``version=8.1`` in the :variable:`CMAKE_GENERATOR_PLATFORM` variable
to select the Windows 8.1 SDK. In CMake 3.27.[0-1] the ``version=`` field
was limited to selecting Windows 10 SDKs.

@ -3,9 +3,11 @@ CMAKE_ADD_CUSTOM_COMMAND_DEPENDS_EXPLICIT_ONLY
.. versionadded:: 3.27 .. versionadded:: 3.27
Whether to enable DEPENDS_EXPLICIT_ONLY option by default in Whether to enable the ``DEPENDS_EXPLICIT_ONLY`` option by default in
:command:`add_custom_command`. :command:`add_custom_command`.
This variable affects the default behavior of the :command:`add_custom_command` This variable affects the default behavior of the :command:`add_custom_command`
command. Setting this variable to ``ON`` is equivalent to using the ``DEPENDS_EXPLICIT_ONLY`` command. Setting this variable to ``ON`` is equivalent to using the
option in all uses of that command. ``DEPENDS_EXPLICIT_ONLY`` option in all uses of that command.
See also :variable:`CMAKE_OPTIMIZE_DEPENDENCIES`.

@ -9,6 +9,7 @@ This variable is used to initialize the :prop_tgt:`ENABLE_EXPORTS` target
property for executable targets when they are created by calls to the property for executable targets when they are created by calls to the
:command:`add_executable` command. See the property documentation for details. :command:`add_executable` command. See the property documentation for details.
This command has been superseded by the This variable has been superseded by the
:variable:`CMAKE_EXECUTABLE_ENABLE_EXPORTS` command. It is provided for :variable:`CMAKE_EXECUTABLE_ENABLE_EXPORTS` variable. It is provided for
compatibility with older CMake code. backward compatibility with older CMake code, but should not be used in new
projects.

@ -50,7 +50,7 @@ Supported pairs are:
.. versionadded:: 3.27 .. versionadded:: 3.27
Specify the Windows SDK version to use. This is supported by VS 2015 and Specify the Windows SDK version to use. This is supported by VS 2015 and
above when targeting Windows 10.0+ or Windows Store. CMake will set the above when targeting Windows or Windows Store. CMake will set the
:variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` variable to the :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` variable to the
selected SDK version. selected SDK version.
@ -66,6 +66,10 @@ Supported pairs are:
the value of :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM`, the value of :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM`,
if that variable is set. if that variable is set.
``8.1``
Specify the 8.1 SDK version. This is always supported by VS 2015.
On VS 2017 and above the 8.1 SDK must be installed.
If the ``version`` field is not specified, CMake selects a version as If the ``version`` field is not specified, CMake selects a version as
described in the :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION` described in the :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION`
variable documentation. variable documentation.

@ -383,6 +383,23 @@ foreach(JAVA_PROG "${JAVA_RUNTIME}" "${JAVA_COMPILE}" "${JAVA_ARCHIVE}")
endforeach() endforeach()
if(APPLE) if(APPLE)
if(DEFINED XCODE_VERSION)
set(_FindJNI_XCODE_VERSION "${XCODE_VERSION}")
else()
# get xcode version
execute_process(
COMMAND xcodebuild -version
OUTPUT_VARIABLE _xcode_version
)
string(REGEX REPLACE "Xcode ([0-9]+(\\.[0-9]+)*)" "\\1" _FindJNI_XCODE_VERSION ${_xcode_version})
unset(_xcode_version)
endif()
if(_FindJNI_XCODE_VERSION VERSION_GREATER 12.1)
set(CMAKE_FIND_FRAMEWORK "NEVER")
endif()
unset(_FindJNI_XCODE_VERSION)
if(CMAKE_FIND_FRAMEWORK STREQUAL "ONLY") if(CMAKE_FIND_FRAMEWORK STREQUAL "ONLY")
set(_JNI_SEARCHES FRAMEWORK) set(_JNI_SEARCHES FRAMEWORK)
elseif(CMAKE_FIND_FRAMEWORK STREQUAL "NEVER") elseif(CMAKE_FIND_FRAMEWORK STREQUAL "NEVER")

@ -2197,7 +2197,7 @@ if ("Interpreter" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
# retrieve various package installation directories # retrieve various package installation directories
execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
"import sys\ntry:\n import sysconfig\n sys.stdout.write(';'.join([sysconfig.get_path('stdlib'),sysconfig.get_path('platstdlib'),sysconfig.get_path('purelib'),sysconfig.get_path('platlib')]))\nexcept Exception:\n from distutils import sysconfig\n sys.stdout.write(';'.join([sysconfig.get_python_lib(plat_specific=False,standard_lib=True),sysconfig.get_python_lib(plat_specific=True,standard_lib=True),sysconfig.get_python_lib(plat_specific=False,standard_lib=False),sysconfig.get_python_lib(plat_specific=True,standard_lib=False)]))" "import sys\nif sys.version_info >= (3,10):\n import sysconfig\n sys.stdout.write(';'.join([sysconfig.get_path('stdlib'),sysconfig.get_path('platstdlib'),sysconfig.get_path('purelib'),sysconfig.get_path('platlib')]))\nelse:\n from distutils import sysconfig\n sys.stdout.write(';'.join([sysconfig.get_python_lib(plat_specific=False,standard_lib=True),sysconfig.get_python_lib(plat_specific=True,standard_lib=True),sysconfig.get_python_lib(plat_specific=False,standard_lib=False),sysconfig.get_python_lib(plat_specific=True,standard_lib=False)]))"
RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
OUTPUT_VARIABLE _${_PYTHON_PREFIX}_LIBPATHS OUTPUT_VARIABLE _${_PYTHON_PREFIX}_LIBPATHS
ERROR_QUIET) ERROR_QUIET)

@ -938,14 +938,10 @@ if(WIN32 AND NOT CYGWIN)
list(APPEND _tools cmcldeps) list(APPEND _tools cmcldeps)
endif() endif()
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "sparc") # Some atomic instructions are implemented using libatomic on some platforms.
# the atomic instructions are implemented using libatomic on some platforms, if(CMake_HAVE_CXX_ATOMIC_LIB)
# so linking to that may be required
check_library_exists(atomic __atomic_fetch_add_4 "" LIBATOMIC_NEEDED)
if(LIBATOMIC_NEEDED)
target_link_libraries(CMakeLib PUBLIC atomic) target_link_libraries(CMakeLib PUBLIC atomic)
endif() endif()
endif()
# On Apple we need CoreFoundation and CoreServices # On Apple we need CoreFoundation and CoreServices
if(APPLE) if(APPLE)

@ -1,7 +1,7 @@
# CMake version number components. # CMake version number components.
set(CMake_VERSION_MAJOR 3) set(CMake_VERSION_MAJOR 3)
set(CMake_VERSION_MINOR 27) set(CMake_VERSION_MINOR 27)
set(CMake_VERSION_PATCH 1) set(CMake_VERSION_PATCH 2)
#set(CMake_VERSION_RC 0) #set(CMake_VERSION_RC 0)
set(CMake_VERSION_IS_DIRTY 0) set(CMake_VERSION_IS_DIRTY 0)
@ -21,7 +21,7 @@ endif()
if(NOT CMake_VERSION_NO_GIT) if(NOT CMake_VERSION_NO_GIT)
# If this source was exported by 'git archive', use its commit info. # If this source was exported by 'git archive', use its commit info.
set(git_info [==[b5c54d9c8a CMake 3.27.1]==]) set(git_info [==[f3d9a82110 CMake 3.27.2]==])
# Otherwise, try to identify the current development source version. # 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]* " 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]* "

@ -0,0 +1,6 @@
#include <atomic>
int main()
{
std::atomic<long long>(0).load();
return 0;
}

@ -0,0 +1 @@
#include "cm_cxx_atomic.cxx"

@ -0,0 +1 @@
#include "cm_cxx_atomic.cxx"

@ -17,6 +17,7 @@ function(cm_check_cxx_feature name)
try_run(CMake_RUN_CXX_${FEATURE} CMake_COMPILE_CXX_${FEATURE} try_run(CMake_RUN_CXX_${FEATURE} CMake_COMPILE_CXX_${FEATURE}
${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_LIST_DIR}/cm_cxx_${name}.cxx ${CMAKE_CURRENT_LIST_DIR}/cm_cxx_${name}.cxx
LINK_LIBRARIES ${cm_check_cxx_feature_LINK_LIBRARIES}
CMAKE_FLAGS ${maybe_cxx_standard} CMAKE_FLAGS ${maybe_cxx_standard}
OUTPUT_VARIABLE OUTPUT OUTPUT_VARIABLE OUTPUT
) )
@ -29,6 +30,7 @@ function(cm_check_cxx_feature name)
try_compile(CMake_HAVE_CXX_${FEATURE} try_compile(CMake_HAVE_CXX_${FEATURE}
${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_LIST_DIR}/cm_cxx_${name}.cxx ${CMAKE_CURRENT_LIST_DIR}/cm_cxx_${name}.cxx
LINK_LIBRARIES ${cm_check_cxx_feature_LINK_LIBRARIES}
CMAKE_FLAGS ${maybe_cxx_standard} CMAKE_FLAGS ${maybe_cxx_standard}
OUTPUT_VARIABLE OUTPUT OUTPUT_VARIABLE OUTPUT
) )
@ -93,3 +95,12 @@ if (NOT CMAKE_CXX_STANDARD LESS "17")
else() else()
set(CMake_HAVE_CXX_FILESYSTEM FALSE) set(CMake_HAVE_CXX_FILESYSTEM FALSE)
endif() endif()
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "armv7l|sparc")
cm_check_cxx_feature(atomic_builtin)
if(NOT CMake_HAVE_CXX_ATOMIC_BUILTIN)
set(cm_check_cxx_feature_LINK_LIBRARIES atomic)
cm_check_cxx_feature(atomic_lib) # defines CMake_HAVE_CXX_ATOMIC_LIB
unset(cm_check_cxx_feature_LINK_LIBRARIES)
endif()
endif()

@ -2555,8 +2555,9 @@ bool HandleGenerateCommand(std::vector<std::string> const& args,
return false; return false;
} }
const bool inputIsContent = arguments.ParsedKeywords[1] == "CONTENT"_s; const bool inputIsContent = arguments.ParsedKeywords[1] == "CONTENT"_s;
if (!inputIsContent && arguments.ParsedKeywords[1] == "INPUT") { if (!inputIsContent && arguments.ParsedKeywords[1] != "INPUT") {
status.SetError("Unknown argument to GENERATE subcommand."); status.SetError("Unknown argument to GENERATE subcommand.");
return false;
} }
std::string const& input = std::string const& input =
inputIsContent ? *arguments.Content : *arguments.Input; inputIsContent ? *arguments.Content : *arguments.Input;

@ -544,7 +544,7 @@ bool cmGlobalVisualStudio10Generator::InitializePlatformWindows(cmMakefile*)
} }
bool cmGlobalVisualStudio10Generator::VerifyNoGeneratorPlatformVersion( bool cmGlobalVisualStudio10Generator::VerifyNoGeneratorPlatformVersion(
cmMakefile*, cm::optional<std::string>) const cmMakefile*) const
{ {
return true; return true;
} }

@ -187,8 +187,7 @@ protected:
bool InitializePlatform(cmMakefile* mf) override; bool InitializePlatform(cmMakefile* mf) override;
virtual bool InitializePlatformWindows(cmMakefile* mf); virtual bool InitializePlatformWindows(cmMakefile* mf);
virtual bool VerifyNoGeneratorPlatformVersion( virtual bool VerifyNoGeneratorPlatformVersion(cmMakefile* mf) const;
cmMakefile* mf, cm::optional<std::string> reason = cm::nullopt) const;
virtual bool ProcessGeneratorToolsetField(std::string const& key, virtual bool ProcessGeneratorToolsetField(std::string const& key,
std::string const& value); std::string const& value);

@ -6,6 +6,7 @@
#include <sstream> #include <sstream>
#include <cm/vector> #include <cm/vector>
#include <cmext/string_view>
#include "cmGlobalGenerator.h" #include "cmGlobalGenerator.h"
#include "cmGlobalGeneratorFactory.h" #include "cmGlobalGeneratorFactory.h"
@ -140,14 +141,103 @@ bool cmGlobalVisualStudio14Generator::MatchesGeneratorName(
bool cmGlobalVisualStudio14Generator::InitializePlatformWindows(cmMakefile* mf) bool cmGlobalVisualStudio14Generator::InitializePlatformWindows(cmMakefile* mf)
{ {
if (cmHasLiteralPrefix(this->SystemVersion, "10.0")) { // If a Windows SDK version is explicitly requested, search for it.
if (this->GeneratorPlatformVersion) {
std::string const& version = *this->GeneratorPlatformVersion;
// VS 2019 and above support specifying plain "10.0".
if (version == "10.0"_s) {
if (this->Version >= VSVersion::VS16) {
this->SetWindowsTargetPlatformVersion("10.0", mf);
return true;
}
/* clang-format off */
mf->IssueMessage(MessageType::FATAL_ERROR, cmStrCat(
"Generator\n"
" ", this->GetName(), "\n"
"given platform specification containing a\n"
" version=10.0\n"
"field. The value 10.0 is only supported by VS 2019 and above.\n"
));
/* clang-format on */
return false;
}
if (cmHasLiteralPrefix(version, "10.0.")) {
return this->SelectWindows10SDK(mf); return this->SelectWindows10SDK(mf);
} }
return this->VerifyNoGeneratorPlatformVersion(mf);
if (version == "8.1"_s) {
if (this->IsWin81SDKInstalled()) {
this->SetWindowsTargetPlatformVersion("8.1", mf);
return true;
}
/* clang-format off */
mf->IssueMessage(MessageType::FATAL_ERROR, cmStrCat(
"Generator\n"
" ", this->GetName(), "\n"
"given platform specification containing a\n"
" version=8.1\n"
"field, but the Windows 8.1 SDK is not installed.\n"
));
/* clang-format on */
return false;
}
if (version.empty()) {
/* clang-format off */
mf->IssueMessage(MessageType::FATAL_ERROR, cmStrCat(
"Generator\n"
" ", this->GetName(), "\n"
"given platform specification with empty\n"
" version=\n"
"field.\n"
));
/* clang-format on */
return false;
}
/* clang-format off */
mf->IssueMessage(MessageType::FATAL_ERROR, cmStrCat(
"Generator\n"
" ", this->GetName(), "\n"
"given platform specification containing a\n"
" version=", version, "\n"
"field with unsupported value.\n"
));
/* clang-format on */
return false;
}
// If we are targeting Windows 10+, we select a Windows 10 SDK.
// If no Windows 8.1 SDK is installed, which is possible with VS 2017 and
// higher, then we must choose a Windows 10 SDK anyway.
if (cmHasLiteralPrefix(this->SystemVersion, "10.0") ||
!this->IsWin81SDKInstalled()) {
return this->SelectWindows10SDK(mf);
}
// Under CMP0149 NEW behavior, we search for a Windows 10 SDK even
// when targeting older Windows versions, but it is not required.
if (mf->GetPolicyStatus(cmPolicies::CMP0149) == cmPolicies::NEW) {
std::string const version = this->GetWindows10SDKVersion(mf);
if (!version.empty()) {
this->SetWindowsTargetPlatformVersion(version, mf);
return true;
}
}
// We are not targeting Windows 10+, so fall back to the Windows 8.1 SDK.
// For VS 2019 and above we must explicitly specify it.
if (this->Version >= cmGlobalVisualStudioGenerator::VSVersion::VS16 &&
!cmSystemTools::VersionCompareGreater(this->SystemVersion, "8.1")) {
this->SetWindowsTargetPlatformVersion("8.1", mf);
}
return true;
} }
bool cmGlobalVisualStudio14Generator::VerifyNoGeneratorPlatformVersion( bool cmGlobalVisualStudio14Generator::VerifyNoGeneratorPlatformVersion(
cmMakefile* mf, cm::optional<std::string> reason) const cmMakefile* mf) const
{ {
if (!this->GeneratorPlatformVersion) { if (!this->GeneratorPlatformVersion) {
return true; return true;
@ -163,9 +253,6 @@ bool cmGlobalVisualStudio14Generator::VerifyNoGeneratorPlatformVersion(
" " << this->SystemName << " " << this->SystemVersion << "\n" " " << this->SystemName << " " << this->SystemVersion << "\n"
; ;
/* clang-format on */ /* clang-format on */
if (reason) {
e << *reason << ".";
}
mf->IssueMessage(MessageType::FATAL_ERROR, e.str()); mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
return false; return false;
} }
@ -207,16 +294,6 @@ bool cmGlobalVisualStudio14Generator::ProcessGeneratorPlatformField(
bool cmGlobalVisualStudio14Generator::SelectWindows10SDK(cmMakefile* mf) bool cmGlobalVisualStudio14Generator::SelectWindows10SDK(cmMakefile* mf)
{ {
if (this->GeneratorPlatformVersion &&
this->GeneratorPlatformVersion->empty()) {
mf->IssueMessage(
MessageType::FATAL_ERROR,
cmStrCat("Generator\n ", this->GetName(),
"\ngiven platform specification with empty\n version=\n"
"field."));
return false;
}
// Find the default version of the Windows 10 SDK. // Find the default version of the Windows 10 SDK.
std::string const version = this->GetWindows10SDKVersion(mf); std::string const version = this->GetWindows10SDKVersion(mf);
@ -248,7 +325,8 @@ void cmGlobalVisualStudio14Generator::SetWindowsTargetPlatformVersion(
std::string const& version, cmMakefile* mf) std::string const& version, cmMakefile* mf)
{ {
this->WindowsTargetPlatformVersion = version; this->WindowsTargetPlatformVersion = version;
if (!cmSystemTools::VersionCompareEqual(this->WindowsTargetPlatformVersion, if (!this->WindowsTargetPlatformVersion.empty() &&
!cmSystemTools::VersionCompareEqual(this->WindowsTargetPlatformVersion,
this->SystemVersion)) { this->SystemVersion)) {
std::ostringstream e; std::ostringstream e;
e << "Selecting Windows SDK version " << this->WindowsTargetPlatformVersion e << "Selecting Windows SDK version " << this->WindowsTargetPlatformVersion
@ -295,6 +373,11 @@ bool cmGlobalVisualStudio14Generator::IsWindowsStoreToolsetInstalled() const
cmSystemTools::KeyWOW64_32); cmSystemTools::KeyWOW64_32);
} }
bool cmGlobalVisualStudio14Generator::IsWin81SDKInstalled() const
{
return true;
}
std::string cmGlobalVisualStudio14Generator::GetWindows10SDKMaxVersion( std::string cmGlobalVisualStudio14Generator::GetWindows10SDKMaxVersion(
cmMakefile* mf) const cmMakefile* mf) const
{ {
@ -356,16 +439,6 @@ std::string cmGlobalVisualStudio14Generator::GetWindows10SDKVersion(
cmMakefile* mf) cmMakefile* mf)
{ {
#if defined(_WIN32) && !defined(__CYGWIN__) #if defined(_WIN32) && !defined(__CYGWIN__)
// Accept specific version requests as-is.
if (this->GeneratorPlatformVersion) {
std::string const& ver = *this->GeneratorPlatformVersion;
// VS 2019 and above support specifying plain "10.0".
if (this->Version >= VSVersion::VS16 && ver == "10.0") {
return ver;
}
}
std::vector<std::string> win10Roots; std::vector<std::string> win10Roots;
{ {

@ -40,10 +40,10 @@ protected:
// of the toolset is installed // of the toolset is installed
bool IsWindowsStoreToolsetInstalled() const; bool IsWindowsStoreToolsetInstalled() const;
virtual bool IsWin81SDKInstalled() const;
bool InitializePlatformWindows(cmMakefile* mf) override; bool InitializePlatformWindows(cmMakefile* mf) override;
bool VerifyNoGeneratorPlatformVersion( bool VerifyNoGeneratorPlatformVersion(cmMakefile* mf) const override;
cmMakefile* mf,
cm::optional<std::string> reason = cm::nullopt) const override;
bool ProcessGeneratorPlatformField(std::string const& key, bool ProcessGeneratorPlatformField(std::string const& key,
std::string const& value) override; std::string const& value) override;

@ -265,22 +265,6 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
auto new_end = std::unique(listFiles.begin(), listFiles.end()); auto new_end = std::unique(listFiles.begin(), listFiles.end());
listFiles.erase(new_end, listFiles.end()); listFiles.erase(new_end, listFiles.end());
// Add all cmake input files which are used by the project
// so Visual Studio does not close them when reloading it.
for (const std::string& listFile : listFiles) {
if (listFile.find("/CMakeFiles/") != std::string::npos) {
continue;
}
if (!cmSystemTools::IsSubDirectory(listFile,
lg.GetMakefile()->GetHomeDirectory()) &&
!cmSystemTools::IsSubDirectory(
listFile, lg.GetMakefile()->GetHomeOutputDirectory())) {
continue;
}
tgt->AddSource(listFile);
}
auto ptr = cm::make_unique<cmGeneratorTarget>(tgt, &lg); auto ptr = cm::make_unique<cmGeneratorTarget>(tgt, &lg);
auto* gt = ptr.get(); auto* gt = ptr.get();
lg.AddGeneratorTarget(std::move(ptr)); lg.AddGeneratorTarget(std::move(ptr));

@ -901,26 +901,6 @@ cmGlobalVisualStudioVersionedGenerator::FindAuxToolset(
return AuxToolset::PropsMissing; return AuxToolset::PropsMissing;
} }
bool cmGlobalVisualStudioVersionedGenerator::InitializePlatformWindows(
cmMakefile* mf)
{
// If the Win 8.1 SDK is installed then we can select a SDK matching
// the target Windows version.
if (this->IsWin81SDKInstalled()) {
// VS 2019 does not default to 8.1 so specify it explicitly when needed.
if (this->Version >= cmGlobalVisualStudioGenerator::VSVersion::VS16 &&
!cmSystemTools::VersionCompareGreater(this->SystemVersion, "8.1")) {
this->SetWindowsTargetPlatformVersion("8.1", mf);
return this->VerifyNoGeneratorPlatformVersion(
mf, "with the Windows 8.1 SDK installed");
}
return cmGlobalVisualStudio14Generator::InitializePlatformWindows(mf);
}
// Otherwise we must choose a Win 10 SDK even if we are not targeting
// Windows 10.
return this->SelectWindows10SDK(mf);
}
bool cmGlobalVisualStudioVersionedGenerator::SelectWindowsStoreToolset( bool cmGlobalVisualStudioVersionedGenerator::SelectWindowsStoreToolset(
std::string& toolset) const std::string& toolset) const
{ {

@ -72,10 +72,8 @@ protected:
// of the toolset is installed // of the toolset is installed
bool IsWindowsStoreToolsetInstalled() const; bool IsWindowsStoreToolsetInstalled() const;
bool InitializePlatformWindows(cmMakefile* mf) override;
// Check for a Win 8 SDK known to the registry or VS installer tool. // Check for a Win 8 SDK known to the registry or VS installer tool.
bool IsWin81SDKInstalled() const; bool IsWin81SDKInstalled() const override;
std::string GetWindows10SDKMaxVersionDefault(cmMakefile*) const override; std::string GetWindows10SDKMaxVersionDefault(cmMakefile*) const override;

@ -802,32 +802,35 @@ cmList& cmList::transform(TransformAction action,
return *this; return *this;
} }
std::string cmList::join(cm::string_view glue) const std::string& cmList::append(std::string& list, std::string&& value)
{
return cmJoin(this->Values, glue);
}
std::string& cmList::append(std::string& list, cm::string_view value)
{ {
if (list.empty()) { if (list.empty()) {
list = std::string(value); list = std::move(value);
} else { } else {
list += cmStrCat(cmList::element_separator, value); list += cmStrCat(cmList::element_separator, value);
} }
return list; return list;
} }
std::string& cmList::append(std::string& list, cm::string_view value)
{
return cmList::append(list, std::string{ value });
}
std::string& cmList::prepend(std::string& list, cm::string_view value) std::string& cmList::prepend(std::string& list, std::string&& value)
{ {
if (list.empty()) { if (list.empty()) {
list = std::string(value); list = std::move(value);
} else { } else {
list.insert(0, cmStrCat(value, cmList::element_separator)); list.insert(0, cmStrCat(value, cmList::element_separator));
} }
return list; return list;
} }
std::string& cmList::prepend(std::string& list, cm::string_view value)
{
return cmList::prepend(list, std::string{ value });
}
cmList::size_type cmList::ComputeIndex(index_type pos, bool boundCheck) const cmList::size_type cmList::ComputeIndex(index_type pos, bool boundCheck) const
{ {

@ -10,7 +10,6 @@
#include <initializer_list> #include <initializer_list>
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <numeric>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#include <utility> #include <utility>
@ -936,7 +935,10 @@ public:
std::vector<std::string> const& args, std::vector<std::string> const& args,
std::unique_ptr<TransformSelector> = {}); std::unique_ptr<TransformSelector> = {});
std::string join(cm::string_view glue) const; std::string join(cm::string_view glue) const
{
return cmList::Join(this->Values, glue);
}
void swap(cmList& other) noexcept { this->Values.swap(other.Values); } void swap(cmList& other) noexcept { this->Values.swap(other.Values); }
@ -1080,6 +1082,7 @@ public:
// but without any intermediate expansion. So the operation is simply a // but without any intermediate expansion. So the operation is simply a
// string concatenation with special handling for the CMake list item // string concatenation with special handling for the CMake list item
// separator // separator
static std::string& append(std::string& list, std::string&& value);
static std::string& append(std::string& list, cm::string_view value); static std::string& append(std::string& list, cm::string_view value);
template <typename InputIterator> template <typename InputIterator>
static std::string& append(std::string& list, InputIterator first, static std::string& append(std::string& list, InputIterator first,
@ -1089,15 +1092,11 @@ public:
return list; return list;
} }
return cmList::append(list, return cmList::append(
cm::string_view{ std::accumulate( list, cmList::Join(first, last, cmList::element_separator));
std::next(first), last, *first,
[](std::string a, const std::string& b) {
return std::move(a) +
std::string(cmList::element_separator) + b;
}) });
} }
static std::string& prepend(std::string& list, std::string&& value);
static std::string& prepend(std::string& list, cm::string_view value); static std::string& prepend(std::string& list, cm::string_view value);
template <typename InputIterator> template <typename InputIterator>
static std::string& prepend(std::string& list, InputIterator first, static std::string& prepend(std::string& list, InputIterator first,
@ -1107,13 +1106,8 @@ public:
return list; return list;
} }
return cmList::prepend(list, return cmList::prepend(
cm::string_view{ std::accumulate( list, cmList::Join(first, last, cmList::element_separator));
std::next(first), last, *first,
[](std::string a, const std::string& b) {
return std::move(a) +
std::string(cmList::element_separator) + b;
}) });
} }
// Non-members // Non-members
@ -1185,6 +1179,37 @@ private:
return container.begin() + delta; return container.begin() + delta;
} }
static std::string const& ToString(std::string const& s) { return s; }
static std::string ToString(cm::string_view s) { return std::string{ s }; }
template <typename Range>
static std::string Join(Range const& r, cm::string_view glue)
{
if (cm::size(r) == 0) {
return std::string{};
}
return cmList::Join(std::begin(r), std::end(r), glue);
}
template <typename InputIterator>
static std::string Join(InputIterator first, InputIterator last,
cm::string_view glue)
{
if (first == last) {
return std::string{};
}
const auto sep = std::string{ glue };
std::string joined = cmList::ToString(*first);
for (auto it = std::next(first); it != last; ++it) {
joined += sep;
joined += cmList::ToString(*it);
}
return joined;
}
container_type Values; container_type Values;
}; };

@ -68,7 +68,7 @@
#endif #endif
// List of variables that are replaced when // List of variables that are replaced when
// rules are expanced. These variables are // rules are expanded. These variables are
// replaced in the form <var> with GetSafeDefinition(var). // replaced in the form <var> with GetSafeDefinition(var).
// ${LANG} is replaced in the variable first with all enabled // ${LANG} is replaced in the variable first with all enabled
// languages. // languages.

@ -9,7 +9,6 @@
#include <set> #include <set>
#include <sstream> #include <sstream>
#include <cm/filesystem>
#include <cm/memory> #include <cm/memory>
#include <cm/optional> #include <cm/optional>
#include <cm/string_view> #include <cm/string_view>
@ -52,8 +51,6 @@
#include "cmValue.h" #include "cmValue.h"
#include "cmVisualStudioGeneratorOptions.h" #include "cmVisualStudioGeneratorOptions.h"
const std::string kBuildSystemSources = "Buildsystem Input Files";
struct cmIDEFlagTable; struct cmIDEFlagTable;
static void ConvertToWindowsSlash(std::string& s); static void ConvertToWindowsSlash(std::string& s);
@ -1954,14 +1951,8 @@ void cmVisualStudio10TargetGenerator::WriteGroups()
"http://schemas.microsoft.com/developer/msbuild/2003"); "http://schemas.microsoft.com/developer/msbuild/2003");
for (auto const& ti : this->Tools) { for (auto const& ti : this->Tools) {
if ((this->GeneratorTarget->GetName() ==
CMAKE_CHECK_BUILD_SYSTEM_TARGET) &&
(ti.first == "None")) {
this->WriteBuildSystemSources(e0, ti.first, ti.second);
} else {
this->WriteGroupSources(e0, ti.first, ti.second, sourceGroups); this->WriteGroupSources(e0, ti.first, ti.second, sourceGroups);
} }
}
// Added files are images and the manifest. // Added files are images and the manifest.
if (!this->AddedFiles.empty()) { if (!this->AddedFiles.empty()) {
@ -2031,18 +2022,6 @@ void cmVisualStudio10TargetGenerator::WriteGroups()
"rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;" "rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;"
"gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms"); "gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms");
} }
if (this->GeneratorTarget->GetName() ==
CMAKE_CHECK_BUILD_SYSTEM_TARGET) {
for (const std::string& filter : this->BuildSystemSourcesFilters) {
std::string guidName = "SG_Filter_";
guidName += filter;
std::string guid = this->GlobalGenerator->GetGUID(guidName);
Elem e2(e1, "Filter");
e2.Attribute("Include", filter);
e2.Element("UniqueIdentifier", "{" + guid + "}");
}
}
} }
} }
fout << '\n'; fout << '\n';
@ -2109,39 +2088,6 @@ void cmVisualStudio10TargetGenerator::WriteGroupSources(
} }
} }
void cmVisualStudio10TargetGenerator::WriteBuildSystemSources(
Elem& e0, std::string const& name, ToolSources const& sources)
{
const std::string srcDir = this->Makefile->GetCurrentSourceDirectory();
const std::string::size_type srcDirLength = srcDir.length();
Elem e1(e0, "ItemGroup");
e1.SetHasElements();
for (ToolSource const& s : sources) {
cmSourceFile const* sf = s.SourceFile;
std::string const& source = sf->GetFullPath();
cm::filesystem::path sourcePath(source);
bool isInSrcDir = cmHasPrefix(source, srcDir);
std::string filter = kBuildSystemSources;
if (isInSrcDir) {
std::string parentPath = sourcePath.parent_path().string();
if (srcDir != parentPath) {
filter += parentPath.substr(srcDirLength);
}
ConvertToWindowsSlash(filter);
this->BuildSystemSourcesFilters.insert(filter);
}
std::string path = this->ConvertPath(source, s.RelativePath);
ConvertToWindowsSlash(path);
Elem e2(e1, name);
e2.Attribute("Include", path);
e2.Element("Filter", filter);
}
}
void cmVisualStudio10TargetGenerator::WriteHeaderSource( void cmVisualStudio10TargetGenerator::WriteHeaderSource(
Elem& e1, cmSourceFile const* sf, ConfigToSettings const& toolSettings) Elem& e1, cmSourceFile const* sf, ConfigToSettings const& toolSettings)
{ {

@ -194,9 +194,6 @@ private:
void WriteGroupSources(Elem& e0, std::string const& name, void WriteGroupSources(Elem& e0, std::string const& name,
ToolSources const& sources, ToolSources const& sources,
std::vector<cmSourceGroup>&); std::vector<cmSourceGroup>&);
void WriteBuildSystemSources(Elem& e0, std::string const& name,
ToolSources const& sources);
void AddMissingSourceGroups(std::set<cmSourceGroup const*>& groupsUsed, void AddMissingSourceGroups(std::set<cmSourceGroup const*>& groupsUsed,
const std::vector<cmSourceGroup>& allGroups); const std::vector<cmSourceGroup>& allGroups);
bool IsResxHeader(const std::string& headerFile); bool IsResxHeader(const std::string& headerFile);
@ -247,7 +244,6 @@ private:
std::set<std::string> ASanEnabledConfigurations; std::set<std::string> ASanEnabledConfigurations;
std::set<std::string> FuzzerEnabledConfigurations; std::set<std::string> FuzzerEnabledConfigurations;
std::map<std::string, std::string> SpectreMitigation; std::map<std::string, std::string> SpectreMitigation;
std::set<std::string> BuildSystemSourcesFilters;
cmGlobalVisualStudio10Generator* const GlobalGenerator; cmGlobalVisualStudio10Generator* const GlobalGenerator;
cmLocalVisualStudio10Generator* const LocalGenerator; cmLocalVisualStudio10Generator* const LocalGenerator;
std::set<std::string> CSharpCustomCommandNames; std::set<std::string> CSharpCustomCommandNames;

@ -859,7 +859,7 @@ bool testStaticModifiers()
} }
{ {
std::string list{ "a;b;c" }; std::string list{ "a;b;c" };
cmList::append(list, ""); cmList::append(list, ""_s);
if (list != "a;b;c;") { if (list != "a;b;c;") {
result = false; result = false;
@ -894,7 +894,7 @@ bool testStaticModifiers()
} }
{ {
std::string list{ "a;b;c" }; std::string list{ "a;b;c" };
cmList::prepend(list, "d;e"); cmList::prepend(list, "d;e"_s);
if (list != "d;e;a;b;c") { if (list != "d;e;a;b;c") {
result = false; result = false;
@ -902,7 +902,7 @@ bool testStaticModifiers()
} }
{ {
std::string list; std::string list;
cmList::prepend(list, "d;e"); cmList::prepend(list, "d;e"_s);
if (list != "d;e") { if (list != "d;e") {
result = false; result = false;
@ -910,7 +910,7 @@ bool testStaticModifiers()
} }
{ {
std::string list{ "a;b;c" }; std::string list{ "a;b;c" };
cmList::prepend(list, ""); cmList::prepend(list, ""_s);
if (list != ";a;b;c") { if (list != ";a;b;c") {
result = false; result = false;

@ -896,216 +896,6 @@ def gen_check_targets(c, g, inSource):
if e["id"] == "^ZERO_CHECK::@6890427a1f51a3e7e1df$": if e["id"] == "^ZERO_CHECK::@6890427a1f51a3e7e1df$":
# The json files have data for Xcode. Substitute data for VS. # The json files have data for Xcode. Substitute data for VS.
e["sources"] = [ e["sources"] = [
{
"path": "^CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^alias/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^codemodel-v2\\.cmake$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^custom/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^cxx/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^framework/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^dir/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^dir/dir/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^fileset/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^imported/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^include_test\\.cmake$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^interface/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^object/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{
"path": "^subdir/CMakeLists\\.txt$",
"isGenerated": None,
"fileSetName": None,
"sourceGroupName": "",
"compileGroupLanguage": None,
"backtrace": [
{
"file": "^CMakeLists\\.txt$",
"line": None,
"command": None,
"hasParent": False,
},
],
},
{ {
"path": "^.*/Tests/RunCMake/FileAPI/codemodel-v2-build/CMakeFiles/([0-9a-f]+/)?generate\\.stamp\\.rule$", "path": "^.*/Tests/RunCMake/FileAPI/codemodel-v2-build/CMakeFiles/([0-9a-f]+/)?generate\\.stamp\\.rule$",
"isGenerated": True, "isGenerated": True,
@ -1123,25 +913,6 @@ def gen_check_targets(c, g, inSource):
}, },
] ]
e["sourceGroups"] = [ e["sourceGroups"] = [
{
"name": "",
"sourcePaths": [
"^CMakeLists\\.txt$",
"^alias/CMakeLists\\.txt$",
"^codemodel-v2\\.cmake$",
"^custom/CMakeLists\\.txt$",
"^cxx/CMakeLists\\.txt$",
"^framework/CMakeLists\\.txt$",
"^dir/CMakeLists\\.txt$",
"^dir/dir/CMakeLists\\.txt$",
"^fileset/CMakeLists\\.txt$",
"^imported/CMakeLists\\.txt$",
"^include_test\\.cmake$",
"^interface/CMakeLists\\.txt$",
"^object/CMakeLists\\.txt$",
"^subdir/CMakeLists\\.txt$",
],
},
{ {
"name": "CMake Rules", "name": "CMake Rules",
"sourcePaths": [ "sourcePaths": [

@ -0,0 +1,4 @@
^CMake Error at OutOfOrderArgs\.cmake:[0-9]+ \(file\):
file Unknown argument to GENERATE subcommand\.
Call Stack \(most recent call first\):
CMakeLists\.txt:[0-9]+ \(include\)$

@ -0,0 +1,4 @@
file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/output.txt"
CONDITION 1
CONTENT "CONTENT argument"
)

@ -15,6 +15,7 @@ endif()
run_cmake(EmptyCondition1) run_cmake(EmptyCondition1)
run_cmake(EmptyCondition2) run_cmake(EmptyCondition2)
run_cmake(BadCondition) run_cmake(BadCondition)
run_cmake(OutOfOrderArgs)
run_cmake(DebugEvaluate) run_cmake(DebugEvaluate)
run_cmake(GenerateSource) run_cmake(GenerateSource)
run_cmake(InputAndContent) run_cmake(InputAndContent)

@ -6,6 +6,6 @@
given platform specification with given platform specification with
version=1\.2\.3\.4 version=10\.0\.0\.0
field, but no Windows SDK with that version was found\.$ field, but no Windows SDK with that version was found\.$

@ -1,19 +0,0 @@
^CMake Error at CMakeLists.txt:[0-9]+ \(project\):
Generator
Visual Studio [^
]+
given platform specification (containing a
version=8\.1
field\. The version field is not supported when targeting
Windows 8\.1(
with the Windows 8\.1 SDK installed\.)?|with
version=8\.1
field, but no Windows SDK with that version was found\.)$

@ -0,0 +1,11 @@
^CMake Error at CMakeLists.txt:[0-9]+ \(project\):
Generator
Visual Studio [^
]+
given platform specification containing a
version=10\.0
field\. The value 10\.0 is only supported by VS 2019 and above\.$

@ -0,0 +1,11 @@
^CMake Error at CMakeLists.txt:[0-9]+ \(project\):
Generator
Visual Studio [^
]+
given platform specification containing a
version=1\.2\.3\.4
field with unsupported value\.$

@ -0,0 +1 @@
message(FATAL_ERROR "This should not be reached!")

@ -36,12 +36,16 @@ if("${RunCMake_GENERATOR}" MATCHES "^Visual Studio (1[4567])( 20[0-9][0-9])?$")
run_cmake(BadFieldUnknown) run_cmake(BadFieldUnknown)
set(RunCMake_GENERATOR_PLATFORM "version=") set(RunCMake_GENERATOR_PLATFORM "version=")
run_cmake(BadVersionEmpty) run_cmake(BadVersionEmpty)
set(RunCMake_GENERATOR_PLATFORM "version=1.2.3.4") set(RunCMake_GENERATOR_PLATFORM "version=10.0.0.0")
run_cmake(BadVersionMissing) run_cmake(BadVersionMissing)
set(RunCMake_GENERATOR_PLATFORM "version=8.1") set(RunCMake_GENERATOR_PLATFORM "version=1.2.3.4")
run_cmake_with_options(BadVersionPlatform -DCMAKE_SYSTEM_VERSION=8.1) run_cmake(BadVersionUnsupported)
if(NOT RunCMake_GENERATOR MATCHES "^Visual Studio (1[45]) ") if(RunCMake_GENERATOR MATCHES "^Visual Studio (1[45]) ")
set(RunCMake_GENERATOR_PLATFORM "version=10.0")
run_cmake(BadVersionPre2019)
unset(RunCMake_GENERATOR_PLATFORM)
else()
set(expect_version "10.0") set(expect_version "10.0")
set(RunCMake_GENERATOR_PLATFORM "version=${expect_version}") set(RunCMake_GENERATOR_PLATFORM "version=${expect_version}")
set(RunCMake_TEST_VARIANT_DESCRIPTION "-${expect_version}") set(RunCMake_TEST_VARIANT_DESCRIPTION "-${expect_version}")
@ -61,6 +65,16 @@ if("${RunCMake_GENERATOR}" MATCHES "^Visual Studio (1[4567])( 20[0-9][0-9])?$")
file(GLOB kits RELATIVE "${kitsInclude}" "${kitsInclude}/*/um/windows.h") file(GLOB kits RELATIVE "${kitsInclude}" "${kitsInclude}/*/um/windows.h")
list(TRANSFORM kits REPLACE "/.*" "") list(TRANSFORM kits REPLACE "/.*" "")
endif() endif()
cmake_host_system_information(RESULT kitsRoot81
QUERY WINDOWS_REGISTRY "HKLM/SOFTWARE/Microsoft/Windows Kits/Installed Roots"
VALUE "KitsRoot81"
VIEW 64_32
ERROR_VARIABLE kitsRoot81Error
)
if(NOT kitsRoot81Error AND EXISTS "${kitsRoot81}/include/um/windows.h")
list(PREPEND kits "8.1")
endif()
if(kits) if(kits)
message(STATUS "Available Kits: ${kits}") message(STATUS "Available Kits: ${kits}")
if(RunCMake_GENERATOR MATCHES "^Visual Studio 14 ") if(RunCMake_GENERATOR MATCHES "^Visual Studio 14 ")
@ -83,7 +97,6 @@ if("${RunCMake_GENERATOR}" MATCHES "^Visual Studio (1[4567])( 20[0-9][0-9])?$")
message(FATAL_ERROR "Could not find any Windows SDKs to drive test cases.") message(FATAL_ERROR "Could not find any Windows SDKs to drive test cases.")
endif() endif()
if(kits)
foreach(expect_version IN LISTS kits) foreach(expect_version IN LISTS kits)
set(RunCMake_GENERATOR_PLATFORM "version=${expect_version}") set(RunCMake_GENERATOR_PLATFORM "version=${expect_version}")
set(RunCMake_TEST_VARIANT_DESCRIPTION "-${expect_version}") set(RunCMake_TEST_VARIANT_DESCRIPTION "-${expect_version}")
@ -101,6 +114,7 @@ if("${RunCMake_GENERATOR}" MATCHES "^Visual Studio (1[4567])( 20[0-9][0-9])?$")
run_cmake_with_options(VersionExists -DCMAKE_SYSTEM_VERSION=${test_version} -DCMAKE_POLICY_DEFAULT_CMP0149=NEW) run_cmake_with_options(VersionExists -DCMAKE_SYSTEM_VERSION=${test_version} -DCMAKE_POLICY_DEFAULT_CMP0149=NEW)
endforeach() endforeach()
endif() endif()
list(REMOVE_ITEM kits 8.1)
foreach(expect_version IN LISTS kits) foreach(expect_version IN LISTS kits)
set(RunCMake_TEST_VARIANT_DESCRIPTION "-WindowsSDKVersion-${expect_version}") set(RunCMake_TEST_VARIANT_DESCRIPTION "-WindowsSDKVersion-${expect_version}")
set(ENV{WindowsSDKVersion} "${expect_version}\\") set(ENV{WindowsSDKVersion} "${expect_version}\\")
@ -108,4 +122,3 @@ if("${RunCMake_GENERATOR}" MATCHES "^Visual Studio (1[4567])( 20[0-9][0-9])?$")
unset(ENV{WindowsSDKVersion}) unset(ENV{WindowsSDKVersion})
endforeach() endforeach()
endif() endif()
endif()

@ -1,9 +1,13 @@
if(actual_stdout MATCHES "CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION='([^']+)'") if(actual_stdout MATCHES "CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION='([^']+)'")
set(actual_version "${CMAKE_MATCH_1}") set(actual_version "${CMAKE_MATCH_1}")
elseif(actual_stdout MATCHES "CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION=''" AND RunCMake_GENERATOR MATCHES "Visual Studio 1[45] ")
set(actual_version "8.1")
else()
set(RunCMake_TEST_FAILED "No CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION found in output.")
return()
endif()
if(NOT "${actual_version}" STREQUAL "${expect_version}") if(NOT "${actual_version}" STREQUAL "${expect_version}")
set(RunCMake_TEST_FAILED "Actual SDK version '${actual_version}' did not match expected '${expect_version}'") set(RunCMake_TEST_FAILED "Actual SDK version '${actual_version}' did not match expected '${expect_version}'")
return() return()
endif() endif()
else()
set(RunCMake_TEST_FAILED "No CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION found in output.")
endif()

@ -1,25 +0,0 @@
set(vcProjectFile "${RunCMake_TEST_BINARY_DIR}/ZERO_CHECK.vcxproj")
if(NOT EXISTS "${vcProjectFile}")
set(RunCMake_TEST_FAILED "Project file ${vcProjectFile} does not exist.")
return()
endif()
set(found_CMakeInputs 0)
file(STRINGS "${vcProjectFile}" lines)
foreach(line IN LISTS lines)
if(line MATCHES "<([A-Za-z0-9_]+) +Include=.*CMakeInputs.cmake")
set(rule "${CMAKE_MATCH_1}")
if(NOT rule STREQUAL "None")
set(RunCMake_TEST_FAILED "CMakeInputs.cmake referenced as ${rule} instead of None")
return()
endif()
if(found_CMakeInputs)
set(RunCMake_TEST_FAILED "CMakeInputs.cmake referenced multiple times")
return()
endif()
set(found_CMakeInputs 1)
endif()
endforeach()
if(NOT found_CMakeInputs)
set(RunCMake_TEST_FAILED "CMakeInputs.cmake not referenced")
endif()

@ -7,7 +7,6 @@ if(CMAKE_C_COMPILER_ID STREQUAL "MSVC" AND CMAKE_C_COMPILER_VERSION VERSION_GREA
run_cmake(LanguageStandard) run_cmake(LanguageStandard)
endif() endif()
run_cmake(CMakeInputs)
run_cmake(CustomCommandGenex) run_cmake(CustomCommandGenex)
if(NOT RunCMake_GENERATOR MATCHES "^Visual Studio 1[1-5] ") if(NOT RunCMake_GENERATOR MATCHES "^Visual Studio 1[1-5] ")
run_cmake(CustomCommandParallel) run_cmake(CustomCommandParallel)

@ -0,0 +1,9 @@
configure_file(ConfigureFile.in foo.txt @ONLY)
add_custom_target(foo)
add_custom_command(
OUTPUT bar.txt
MAIN_DEPENDENCY ConfigureFile.in # Attach to input of configure_file
DEPENDS foo
COMMAND ${CMAKE_COMMAND} -E copy foo.txt bar.txt
)
add_custom_target(bar DEPENDS bar.txt)

@ -7,6 +7,7 @@ run_cmake(BadArgument)
run_cmake(BadByproduct) run_cmake(BadByproduct)
run_cmake(BadOutput) run_cmake(BadOutput)
run_cmake(BadCommand) run_cmake(BadCommand)
run_cmake(ConfigureFile)
run_cmake(GeneratedProperty) run_cmake(GeneratedProperty)
run_cmake(LiteralQuotes) run_cmake(LiteralQuotes)
run_cmake(NoArguments) run_cmake(NoArguments)

@ -33,5 +33,8 @@ if(WIN32)
elseif(NOT APPLE) elseif(NOT APPLE)
target_link_libraries(cmcppdap PRIVATE Threads::Threads) target_link_libraries(cmcppdap PRIVATE Threads::Threads)
endif() endif()
if(CMake_HAVE_CXX_ATOMIC_LIB)
target_link_libraries(cmcppdap PRIVATE atomic)
endif()
install(FILES NOTICE DESTINATION ${CMAKE_DOC_DIR}/cmcppdap) install(FILES NOTICE DESTINATION ${CMAKE_DOC_DIR}/cmcppdap)

Loading…
Cancel
Save