echo/CMake
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Drop Visual Studio 11 2012 generator

Browse Source 
This generator has been deprecated since CMake 3.25.  Remove it.
This commit is contained in:
Brad King 2023-06-13 13:48:20 -04:00
parent f444f172c3
commit 536c1de1d4
29 changed files with 23 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Help/command/add_custom_command.rst
View File

@ -512,7 +512,7 @@ one of the keywords to make clear the behavior they expect.
Because generator expressions can be used in custom commands,
it is possible to define ``COMMAND`` lines or whole custom commands
which evaluate to empty strings for certain configurations.
For **Visual Studio 11 2012 (and newer)** generators these command
For **Visual Studio 12 2013 (and newer)** generators these command
lines or custom commands will be omitted for the specific
configuration and no "empty-string-command" will be added.

59
Help/generator/Visual Studio 11 2012.rst
View File

@ -1,57 +1,8 @@
Visual Studio 11 2012
---------------------
Deprecated. Generates Visual Studio 11 (VS 2012) project files.
.. note::
This generator is deprecated and will be removed in a future version
of CMake. It will still be possible to build with VS 11 2012 tools
using the :generator:`Visual Studio 12 2013` (or above) generator
with :variable:`CMAKE_GENERATOR_TOOLSET` set to ``v110``, or by
using the :generator:`NMake Makefiles` generator.
For compatibility with CMake versions prior to 3.0, one may specify this
generator using the name "Visual Studio 11" without the year component.
Project Types
^^^^^^^^^^^^^
Only Visual C++ and C# projects may be generated (and Fortran with
Intel compiler integration). Other types of projects (JavaScript,
Database, Website, etc.) are not supported.
Platform Selection
^^^^^^^^^^^^^^^^^^
The default target platform name (architecture) is ``Win32``.
.. versionadded:: 3.1
The :variable:`CMAKE_GENERATOR_PLATFORM` variable may be set, perhaps
via the :option:`cmake -A` option, to specify a target platform
name (architecture). For example:
* ``cmake -G "Visual Studio 11 2012" -A Win32``
* ``cmake -G "Visual Studio 11 2012" -A x64``
* ``cmake -G "Visual Studio 11 2012" -A ARM``
* ``cmake -G "Visual Studio 11 2012" -A <WinCE-SDK>``
(Specify a target platform matching a Windows CE SDK name.)
For compatibility with CMake versions prior to 3.1, one may specify
a target platform name optionally at the end of the generator name.
This is supported only for:
``Visual Studio 11 2012 Win64``
Specify target platform ``x64``.
``Visual Studio 11 2012 ARM``
Specify target platform ``ARM``.
``Visual Studio 11 2012 <WinCE-SDK>``
Specify target platform matching a Windows CE SDK name.
Toolset Selection
^^^^^^^^^^^^^^^^^
The ``v110`` toolset that comes with Visual Studio 11 2012 is selected by
default. The :variable:`CMAKE_GENERATOR_TOOLSET` option may be set, perhaps
via the :option:`cmake -T` option, to specify another toolset.
Removed. This once generated Visual Studio 11 2012 project files, but
the generator has been removed since CMake 3.28. It is still possible
to build with VS 11 2012 tools using the :generator:`Visual Studio 12 2013`
(or above) generator with :variable:`CMAKE_GENERATOR_TOOLSET` set to ``v110``,
or by using the :generator:`NMake Makefiles` generator.

2
Help/prop_tgt/VS_DEBUGGER_COMMAND.rst
View File

@ -11,5 +11,5 @@ project file. This property is initialized by the value of the variable
:variable:`CMAKE_VS_DEBUGGER_COMMAND` if it is set when a target is
created.
This property only works for Visual Studio 11 2012 and above;
This property only works for Visual Studio 12 2013 and above;
it is ignored on other generators.

2
Help/prop_tgt/VS_DEBUGGER_COMMAND_ARGUMENTS.rst
View File

@ -11,5 +11,5 @@ project file. This property is initialized by the value of the variable
:variable:`CMAKE_VS_DEBUGGER_COMMAND_ARGUMENTS` if it is set when a target is
created.
This property only works for Visual Studio 11 2012 and above;
This property only works for Visual Studio 12 2013 and above;
it is ignored on other generators.

2
Help/prop_tgt/VS_DEBUGGER_ENVIRONMENT.rst
View File

@ -11,5 +11,5 @@ project file. This property is initialized by the value of the variable
:variable:`CMAKE_VS_DEBUGGER_ENVIRONMENT` if it is set when a target is
created.
This property only works for Visual Studio 11 2012 and above;
This property only works for Visual Studio 12 2013 and above;
it is ignored on other generators.

2
Help/prop_tgt/VS_DEBUGGER_WORKING_DIRECTORY.rst
View File

@ -11,5 +11,5 @@ project file. This property is initialized by the value of the variable
:variable:`CMAKE_VS_DEBUGGER_WORKING_DIRECTORY` if it is set when a target is
created.
This property only works for Visual Studio 11 2012 and above;
This property only works for Visual Studio 12 2013 and above;
it is ignored on other generators.

2
Help/prop_tgt/VS_DOTNET_STARTUP_OBJECT.rst
View File

@ -12,7 +12,7 @@ If the property is unset, Visual Studio uses the first matching
than one ``Main()`` method is available in the current project, the property
becomes mandatory for building the project.
This property only works for Visual Studio 11 2012 and above;
This property only works for Visual Studio 12 2013 and above;
it is ignored on other generators.
.. code-block:: cmake

2
Help/prop_tgt/VS_KEYWORD.rst
View File

@ -7,4 +7,4 @@ Can be set to change the visual studio keyword, for example Qt
integration works better if this is set to Qt4VSv1.0.
Use the :prop_tgt:`VS_GLOBAL_KEYWORD` target property to set the
keyword for Visual Studio 11 (2012) and newer.
keyword for Visual Studio 12 (2013) and newer.

4
Help/release/dev/remove-vs11-generator.rst Normal file
View File

@ -0,0 +1,4 @@
remove-vs11-generator
---------------------
* The :generator:`Visual Studio 11 2012` generator has been removed.

2
Help/variable/CMAKE_CFG_INTDIR.rst
View File

@ -19,7 +19,7 @@ Example values:
::
$(ConfigurationName) = Visual Studio 9
$(Configuration) = Visual Studio 11 and above
$(Configuration) = Visual Studio 12 and above
$(CONFIGURATION) = Xcode
. = Make-based tools
. = Ninja

2
Help/variable/CMAKE_VS_DEVENV_COMMAND.rst
View File

@ -10,5 +10,5 @@ This variable is not defined by other generators even if ``devenv.com``
is installed on the computer.
The :variable:`CMAKE_VS_MSBUILD_COMMAND` is also provided for
:generator:`Visual Studio 11 2012` and above.
:generator:`Visual Studio 12 2013` and above.
See also the :variable:`CMAKE_MAKE_PROGRAM` variable.

2
Help/variable/CMAKE_VS_MSBUILD_COMMAND.rst
View File

@ -1,7 +1,7 @@
CMAKE_VS_MSBUILD_COMMAND
------------------------
The generators for :generator:`Visual Studio 11 2012` and above set this
The generators for :generator:`Visual Studio 12 2013` and above set this
variable to the ``MSBuild.exe`` command installed with the corresponding
Visual Studio version.

2
Modules/CMakeDetermineCSharpCompiler.cmake
View File

@ -3,7 +3,7 @@
if(NOT ${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])")
message(FATAL_ERROR
"C# is currently only supported for Microsoft Visual Studio 11 2012 and later.")
"C# is currently only supported for Microsoft Visual Studio 12 2013 and later.")
endif()
include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)

4
Modules/UseSWIG.cmake
View File

@ -189,7 +189,7 @@ ensure generated files will receive the required settings.
:ref:`Makefile <Makefile Generators>`,
:ref:`Ninja <Ninja Generators>`, :generator:`Xcode`, and
:ref:`Visual Studio <Visual Studio Generators>`
(:generator:`Visual Studio 11 2012` and above) generators. Default value is
(:generator:`Visual Studio 12 2013` and above) generators. Default value is
``FALSE``.
.. versionadded:: 3.21
@ -353,7 +353,7 @@ as well as ``SWIG``:
:ref:`Makefile <Makefile Generators>`,
:ref:`Ninja <Ninja Generators>`, :generator:`Xcode`, and
:ref:`Visual Studio <Visual Studio Generators>`
(:generator:`Visual Studio 11 2012` and above) generators. Default value is
(:generator:`Visual Studio 12 2013` and above) generators. Default value is
``FALSE``.
Source file property ``USE_SWIG_DEPENDENCIES``, if not defined, will be

1
Source/cmGlobalVisualStudio10Generator.cxx
View File

@ -1230,7 +1230,6 @@ const char* cmGlobalVisualStudio10Generator::GetToolsVersion() const
{
switch (this->Version) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
case cmGlobalVisualStudioGenerator::VSVersion::VS11:
return "4.0";
// in Visual Studio 2013 they detached the MSBuild tools version

139
Source/cmGlobalVisualStudio11Generator.cxx
View File

@ -8,156 +8,17 @@
#include <vector>
#include "cmGlobalGenerator.h"
#include "cmGlobalGeneratorFactory.h"
#include "cmGlobalVisualStudioGenerator.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
static const char vs11generatorName[] = "Visual Studio 11 2012";
// Map generator name without year to name with year.
static const char* cmVS11GenName(const std::string& name, std::string& genName)
{
if (strncmp(name.c_str(), vs11generatorName,
sizeof(vs11generatorName) - 6) != 0) {
return nullptr;
}
const char* p = name.c_str() + sizeof(vs11generatorName) - 6;
if (cmHasLiteralPrefix(p, " 2012")) {
p += 5;
}
genName = std::string(vs11generatorName) + p;
return p;
}
class cmGlobalVisualStudio11Generator::Factory
: public cmGlobalGeneratorFactory
{
public:
std::unique_ptr<cmGlobalGenerator> CreateGlobalGenerator(
const std::string& name, bool allowArch, cmake* cm) const override
{
std::string genName;
const char* p = cmVS11GenName(name, genName);
if (!p) {
return std::unique_ptr<cmGlobalGenerator>();
}
if (!*p) {
return std::unique_ptr<cmGlobalGenerator>(
new cmGlobalVisualStudio11Generator(cm, genName, ""));
}
if (!allowArch || *p++ != ' ') {
return std::unique_ptr<cmGlobalGenerator>();
}
if (strcmp(p, "Win64") == 0) {
return std::unique_ptr<cmGlobalGenerator>(
new cmGlobalVisualStudio11Generator(cm, genName, "x64"));
}
if (strcmp(p, "ARM") == 0) {
return std::unique_ptr<cmGlobalGenerator>(
new cmGlobalVisualStudio11Generator(cm, genName, "ARM"));
}
std::set<std::string> installedSDKs =
cmGlobalVisualStudio11Generator::GetInstalledWindowsCESDKs();
if (installedSDKs.find(p) == installedSDKs.end()) {
return std::unique_ptr<cmGlobalGenerator>();
}
auto ret = std::unique_ptr<cmGlobalVisualStudio11Generator>(
new cmGlobalVisualStudio11Generator(cm, name, p));
ret->WindowsCEVersion = "8.00";
return std::unique_ptr<cmGlobalGenerator>(std::move(ret));
}
cmDocumentationEntry GetDocumentation() const override
{
return { std::string(vs11generatorName) + " [arch]",
"Deprecated. Generates Visual Studio 2012 project files. "
"Optional [arch] can be \"Win64\" or \"ARM\"." };
}
std::vector<std::string> GetGeneratorNames() const override
{
std::vector<std::string> names;
names.push_back(vs11generatorName);
return names;
}
std::vector<std::string> GetGeneratorNamesWithPlatform() const override
{
std::vector<std::string> names;
names.push_back(vs11generatorName + std::string(" ARM"));
names.push_back(vs11generatorName + std::string(" Win64"));
std::set<std::string> installedSDKs =
cmGlobalVisualStudio11Generator::GetInstalledWindowsCESDKs();
for (std::string const& i : installedSDKs) {
names.push_back(std::string(vs11generatorName) + " " + i);
}
return names;
}
bool SupportsToolset() const override { return true; }
bool SupportsPlatform() const override { return true; }
std::vector<std::string> GetKnownPlatforms() const override
{
std::vector<std::string> platforms;
platforms.emplace_back("x64");
platforms.emplace_back("Win32");
platforms.emplace_back("ARM");
std::set<std::string> installedSDKs =
cmGlobalVisualStudio11Generator::GetInstalledWindowsCESDKs();
for (std::string const& i : installedSDKs) {
platforms.emplace_back(i);
}
return platforms;
}
std::string GetDefaultPlatformName() const override { return "Win32"; }
};
std::unique_ptr<cmGlobalGeneratorFactory>
cmGlobalVisualStudio11Generator::NewFactory()
{
return std::unique_ptr<cmGlobalGeneratorFactory>(new Factory);
}
cmGlobalVisualStudio11Generator::cmGlobalVisualStudio11Generator(
cmake* cm, const std::string& name,
std::string const& platformInGeneratorName)
: cmGlobalVisualStudio10Generator(cm, name, platformInGeneratorName)
{
std::string vc11Express;
this->ExpressEdition = cmSystemTools::ReadRegistryValue(
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\11.0\\Setup\\VC;"
"ProductDir",
vc11Express, cmSystemTools::KeyWOW64_32);
this->DefaultPlatformToolset = "v110";
this->DefaultCLFlagTableName = "v11";
this->DefaultCSharpFlagTableName = "v11";
this->DefaultLibFlagTableName = "v11";
this->DefaultLinkFlagTableName = "v11";
this->DefaultMasmFlagTableName = "v11";
this->DefaultRCFlagTableName = "v11";
this->Version = VSVersion::VS11;
}
bool cmGlobalVisualStudio11Generator::MatchesGeneratorName(
const std::string& name) const
{
std::string genName;
if (cmVS11GenName(name, genName)) {
return genName == this->GetName();
}
return false;
}
void cmGlobalVisualStudio11Generator::EnableLanguage(

9
Source/cmGlobalVisualStudio11Generator.h
View File

@ -13,7 +13,6 @@
#include "cmGlobalVisualStudio10Generator.h"
#include "cmTransformDepfile.h"
class cmGlobalGeneratorFactory;
class cmMakefile;
class cmake;
@ -21,10 +20,6 @@ class cmake;
class cmGlobalVisualStudio11Generator : public cmGlobalVisualStudio10Generator
{
public:
static std::unique_ptr<cmGlobalGeneratorFactory> NewFactory();
bool MatchesGeneratorName(const std::string& name) const override;
void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
bool optional) override;
@ -58,8 +53,4 @@ protected:
/** Return true if target system supports debugging deployment. */
bool TargetSystemSupportsDeployment() const override;
private:
class Factory;
friend class Factory;
};

20
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -329,26 +329,6 @@ void cmGlobalVisualStudio7Generator::Generate()
"Add CMAKE_WARN_VS9=OFF to the cache to disable this warning.");
}
}
if (this->Version == VSVersion::VS11 &&
!this->CMakeInstance->GetIsInTryCompile()) {
std::string cmakeWarnVS11;
if (cmValue cached = this->CMakeInstance->GetState()->GetCacheEntryValue(
"CMAKE_WARN_VS11")) {
this->CMakeInstance->MarkCliAsUsed("CMAKE_WARN_VS11");
cmakeWarnVS11 = *cached;
} else {
cmSystemTools::GetEnv("CMAKE_WARN_VS11", cmakeWarnVS11);
}
if (cmakeWarnVS11.empty() || !cmIsOff(cmakeWarnVS11)) {
this->CMakeInstance->IssueMessage(
MessageType::WARNING,
"The \"Visual Studio 11 2012\" generator is deprecated "
"and will be removed in a future version of CMake."
"\n"
"Add CMAKE_WARN_VS11=OFF to the cache to disable this warning.");
}
}
}
void cmGlobalVisualStudio7Generator::OutputSLNFile(

10
Source/cmGlobalVisualStudioGenerator.cxx
View File

@ -97,8 +97,6 @@ const char* cmGlobalVisualStudioGenerator::GetIDEVersion() const
switch (this->Version) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
return "9.0";
case cmGlobalVisualStudioGenerator::VSVersion::VS11:
return "11.0";
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "12.0";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
@ -124,14 +122,6 @@ void cmGlobalVisualStudioGenerator::WriteSLNHeader(std::ostream& fout)
fout << "Microsoft Visual Studio Solution File, Format Version 10.00\n";
fout << "# Visual Studio 2008\n";
break;
case cmGlobalVisualStudioGenerator::VSVersion::VS11:
fout << "Microsoft Visual Studio Solution File, Format Version 12.00\n";
if (this->ExpressEdition) {
fout << "# Visual Studio Express 2012 for Windows Desktop\n";
} else {
fout << "# Visual Studio 2012\n";
}
break;
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
fout << "Microsoft Visual Studio Solution File, Format Version 12.00\n";
if (this->ExpressEdition) {

1
Source/cmGlobalVisualStudioGenerator.h
View File

@ -35,7 +35,6 @@ public:
enum class VSVersion : uint16_t
{
VS9 = 90,
VS11 = 110,
VS12 = 120,
/* VS13 = 130 was skipped */
VS14 = 140,

9
Source/cmGlobalVisualStudioVersionedGenerator.cxx
View File

@ -127,8 +127,6 @@ static unsigned int VSVersionToMajor(
switch (v) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
return 9;
case cmGlobalVisualStudioGenerator::VSVersion::VS11:
return 11;
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return 12;
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
@ -149,8 +147,6 @@ static const char* VSVersionToToolset(
switch (v) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
return "v90";
case cmGlobalVisualStudioGenerator::VSVersion::VS11:
return "v110";
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "v120";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
@ -171,8 +167,6 @@ static std::string VSVersionToMajorString(
switch (v) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
return "9";
case cmGlobalVisualStudioGenerator::VSVersion::VS11:
return "11";
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "12";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
@ -192,7 +186,6 @@ static const char* VSVersionToAndroidToolset(
{
switch (v) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
case cmGlobalVisualStudioGenerator::VSVersion::VS11:
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
@ -493,7 +486,6 @@ bool cmGlobalVisualStudioVersionedGenerator::MatchesGeneratorName(
std::string genName;
switch (this->Version) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
case cmGlobalVisualStudioGenerator::VSVersion::VS11:
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
break;
@ -761,7 +753,6 @@ cmGlobalVisualStudioVersionedGenerator::GetAndroidApplicationTypeRevision()
{
switch (this->Version) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
case cmGlobalVisualStudioGenerator::VSVersion::VS11:
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:

2
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -198,7 +198,7 @@ void cmLocalVisualStudio7Generator::GenerateTarget(cmGeneratorTarget* target)
// Intel Fortran always uses VS9 format ".vfproj" files.
cmGlobalVisualStudioGenerator::VSVersion realVersion = gg->GetVersion();
if (this->FortranProject &&
gg->GetVersion() >= cmGlobalVisualStudioGenerator::VSVersion::VS11) {
gg->GetVersion() >= cmGlobalVisualStudioGenerator::VSVersion::VS12) {
gg->SetVersion(cmGlobalVisualStudioGenerator::VSVersion::VS9);
}

1
Source/cmVisualStudioGeneratorOptions.cxx
View File

@ -75,7 +75,6 @@ void cmVisualStudioGeneratorOptions::FixExceptionHandlingDefault()
// the flag to disable exception handling. When the user does
// remove the flag we need to override the IDE default of on.
switch (this->Version) {
case cmGlobalVisualStudioGenerator::VSVersion::VS11:
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
case cmGlobalVisualStudioGenerator::VSVersion::VS15:

3
Source/cmake.cxx
View File

@ -94,7 +94,6 @@
# include "cmGlobalBorlandMakefileGenerator.h"
# include "cmGlobalJOMMakefileGenerator.h"
# include "cmGlobalNMakeMakefileGenerator.h"
# include "cmGlobalVisualStudio11Generator.h"
# include "cmGlobalVisualStudio12Generator.h"
# include "cmGlobalVisualStudio14Generator.h"
# include "cmGlobalVisualStudio9Generator.h"
@ -2605,7 +2604,6 @@ std::unique_ptr<cmGlobalGenerator> cmake::EvaluateDefaultGlobalGenerator()
static VSVersionedGenerator const vsGenerators[] = {
{ "14.0", "Visual Studio 14 2015" }, //
{ "12.0", "Visual Studio 12 2013" }, //
{ "11.0", "Visual Studio 11 2012" }, //
{ "9.0", "Visual Studio 9 2008" }
};
static const char* const vsEntries[] = {
@ -2990,7 +2988,6 @@ void cmake::AddDefaultGenerators()
cmGlobalVisualStudioVersionedGenerator::NewFactory15());
this->Generators.push_back(cmGlobalVisualStudio14Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio12Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio11Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio9Generator::NewFactory());
this->Generators.push_back(cmGlobalBorlandMakefileGenerator::NewFactory());
this->Generators.push_back(cmGlobalNMakeMakefileGenerator::NewFactory());

18
Tests/CMakeLists.txt
View File

@ -42,8 +42,6 @@ endif()
# Suppress generator deprecation warnings in test suite.
if(CMAKE_GENERATOR MATCHES "^Visual Studio 9 2008")
set(TEST_WARN_VS_CODE "set(ENV{CMAKE_WARN_VS9} OFF)")
elseif(CMAKE_GENERATOR MATCHES "^Visual Studio 11 2012")
set(TEST_WARN_VS_CODE "set(ENV{CMAKE_WARN_VS11} OFF)")
else()
set(TEST_WARN_VS_CODE "")
endif()
@ -2279,11 +2277,6 @@ if(BUILD_TESTING)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}")
endmacro()
if(vs11 AND ws80)
add_test_VSWinStorePhone(vs11-store80-X86 "Visual Studio 11 2012" WindowsStore 8.0 Win32)
add_test_VSWinStorePhone(vs11-store80-ARM "Visual Studio 11 2012" WindowsStore 8.0 ARM)
add_test_VSWinStorePhone(vs11-store80-X64 "Visual Studio 11 2012" WindowsStore 8.0 x64)
endif()
if(vs12 AND ws81)
add_test_VSWinStorePhone(vs12-store81-X86 "Visual Studio 12 2013" WindowsStore 8.1 Win32)
add_test_VSWinStorePhone(vs12-store81-ARM "Visual Studio 12 2013" WindowsStore 8.1 ARM)
@ -2311,10 +2304,6 @@ if(BUILD_TESTING)
add_test_VSWinStorePhone(vs14-store10_0-ARM "Visual Studio 14 2015" WindowsStore 10.0 ARM)
add_test_VSWinStorePhone(vs14-store10_0-X64 "Visual Studio 14 2015" WindowsStore 10.0 x64)
endif()
if(vs11 AND wp80)
add_test_VSWinStorePhone(vs11-phone80-X86 "Visual Studio 11 2012" WindowsPhone 8.0 Win32)
add_test_VSWinStorePhone(vs11-phone80-ARM "Visual Studio 11 2012" WindowsPhone 8.0 ARM)
endif()
if(vs12 AND wp81)
add_test_VSWinStorePhone(vs12-phone81-X86 "Visual Studio 12 2013" WindowsPhone 8.1 Win32)
add_test_VSWinStorePhone(vs12-phone81-ARM "Visual Studio 12 2013" WindowsPhone 8.1 ARM)
@ -2341,10 +2330,6 @@ if(BUILD_TESTING)
endforeach()
endmacro()
if(vs11)
add_test_VSWinCE(vs11-ce80-ARM "Visual Studio 11 2012" WindowsCE 8.0 ${wince_sdk})
endif()
if(vs12)
add_test_VSWinCE(vs12-ce80-ARM "Visual Studio 12 2013" WindowsCE 8.0 ${wince_sdk})
endif()
@ -2471,9 +2456,6 @@ if(BUILD_TESTING)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSAndroid/${name}")
endmacro()
if(tegra AND NOT "${CMake_SOURCE_DIR};${CMake_BINARY_DIR}" MATCHES " ")
if(vs11)
add_test_VSAndroid(vs11 "Visual Studio 11 2012" "Tegra-Android")
endif()
if(vs12)
add_test_VSAndroid(vs12 "Visual Studio 12 2013" "Tegra-Android")
endif()

0
Tests/RunCMake/CommandLine/DeprecateVS11-WARN-OFF.cmake
View File

5
Tests/RunCMake/CommandLine/DeprecateVS11-WARN-ON-stderr.txt
View File

@ -1,5 +0,0 @@
^CMake Warning:
The "Visual Studio 11 2012" generator is deprecated and will be removed in
a future version of CMake.
Add CMAKE_WARN_VS11=OFF to the cache to disable this warning.$

0
Tests/RunCMake/CommandLine/DeprecateVS11-WARN-ON.cmake
View File

7
Tests/RunCMake/CommandLine/RunCMakeTest.cmake
View File

@ -1118,10 +1118,3 @@ if(RunCMake_GENERATOR MATCHES "^Visual Studio 9 2008")
run_cmake(DeprecateVS9-WARN-ON)
run_cmake_with_options(DeprecateVS9-WARN-OFF -DCMAKE_WARN_VS9=OFF)
endif()
if(RunCMake_GENERATOR MATCHES "^Visual Studio 11 2012")
run_cmake_with_options(DeprecateVS11-WARN-ON -DCMAKE_WARN_VS11=ON)
unset(ENV{CMAKE_WARN_VS11})
run_cmake(DeprecateVS11-WARN-ON)
run_cmake_with_options(DeprecateVS11-WARN-OFF -DCMAKE_WARN_VS11=OFF)
endif()