kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'clean-up-vs-generators' 

dad8b03f VS: Remove obsolete methods.
e435f875 VS: Move version information to global generator.
b5f093f0 VS: Simplify setting of flag table.
This commit is contained in:
Brad King 2015-05-19 11:09:34 -04:00 committed by CMake Topic Stage
parent 93acb504c0 dad8b03fbe
commit 56dc91c3ad
29 changed files with 162 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/cmGlobalVisualStudio10Generator.cxx
View File

@ -105,6 +105,7 @@ cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(
this->SystemIsWindowsPhone = false;
this->SystemIsWindowsStore = false;
this->MSBuildCommandInitialized = false;
this->Version = VS10;
}
//----------------------------------------------------------------------------
@ -311,8 +312,7 @@ void cmGlobalVisualStudio10Generator::WriteSLNHeader(std::ostream& fout)
cmLocalGenerator *
cmGlobalVisualStudio10Generator::CreateLocalGenerator(cmLocalGenerator* parent)
{
return new cmLocalVisualStudio10Generator(
cmLocalVisualStudioGenerator::VS10, this, parent);
return new cmLocalVisualStudio10Generator(this, parent);
}
//----------------------------------------------------------------------------

9
Source/cmGlobalVisualStudio11Generator.cxx
View File

@ -117,6 +117,7 @@ cmGlobalVisualStudio11Generator::cmGlobalVisualStudio11Generator(
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\11.0\\Setup\\VC;"
"ProductDir", vc11Express, cmSystemTools::KeyWOW64_32);
this->DefaultPlatformToolset = "v110";
this->Version = VS11;
}
//----------------------------------------------------------------------------
@ -236,14 +237,6 @@ void cmGlobalVisualStudio11Generator::WriteSLNHeader(std::ostream& fout)
}
}
//----------------------------------------------------------------------------
cmLocalGenerator *
cmGlobalVisualStudio11Generator::CreateLocalGenerator(cmLocalGenerator* parent)
{
return new cmLocalVisualStudio10Generator(
cmLocalVisualStudioGenerator::VS11, this, parent);
}
//----------------------------------------------------------------------------
bool cmGlobalVisualStudio11Generator::UseFolderProperty()
{

3
Source/cmGlobalVisualStudio11Generator.h
View File

@ -28,9 +28,6 @@ public:
virtual void WriteSLNHeader(std::ostream& fout);
///! create the correct local generator
virtual cmLocalGenerator *CreateLocalGenerator(cmLocalGenerator* parent = 0);
protected:
virtual bool InitializeWindowsPhone(cmMakefile* mf);
virtual bool InitializeWindowsStore(cmMakefile* mf);

9
Source/cmGlobalVisualStudio12Generator.cxx
View File

@ -97,6 +97,7 @@ cmGlobalVisualStudio12Generator::cmGlobalVisualStudio12Generator(
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\12.0\\Setup\\VC;"
"ProductDir", vc12Express, cmSystemTools::KeyWOW64_32);
this->DefaultPlatformToolset = "v120";
this->Version = VS12;
}
//----------------------------------------------------------------------------
@ -216,14 +217,6 @@ void cmGlobalVisualStudio12Generator::WriteSLNHeader(std::ostream& fout)
}
}
//----------------------------------------------------------------------------
cmLocalGenerator *
cmGlobalVisualStudio12Generator::CreateLocalGenerator(cmLocalGenerator* parent)
{
return new cmLocalVisualStudio10Generator(
cmLocalVisualStudioGenerator::VS12, this, parent);
}
//----------------------------------------------------------------------------
bool
cmGlobalVisualStudio12Generator::IsWindowsDesktopToolsetInstalled() const

3
Source/cmGlobalVisualStudio12Generator.h
View File

@ -28,9 +28,6 @@ public:
virtual void WriteSLNHeader(std::ostream& fout);
///! create the correct local generator
virtual cmLocalGenerator *CreateLocalGenerator(cmLocalGenerator* parent = 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

9
Source/cmGlobalVisualStudio14Generator.cxx
View File

@ -97,6 +97,7 @@ cmGlobalVisualStudio14Generator::cmGlobalVisualStudio14Generator(
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\14.0\\Setup\\VC;"
"ProductDir", vc14Express, cmSystemTools::KeyWOW64_32);
this->DefaultPlatformToolset = "v140";
this->Version = VS14;
}
//----------------------------------------------------------------------------
@ -126,11 +127,3 @@ void cmGlobalVisualStudio14Generator::WriteSLNHeader(std::ostream& fout)
fout << "# Visual Studio 14\n";
}
}
//----------------------------------------------------------------------------
cmLocalGenerator *
cmGlobalVisualStudio14Generator::CreateLocalGenerator(cmLocalGenerator* parent)
{
return new cmLocalVisualStudio10Generator(
cmLocalVisualStudioGenerator::VS14, this, parent);
}

3
Source/cmGlobalVisualStudio14Generator.h
View File

@ -28,9 +28,6 @@ public:
virtual void WriteSLNHeader(std::ostream& fout);
///! create the correct local generator
virtual cmLocalGenerator *CreateLocalGenerator(cmLocalGenerator* parent = 0);
virtual const char* GetToolsVersion() { return "14.0"; }
protected:
virtual const char* GetIDEVersion() { return "14.0"; }

1
Source/cmGlobalVisualStudio6Generator.cxx
View File

@ -34,6 +34,7 @@ std::string GetVS6TargetName(const std::string& targetName)
cmGlobalVisualStudio6Generator::cmGlobalVisualStudio6Generator()
{
this->MSDevCommandInitialized = false;
this->Version = VS6;
}
void cmGlobalVisualStudio6Generator

13
Source/cmGlobalVisualStudio71Generator.cxx
View File

@ -21,18 +21,7 @@ cmGlobalVisualStudio71Generator::cmGlobalVisualStudio71Generator(
: cmGlobalVisualStudio7Generator(platformName)
{
this->ProjectConfigurationSectionName = "ProjectConfiguration";
}
//----------------------------------------------------------------------------
///! Create a local generator appropriate to this Global Generator
cmLocalGenerator *
cmGlobalVisualStudio71Generator::CreateLocalGenerator(cmLocalGenerator* parent)
{
cmLocalVisualStudio7Generator *lg =
new cmLocalVisualStudio7Generator(cmLocalVisualStudioGenerator::VS71,
this, parent);
lg->SetExtraFlagTable(this->GetExtraFlagTableVS7());
return lg;
this->Version = VS71;
}
//----------------------------------------------------------------------------

3
Source/cmGlobalVisualStudio71Generator.h
View File

@ -36,9 +36,6 @@ public:
/** Get the documentation entry for this generator. */
static void GetDocumentation(cmDocumentationEntry& entry);
///! Create a local generator appropriate to this Global Generator
virtual cmLocalGenerator *CreateLocalGenerator(cmLocalGenerator* parent = 0);
/**
* Where does this version of Visual Studio look for macros for the
* current user? Returns the empty string if this version of Visual

62
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -18,6 +18,32 @@
#include "cmake.h"
#include <cmsys/Encoding.hxx>
//----------------------------------------------------------------------------
static cmVS7FlagTable cmVS7ExtraFlagTable[] =
{
// Precompiled header and related options. Note that the
// UsePrecompiledHeader entries are marked as "Continue" so that the
// corresponding PrecompiledHeaderThrough entry can be found.
{"UsePrecompiledHeader", "YX", "Automatically Generate", "2",
cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
{"PrecompiledHeaderThrough", "YX", "Precompiled Header Name", "",
cmVS7FlagTable::UserValueRequired},
{"UsePrecompiledHeader", "Yu", "Use Precompiled Header", "3",
cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
{"PrecompiledHeaderThrough", "Yu", "Precompiled Header Name", "",
cmVS7FlagTable::UserValueRequired},
{"WholeProgramOptimization", "LTCG", "WholeProgramOptimization", "true", 0},
// Exception handling mode. If no entries match, it will be FALSE.
{"ExceptionHandling", "GX", "enable c++ exceptions", "true", 0},
{"ExceptionHandling", "EHsc", "enable c++ exceptions", "true", 0},
// The EHa option does not have an IDE setting. Let it go to false,
// and have EHa passed on the command line by leaving out the table
// entry.
{0,0,0,0,0}
};
cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator(
const std::string& platformName)
{
@ -33,6 +59,8 @@ cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator(
{
this->DefaultPlatformName = platformName;
}
this->ExtraFlagTable = cmVS7ExtraFlagTable;
this->Version = VS7;
}
cmGlobalVisualStudio7Generator::~cmGlobalVisualStudio7Generator()
@ -254,9 +282,7 @@ cmLocalGenerator *
cmGlobalVisualStudio7Generator::CreateLocalGenerator(cmLocalGenerator* parent)
{
cmLocalVisualStudio7Generator *lg =
new cmLocalVisualStudio7Generator(cmLocalVisualStudioGenerator::VS7,
this, parent);
lg->SetExtraFlagTable(this->GetExtraFlagTableVS7());
new cmLocalVisualStudio7Generator(this, parent);
return lg;
}
@ -1086,36 +1112,6 @@ cmGlobalVisualStudio7Generator
return false;
}
//----------------------------------------------------------------------------
static cmVS7FlagTable cmVS7ExtraFlagTable[] =
{
// Precompiled header and related options. Note that the
// UsePrecompiledHeader entries are marked as "Continue" so that the
// corresponding PrecompiledHeaderThrough entry can be found.
{"UsePrecompiledHeader", "YX", "Automatically Generate", "2",
cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
{"PrecompiledHeaderThrough", "YX", "Precompiled Header Name", "",
cmVS7FlagTable::UserValueRequired},
{"UsePrecompiledHeader", "Yu", "Use Precompiled Header", "3",
cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
{"PrecompiledHeaderThrough", "Yu", "Precompiled Header Name", "",
cmVS7FlagTable::UserValueRequired},
{"WholeProgramOptimization", "LTCG", "WholeProgramOptimization", "true", 0},
// Exception handling mode. If no entries match, it will be FALSE.
{"ExceptionHandling", "GX", "enable c++ exceptions", "true", 0},
{"ExceptionHandling", "EHsc", "enable c++ exceptions", "true", 0},
// The EHa option does not have an IDE setting. Let it go to false,
// and have EHa passed on the command line by leaving out the table
// entry.
{0,0,0,0,0}
};
cmIDEFlagTable const* cmGlobalVisualStudio7Generator::GetExtraFlagTableVS7()
{
return cmVS7ExtraFlagTable;
}
std::string cmGlobalVisualStudio7Generator::Encoding()
{
std::ostringstream encoding;

3
Source/cmGlobalVisualStudio7Generator.h
View File

@ -111,6 +111,8 @@ public:
// Encoding for Visual Studio files
virtual std::string Encoding();
cmIDEFlagTable const* ExtraFlagTable;
protected:
virtual void Generate();
virtual const char* GetIDEVersion() { return "7.0"; }
@ -120,7 +122,6 @@ protected:
static const char* ExternalProjectType(const char* location);
static cmIDEFlagTable const* GetExtraFlagTableVS7();
virtual void OutputSLNFile(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
virtual void WriteSLNFile(std::ostream& fout, cmLocalGenerator* root,

14
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -101,6 +101,8 @@ cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(
{
this->ProjectConfigurationSectionName = "ProjectConfigurationPlatforms";
this->Name = name;
this->ExtraFlagTable = this->GetExtraFlagTableVS8();
this->Version = VS8;
}
//----------------------------------------------------------------------------
@ -123,18 +125,6 @@ std::string cmGlobalVisualStudio8Generator::FindDevEnvCommand()
return this->cmGlobalVisualStudio71Generator::FindDevEnvCommand();
}
//----------------------------------------------------------------------------
///! Create a local generator appropriate to this Global Generator
cmLocalGenerator *
cmGlobalVisualStudio8Generator::CreateLocalGenerator(cmLocalGenerator* parent)
{
cmLocalVisualStudio7Generator *lg =
new cmLocalVisualStudio7Generator(cmLocalVisualStudioGenerator::VS8,
this, parent);
lg->SetExtraFlagTable(this->GetExtraFlagTableVS8());
return lg;
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudio8Generator
::EnableLanguage(std::vector<std::string>const & lang,

3
Source/cmGlobalVisualStudio8Generator.h
View File

@ -33,9 +33,6 @@ public:
/** Get the documentation entry for this generator. */
static void GetDocumentation(cmDocumentationEntry& entry);
///! Create a local generator appropriate to this Global Generator
virtual cmLocalGenerator *CreateLocalGenerator(cmLocalGenerator* parent = 0);
virtual void EnableLanguage(std::vector<std::string>const& languages,
cmMakefile *, bool optional);
virtual void AddPlatformDefinitions(cmMakefile* mf);

12
Source/cmGlobalVisualStudio9Generator.cxx
View File

@ -104,6 +104,7 @@ cmGlobalVisualStudio9Generator::cmGlobalVisualStudio9Generator(
const std::string& name, const std::string& platformName)
: cmGlobalVisualStudio8Generator(name, platformName)
{
this->Version = VS9;
}
//----------------------------------------------------------------------------
@ -113,17 +114,6 @@ void cmGlobalVisualStudio9Generator::WriteSLNHeader(std::ostream& fout)
fout << "# Visual Studio 2008\n";
}
///! Create a local generator appropriate to this Global Generator
cmLocalGenerator *
cmGlobalVisualStudio9Generator::CreateLocalGenerator(cmLocalGenerator* parent)
{
cmLocalVisualStudio7Generator *lg
= new cmLocalVisualStudio7Generator(cmLocalVisualStudioGenerator::VS9,
this, parent);
lg->SetExtraFlagTable(this->GetExtraFlagTableVS8());
return lg;
}
//----------------------------------------------------------------------------
std::string cmGlobalVisualStudio9Generator::GetUserMacrosDirectory()
{

3
Source/cmGlobalVisualStudio9Generator.h
View File

@ -28,9 +28,6 @@ public:
const std::string& platformName);
static cmGlobalGeneratorFactory* NewFactory();
///! create the correct local generator
virtual cmLocalGenerator *CreateLocalGenerator(cmLocalGenerator* parent = 0);
/**
* Try to determine system information such as shared library
* extension, pthreads, byte order etc.

13
Source/cmGlobalVisualStudioGenerator.cxx
View File

@ -32,6 +32,19 @@ cmGlobalVisualStudioGenerator::~cmGlobalVisualStudioGenerator()
{
}
//----------------------------------------------------------------------------
cmGlobalVisualStudioGenerator::VSVersion
cmGlobalVisualStudioGenerator::GetVersion() const
{
return this->Version;
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudioGenerator::SetVersion(VSVersion v)
{
this->Version = v;
}
//----------------------------------------------------------------------------
std::string cmGlobalVisualStudioGenerator::GetRegistryBase()
{

21
Source/cmGlobalVisualStudioGenerator.h
View File

@ -23,9 +23,27 @@
class cmGlobalVisualStudioGenerator : public cmGlobalGenerator
{
public:
/** Known versions of Visual Studio. */
enum VSVersion
{
VS6 = 60,
VS7 = 70,
VS71 = 71,
VS8 = 80,
VS9 = 90,
VS10 = 100,
VS11 = 110,
VS12 = 120,
/* VS13 = 130 was skipped */
VS14 = 140
};
cmGlobalVisualStudioGenerator();
virtual ~cmGlobalVisualStudioGenerator();
VSVersion GetVersion() const;
void SetVersion(VSVersion v);
/**
* Configure CMake's Visual Studio macros file into the user's Visual
* Studio macros directory.
@ -107,6 +125,9 @@ protected:
typedef std::map<cmTarget const*, std::string> UtilityDependsMap;
UtilityDependsMap UtilityDepends;
protected:
VSVersion Version;
private:
virtual std::string GetVSMakeProgram() = 0;
void PrintCompilerAdvice(std::ostream&, std::string const&,

4
Source/cmLocalVisualStudio10Generator.cxx
View File

@ -62,9 +62,9 @@ class cmVS10XMLParser : public cmXMLParser
//----------------------------------------------------------------------------
cmLocalVisualStudio10Generator
::cmLocalVisualStudio10Generator(VSVersion v, cmGlobalGenerator* gg,
::cmLocalVisualStudio10Generator(cmGlobalGenerator* gg,
cmLocalGenerator* parent):
cmLocalVisualStudio7Generator(v, gg, parent)
cmLocalVisualStudio7Generator(gg, parent)
{
}

2
Source/cmLocalVisualStudio10Generator.h
View File

@ -25,7 +25,7 @@ class cmLocalVisualStudio10Generator : public cmLocalVisualStudio7Generator
{
public:
///! Set cache only and recurse to false by default.
cmLocalVisualStudio10Generator(VSVersion v, cmGlobalGenerator* gg,
cmLocalVisualStudio10Generator(cmGlobalGenerator* gg,
cmLocalGenerator* parent);
virtual ~cmLocalVisualStudio10Generator();

2
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -26,7 +26,7 @@
cmLocalVisualStudio6Generator
::cmLocalVisualStudio6Generator(cmGlobalGenerator* gg,
cmLocalGenerator* parent):
cmLocalVisualStudioGenerator(VS6, gg, parent)
cmLocalVisualStudioGenerator(gg, parent)
{
}

52
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -55,11 +55,10 @@ static void cmConvertToWindowsSlash(std::string& s)
//----------------------------------------------------------------------------
cmLocalVisualStudio7Generator
::cmLocalVisualStudio7Generator(VSVersion v, cmGlobalGenerator* gg,
::cmLocalVisualStudio7Generator(cmGlobalGenerator* gg,
cmLocalGenerator* parent):
cmLocalVisualStudioGenerator(v, gg, parent)
cmLocalVisualStudioGenerator(gg, parent)
{
this->ExtraFlagTable = 0;
this->Internal = new cmLocalVisualStudio7GeneratorInternals(this);
}
@ -241,18 +240,17 @@ void cmLocalVisualStudio7Generator::WriteStampFiles()
void cmLocalVisualStudio7Generator
::CreateSingleVCProj(const std::string& lname, cmTarget &target)
{
this->FortranProject =
static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
->TargetIsFortranOnly(target);
this->WindowsCEProject =
static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
->TargetsWindowsCE();
cmGlobalVisualStudioGenerator* gg
= static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
this->FortranProject = gg->TargetIsFortranOnly(target);
this->WindowsCEProject = gg->TargetsWindowsCE();
// Intel Fortran for VS10 uses VS9 format ".vfproj" files.
VSVersion realVersion = this->Version;
if(this->FortranProject && this->Version >= VS10)
cmGlobalVisualStudioGenerator::VSVersion realVersion = gg->GetVersion();
if(this->FortranProject
&& gg->GetVersion() >= cmGlobalVisualStudioGenerator::VS10)
{
this->Version = VS9;
gg->SetVersion(cmGlobalVisualStudioGenerator::VS9);
}
// add to the list of projects
@ -282,7 +280,7 @@ void cmLocalVisualStudio7Generator
this->GlobalGenerator->FileReplacedDuringGenerate(fname);
}
this->Version = realVersion;
gg->SetVersion(realVersion);
}
//----------------------------------------------------------------------------
@ -773,7 +771,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
}
Options targetOptions(this, t,
table,
this->ExtraFlagTable);
gg->ExtraFlagTable);
targetOptions.FixExceptionHandlingDefault();
std::string asmLocation = configName + "/";
targetOptions.AddFlag("AssemblerListingLocation", asmLocation.c_str());
@ -995,7 +993,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
// end of <Tool Name=VCMIDLTool
// Check if we need the FAT32 workaround.
if(targetBuilds && this->Version >= VS8)
if(targetBuilds && this->GetVersion() >= cmGlobalVisualStudioGenerator::VS8)
{
// Check the filesystem type where the target will be written.
if(cmLVS6G_IsFAT(target.GetDirectory(configName).c_str()))
@ -1130,7 +1128,8 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
fout << "\t\t\t<Tool\n"
<< "\t\t\t\tName=\"" << tool << "\"\n";
if(this->GetVersion() < VS8 || this->FortranProject)
if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8
|| this->FortranProject)
{
std::ostringstream libdeps;
this->Internal->OutputObjects(libdeps, &target);
@ -1190,7 +1189,8 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
// libraries which may be set by the user to something bad.
fout << "\t\t\t\tAdditionalDependencies=\"$(NOINHERIT) "
<< this->Makefile->GetSafeDefinition(standardLibsVar.c_str());
if(this->GetVersion() < VS8 || this->FortranProject)
if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8
|| this->FortranProject)
{
this->Internal->OutputObjects(fout, &target, " ");
}
@ -1218,7 +1218,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
}
if(this->WindowsCEProject)
{
if(this->GetVersion() < VS9)
if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS9)
{
fout << "\t\t\t\tSubSystem=\"9\"\n";
}
@ -1288,7 +1288,8 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
// libraries which may be set by the user to something bad.
fout << "\t\t\t\tAdditionalDependencies=\"$(NOINHERIT) "
<< this->Makefile->GetSafeDefinition(standardLibsVar.c_str());
if(this->GetVersion() < VS8 || this->FortranProject)
if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8
|| this->FortranProject)
{
this->Internal->OutputObjects(fout, &target, " ");
}
@ -1316,7 +1317,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
}
if ( this->WindowsCEProject )
{
if(this->GetVersion() < VS9)
if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS9)
{
fout << "\t\t\t\tSubSystem=\"9\"\n";
}
@ -1517,7 +1518,8 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
this->WriteGroup(&sg, target, fout, libName, configs);
}
if(this->GetVersion() >= VS8 && !this->FortranProject)
if(this->GetVersion() >= cmGlobalVisualStudioGenerator::VS8
&& !this->FortranProject)
{
// VS >= 8 support per-config source locations so we
// list object library content as external objects.
@ -1842,7 +1844,7 @@ bool cmLocalVisualStudio7Generator
table = cmLocalVisualStudio7GeneratorFortranFlagTable;
}
Options fileOptions(this, tool, table,
this->ExtraFlagTable);
gg->ExtraFlagTable);
fileOptions.Parse(fc.CompileFlags.c_str());
fileOptions.AddDefines(fc.CompileDefs.c_str());
fileOptions.AddDefines(fc.CompileDefsConfig.c_str());
@ -2149,13 +2151,13 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
<< gg->Encoding() << "\"?>\n"
<< "<VisualStudioProject\n"
<< "\tProjectType=\"Visual C++\"\n";
if(this->Version == VS71)
if(gg->GetVersion() == cmGlobalVisualStudioGenerator::VS71)
{
fout << "\tVersion=\"7.10\"\n";
}
else
{
fout << "\tVersion=\"" << (this->Version/10) << ".00\"\n";
fout << "\tVersion=\"" << (gg->GetVersion()/10) << ".00\"\n";
}
const char* projLabel = target.GetProperty("PROJECT_LABEL");
if(!projLabel)
@ -2168,7 +2170,7 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
keyword = "Win32Proj";
}
fout << "\tName=\"" << projLabel << "\"\n";
if(this->Version >= VS8)
if(gg->GetVersion() >= cmGlobalVisualStudioGenerator::VS8)
{
fout << "\tProjectGUID=\"{" << gg->GetGUID(libName.c_str()) << "}\"\n";
}

5
Source/cmLocalVisualStudio7Generator.h
View File

@ -35,7 +35,7 @@ class cmLocalVisualStudio7Generator : public cmLocalVisualStudioGenerator
{
public:
///! Set cache only and recurse to false by default.
cmLocalVisualStudio7Generator(VSVersion v, cmGlobalGenerator* gg,
cmLocalVisualStudio7Generator(cmGlobalGenerator* gg,
cmLocalGenerator* parent);
virtual ~cmLocalVisualStudio7Generator();
@ -54,8 +54,6 @@ public:
*/
void SetBuildType(BuildType,const std::string& name);
void SetExtraFlagTable(cmVS7FlagTable const* table)
{ this->ExtraFlagTable = table; }
virtual std::string GetTargetDirectory(cmTarget const&) const;
cmSourceFile* CreateVCProjBuildRule();
void WriteStampFiles();
@ -119,7 +117,6 @@ private:
class EventWriter;
friend class EventWriter;
cmVS7FlagTable const* ExtraFlagTable;
std::string ModuleDefinitionFile;
bool FortranProject;
bool WindowsCEProject;

12
Source/cmLocalVisualStudioGenerator.cxx
View File

@ -19,11 +19,10 @@
//----------------------------------------------------------------------------
cmLocalVisualStudioGenerator
::cmLocalVisualStudioGenerator(VSVersion v, cmGlobalGenerator* gg,
::cmLocalVisualStudioGenerator(cmGlobalGenerator* gg,
cmLocalGenerator* parent)
: cmLocalGenerator(gg, parent)
{
this->Version = v;
}
//----------------------------------------------------------------------------
@ -31,6 +30,15 @@ cmLocalVisualStudioGenerator::~cmLocalVisualStudioGenerator()
{
}
//----------------------------------------------------------------------------
cmGlobalVisualStudioGenerator::VSVersion
cmLocalVisualStudioGenerator::GetVersion() const
{
cmGlobalVisualStudioGenerator* gg =
static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
return gg->GetVersion();
}
//----------------------------------------------------------------------------
void cmLocalVisualStudioGenerator::ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,

23
Source/cmLocalVisualStudioGenerator.h
View File

@ -13,6 +13,7 @@
#define cmLocalVisualStudioGenerator_h
#include "cmLocalGenerator.h"
#include "cmGlobalVisualStudioGenerator.h"
#include <cmsys/auto_ptr.hxx>
@ -30,22 +31,7 @@ class cmCustomCommandGenerator;
class cmLocalVisualStudioGenerator : public cmLocalGenerator
{
public:
/** Known versions of Visual Studio. */
enum VSVersion
{
VS6 = 60,
VS7 = 70,
VS71 = 71,
VS8 = 80,
VS9 = 90,
VS10 = 100,
VS11 = 110,
VS12 = 120,
/* VS13 = 130 was skipped */
VS14 = 140
};
cmLocalVisualStudioGenerator(VSVersion v, cmGlobalGenerator* gg,
cmLocalVisualStudioGenerator(cmGlobalGenerator* gg,
cmLocalGenerator* parent);
virtual ~cmLocalVisualStudioGenerator();
@ -57,8 +43,7 @@ public:
sequence of custom commands. */
const char* GetReportErrorLabel() const;
/** Version of Visual Studio. */
VSVersion GetVersion() const { return this->Version; }
cmGlobalVisualStudioGenerator::VSVersion GetVersion() const;
virtual std::string ComputeLongestObjectDirectory(cmTarget&) const = 0;
@ -76,8 +61,6 @@ protected:
cmsys::auto_ptr<cmCustomCommand>
MaybeCreateImplibDir(cmTarget& target, const std::string& config,
bool isFortran);
VSVersion Version;
};
#endif

8
Source/cmQtAutoGenerators.cxx
View File

@ -20,7 +20,7 @@
#include "cmAlgorithms.h"
#if defined(_WIN32) && !defined(__CYGWIN__)
# include "cmLocalVisualStudioGenerator.h"
# include "cmGlobalVisualStudioGenerator.h"
#endif
#include <sys/stat.h>
@ -372,13 +372,13 @@ bool cmQtAutoGenerators::InitializeAutogenTarget(cmTarget* target)
cmGlobalGenerator* gg = localGen->GetGlobalGenerator();
if(gg->GetName().find("Visual Studio") != std::string::npos)
{
cmLocalVisualStudioGenerator* vslg =
static_cast<cmLocalVisualStudioGenerator*>(localGen);
cmGlobalVisualStudioGenerator* vsgg =
static_cast<cmGlobalVisualStudioGenerator*>(gg);
// Under VS >= 7 use a PRE_BUILD event instead of a separate target to
// reduce the number of targets loaded into the IDE.
// This also works around a VS 11 bug that may skip updating the target:
// https://connect.microsoft.com/VisualStudio/feedback/details/769495
usePRE_BUILD = vslg->GetVersion() >= cmLocalVisualStudioGenerator::VS7;
usePRE_BUILD = vsgg->GetVersion() >= cmGlobalVisualStudioGenerator::VS7;
if(usePRE_BUILD)
{
for (std::vector<std::string>::iterator it = depends.begin();

47
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -47,13 +47,13 @@ cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetClFlagTable() const
{
if(this->MSTools)
{
cmLocalVisualStudioGenerator::VSVersion
cmGlobalVisualStudioGenerator::VSVersion
v = this->LocalGenerator->GetVersion();
if(v >= cmLocalVisualStudioGenerator::VS14)
if(v >= cmGlobalVisualStudioGenerator::VS14)
{ return cmVS14CLFlagTable; }
else if(v >= cmLocalVisualStudioGenerator::VS12)
else if(v >= cmGlobalVisualStudioGenerator::VS12)
{ return cmVS12CLFlagTable; }
else if(v == cmLocalVisualStudioGenerator::VS11)
else if(v == cmGlobalVisualStudioGenerator::VS11)
{ return cmVS11CLFlagTable; }
else
{ return cmVS10CLFlagTable; }
@ -65,13 +65,13 @@ cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetRcFlagTable() const
{
if(this->MSTools)
{
cmLocalVisualStudioGenerator::VSVersion
cmGlobalVisualStudioGenerator::VSVersion
v = this->LocalGenerator->GetVersion();
if(v >= cmLocalVisualStudioGenerator::VS14)
if(v >= cmGlobalVisualStudioGenerator::VS14)
{ return cmVS14RCFlagTable; }
else if(v >= cmLocalVisualStudioGenerator::VS12)
else if(v >= cmGlobalVisualStudioGenerator::VS12)
{ return cmVS12RCFlagTable; }
else if(v == cmLocalVisualStudioGenerator::VS11)
else if(v == cmGlobalVisualStudioGenerator::VS11)
{ return cmVS11RCFlagTable; }
else
{ return cmVS10RCFlagTable; }
@ -83,13 +83,13 @@ cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetLibFlagTable() const
{
if(this->MSTools)
{
cmLocalVisualStudioGenerator::VSVersion
cmGlobalVisualStudioGenerator::VSVersion
v = this->LocalGenerator->GetVersion();
if(v >= cmLocalVisualStudioGenerator::VS14)
if(v >= cmGlobalVisualStudioGenerator::VS14)
{ return cmVS14LibFlagTable; }
else if(v >= cmLocalVisualStudioGenerator::VS12)
else if(v >= cmGlobalVisualStudioGenerator::VS12)
{ return cmVS12LibFlagTable; }
else if(v == cmLocalVisualStudioGenerator::VS11)
else if(v == cmGlobalVisualStudioGenerator::VS11)
{ return cmVS11LibFlagTable; }
else
{ return cmVS10LibFlagTable; }
@ -101,13 +101,13 @@ cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetLinkFlagTable() const
{
if(this->MSTools)
{
cmLocalVisualStudioGenerator::VSVersion
cmGlobalVisualStudioGenerator::VSVersion
v = this->LocalGenerator->GetVersion();
if(v >= cmLocalVisualStudioGenerator::VS14)
if(v >= cmGlobalVisualStudioGenerator::VS14)
{ return cmVS14LinkFlagTable; }
else if(v >= cmLocalVisualStudioGenerator::VS12)
else if(v >= cmGlobalVisualStudioGenerator::VS12)
{ return cmVS12LinkFlagTable; }
else if(v == cmLocalVisualStudioGenerator::VS11)
else if(v == cmGlobalVisualStudioGenerator::VS11)
{ return cmVS11LinkFlagTable; }
else
{ return cmVS10LinkFlagTable; }
@ -119,13 +119,13 @@ cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetMasmFlagTable() const
{
if(this->MSTools)
{
cmLocalVisualStudioGenerator::VSVersion
cmGlobalVisualStudioGenerator::VSVersion
v = this->LocalGenerator->GetVersion();
if(v >= cmLocalVisualStudioGenerator::VS14)
if(v >= cmGlobalVisualStudioGenerator::VS14)
{ return cmVS14MASMFlagTable; }
else if(v >= cmLocalVisualStudioGenerator::VS12)
else if(v >= cmGlobalVisualStudioGenerator::VS12)
{ return cmVS12MASMFlagTable; }
else if(v == cmLocalVisualStudioGenerator::VS11)
else if(v == cmGlobalVisualStudioGenerator::VS11)
{ return cmVS11MASMFlagTable; }
else
{ return cmVS10MASMFlagTable; }
@ -911,7 +911,8 @@ cmVisualStudio10TargetGenerator::WriteCustomRule(cmSourceFile const* source,
sep = ";";
}
(*this->BuildFileStream ) << "</Outputs>\n";
if(this->LocalGenerator->GetVersion() > cmLocalVisualStudioGenerator::VS10)
if(this->LocalGenerator->GetVersion()
> cmGlobalVisualStudioGenerator::VS10)
{
// VS >= 11 let us turn off linking of custom command outputs.
this->WritePlatformConfigTag("LinkObjects", i->c_str(), 3);
@ -1416,7 +1417,7 @@ void cmVisualStudio10TargetGenerator::WriteSource(
// conversion uses full paths when possible to allow deeper trees.
bool forceRelative = false;
std::string sourceFile = this->ConvertPath(sf->GetFullPath(), false);
if(this->LocalGenerator->GetVersion() == cmLocalVisualStudioGenerator::VS10
if(this->LocalGenerator->GetVersion() == cmGlobalVisualStudioGenerator::VS10
&& cmSystemTools::FileIsFullPath(sourceFile.c_str()))
{
// Normal path conversion resulted in a full path. VS 10 (but not 11)
@ -1544,7 +1545,7 @@ void cmVisualStudio10TargetGenerator::WriteAllSources()
++si;
}
}
if(this->LocalGenerator->GetVersion() > cmLocalVisualStudioGenerator::VS10)
if(this->LocalGenerator->GetVersion() > cmGlobalVisualStudioGenerator::VS10)
{
// For VS >= 11 we use LinkObjects to avoid linking custom command
// outputs. Use Object for all external objects, generated or not.

26
Source/cmVisualStudioGeneratorOptions.cxx
View File

@ -96,14 +96,14 @@ void cmVisualStudioGeneratorOptions::FixExceptionHandlingDefault()
// remove the flag we need to override the IDE default of on.
switch (this->Version)
{
case cmLocalVisualStudioGenerator::VS7:
case cmLocalVisualStudioGenerator::VS71:
case cmGlobalVisualStudioGenerator::VS7:
case cmGlobalVisualStudioGenerator::VS71:
this->FlagMap["ExceptionHandling"] = "FALSE";
break;
case cmLocalVisualStudioGenerator::VS10:
case cmLocalVisualStudioGenerator::VS11:
case cmLocalVisualStudioGenerator::VS12:
case cmLocalVisualStudioGenerator::VS14:
case cmGlobalVisualStudioGenerator::VS10:
case cmGlobalVisualStudioGenerator::VS11:
case cmGlobalVisualStudioGenerator::VS12:
case cmGlobalVisualStudioGenerator::VS14:
// 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
@ -132,7 +132,7 @@ void cmVisualStudioGeneratorOptions::SetVerboseMakefile(bool verbose)
this->FlagMap.find("SuppressStartupBanner") == this->FlagMap.end())
{
this->FlagMap["SuppressStartupBanner"] =
this->Version < cmLocalVisualStudioGenerator::VS10 ? "FALSE" : "";
this->Version < cmGlobalVisualStudioGenerator::VS10 ? "FALSE" : "";
}
}
@ -270,7 +270,7 @@ cmVisualStudioGeneratorOptions
{
return;
}
if(this->Version >= cmLocalVisualStudioGenerator::VS10)
if(this->Version >= cmGlobalVisualStudioGenerator::VS10)
{
// if there are configuration specific flags, then
// use the configuration specific tag for PreprocessorDefinitions
@ -298,7 +298,7 @@ cmVisualStudioGeneratorOptions
{
// Escape the definition for the compiler.
std::string define;
if(this->Version < cmLocalVisualStudioGenerator::VS10)
if(this->Version < cmGlobalVisualStudioGenerator::VS10)
{
define =
this->LocalGenerator->EscapeForShell(di->c_str(), true);
@ -308,7 +308,7 @@ cmVisualStudioGeneratorOptions
define = *di;
}
// Escape this flag for the IDE.
if(this->Version >= cmLocalVisualStudioGenerator::VS10)
if(this->Version >= cmGlobalVisualStudioGenerator::VS10)
{
define = cmVisualStudio10GeneratorOptionsEscapeForXML(define);
@ -325,7 +325,7 @@ cmVisualStudioGeneratorOptions
fout << sep << define;
sep = ";";
}
if(this->Version >= cmLocalVisualStudioGenerator::VS10)
if(this->Version >= cmGlobalVisualStudioGenerator::VS10)
{
fout << ";%(PreprocessorDefinitions)</PreprocessorDefinitions>" << suffix;
}
@ -340,7 +340,7 @@ void
cmVisualStudioGeneratorOptions
::OutputFlagMap(std::ostream& fout, const char* indent)
{
if(this->Version >= cmLocalVisualStudioGenerator::VS10)
if(this->Version >= cmGlobalVisualStudioGenerator::VS10)
{
for(std::map<std::string, FlagValue>::iterator m = this->FlagMap.begin();
m != this->FlagMap.end(); ++m)
@ -395,7 +395,7 @@ cmVisualStudioGeneratorOptions
{
if(!this->FlagString.empty())
{
if(this->Version >= cmLocalVisualStudioGenerator::VS10)
if(this->Version >= cmGlobalVisualStudioGenerator::VS10)
{
fout << prefix;
if(this->Configuration.size())

2
Source/cmVisualStudioGeneratorOptions.h
View File

@ -73,7 +73,7 @@ public:
void SetConfiguration(const char* config);
private:
cmLocalVisualStudioGenerator* LocalGenerator;
cmLocalVisualStudioGenerator::VSVersion Version;
cmGlobalVisualStudioGenerator::VSVersion Version;
std::string Configuration;
Tool CurrentTool;