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

Drop Visual Studio 8 2005 generator

Browse Source 
This generator has been deprecated since CMake 3.9.  Remove it.
This commit is contained in:
Brad King 2018-03-08 11:30:02 -05:00
parent e7af91d026
commit eb80af9093
29 changed files with 33 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Help/command/add_custom_command.rst
View File

@ -217,7 +217,7 @@ of the following is specified:
``PRE_BUILD``
Run before any other rules are executed within the target.
This is supported only on Visual Studio 8 or later.
This is supported only on Visual Studio 9 or later.
For all other generators ``PRE_BUILD`` will be treated as
``PRE_LINK``.
``PRE_LINK``

23
Help/generator/Visual Studio 8 2005.rst
View File

@ -1,23 +1,6 @@
Visual Studio 8 2005
--------------------
Deprecated. Generates Visual Studio 8 2005 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 8 2005 tools
using the :generator:`Visual Studio 10 2010` (or above) generator
with :variable:`CMAKE_GENERATOR_TOOLSET` set to ``v80``, or by
using the :generator:`NMake Makefiles` generator.
The :variable:`CMAKE_GENERATOR_PLATFORM` variable may be set
to specify a target platform name.
For compatibility with CMake versions prior to 3.1, one may specify
a target platform name optionally at the end of this generator name:
``Visual Studio 8 2005 Win64``
Specify target platform ``x64``.
``Visual Studio 8 2005 <WinCE-SDK>``
Specify target platform matching a Windows CE SDK name.
Removed. This once generated Visual Studio 8 2005 project files, but
the generator has been removed since CMake 3.12. It is still possible to
build with VS 2005 tools using the :generator:`NMake Makefiles` generator.

2
Help/prop_dir/VS_GLOBAL_SECTION_POST_section.rst
View File

@ -17,7 +17,7 @@ pairs. Each such pair will be transformed into an entry in the
solution global section. Whitespace around key and value is ignored.
List elements which do not contain an equal sign are skipped.
This property only works for Visual Studio 8 and above; it is ignored
This property only works for Visual Studio 9 and above; it is ignored
on other generators. The property only applies when set on a
directory whose CMakeLists.txt contains a project() command.

2
Help/prop_dir/VS_GLOBAL_SECTION_PRE_section.rst
View File

@ -17,6 +17,6 @@ pairs. Each such pair will be transformed into an entry in the
solution global section. Whitespace around key and value is ignored.
List elements which do not contain an equal sign are skipped.
This property only works for Visual Studio 8 and above; it is ignored
This property only works for Visual Studio 9 and above; it is ignored
on other generators. The property only applies when set on a
directory whose CMakeLists.txt contains a project() command.

4
Help/prop_tgt/DEPLOYMENT_REMOTE_DIRECTORY.rst
View File

@ -3,8 +3,8 @@ DEPLOYMENT_REMOTE_DIRECTORY
Set the WinCE project ``RemoteDirectory`` in ``DeploymentTool`` and
``RemoteExecutable`` in ``DebuggerTool`` in ``.vcproj`` files generated
by the :generator:`Visual Studio 9 2008` and :generator:`Visual Studio 8 2005`
generators. This is useful when you want to debug on remote WinCE device.
by the :generator:`Visual Studio 9 2008` generator.
This is useful when you want to debug on remote WinCE device.
For example:
.. code-block:: cmake

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

@ -0,0 +1,4 @@
remove-vs8-generator
--------------------
* The :generator:`Visual Studio 8 2005` generator has been removed.

2
Help/variable/CMAKE_CFG_INTDIR.rst
View File

@ -12,7 +12,7 @@ Example values:
::
$(ConfigurationName) = Visual Studio 8, 9
$(ConfigurationName) = Visual Studio 9
$(Configuration) = Visual Studio 10
$(CONFIGURATION) = Xcode
. = Make-based tools

2
Help/variable/CMAKE_VS_DEVENV_COMMAND.rst
View File

@ -1,7 +1,7 @@
CMAKE_VS_DEVENV_COMMAND
-----------------------
The generators for :generator:`Visual Studio 8 2005` and above set this
The generators for :generator:`Visual Studio 9 2008` and above set this
variable to the ``devenv.com`` command installed with the corresponding
Visual Studio version. Note that this variable may be empty on
Visual Studio Express editions because they do not provide this tool.

2
Help/variable/CMAKE_VS_INTEL_Fortran_PROJECT_VERSION.rst
View File

@ -1,7 +1,7 @@
CMAKE_VS_INTEL_Fortran_PROJECT_VERSION
--------------------------------------
When generating for :generator:`Visual Studio 8 2005` or greater with the Intel
When generating for :generator:`Visual Studio 9 2008` or greater with the Intel
Fortran plugin installed, this specifies the ``.vfproj`` project file format
version. This is intended for internal use by CMake and should not be
used by project code.

2
Modules/CMakeDetermineCSharpCompiler.cmake
View File

@ -1,7 +1,7 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
if(NOT ${CMAKE_GENERATOR} MATCHES "Visual Studio ([^89]|[89][0-9])")
if(NOT ${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])")
message(FATAL_ERROR
"C# is currently only supported for Microsoft Visual Studio 2010 and later.")
endif()

2
Modules/CMakeDetermineCUDACompiler.cmake
View File

@ -6,7 +6,7 @@ include(${CMAKE_ROOT}/Modules//CMakeParseImplicitLinkInfo.cmake)
if( NOT ( ("${CMAKE_GENERATOR}" MATCHES "Make") OR
("${CMAKE_GENERATOR}" MATCHES "Ninja") OR
("${CMAKE_GENERATOR}" MATCHES "Visual Studio (1|[89][0-9])") ) )
("${CMAKE_GENERATOR}" MATCHES "Visual Studio (1|[9][0-9])") ) )
message(FATAL_ERROR "CUDA language not currently supported by \"${CMAKE_GENERATOR}\" generator")
endif()

2
Modules/CTest.cmake
View File

@ -54,7 +54,7 @@ in the ``CTestConfig.cmake`` file.
option(BUILD_TESTING "Build the testing tree." ON)
# function to turn generator name into a version string
# like vs8 vs9
# like vs9 or vs10
function(GET_VS_VERSION_STRING generator var)
string(REGEX REPLACE "Visual Studio ([0-9][0-9]?)($|.*)" "\\1"
NUMBER "${generator}")

3
Modules/Platform/Windows-df.cmake
View File

@ -30,9 +30,6 @@ set(CMAKE_Fortran_LINK_EXECUTABLE
set(CMAKE_CREATE_WIN32_EXE /winapp)
set(CMAKE_CREATE_CONSOLE_EXE )
if(CMAKE_GENERATOR MATCHES "Visual Studio 8")
set (CMAKE_NO_BUILD_TYPE 1)
endif()
# does the compiler support pdbtype and is it the newer compiler
set(CMAKE_BUILD_TYPE_INIT Debug)

13
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -294,19 +294,6 @@ void cmGlobalVisualStudio7Generator::Generate()
if (!cmSystemTools::GetErrorOccuredFlag()) {
this->CallVisualStudioMacro(MacroReload);
}
if (this->Version == VS8 && !this->CMakeInstance->GetIsInTryCompile()) {
const char* cmakeWarnVS8 =
this->CMakeInstance->GetState()->GetCacheEntryValue("CMAKE_WARN_VS8");
if (!cmakeWarnVS8 || !cmSystemTools::IsOff(cmakeWarnVS8)) {
this->CMakeInstance->IssueMessage(
cmake::WARNING,
"The \"Visual Studio 8 2005\" generator is deprecated "
"and will be removed in a future version of CMake."
"\n"
"Add CMAKE_WARN_VS8=OFF to the cache to disable this warning.");
}
}
}
void cmGlobalVisualStudio7Generator::OutputSLNFile(

122
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -11,75 +11,6 @@
#include "cmVisualStudioWCEPlatformParser.h"
#include "cmake.h"
static const char vs8generatorName[] = "Visual Studio 8 2005";
class cmGlobalVisualStudio8Generator::Factory : public cmGlobalGeneratorFactory
{
public:
cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
cmake* cm) const override
{
if (strncmp(name.c_str(), vs8generatorName,
sizeof(vs8generatorName) - 1) != 0) {
return 0;
}
const char* p = name.c_str() + sizeof(vs8generatorName) - 1;
if (p[0] == '\0') {
return new cmGlobalVisualStudio8Generator(cm, name, "");
}
if (p[0] != ' ') {
return 0;
}
++p;
if (!strcmp(p, "Win64")) {
return new cmGlobalVisualStudio8Generator(cm, name, "x64");
}
cmVisualStudioWCEPlatformParser parser(p);
parser.ParseVersion("8.0");
if (!parser.Found()) {
return 0;
}
cmGlobalVisualStudio8Generator* ret =
new cmGlobalVisualStudio8Generator(cm, name, p);
ret->WindowsCEVersion = parser.GetOSVersion();
return ret;
}
void GetDocumentation(cmDocumentationEntry& entry) const override
{
entry.Name = std::string(vs8generatorName) + " [arch]";
entry.Brief = "Deprecated. Generates Visual Studio 2005 project files. "
"Optional [arch] can be \"Win64\".";
}
void GetGenerators(std::vector<std::string>& names) const override
{
names.push_back(vs8generatorName);
names.push_back(vs8generatorName + std::string(" Win64"));
cmVisualStudioWCEPlatformParser parser;
parser.ParseVersion("8.0");
const std::vector<std::string>& availablePlatforms =
parser.GetAvailablePlatforms();
for (std::string const& i : availablePlatforms) {
names.push_back("Visual Studio 8 2005 " + i);
}
}
bool SupportsToolset() const override { return false; }
bool SupportsPlatform() const override { return true; }
};
cmGlobalGeneratorFactory* cmGlobalVisualStudio8Generator::NewFactory()
{
return new Factory;
}
cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(
cmake* cm, const std::string& name, const std::string& platformName)
: cmGlobalVisualStudio71Generator(cm, platformName)
@ -87,12 +18,6 @@ cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(
this->ProjectConfigurationSectionName = "ProjectConfigurationPlatforms";
this->Name = name;
this->ExtraFlagTable = this->GetExtraFlagTableVS8();
this->Version = VS8;
std::string vc8Express;
this->ExpressEdition = cmSystemTools::ReadRegistryValue(
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\8.0\\Setup\\VC;"
"ProductDir",
vc8Express, cmSystemTools::KeyWOW64_32);
}
std::string cmGlobalVisualStudio8Generator::FindDevEnvCommand()
@ -143,13 +68,6 @@ bool cmGlobalVisualStudio8Generator::SetGeneratorPlatform(std::string const& p,
}
}
// output standard header for dsw file
void cmGlobalVisualStudio8Generator::WriteSLNHeader(std::ostream& fout)
{
fout << "Microsoft Visual Studio Solution File, Format Version 9.00\n";
fout << "# Visual Studio 2005\n";
}
std::string cmGlobalVisualStudio8Generator::GetGenerateStampList()
{
return "generate.stamp.list";
@ -165,46 +83,6 @@ bool cmGlobalVisualStudio8Generator::UseFolderProperty()
return IsExpressEdition() ? false : cmGlobalGenerator::UseFolderProperty();
}
std::string cmGlobalVisualStudio8Generator::GetUserMacrosDirectory()
{
// Some VS8 sp0 versions cannot run macros.
// See http://support.microsoft.com/kb/928209
const char* vc8sp1Registry =
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\"
"InstalledProducts\\KB926601;";
const char* vc8exSP1Registry =
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\"
"InstalledProducts\\KB926748;";
std::string vc8sp1;
if (!cmSystemTools::ReadRegistryValue(vc8sp1Registry, vc8sp1) &&
!cmSystemTools::ReadRegistryValue(vc8exSP1Registry, vc8sp1)) {
return "";
}
std::string base;
std::string path;
// base begins with the VisualStudioProjectsLocation reg value...
if (cmSystemTools::ReadRegistryValue(
"HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\8.0;"
"VisualStudioProjectsLocation",
base)) {
cmSystemTools::ConvertToUnixSlashes(base);
// 8.0 macros folder:
path = base + "/VSMacros80";
}
// path is (correctly) still empty if we did not read the base value from
// the Registry value
return path;
}
std::string cmGlobalVisualStudio8Generator::GetUserMacrosRegKeyBase()
{
return "Software\\Microsoft\\VisualStudio\\8.0\\vsmacros";
}
bool cmGlobalVisualStudio8Generator::AddCheckTarget()
{
// Add a special target on which all other targets depend that

19
Source/cmGlobalVisualStudio8Generator.h
View File

@ -15,7 +15,6 @@ class cmGlobalVisualStudio8Generator : public cmGlobalVisualStudio71Generator
public:
cmGlobalVisualStudio8Generator(cmake* cm, const std::string& name,
const std::string& platformName);
static cmGlobalGeneratorFactory* NewFactory();
///! Get the name for the generator.
std::string GetName() const override { return this->Name; }
@ -35,19 +34,6 @@ public:
*/
void Configure() override;
/**
* Where does this version of Visual Studio look for macros for the
* current user? Returns the empty string if this version of Visual
* Studio does not implement support for VB macros.
*/
std::string GetUserMacrosDirectory() override;
/**
* What is the reg key path to "vsmacros" for this version of Visual
* Studio?
*/
std::string GetUserMacrosRegKeyBase() override;
/** Return true if the target project file should have the option
LinkLibraryDependencies and link to .sln dependencies. */
bool NeedLinkLibraryDependencies(cmGeneratorTarget* target) override;
@ -75,7 +61,6 @@ protected:
virtual bool NeedsDeploy(cmStateEnums::TargetType type) const;
static cmIDEFlagTable const* GetExtraFlagTableVS8();
void WriteSLNHeader(std::ostream& fout) override;
void WriteSolutionConfigurations(
std::ostream& fout, std::vector<std::string> const& configs) override;
void WriteProjectConfigurations(
@ -93,9 +78,5 @@ protected:
std::string Name;
std::string WindowsCEVersion;
bool ExpressEdition;
private:
class Factory;
friend class Factory;
};
#endif

1
Source/cmGlobalVisualStudioGenerator.h
View File

@ -32,7 +32,6 @@ public:
/** Known versions of Visual Studio. */
enum VSVersion
{
VS8 = 80,
VS9 = 90,
VS10 = 100,
VS11 = 110,

2
Source/cmSystemTools.cxx
View File

@ -1509,7 +1509,7 @@ cmSystemTools::SaveRestoreEnvironment::~SaveRestoreEnvironment()
void cmSystemTools::EnableVSConsoleOutput()
{
#ifdef _WIN32
// Visual Studio 8 2005 (devenv.exe or VCExpress.exe) will not
// Visual Studio tools like devenv may not
// display output to the console unless this environment variable is
// set. We need it to capture the output of these build tools.
// Note for future work that one could pass "/out \\.\pipe\NAME" to

7
Source/cmake.cxx
View File

@ -55,7 +55,6 @@
#include "cmGlobalVisualStudio12Generator.h"
#include "cmGlobalVisualStudio14Generator.h"
#include "cmGlobalVisualStudio15Generator.h"
#include "cmGlobalVisualStudio8Generator.h"
#include "cmGlobalVisualStudio9Generator.h"
#include "cmVSSetupHelper.h"
@ -1464,8 +1463,7 @@ void cmake::CreateDefaultGlobalGenerator()
{ "12.0", "Visual Studio 12 2013" }, //
{ "11.0", "Visual Studio 11 2012" }, //
{ "10.0", "Visual Studio 10 2010" }, //
{ "9.0", "Visual Studio 9 2008" }, //
{ "8.0", "Visual Studio 8 2005" }
{ "9.0", "Visual Studio 9 2008" }
};
static const char* const vsEntries[] = {
"\\Setup\\VC;ProductDir", //
@ -1689,7 +1687,6 @@ void cmake::AddDefaultGenerators()
this->Generators.push_back(cmGlobalVisualStudio11Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio10Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio9Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio8Generator::NewFactory());
this->Generators.push_back(cmGlobalBorlandMakefileGenerator::NewFactory());
this->Generators.push_back(cmGlobalNMakeMakefileGenerator::NewFactory());
this->Generators.push_back(cmGlobalJOMMakefileGenerator::NewFactory());
@ -2434,7 +2431,7 @@ int cmake::Build(const std::string& dir, const std::string& target,
// to limitations of the underlying build system.
std::string const stampList = cachePath + "/" +
GetCMakeFilesDirectoryPostSlash() +
cmGlobalVisualStudio8Generator::GetGenerateStampList();
cmGlobalVisualStudio9Generator::GetGenerateStampList();
// Note that the stampList file only exists for VS generators.
if (cmSystemTools::FileExists(stampList) &&

2
Tests/BuildDepends/CMakeLists.txt
View File

@ -42,7 +42,7 @@ list(APPEND _cmake_options "-DTEST_LINK_DEPENDS=${TEST_LINK_DEPENDS}")
list(APPEND _cmake_options "-DCMAKE_FORCE_DEPFILES=1")
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio ([^89]|[89][0-9])")
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio ([^9]|9[0-9])")
set(TEST_MULTI3 1)
list(APPEND _cmake_options "-DTEST_MULTI3=1")
endif()

10
Tests/CMakeLists.txt
View File

@ -64,7 +64,7 @@ if(BUILD_TESTING)
set(CMake_TEST_DEVENV "")
if(CMAKE_VS_DEVENV_COMMAND)
set(CMake_TEST_DEVENV "${CMAKE_VS_DEVENV_COMMAND}")
elseif(CMAKE_GENERATOR MATCHES "Visual Studio [89] " AND
elseif(CMAKE_GENERATOR MATCHES "Visual Studio 9 " AND
NOT CMAKE_MAKE_PROGRAM MATCHES "[mM][sS][bB][uU][iI][lL][dD]\\.[eE][xX][eE]")
set(CMake_TEST_DEVENV "${CMAKE_MAKE_PROGRAM}")
endif()
@ -345,7 +345,7 @@ if(BUILD_TESTING)
endif()
endif()
if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^89]|[89][0-9])")
if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])")
ADD_TEST_MACRO(CSharpOnly CSharpOnly)
ADD_TEST_MACRO(CSharpLinkToCxx CSharpLinkToCxx)
ADD_TEST_MACRO(CSharpLinkFromCxx CSharpLinkFromCxx)
@ -1929,7 +1929,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release
endif()
if(MSVC AND NOT MSVC_VERSION LESS 1310
AND (NOT CMAKE_GENERATOR MATCHES "Visual Studio [89]( |$)"
AND (NOT CMAKE_GENERATOR MATCHES "Visual Studio 9 "
OR CMAKE_SIZEOF_VOID_P EQUAL 4)
)
ADD_TEST_MACRO(VSMASM VSMASM)
@ -1940,7 +1940,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release
ADD_TEST_MACRO(SBCS SBCS)
endif()
if(NOT "${CMAKE_GENERATOR}" MATCHES "Visual Studio [89]( |$)"
if(NOT "${CMAKE_GENERATOR}" MATCHES "Visual Studio 9 "
AND NOT CMAKE_GENERATOR_TOOLSET)
ADD_TEST_MACRO(VSWindowsFormsResx VSWindowsFormsResx)
endif()
@ -2139,7 +2139,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release
endif()
endif()
if(CMAKE_GENERATOR MATCHES "Visual Studio ([^89]|[89][0-9])" AND nasm)
if(CMAKE_GENERATOR MATCHES "Visual Studio ([^9]|9[0-9])" AND nasm)
ADD_TEST_MACRO(VSNASM VSNASM)
endif()

2
Tests/CMakeOnly/CMakeLists.txt
View File

@ -33,7 +33,7 @@ add_CMakeOnly_test(CompilerIdCXX)
if(CMAKE_Fortran_COMPILER)
add_CMakeOnly_test(CompilerIdFortran)
endif()
if(CMAKE_GENERATOR MATCHES "Visual Studio ([^89]|[89][0-9])")
if(CMAKE_GENERATOR MATCHES "Visual Studio ([^9]|9[0-9])")
add_CMakeOnly_test(CompilerIdCSharp)
endif()

4
Tests/OutOfSource/OutOfSourceSubdir/CMakeLists.txt
View File

@ -16,11 +16,11 @@ if ("${PROJECT_SOURCE_DIR}" STREQUAL "${ANOTHER_PROJ_SOURCE_DIR}")
# Use a separate variable for computation.
set(MAXPATH "${CMAKE_OBJECT_PATH_MAX}")
# VS8 adds "OutOfSource/SubDir/OutOfSourceSubdir/../../../" to the
# VS adds "OutOfSource/SubDir/OutOfSourceSubdir/../../../" to the
# path of the source file for no good reason. Reduce the length
# limit by 46 characters to account for it. It should still be long
# enough to require special object file name conversion.
if(${CMAKE_GENERATOR} MATCHES "Visual Studio (8|10)")
if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
math(EXPR MAXPATH "${MAXPATH} - 46")
endif()

6
Tests/RunCMake/CMakeLists.txt
View File

@ -306,13 +306,13 @@ endif()
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
add_RunCMake_test(include_external_msproject)
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([89]|10)" AND NOT CMAKE_VS_DEVENV_COMMAND)
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio (9|10)" AND NOT CMAKE_VS_DEVENV_COMMAND)
set(NO_USE_FOLDERS 1)
endif()
add_RunCMake_test(VSSolution -DNO_USE_FOLDERS=${NO_USE_FOLDERS})
endif()
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([^89]|[89][0-9])")
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([^9]|9[0-9])")
add_RunCMake_test(VS10Project)
endif()
@ -434,6 +434,6 @@ if(CMake_TEST_ANDROID_NDK OR CMake_TEST_ANDROID_STANDALONE_TOOLCHAIN)
set_property(TEST RunCMake.Android PROPERTY TIMEOUT ${CMake_TEST_ANDROID_TIMEOUT})
endif()
if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^89]|[89][0-9])")
if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|9[0-9])")
add_RunCMake_test(CSharpCustomCommand)
endif()

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

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

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

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

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

@ -78,13 +78,6 @@ if(RunCMake_GENERATOR STREQUAL "Ninja")
unset(RunCMake_TEST_NO_CLEAN)
endif()
if(RunCMake_GENERATOR MATCHES "^Visual Studio 8 2005")
set(RunCMake_WARN_VS8 1)
run_cmake(DeprecateVS8-WARN-ON)
unset(RunCMake_WARN_VS8)
run_cmake(DeprecateVS8-WARN-OFF)
endif()
if(UNIX)
run_cmake_command(E_create_symlink-no-arg
${CMAKE_COMMAND} -E create_symlink

3
Tests/RunCMake/RunCMake.cmake
View File

@ -51,9 +51,6 @@ function(run_cmake test)
if(APPLE)
list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_POLICY_DEFAULT_CMP0025=NEW)
endif()
if(RunCMake_GENERATOR MATCHES "^Visual Studio 8 2005" AND NOT RunCMake_WARN_VS8)
list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_WARN_VS8=OFF)
endif()
if(RunCMake_MAKE_PROGRAM)
list(APPEND RunCMake_TEST_OPTIONS "-DCMAKE_MAKE_PROGRAM=${RunCMake_MAKE_PROGRAM}")
endif()