mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-02-09 00:29:55 -06:00
Code Issues Packages Projects Releases Wiki Activity

Drop Visual Studio 9 2008 generator

Browse Source 
This generator has been deprecated since CMake 3.27.  Remove it.
This commit is contained in:
Brad King
2024-05-06 12:40:04 -04:00
parent 88c70dde34
commit 03c31b0395
63 changed files with 71 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Source/CMakeLists.txt
View File

@@ -886,8 +886,6 @@ if(WIN32)
cmGlobalVisualStudio7Generator.h
cmGlobalVisualStudio8Generator.cxx
cmGlobalVisualStudio8Generator.h
cmGlobalVisualStudio9Generator.cxx
cmGlobalVisualStudio9Generator.h
cmVisualStudioGeneratorOptions.h
cmVisualStudioGeneratorOptions.cxx
cmVsProjectType.h

6
Source/cmGlobalVisualStudio10Generator.cxx
View File

@@ -1275,12 +1275,6 @@ std::string cmGlobalVisualStudio10Generator::Encoding()
const char* cmGlobalVisualStudio10Generator::GetToolsVersion() const
{
switch (this->Version) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
return "4.0";
// in Visual Studio 2013 they detached the MSBuild tools version
// from the .Net Framework version and instead made it have it's own
// version number
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "12.0";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:

20
Source/cmGlobalVisualStudio7Generator.cxx
View File

@@ -310,26 +310,6 @@ void cmGlobalVisualStudio7Generator::Generate()
GetSLNFile(this->LocalGenerators[0].get()));
}
if (this->Version == VSVersion::VS9 &&
!this->CMakeInstance->GetIsInTryCompile()) {
std::string cmakeWarnVS9;
if (cmValue cached = this->CMakeInstance->GetState()->GetCacheEntryValue(
"CMAKE_WARN_VS9")) {
this->CMakeInstance->MarkCliAsUsed("CMAKE_WARN_VS9");
cmakeWarnVS9 = *cached;
} else {
cmSystemTools::GetEnv("CMAKE_WARN_VS9", cmakeWarnVS9);
}
if (cmakeWarnVS9.empty() || !cmIsOff(cmakeWarnVS9)) {
this->CMakeInstance->IssueMessage(
MessageType::WARNING,
"The \"Visual Studio 9 2008\" generator is deprecated "
"and will be removed in a future version of CMake."
"\n"
"Add CMAKE_WARN_VS9=OFF to the cache to disable this warning.");
}
}
if (this->Version == VSVersion::VS12 &&
!this->CMakeInstance->GetIsInTryCompile()) {
std::string cmakeWarnVS12;

163
Source/cmGlobalVisualStudio9Generator.cxx
View File

@@ -1,163 +0,0 @@
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmGlobalVisualStudio9Generator.h"
#include <cstring>
#include <utility>
#include <vector>
#include "cmGlobalGenerator.h"
#include "cmGlobalGeneratorFactory.h"
#include "cmGlobalVisualStudioGenerator.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmVisualStudioWCEPlatformParser.h"
class cmake;
static const char vs9generatorName[] = "Visual Studio 9 2008";
class cmGlobalVisualStudio9Generator::Factory : public cmGlobalGeneratorFactory
{
public:
std::unique_ptr<cmGlobalGenerator> CreateGlobalGenerator(
const std::string& name, bool allowArch, cmake* cm) const override
{
if (strncmp(name.c_str(), vs9generatorName,
sizeof(vs9generatorName) - 1) != 0) {
return std::unique_ptr<cmGlobalGenerator>();
}
const char* p = name.c_str() + sizeof(vs9generatorName) - 1;
if (p[0] == '\0') {
return std::unique_ptr<cmGlobalGenerator>(
new cmGlobalVisualStudio9Generator(cm, name, ""));
}
if (!allowArch || p[0] != ' ') {
return std::unique_ptr<cmGlobalGenerator>();
}
++p;
if (!strcmp(p, "IA64")) {
return std::unique_ptr<cmGlobalGenerator>(
new cmGlobalVisualStudio9Generator(cm, name, "Itanium"));
}
if (!strcmp(p, "Win64")) {
return std::unique_ptr<cmGlobalGenerator>(
new cmGlobalVisualStudio9Generator(cm, name, "x64"));
}
cmVisualStudioWCEPlatformParser parser(p);
parser.ParseVersion("9.0");
if (!parser.Found()) {
return std::unique_ptr<cmGlobalGenerator>();
}
auto ret = std::unique_ptr<cmGlobalVisualStudio9Generator>(
new cmGlobalVisualStudio9Generator(cm, name, p));
ret->WindowsCEVersion = parser.GetOSVersion();
return std::unique_ptr<cmGlobalGenerator>(std::move(ret));
}
cmDocumentationEntry GetDocumentation() const override
{
return { cmStrCat(vs9generatorName, " [arch]"),
"Deprecated. Generates Visual Studio 2008 project files. "
"Optional [arch] can be \"Win64\" or \"IA64\"." };
}
std::vector<std::string> GetGeneratorNames() const override
{
std::vector<std::string> names;
names.emplace_back(vs9generatorName);
return names;
}
std::vector<std::string> GetGeneratorNamesWithPlatform() const override
{
std::vector<std::string> names;
names.emplace_back(cmStrCat(vs9generatorName, " Win64"));
names.emplace_back(cmStrCat(vs9generatorName, " IA64"));
cmVisualStudioWCEPlatformParser parser;
parser.ParseVersion("9.0");
const std::vector<std::string>& availablePlatforms =
parser.GetAvailablePlatforms();
for (std::string const& i : availablePlatforms) {
names.emplace_back(cmStrCat("Visual Studio 9 2008 ", i));
}
return names;
}
bool SupportsToolset() const override { return false; }
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("Itanium");
cmVisualStudioWCEPlatformParser parser;
parser.ParseVersion("9.0");
const std::vector<std::string>& availablePlatforms =
parser.GetAvailablePlatforms();
for (std::string const& i : availablePlatforms) {
platforms.emplace_back(i);
}
return platforms;
}
std::string GetDefaultPlatformName() const override { return "Win32"; }
};
std::unique_ptr<cmGlobalGeneratorFactory>
cmGlobalVisualStudio9Generator::NewFactory()
{
return std::unique_ptr<cmGlobalGeneratorFactory>(new Factory);
}
cmGlobalVisualStudio9Generator::cmGlobalVisualStudio9Generator(
cmake* cm, const std::string& name,
std::string const& platformInGeneratorName)
: cmGlobalVisualStudio8Generator(cm, name, platformInGeneratorName)
{
this->Version = VSVersion::VS9;
std::string vc9Express;
this->ExpressEdition = cmSystemTools::ReadRegistryValue(
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\9.0\\Setup\\VC;"
"ProductDir",
vc9Express, cmSystemTools::KeyWOW64_32);
}
std::string cmGlobalVisualStudio9Generator::GetUserMacrosDirectory()
{
std::string base;
std::string path;
// base begins with the VisualStudioProjectsLocation reg value...
if (cmSystemTools::ReadRegistryValue(
"HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\9.0;"
"VisualStudioProjectsLocation",
base)) {
cmSystemTools::ConvertToUnixSlashes(base);
// 9.0 macros folder:
path = cmStrCat(base, "/VSMacros80");
// *NOT* a typo; right now in Visual Studio 2008 beta the macros
// folder is VSMacros80... They may change it to 90 before final
// release of 2008 or they may not... we'll have to keep our eyes
// on it
}
// path is (correctly) still empty if we did not read the base value from
// the Registry value
return path;
}
std::string cmGlobalVisualStudio9Generator::GetUserMacrosRegKeyBase()
{
return R"(Software\Microsoft\VisualStudio\9.0\vsmacros)";
}

43
Source/cmGlobalVisualStudio9Generator.h
View File

@@ -1,43 +0,0 @@
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#pragma once
#include <memory>
#include <string>
#include "cmGlobalVisualStudio8Generator.h"
class cmGlobalGeneratorFactory;
class cmake;
/** \class cmGlobalVisualStudio9Generator
* \brief Write a Unix makefiles.
*
* cmGlobalVisualStudio9Generator manages UNIX build process for a tree
*/
class cmGlobalVisualStudio9Generator : public cmGlobalVisualStudio8Generator
{
public:
static std::unique_ptr<cmGlobalGeneratorFactory> NewFactory();
/**
* 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;
protected:
cmGlobalVisualStudio9Generator(cmake* cm, const std::string& name,
std::string const& platformInGeneratorName);
private:
class Factory;
friend class Factory;
};

6
Source/cmGlobalVisualStudioGenerator.cxx
View File

@@ -104,8 +104,6 @@ std::string const& cmGlobalVisualStudioGenerator::GetPlatformName() const
const char* cmGlobalVisualStudioGenerator::GetIDEVersion() const
{
switch (this->Version) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
return "9.0";
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "12.0";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
@@ -127,10 +125,6 @@ void cmGlobalVisualStudioGenerator::WriteSLNHeader(std::ostream& fout)
fout << '\n';
switch (this->Version) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
fout << "Microsoft Visual Studio Solution File, Format Version 10.00\n";
fout << "# Visual Studio 2008\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

@@ -34,7 +34,6 @@ public:
/** Known versions of Visual Studio. */
enum class VSVersion : uint16_t
{
VS9 = 90,
VS12 = 120,
/* VS13 = 130 was skipped */
VS14 = 140,

9
Source/cmGlobalVisualStudioVersionedGenerator.cxx
View File

@@ -125,8 +125,6 @@ static unsigned int VSVersionToMajor(
cmGlobalVisualStudioGenerator::VSVersion v)
{
switch (v) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
return 9;
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return 12;
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
@@ -145,8 +143,6 @@ static const char* VSVersionToToolset(
cmGlobalVisualStudioGenerator::VSVersion v)
{
switch (v) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
return "v90";
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "v120";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
@@ -165,8 +161,6 @@ static std::string VSVersionToMajorString(
cmGlobalVisualStudioGenerator::VSVersion v)
{
switch (v) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
return "9";
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "12";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
@@ -185,7 +179,6 @@ static const char* VSVersionToAndroidToolset(
cmGlobalVisualStudioGenerator::VSVersion v)
{
switch (v) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
@@ -485,7 +478,6 @@ bool cmGlobalVisualStudioVersionedGenerator::MatchesGeneratorName(
{
std::string genName;
switch (this->Version) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
case cmGlobalVisualStudioGenerator::VSVersion::VS14:
break;
@@ -752,7 +744,6 @@ cmGlobalVisualStudioVersionedGenerator::GetAndroidApplicationTypeRevision()
const
{
switch (this->Version) {
case cmGlobalVisualStudioGenerator::VSVersion::VS9:
case cmGlobalVisualStudioGenerator::VSVersion::VS12:
return "";
case cmGlobalVisualStudioGenerator::VSVersion::VS14:

14
Source/cmLocalVisualStudio7Generator.cxx
View File

@@ -1133,12 +1133,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(
fout << "\t\t\t\tGenerateDebugInformation=\"true\"\n";
}
if (this->WindowsCEProject) {
if (this->GetVersion() <
cmGlobalVisualStudioGenerator::VSVersion::VS9) {
fout << "\t\t\t\tSubSystem=\"9\"\n";
} else {
fout << "\t\t\t\tSubSystem=\"8\"\n";
}
fout << "\t\t\t\tSubSystem=\"8\"\n";
}
std::string stackVar = cmStrCat("CMAKE_", linkLanguage, "_STACK_SIZE");
cmValue stackVal = this->Makefile->GetDefinition(stackVar);
@@ -1221,12 +1216,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(
fout << "\t\t\t\tGenerateDebugInformation=\"true\"\n";
}
if (this->WindowsCEProject) {
if (this->GetVersion() <
cmGlobalVisualStudioGenerator::VSVersion::VS9) {
fout << "\t\t\t\tSubSystem=\"9\"\n";
} else {
fout << "\t\t\t\tSubSystem=\"8\"\n";
}
fout << "\t\t\t\tSubSystem=\"8\"\n";
if (!linkOptions.GetFlag("EntryPointSymbol")) {
const char* entryPointSymbol = targetOptions.UsingUnicode()

26
Source/cmVisualStudioGeneratorOptions.cxx
View File

@@ -26,7 +26,6 @@ cmVisualStudioGeneratorOptions::cmVisualStudioGeneratorOptions(
cmVS7FlagTable const* extraTable)
: cmIDEOptions()
, LocalGenerator(lg)
, Version(lg->GetVersion())
, CurrentTool(tool)
{
// Store the given flag tables.
@@ -75,8 +74,7 @@ void cmVisualStudioGeneratorOptions::FixExceptionHandlingDefault()
// initialization to off, but the user has the option of removing
// the flag to disable exception handling. When the user does
// remove the flag we need to override the IDE default of on.
if (this->Version != cmGlobalVisualStudioGenerator::VSVersion::VS9 &&
!this->LocalGenerator->IsVFProj()) {
if (!this->LocalGenerator->IsVFProj()) {
// by default VS puts <ExceptionHandling></ExceptionHandling> empty
// for a project, to make our projects look the same put a new line
// and space over for the closing </ExceptionHandling> as the default
@@ -94,15 +92,12 @@ void cmVisualStudioGeneratorOptions::SetVerboseMakefile(bool verbose)
// to the generated project to disable logo suppression. Otherwise
// the GUI default is to enable suppression.
//
// On Visual Studio 9, the value of this attribute should be
// In '.vfproj' files, the value of this attribute should be
// "FALSE", instead of an empty string.
if (verbose &&
this->FlagMap.find("SuppressStartupBanner") == this->FlagMap.end()) {
this->FlagMap["SuppressStartupBanner"] =
this->Version != cmGlobalVisualStudioGenerator::VSVersion::VS9 &&
!this->LocalGenerator->IsVFProj()
? ""
: "FALSE";
!this->LocalGenerator->IsVFProj() ? "" : "FALSE";
}
}
@@ -369,15 +364,13 @@ void cmVisualStudioGeneratorOptions::OutputPreprocessorDefinitions(
}
std::ostringstream oss;
if (this->Version != cmGlobalVisualStudioGenerator::VSVersion::VS9 &&
!this->LocalGenerator->IsVFProj()) {
if (!this->LocalGenerator->IsVFProj()) {
oss << "%(" << tag << ')';
}
auto de = cmRemoveDuplicates(this->Defines);
for (std::string const& di : cmMakeRange(this->Defines.cbegin(), de)) {
std::string define;
if (this->Version != cmGlobalVisualStudioGenerator::VSVersion::VS9 &&
!this->LocalGenerator->IsVFProj()) {
if (!this->LocalGenerator->IsVFProj()) {
// Escape the definition for MSBuild.
define = di;
cmVS10EscapeForMSBuild(define);
@@ -424,8 +417,7 @@ void cmVisualStudioGeneratorOptions::OutputAdditionalIncludeDirectories(
}
// Escape this include for the MSBuild.
if (this->Version != cmGlobalVisualStudioGenerator::VSVersion::VS9 &&
!this->LocalGenerator->IsVFProj()) {
if (!this->LocalGenerator->IsVFProj()) {
cmVS10EscapeForMSBuild(include);
}
oss << sep << include;
@@ -437,8 +429,7 @@ void cmVisualStudioGeneratorOptions::OutputAdditionalIncludeDirectories(
}
}
if (this->Version != cmGlobalVisualStudioGenerator::VSVersion::VS9 &&
!this->LocalGenerator->IsVFProj()) {
if (!this->LocalGenerator->IsVFProj()) {
oss << sep << "%(" << tag << ')';
}
@@ -452,8 +443,7 @@ void cmVisualStudioGeneratorOptions::OutputFlagMap(std::ostream& fout,
std::ostringstream oss;
const char* sep = "";
for (std::string i : m.second) {
if (this->Version != cmGlobalVisualStudioGenerator::VSVersion::VS9 &&
!this->LocalGenerator->IsVFProj()) {
if (!this->LocalGenerator->IsVFProj()) {
cmVS10EscapeForMSBuild(i);
}
oss << sep << i;

1
Source/cmVisualStudioGeneratorOptions.h
View File

@@ -87,7 +87,6 @@ protected:
private:
cmLocalVisualStudioGenerator* LocalGenerator;
cmGlobalVisualStudioGenerator::VSVersion Version;
std::string Configuration;
Tool CurrentTool;

15
Source/cmake.cxx
View File

@@ -97,7 +97,6 @@
# include "cmGlobalNMakeMakefileGenerator.h"
# include "cmGlobalVisualStudio12Generator.h"
# include "cmGlobalVisualStudio14Generator.h"
# include "cmGlobalVisualStudio9Generator.h"
# include "cmGlobalVisualStudioVersionedGenerator.h"
# include "cmVSSetupHelper.h"
@@ -2636,7 +2635,6 @@ std::unique_ptr<cmGlobalGenerator> cmake::EvaluateDefaultGlobalGenerator()
static VSVersionedGenerator const vsGenerators[] = {
{ "14.0", "Visual Studio 14 2015" }, //
{ "12.0", "Visual Studio 12 2013" }, //
{ "9.0", "Visual Studio 9 2008" }
};
static const char* const vsEntries[] = {
"\\Setup\\VC;ProductDir", //
@@ -3021,7 +3019,6 @@ void cmake::AddDefaultGenerators()
cmGlobalVisualStudioVersionedGenerator::NewFactory15());
this->Generators.push_back(cmGlobalVisualStudio14Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio12Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio9Generator::NewFactory());
this->Generators.push_back(cmGlobalBorlandMakefileGenerator::NewFactory());
this->Generators.push_back(cmGlobalNMakeMakefileGenerator::NewFactory());
this->Generators.push_back(cmGlobalJOMMakefileGenerator::NewFactory());
@@ -3781,22 +3778,12 @@ int cmake::Build(int jobs, std::string dir, std::vector<std::string> targets,
// itself, there is the risk of building an out-of-date solution file due
// to limitations of the underlying build system.
std::string const stampList = cachePath + "/" + "CMakeFiles/" +
cmGlobalVisualStudio9Generator::GetGenerateStampList();
cmGlobalVisualStudio12Generator::GetGenerateStampList();
// Note that the stampList file only exists for VS generators.
if (cmSystemTools::FileExists(stampList)) {
// Check if running for Visual Studio 9 - we need to explicitly run
// the glob verification script before starting the build
this->AddScriptingCommands();
if (this->GlobalGenerator->MatchesGeneratorName("Visual Studio 9 2008")) {
std::string const globVerifyScript =
cachePath + "/" + "CMakeFiles/" + "VerifyGlobs.cmake";
if (cmSystemTools::FileExists(globVerifyScript)) {
std::vector<std::string> args;
this->ReadListFile(args, globVerifyScript);
}
}
if (!cmakeCheckStampList(stampList)) {
// Correctly initialize the home (=source) and home output (=binary)