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

Update upstream source from tag 'upstream/3.27.2'

Browse Source 
Update to upstream version '3.27.2'
with Debian dir f4ccc9b3250704019944e278e61e98e386b976b7
This commit is contained in:
Timo Röhling 2023-08-11 12:02:40 +02:00
commit e0471bbdfe
53 changed files with 374 additions and 516 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Help/command/add_custom_command.rst
View File

@ -362,7 +362,7 @@ The options are:
.. 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.
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
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
^^^^^^^^^^^^^^^^^^^^^^^^^^

6
Help/command/if.rst
View File

@ -170,9 +170,9 @@ File Operations
.. signature:: if(EXISTS <path-to-file-or-directory>)
True if the named file or directory exists. Behavior is well-defined
only for explicit full paths (a leading ``~/`` is not expanded as
a home directory and is considered a relative path).
True if the named file or directory exists and is readable. Behavior
is well-defined only for explicit full paths (a leading ``~/`` is not
expanded as a home directory and is considered a relative path).
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.

4
Help/guide/importing-exporting/index.rst
View File

@ -322,10 +322,10 @@ were built in its own tree. For example:
add_executable(myexe src1.c src2.c )
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
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.
Executables may also be exported and imported using the same process.

6
Help/manual/cmake-generator-expressions.7.rst
View File

@ -2267,9 +2267,9 @@ In the following, the phrase "the ``tgt`` filename" means the name of the
section for details. Many :ref:`Find Modules` produce imported targets
with the ``UNKNOWN`` type and therefore will be ignored.
On platforms that support runtime paths (``RPATH``), refer to the
:prop_tgt:`INSTALL_RPATH` target property.
On Apple platforms, refer to the :prop_tgt:`INSTALL_NAME_DIR` target property.
On platforms that support runtime paths (``RPATH``), refer to the
:prop_tgt:`INSTALL_RPATH` target property.
On Apple platforms, refer to the :prop_tgt:`INSTALL_NAME_DIR` target property.
.. genex:: $<TARGET_RUNTIME_DLL_DIRS:tgt>

45
Help/prop_tgt/ENABLE_EXPORTS.rst
View File

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

18
Help/release/3.27.rst
View File

@ -33,7 +33,7 @@ Generators
linker will cause a relink if they change (typically modified timestamps).
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
in the :variable:`CMAKE_GENERATOR_PLATFORM` variable.
See :ref:`Visual Studio Platform Selection`.
@ -257,6 +257,9 @@ Other Changes
* :ref:`Visual Studio Generators`, for VS 15.8 (2017) and newer, now
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
=======
@ -268,3 +271,16 @@ Changes made since CMake 3.27.0 include the following.
* This version made no changes to documented features or interfaces.
Some implementation updates were made to support ecosystem changes
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.

8
Help/variable/CMAKE_ADD_CUSTOM_COMMAND_DEPENDS_EXPLICIT_ONLY.rst
View File

@ -3,9 +3,11 @@ CMAKE_ADD_CUSTOM_COMMAND_DEPENDS_EXPLICIT_ONLY
.. 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`.
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``
option in all uses of that command.
command. Setting this variable to ``ON`` is equivalent to using the
``DEPENDS_EXPLICIT_ONLY`` option in all uses of that command.
See also :variable:`CMAKE_OPTIMIZE_DEPENDENCIES`.

7
Help/variable/CMAKE_ENABLE_EXPORTS.rst
View File

@ -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
:command:`add_executable` command. See the property documentation for details.
This command has been superseded by the
:variable:`CMAKE_EXECUTABLE_ENABLE_EXPORTS` command. It is provided for
compatibility with older CMake code.
This variable has been superseded by the
:variable:`CMAKE_EXECUTABLE_ENABLE_EXPORTS` variable. It is provided for
backward compatibility with older CMake code, but should not be used in new
projects.

6
Help/variable/CMAKE_GENERATOR_PLATFORM.rst
View File

@ -50,7 +50,7 @@ Supported pairs are:
.. versionadded:: 3.27
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
selected SDK version.
@ -66,6 +66,10 @@ Supported pairs are:
the value of :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM`,
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
described in the :variable:`CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION`
variable documentation.

17
Modules/FindJNI.cmake
View File

@ -383,6 +383,23 @@ foreach(JAVA_PROG "${JAVA_RUNTIME}" "${JAVA_COMPILE}" "${JAVA_ARCHIVE}")
endforeach()
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")
set(_JNI_SEARCHES FRAMEWORK)
elseif(CMAKE_FIND_FRAMEWORK STREQUAL "NEVER")

2
Modules/FindPython/Support.cmake
View File

@ -2197,7 +2197,7 @@ if ("Interpreter" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
# retrieve various package installation directories
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
OUTPUT_VARIABLE _${_PYTHON_PREFIX}_LIBPATHS
ERROR_QUIET)

10
Source/CMakeLists.txt
View File

@ -938,13 +938,9 @@ if(WIN32 AND NOT CYGWIN)
list(APPEND _tools cmcldeps)
endif()
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "sparc")
# the atomic instructions are implemented using libatomic on some platforms,
# 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)
endif()
# Some atomic instructions are implemented using libatomic on some platforms.
if(CMake_HAVE_CXX_ATOMIC_LIB)
target_link_libraries(CMakeLib PUBLIC atomic)
endif()
# On Apple we need CoreFoundation and CoreServices

4
Source/CMakeVersion.cmake
View File

@ -1,7 +1,7 @@
# CMake version number components.
set(CMake_VERSION_MAJOR 3)
set(CMake_VERSION_MINOR 27)
set(CMake_VERSION_PATCH 1)
set(CMake_VERSION_PATCH 2)
#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 [==[b5c54d9c8a CMake 3.27.1]==])
set(git_info [==[f3d9a82110 CMake 3.27.2]==])
# 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]* "

6
Source/Checks/cm_cxx_atomic.cxx Normal file
View File

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

1
Source/Checks/cm_cxx_atomic_builtin.cxx Normal file
View File

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

1
Source/Checks/cm_cxx_atomic_lib.cxx Normal file
View File

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

11
Source/Checks/cm_cxx_features.cmake
View File

@ -17,6 +17,7 @@ function(cm_check_cxx_feature name)
try_run(CMake_RUN_CXX_${FEATURE} CMake_COMPILE_CXX_${FEATURE}
${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_LIST_DIR}/cm_cxx_${name}.cxx
LINK_LIBRARIES ${cm_check_cxx_feature_LINK_LIBRARIES}
CMAKE_FLAGS ${maybe_cxx_standard}
OUTPUT_VARIABLE OUTPUT
)
@ -29,6 +30,7 @@ function(cm_check_cxx_feature name)
try_compile(CMake_HAVE_CXX_${FEATURE}
${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_LIST_DIR}/cm_cxx_${name}.cxx
LINK_LIBRARIES ${cm_check_cxx_feature_LINK_LIBRARIES}
CMAKE_FLAGS ${maybe_cxx_standard}
OUTPUT_VARIABLE OUTPUT
)
@ -93,3 +95,12 @@ if (NOT CMAKE_CXX_STANDARD LESS "17")
else()
set(CMake_HAVE_CXX_FILESYSTEM FALSE)
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()

3
Source/cmFileCommand.cxx
View File

@ -2555,8 +2555,9 @@ bool HandleGenerateCommand(std::vector<std::string> const& args,
return false;
}
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.");
return false;
}
std::string const& input =
inputIsContent ? *arguments.Content : *arguments.Input;

2
Source/cmGlobalVisualStudio10Generator.cxx
View File

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

3
Source/cmGlobalVisualStudio10Generator.h
View File

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

127
Source/cmGlobalVisualStudio14Generator.cxx
View File

@ -6,6 +6,7 @@
#include <sstream>
#include <cm/vector>
#include <cmext/string_view>
#include "cmGlobalGenerator.h"
#include "cmGlobalGeneratorFactory.h"
@ -140,14 +141,103 @@ bool cmGlobalVisualStudio14Generator::MatchesGeneratorName(
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);
}
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);
}
return this->VerifyNoGeneratorPlatformVersion(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(
cmMakefile* mf, cm::optional<std::string> reason) const
cmMakefile* mf) const
{
if (!this->GeneratorPlatformVersion) {
return true;
@ -163,9 +253,6 @@ bool cmGlobalVisualStudio14Generator::VerifyNoGeneratorPlatformVersion(
" " << this->SystemName << " " << this->SystemVersion << "\n"
;
/* clang-format on */
if (reason) {
e << *reason << ".";
}
mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
return false;
}
@ -207,16 +294,6 @@ bool cmGlobalVisualStudio14Generator::ProcessGeneratorPlatformField(
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.
std::string const version = this->GetWindows10SDKVersion(mf);
@ -248,7 +325,8 @@ void cmGlobalVisualStudio14Generator::SetWindowsTargetPlatformVersion(
std::string const& version, cmMakefile* mf)
{
this->WindowsTargetPlatformVersion = version;
if (!cmSystemTools::VersionCompareEqual(this->WindowsTargetPlatformVersion,
if (!this->WindowsTargetPlatformVersion.empty() &&
!cmSystemTools::VersionCompareEqual(this->WindowsTargetPlatformVersion,
this->SystemVersion)) {
std::ostringstream e;
e << "Selecting Windows SDK version " << this->WindowsTargetPlatformVersion
@ -295,6 +373,11 @@ bool cmGlobalVisualStudio14Generator::IsWindowsStoreToolsetInstalled() const
cmSystemTools::KeyWOW64_32);
}
bool cmGlobalVisualStudio14Generator::IsWin81SDKInstalled() const
{
return true;
}
std::string cmGlobalVisualStudio14Generator::GetWindows10SDKMaxVersion(
cmMakefile* mf) const
{
@ -356,16 +439,6 @@ std::string cmGlobalVisualStudio14Generator::GetWindows10SDKVersion(
cmMakefile* mf)
{
#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;
{

6
Source/cmGlobalVisualStudio14Generator.h
View File

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

16
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -265,22 +265,6 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
auto new_end = std::unique(listFiles.begin(), 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* gt = ptr.get();
lg.AddGeneratorTarget(std::move(ptr));

20
Source/cmGlobalVisualStudioVersionedGenerator.cxx
View File

@ -901,26 +901,6 @@ cmGlobalVisualStudioVersionedGenerator::FindAuxToolset(
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(
std::string& toolset) const
{

4
Source/cmGlobalVisualStudioVersionedGenerator.h
View File

@ -72,10 +72,8 @@ protected:
// of the toolset is installed
bool IsWindowsStoreToolsetInstalled() const;
bool InitializePlatformWindows(cmMakefile* mf) override;
// 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;

21
Source/cmList.cxx
View File

@ -802,32 +802,35 @@ cmList& cmList::transform(TransformAction action,
return *this;
}
std::string cmList::join(cm::string_view glue) const
{
return cmJoin(this->Values, glue);
}
std::string& cmList::append(std::string& list, cm::string_view value)
std::string& cmList::append(std::string& list, std::string&& value)
{
if (list.empty()) {
list = std::string(value);
list = std::move(value);
} else {
list += cmStrCat(cmList::element_separator, value);
}
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()) {
list = std::string(value);
list = std::move(value);
} else {
list.insert(0, cmStrCat(value, cmList::element_separator));
}
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
{

57
Source/cmList.h
View File

@ -10,7 +10,6 @@
#include <initializer_list>
#include <iterator>
#include <memory>
#include <numeric>
#include <stdexcept>
#include <string>
#include <utility>
@ -936,7 +935,10 @@ public:
std::vector<std::string> const& args,
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); }
@ -1080,6 +1082,7 @@ public:
// but without any intermediate expansion. So the operation is simply a
// string concatenation with special handling for the CMake list item
// separator
static std::string& append(std::string& list, std::string&& value);
static std::string& append(std::string& list, cm::string_view value);
template <typename InputIterator>
static std::string& append(std::string& list, InputIterator first,
@ -1089,15 +1092,11 @@ public:
return list;
}
return cmList::append(list,
cm::string_view{ std::accumulate(
std::next(first), last, *first,
[](std::string a, const std::string& b) {
return std::move(a) +
std::string(cmList::element_separator) + b;
}) });
return cmList::append(
list, cmList::Join(first, last, cmList::element_separator));
}
static std::string& prepend(std::string& list, std::string&& value);
static std::string& prepend(std::string& list, cm::string_view value);
template <typename InputIterator>
static std::string& prepend(std::string& list, InputIterator first,
@ -1107,13 +1106,8 @@ public:
return list;
}
return cmList::prepend(list,
cm::string_view{ std::accumulate(
std::next(first), last, *first,
[](std::string a, const std::string& b) {
return std::move(a) +
std::string(cmList::element_separator) + b;
}) });
return cmList::prepend(
list, cmList::Join(first, last, cmList::element_separator));
}
// Non-members
@ -1185,6 +1179,37 @@ private:
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;
};

2
Source/cmLocalGenerator.cxx
View File

@ -68,7 +68,7 @@
#endif
// 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).
// ${LANG} is replaced in the variable first with all enabled
// languages.

56
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -9,7 +9,6 @@
#include <set>
#include <sstream>
#include <cm/filesystem>
#include <cm/memory>
#include <cm/optional>
#include <cm/string_view>
@ -52,8 +51,6 @@
#include "cmValue.h"
#include "cmVisualStudioGeneratorOptions.h"
const std::string kBuildSystemSources = "Buildsystem Input Files";
struct cmIDEFlagTable;
static void ConvertToWindowsSlash(std::string& s);
@ -1954,13 +1951,7 @@ void cmVisualStudio10TargetGenerator::WriteGroups()
"http://schemas.microsoft.com/developer/msbuild/2003");
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.
@ -2031,18 +2022,6 @@ void cmVisualStudio10TargetGenerator::WriteGroups()
"rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;"
"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';
@ -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(
Elem& e1, cmSourceFile const* sf, ConfigToSettings const& toolSettings)
{

4
Source/cmVisualStudio10TargetGenerator.h
View File

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

8
Tests/CMakeLib/testList.cxx
View File

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

229
Tests/RunCMake/FileAPI/codemodel-v2-check.py
View File

@ -896,216 +896,6 @@ def gen_check_targets(c, g, inSource):
if e["id"] == "^ZERO_CHECK::@6890427a1f51a3e7e1df$":
# The json files have data for Xcode. Substitute data for VS.
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$",
"isGenerated": True,
@ -1123,25 +913,6 @@ def gen_check_targets(c, g, inSource):
},
]
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",
"sourcePaths": [

0
Tests/RunCMake/GeneratorPlatform/BadVersionPlatform-result.txt → Tests/RunCMake/File_Generate/OutOfOrderArgs-result.txt
View File

4
Tests/RunCMake/File_Generate/OutOfOrderArgs-stderr.txt Normal file
View File

@ -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\)$

4
Tests/RunCMake/File_Generate/OutOfOrderArgs.cmake Normal file
View File

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

1
Tests/RunCMake/File_Generate/RunCMakeTest.cmake
View File

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

2
Tests/RunCMake/GeneratorPlatform/BadVersionMissing-stderr.txt
View File

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

19
Tests/RunCMake/GeneratorPlatform/BadVersionPlatform-stderr.txt
View File

@ -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\.)$

1
Tests/RunCMake/GeneratorPlatform/BadVersionPre2019-result.txt Normal file
View File

@ -0,0 +1 @@
1

11
Tests/RunCMake/GeneratorPlatform/BadVersionPre2019-stderr.txt Normal file
View File

@ -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
Tests/RunCMake/GeneratorPlatform/BadVersionPlatform.cmake → Tests/RunCMake/GeneratorPlatform/BadVersionPre2019.cmake
View File

1
Tests/RunCMake/GeneratorPlatform/BadVersionUnsupported-result.txt Normal file
View File

@ -0,0 +1 @@
1

11
Tests/RunCMake/GeneratorPlatform/BadVersionUnsupported-stderr.txt Normal file
View File

@ -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\.$

1
Tests/RunCMake/GeneratorPlatform/BadVersionUnsupported.cmake Normal file
View File

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

67
Tests/RunCMake/GeneratorPlatform/RunCMakeTest.cmake
View File

@ -36,12 +36,16 @@ if("${RunCMake_GENERATOR}" MATCHES "^Visual Studio (1[4567])( 20[0-9][0-9])?$")
run_cmake(BadFieldUnknown)
set(RunCMake_GENERATOR_PLATFORM "version=")
run_cmake(BadVersionEmpty)
set(RunCMake_GENERATOR_PLATFORM "version=1.2.3.4")
set(RunCMake_GENERATOR_PLATFORM "version=10.0.0.0")
run_cmake(BadVersionMissing)
set(RunCMake_GENERATOR_PLATFORM "version=8.1")
run_cmake_with_options(BadVersionPlatform -DCMAKE_SYSTEM_VERSION=8.1)
set(RunCMake_GENERATOR_PLATFORM "version=1.2.3.4")
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(RunCMake_GENERATOR_PLATFORM "version=${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")
list(TRANSFORM kits REPLACE "/.*" "")
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)
message(STATUS "Available Kits: ${kits}")
if(RunCMake_GENERATOR MATCHES "^Visual Studio 14 ")
@ -83,29 +97,28 @@ 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.")
endif()
if(kits)
foreach(expect_version IN LISTS kits)
set(RunCMake_GENERATOR_PLATFORM "version=${expect_version}")
set(RunCMake_TEST_VARIANT_DESCRIPTION "-${expect_version}")
run_cmake_with_options(VersionExists -DCMAKE_SYSTEM_VERSION=10.0)
unset(RunCMake_GENERATOR_PLATFORM)
endforeach()
foreach(expect_version IN LISTS kits)
set(RunCMake_TEST_VARIANT_DESCRIPTION "-CMP0149-OLD-${expect_version}")
run_cmake_with_options(VersionExists -DCMAKE_SYSTEM_VERSION=${expect_version} -DCMAKE_POLICY_DEFAULT_CMP0149=OLD)
endforeach()
if(kits MATCHES "(^|;)([0-9.]+)$")
set(expect_version "${CMAKE_MATCH_2}")
foreach(test_version IN LISTS kits)
set(RunCMake_TEST_VARIANT_DESCRIPTION "-CMP0149-NEW-${test_version}")
run_cmake_with_options(VersionExists -DCMAKE_SYSTEM_VERSION=${test_version} -DCMAKE_POLICY_DEFAULT_CMP0149=NEW)
endforeach()
endif()
foreach(expect_version IN LISTS kits)
set(RunCMake_TEST_VARIANT_DESCRIPTION "-WindowsSDKVersion-${expect_version}")
set(ENV{WindowsSDKVersion} "${expect_version}\\")
run_cmake_with_options(VersionExists -DCMAKE_SYSTEM_VERSION=10.0 -DCMAKE_POLICY_DEFAULT_CMP0149=NEW)
unset(ENV{WindowsSDKVersion})
foreach(expect_version IN LISTS kits)
set(RunCMake_GENERATOR_PLATFORM "version=${expect_version}")
set(RunCMake_TEST_VARIANT_DESCRIPTION "-${expect_version}")
run_cmake_with_options(VersionExists -DCMAKE_SYSTEM_VERSION=10.0)
unset(RunCMake_GENERATOR_PLATFORM)
endforeach()
foreach(expect_version IN LISTS kits)
set(RunCMake_TEST_VARIANT_DESCRIPTION "-CMP0149-OLD-${expect_version}")
run_cmake_with_options(VersionExists -DCMAKE_SYSTEM_VERSION=${expect_version} -DCMAKE_POLICY_DEFAULT_CMP0149=OLD)
endforeach()
if(kits MATCHES "(^|;)([0-9.]+)$")
set(expect_version "${CMAKE_MATCH_2}")
foreach(test_version IN LISTS kits)
set(RunCMake_TEST_VARIANT_DESCRIPTION "-CMP0149-NEW-${test_version}")
run_cmake_with_options(VersionExists -DCMAKE_SYSTEM_VERSION=${test_version} -DCMAKE_POLICY_DEFAULT_CMP0149=NEW)
endforeach()
endif()
list(REMOVE_ITEM kits 8.1)
foreach(expect_version IN LISTS kits)
set(RunCMake_TEST_VARIANT_DESCRIPTION "-WindowsSDKVersion-${expect_version}")
set(ENV{WindowsSDKVersion} "${expect_version}\\")
run_cmake_with_options(VersionExists -DCMAKE_SYSTEM_VERSION=10.0 -DCMAKE_POLICY_DEFAULT_CMP0149=NEW)
unset(ENV{WindowsSDKVersion})
endforeach()
endif()

12
Tests/RunCMake/GeneratorPlatform/VersionExists-check.cmake
View File

@ -1,9 +1,13 @@
if(actual_stdout MATCHES "CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION='([^']+)'")
set(actual_version "${CMAKE_MATCH_1}")
if(NOT "${actual_version}" STREQUAL "${expect_version}")
set(RunCMake_TEST_FAILED "Actual SDK version '${actual_version}' did not match expected '${expect_version}'")
return()
endif()
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}")
set(RunCMake_TEST_FAILED "Actual SDK version '${actual_version}' did not match expected '${expect_version}'")
return()
endif()

25
Tests/RunCMake/VS10Project/CMakeInputs-check.cmake
View File

@ -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()

0
Tests/RunCMake/VS10Project/CMakeInputs.cmake
View File

1
Tests/RunCMake/VS10Project/RunCMakeTest.cmake
View File

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

9
Tests/RunCMake/add_custom_command/ConfigureFile.cmake Normal file
View File

@ -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)

1
Tests/RunCMake/add_custom_command/ConfigureFile.in Normal file
View File

@ -0,0 +1 @@
# ConfigureFile case

1
Tests/RunCMake/add_custom_command/RunCMakeTest.cmake
View File

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

3
Utilities/cmcppdap/CMakeLists.txt
View File

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