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

Merge topic 'vs10-refactor' 

1edaef39 VS: Factor MS-tool-specific vcxproj settings into helper
808f4b1f VS: Re-order logic to group MS-tool-specific options together
13e6d559 VS: Set some options directly instead of using flag map
8f4bdcc6 VS: Remove always-true condition on compile options block
eaa9f2f8 VS: Refactor internal generator factory logic
2b3e7b6f VS: Fix vcxproj specification of empty output file extension
39af06e7 VS: Fix vcxproj elements specifying binary output locations
ee329d54 VS: Refactor flag table lookup
This commit is contained in:
Brad King 2014-06-10 09:17:36 -04:00 committed by CMake Topic Stage
parent 0c73273b1a 1edaef39f1
commit f1b91a8af6
5 changed files with 177 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Source/cmGlobalVisualStudio10Generator.cxx
View File

@ -48,17 +48,19 @@ public:
const char* p = cmVS10GenName(name, genName); const char* p = cmVS10GenName(name, genName);
if(!p) if(!p)
{ return 0; } { return 0; }
if(strcmp(p, "") == 0) if(!*p)
{ {
return new cmGlobalVisualStudio10Generator( return new cmGlobalVisualStudio10Generator(
genName, "", ""); genName, "", "");
} }
if(strcmp(p, " Win64") == 0) if(*p++ != ' ')
{ return 0; }
if(strcmp(p, "Win64") == 0)
{ {
return new cmGlobalVisualStudio10Generator( return new cmGlobalVisualStudio10Generator(
genName, "x64", "CMAKE_FORCE_WIN64"); genName, "x64", "CMAKE_FORCE_WIN64");
} }
if(strcmp(p, " IA64") == 0) if(strcmp(p, "IA64") == 0)
{ {
return new cmGlobalVisualStudio10Generator( return new cmGlobalVisualStudio10Generator(
genName, "Itanium", "CMAKE_FORCE_IA64"); genName, "Itanium", "CMAKE_FORCE_IA64");

13
Source/cmGlobalVisualStudio11Generator.cxx
View File

@ -43,27 +43,24 @@ public:
const char* p = cmVS11GenName(name, genName); const char* p = cmVS11GenName(name, genName);
if(!p) if(!p)
{ return 0; } { return 0; }
if(strcmp(p, "") == 0) if(!*p)
{ {
return new cmGlobalVisualStudio11Generator( return new cmGlobalVisualStudio11Generator(
genName, "", ""); genName, "", "");
} }
if(strcmp(p, " Win64") == 0) if(*p++ != ' ')
{ return 0; }
if(strcmp(p, "Win64") == 0)
{ {
return new cmGlobalVisualStudio11Generator( return new cmGlobalVisualStudio11Generator(
genName, "x64", "CMAKE_FORCE_WIN64"); genName, "x64", "CMAKE_FORCE_WIN64");
} }
if(strcmp(p, " ARM") == 0) if(strcmp(p, "ARM") == 0)
{ {
return new cmGlobalVisualStudio11Generator( return new cmGlobalVisualStudio11Generator(
genName, "ARM", ""); genName, "ARM", "");
} }
if(*p++ != ' ')
{
return 0;
}
std::set<std::string> installedSDKs = std::set<std::string> installedSDKs =
cmGlobalVisualStudio11Generator::GetInstalledWindowsCESDKs(); cmGlobalVisualStudio11Generator::GetInstalledWindowsCESDKs();

8
Source/cmGlobalVisualStudio12Generator.cxx
View File

@ -43,17 +43,19 @@ public:
const char* p = cmVS12GenName(name, genName); const char* p = cmVS12GenName(name, genName);
if(!p) if(!p)
{ return 0; } { return 0; }
if(strcmp(p, "") == 0) if(!*p)
{ {
return new cmGlobalVisualStudio12Generator( return new cmGlobalVisualStudio12Generator(
genName, "", ""); genName, "", "");
} }
if(strcmp(p, " Win64") == 0) if(*p++ != ' ')
{ return 0; }
if(strcmp(p, "Win64") == 0)
{ {
return new cmGlobalVisualStudio12Generator( return new cmGlobalVisualStudio12Generator(
genName, "x64", "CMAKE_FORCE_WIN64"); genName, "x64", "CMAKE_FORCE_WIN64");
} }
if(strcmp(p, " ARM") == 0) if(strcmp(p, "ARM") == 0)
{ {
return new cmGlobalVisualStudio12Generator( return new cmGlobalVisualStudio12Generator(
genName, "ARM", ""); genName, "ARM", "");

296
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -32,34 +32,37 @@
#include <cmsys/auto_ptr.hxx> #include <cmsys/auto_ptr.hxx>
static cmVS7FlagTable const* cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetClFlagTable() const
cmVSGetCLFlagTable(cmLocalVisualStudioGenerator* lg)
{ {
if(lg->GetVersion() >= cmLocalVisualStudioGenerator::VS12) cmLocalVisualStudioGenerator::VSVersion
v = this->LocalGenerator->GetVersion();
if(v >= cmLocalVisualStudioGenerator::VS12)
{ return cmVS12CLFlagTable; } { return cmVS12CLFlagTable; }
else if(lg->GetVersion() == cmLocalVisualStudioGenerator::VS11) else if(v == cmLocalVisualStudioGenerator::VS11)
{ return cmVS11CLFlagTable; } { return cmVS11CLFlagTable; }
else else
{ return cmVS10CLFlagTable; } { return cmVS10CLFlagTable; }
} }
static cmVS7FlagTable const* cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetLibFlagTable() const
cmVSGetLibFlagTable(cmLocalVisualStudioGenerator* lg)
{ {
if(lg->GetVersion() >= cmLocalVisualStudioGenerator::VS12) cmLocalVisualStudioGenerator::VSVersion
v = this->LocalGenerator->GetVersion();
if(v >= cmLocalVisualStudioGenerator::VS12)
{ return cmVS12LibFlagTable; } { return cmVS12LibFlagTable; }
else if(lg->GetVersion() == cmLocalVisualStudioGenerator::VS11) else if(v == cmLocalVisualStudioGenerator::VS11)
{ return cmVS11LibFlagTable; } { return cmVS11LibFlagTable; }
else else
{ return cmVS10LibFlagTable; } { return cmVS10LibFlagTable; }
} }
static cmVS7FlagTable const* cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetLinkFlagTable() const
cmVSGetLinkFlagTable(cmLocalVisualStudioGenerator* lg)
{ {
if(lg->GetVersion() >= cmLocalVisualStudioGenerator::VS12) cmLocalVisualStudioGenerator::VSVersion
v = this->LocalGenerator->GetVersion();
if(v >= cmLocalVisualStudioGenerator::VS12)
{ return cmVS12LinkFlagTable; } { return cmVS12LinkFlagTable; }
else if(lg->GetVersion() == cmLocalVisualStudioGenerator::VS11) else if(v == cmLocalVisualStudioGenerator::VS11)
{ return cmVS11LinkFlagTable; } { return cmVS11LinkFlagTable; }
else else
{ return cmVS10LinkFlagTable; } { return cmVS10LinkFlagTable; }
@ -464,8 +467,6 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurations()
void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues() void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues()
{ {
cmGlobalVisualStudio10Generator* gg =
static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
std::vector<std::string> *configs = std::vector<std::string> *configs =
static_cast<cmGlobalVisualStudio7Generator *> static_cast<cmGlobalVisualStudio7Generator *>
(this->GlobalGenerator)->GetConfigurations(); (this->GlobalGenerator)->GetConfigurations();
@ -500,55 +501,64 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues()
configType += "</ConfigurationType>\n"; configType += "</ConfigurationType>\n";
this->WriteString(configType.c_str(), 2); this->WriteString(configType.c_str(), 2);
const char* mfcFlag = this->WriteMSToolConfigurationValues(*i);
this->Target->GetMakefile()->GetDefinition("CMAKE_MFC_FLAG");
std::string mfcFlagValue = mfcFlag ? mfcFlag : "0";
std::string useOfMfcValue = "false";
if(mfcFlagValue == "1")
{
useOfMfcValue = "Static";
}
else if(mfcFlagValue == "2")
{
useOfMfcValue = "Dynamic";
}
std::string mfcLine = "<UseOfMfc>";
mfcLine += useOfMfcValue + "</UseOfMfc>\n";
this->WriteString(mfcLine.c_str(), 2);
if((this->Target->GetType() <= cmTarget::OBJECT_LIBRARY &&
this->ClOptions[*i]->UsingUnicode()) ||
this->Target->GetPropertyAsBool("VS_WINRT_EXTENSIONS"))
{
this->WriteString("<CharacterSet>Unicode</CharacterSet>\n", 2);
}
else if (this->Target->GetType() <= cmTarget::MODULE_LIBRARY &&
this->ClOptions[*i]->UsingSBCS())
{
this->WriteString("<CharacterSet>NotSet</CharacterSet>\n", 2);
}
else
{
this->WriteString("<CharacterSet>MultiByte</CharacterSet>\n", 2);
}
if(const char* toolset = gg->GetPlatformToolset())
{
std::string pts = "<PlatformToolset>";
pts += toolset;
pts += "</PlatformToolset>\n";
this->WriteString(pts.c_str(), 2);
}
if(this->Target->GetPropertyAsBool("VS_WINRT_EXTENSIONS"))
{
this->WriteString("<WindowsAppContainer>true"
"</WindowsAppContainer>\n", 2);
}
this->WriteString("</PropertyGroup>\n", 1); this->WriteString("</PropertyGroup>\n", 1);
} }
} }
//----------------------------------------------------------------------------
void cmVisualStudio10TargetGenerator
::WriteMSToolConfigurationValues(std::string const& config)
{
cmGlobalVisualStudio10Generator* gg =
static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
const char* mfcFlag =
this->Target->GetMakefile()->GetDefinition("CMAKE_MFC_FLAG");
std::string mfcFlagValue = mfcFlag ? mfcFlag : "0";
std::string useOfMfcValue = "false";
if(mfcFlagValue == "1")
{
useOfMfcValue = "Static";
}
else if(mfcFlagValue == "2")
{
useOfMfcValue = "Dynamic";
}
std::string mfcLine = "<UseOfMfc>";
mfcLine += useOfMfcValue + "</UseOfMfc>\n";
this->WriteString(mfcLine.c_str(), 2);
if((this->Target->GetType() <= cmTarget::OBJECT_LIBRARY &&
this->ClOptions[config]->UsingUnicode()) ||
this->Target->GetPropertyAsBool("VS_WINRT_EXTENSIONS"))
{
this->WriteString("<CharacterSet>Unicode</CharacterSet>\n", 2);
}
else if (this->Target->GetType() <= cmTarget::MODULE_LIBRARY &&
this->ClOptions[config]->UsingSBCS())
{
this->WriteString("<CharacterSet>NotSet</CharacterSet>\n", 2);
}
else
{
this->WriteString("<CharacterSet>MultiByte</CharacterSet>\n", 2);
}
if(const char* toolset = gg->GetPlatformToolset())
{
std::string pts = "<PlatformToolset>";
pts += toolset;
pts += "</PlatformToolset>\n";
this->WriteString(pts.c_str(), 2);
}
if(this->Target->GetPropertyAsBool("VS_WINRT_EXTENSIONS"))
{
this->WriteString("<WindowsAppContainer>true"
"</WindowsAppContainer>\n", 2);
}
}
void cmVisualStudio10TargetGenerator::WriteCustomCommands() void cmVisualStudio10TargetGenerator::WriteCustomCommands()
{ {
this->SourcesVisited.clear(); this->SourcesVisited.clear();
@ -1144,17 +1154,18 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
} }
// if the source file does not match the linker language // if the source file does not match the linker language
// then force c or c++ // then force c or c++
const char* compileAs = 0;
if(needForceLang || (linkLanguage != lang)) if(needForceLang || (linkLanguage != lang))
{ {
if(lang == "CXX") if(lang == "CXX")
{ {
// force a C++ file type // force a C++ file type
flags += " /TP "; compileAs = "CompileAsCpp";
} }
else if(lang == "C") else if(lang == "C")
{ {
// force to c // force to c
flags += " /TC "; compileAs = "CompileAsC";
} }
} }
bool hasFlags = false; bool hasFlags = false;
@ -1190,7 +1201,7 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
} }
// if we have flags or defines for this config then // if we have flags or defines for this config then
// use them // use them
if(flags.size() || configDefines.size()) if(!flags.empty() || !configDefines.empty() || compileAs)
{ {
(*this->BuildFileStream ) << firstString; (*this->BuildFileStream ) << firstString;
firstString = ""; // only do firstString once firstString = ""; // only do firstString once
@ -1198,7 +1209,11 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
cmVisualStudioGeneratorOptions cmVisualStudioGeneratorOptions
clOptions(this->LocalGenerator, clOptions(this->LocalGenerator,
cmVisualStudioGeneratorOptions::Compiler, cmVisualStudioGeneratorOptions::Compiler,
cmVSGetCLFlagTable(this->LocalGenerator), 0, this); this->GetClFlagTable(), 0, this);
if(compileAs)
{
clOptions.AddFlag("CompileAs", compileAs);
}
clOptions.Parse(flags.c_str()); clOptions.Parse(flags.c_str());
clOptions.AddDefines(configDefines.c_str()); clOptions.AddDefines(configDefines.c_str());
clOptions.SetConfiguration((*config).c_str()); clOptions.SetConfiguration((*config).c_str());
@ -1260,23 +1275,28 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions()
this->ConvertToWindowsSlash(outDir); this->ConvertToWindowsSlash(outDir);
this->WritePlatformConfigTag("OutDir", config->c_str(), 3); this->WritePlatformConfigTag("OutDir", config->c_str(), 3);
*this->BuildFileStream << outDir *this->BuildFileStream << cmVS10EscapeXML(outDir)
<< "</OutDir>\n"; << "</OutDir>\n";
this->WritePlatformConfigTag("IntDir", config->c_str(), 3); this->WritePlatformConfigTag("IntDir", config->c_str(), 3);
*this->BuildFileStream << intermediateDir *this->BuildFileStream << cmVS10EscapeXML(intermediateDir)
<< "</IntDir>\n"; << "</IntDir>\n";
std::string name =
cmSystemTools::GetFilenameWithoutLastExtension(targetNameFull);
this->WritePlatformConfigTag("TargetName", config->c_str(), 3); this->WritePlatformConfigTag("TargetName", config->c_str(), 3);
*this->BuildFileStream *this->BuildFileStream << cmVS10EscapeXML(name) << "</TargetName>\n";
<< cmSystemTools::GetFilenameWithoutLastExtension(
targetNameFull.c_str())
<< "</TargetName>\n";
std::string ext =
cmSystemTools::GetFilenameLastExtension(targetNameFull);
if(ext.empty())
{
// An empty TargetExt causes a default extension to be used.
// A single "." appears to be treated as an empty extension.
ext = ".";
}
this->WritePlatformConfigTag("TargetExt", config->c_str(), 3); this->WritePlatformConfigTag("TargetExt", config->c_str(), 3);
*this->BuildFileStream *this->BuildFileStream << cmVS10EscapeXML(ext) << "</TargetExt>\n";
<< cmSystemTools::GetFilenameLastExtension(targetNameFull.c_str())
<< "</TargetExt>\n";
this->OutputLinkIncremental(*config); this->OutputLinkIncremental(*config);
} }
@ -1355,48 +1375,44 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
cmsys::auto_ptr<Options> pOptions( cmsys::auto_ptr<Options> pOptions(
new Options(this->LocalGenerator, Options::Compiler, new Options(this->LocalGenerator, Options::Compiler,
cmVSGetCLFlagTable(this->LocalGenerator))); this->GetClFlagTable()));
Options& clOptions = *pOptions; Options& clOptions = *pOptions;
std::string flags; std::string flags;
// collect up flags for const std::string& linkLanguage =
if(this->Target->GetType() < cmTarget::UTILITY) this->Target->GetLinkerLanguage(configName.c_str());
if(linkLanguage.empty())
{ {
const std::string& linkLanguage = cmSystemTools::Error
this->Target->GetLinkerLanguage(configName.c_str()); ("CMake can not determine linker language for target: ",
if(linkLanguage.empty()) this->Name.c_str());
{ return false;
cmSystemTools::Error
("CMake can not determine linker language for target: ",
this->Name.c_str());
return false;
}
if(linkLanguage == "C" || linkLanguage == "CXX"
|| linkLanguage == "Fortran")
{
std::string baseFlagVar = "CMAKE_";
baseFlagVar += linkLanguage;
baseFlagVar += "_FLAGS";
flags = this->
Target->GetMakefile()->GetRequiredDefinition(baseFlagVar.c_str());
std::string flagVar = baseFlagVar + std::string("_") +
cmSystemTools::UpperCase(configName);
flags += " ";
flags += this->
Target->GetMakefile()->GetRequiredDefinition(flagVar.c_str());
}
// set the correct language
if(linkLanguage == "C")
{
flags += " /TC ";
}
if(linkLanguage == "CXX")
{
flags += " /TP ";
}
this->LocalGenerator->AddCompileOptions(flags, this->Target,
linkLanguage, configName.c_str());
} }
if(linkLanguage == "C" || linkLanguage == "CXX"
|| linkLanguage == "Fortran")
{
std::string baseFlagVar = "CMAKE_";
baseFlagVar += linkLanguage;
baseFlagVar += "_FLAGS";
flags = this->
Target->GetMakefile()->GetRequiredDefinition(baseFlagVar.c_str());
std::string flagVar = baseFlagVar + std::string("_") +
cmSystemTools::UpperCase(configName);
flags += " ";
flags += this->
Target->GetMakefile()->GetRequiredDefinition(flagVar.c_str());
}
// set the correct language
if(linkLanguage == "C")
{
clOptions.AddFlag("CompileAs", "CompileAsC");
}
if(linkLanguage == "CXX")
{
clOptions.AddFlag("CompileAs", "CompileAsCpp");
}
this->LocalGenerator->AddCompileOptions(flags, this->Target,
linkLanguage, configName.c_str());
// Get preprocessor definitions for this directory. // Get preprocessor definitions for this directory.
std::string defineFlags = this->Target->GetMakefile()->GetDefineFlags(); std::string defineFlags = this->Target->GetMakefile()->GetDefineFlags();
@ -1436,6 +1452,10 @@ void cmVisualStudio10TargetGenerator::WriteClOptions(
clOptions.OutputAdditionalOptions(*this->BuildFileStream, " ", ""); clOptions.OutputAdditionalOptions(*this->BuildFileStream, " ", "");
this->OutputIncludes(includes); this->OutputIncludes(includes);
clOptions.OutputFlagMap(*this->BuildFileStream, " "); clOptions.OutputFlagMap(*this->BuildFileStream, " ");
clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ",
"\n", "CXX");
this->WriteString("<ObjectFileName>$(IntDir)</ObjectFileName>\n", 3);
// If not in debug mode, write the DebugInformationFormat field // If not in debug mode, write the DebugInformationFormat field
// without value so PDBs don't get generated uselessly. // without value so PDBs don't get generated uselessly.
@ -1445,10 +1465,6 @@ void cmVisualStudio10TargetGenerator::WriteClOptions(
"</DebugInformationFormat>\n", 3); "</DebugInformationFormat>\n", 3);
} }
clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ",
"\n", "CXX");
this->WriteString("<ObjectFileName>$(IntDir)</ObjectFileName>\n", 3);
// Specify the compiler program database file if configured. // Specify the compiler program database file if configured.
std::string pdb = this->Target->GetCompilePDBPath(configName.c_str()); std::string pdb = this->Target->GetCompilePDBPath(configName.c_str());
if(!pdb.empty()) if(!pdb.empty())
@ -1508,7 +1524,7 @@ cmVisualStudio10TargetGenerator::WriteLibOptions(std::string const& config)
cmVisualStudioGeneratorOptions cmVisualStudioGeneratorOptions
libOptions(this->LocalGenerator, libOptions(this->LocalGenerator,
cmVisualStudioGeneratorOptions::Linker, cmVisualStudioGeneratorOptions::Linker,
cmVSGetLibFlagTable(this->LocalGenerator), 0, this); this->GetLibFlagTable(), 0, this);
libOptions.Parse(libflags.c_str()); libOptions.Parse(libflags.c_str());
libOptions.OutputAdditionalOptions(*this->BuildFileStream, " ", ""); libOptions.OutputAdditionalOptions(*this->BuildFileStream, " ", "");
libOptions.OutputFlagMap(*this->BuildFileStream, " "); libOptions.OutputFlagMap(*this->BuildFileStream, " ");
@ -1543,7 +1559,7 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
{ {
cmsys::auto_ptr<Options> pOptions( cmsys::auto_ptr<Options> pOptions(
new Options(this->LocalGenerator, Options::Linker, new Options(this->LocalGenerator, Options::Linker,
cmVSGetLinkFlagTable(this->LocalGenerator), 0, this)); this->GetLinkFlagTable(), 0, this));
Options& linkOptions = *pOptions; Options& linkOptions = *pOptions;
const std::string& linkLanguage = const std::string& linkLanguage =
@ -1567,16 +1583,7 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
{ {
linkType = "EXE"; linkType = "EXE";
} }
std::string stackVar = "CMAKE_";
stackVar += linkLanguage;
stackVar += "_STACK_SIZE";
const char* stackVal = this->Makefile->GetDefinition(stackVar.c_str());
std::string flags; std::string flags;
if(stackVal)
{
flags += " /STACK:";
flags += stackVal;
}
std::string linkFlagVarBase = "CMAKE_"; std::string linkFlagVarBase = "CMAKE_";
linkFlagVarBase += linkType; linkFlagVarBase += linkType;
linkFlagVarBase += "_LINKER_FLAGS"; linkFlagVarBase += "_LINKER_FLAGS";
@ -1600,14 +1607,6 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
flags += " "; flags += " ";
flags += flagsConfig; flags += flagsConfig;
} }
if ( this->Target->GetPropertyAsBool("WIN32_EXECUTABLE") )
{
linkOptions.AddFlag("SubSystem", "Windows");
}
else
{
linkOptions.AddFlag("SubSystem", "Console");
}
std::string standardLibsVar = "CMAKE_"; std::string standardLibsVar = "CMAKE_";
standardLibsVar += linkLanguage; standardLibsVar += linkLanguage;
standardLibsVar += "_STANDARD_LIBRARIES"; standardLibsVar += "_STANDARD_LIBRARIES";
@ -1661,15 +1660,7 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
linkDirs += "%(AdditionalLibraryDirectories)"; linkDirs += "%(AdditionalLibraryDirectories)";
linkOptions.AddFlag("AdditionalLibraryDirectories", linkDirs.c_str()); linkOptions.AddFlag("AdditionalLibraryDirectories", linkDirs.c_str());
linkOptions.AddFlag("AdditionalDependencies", libs.c_str()); linkOptions.AddFlag("AdditionalDependencies", libs.c_str());
linkOptions.AddFlag("Version", "");
if(linkOptions.IsDebug() || flags.find("/debug") != flags.npos)
{
linkOptions.AddFlag("GenerateDebugInformation", "true");
}
else
{
linkOptions.AddFlag("GenerateDebugInformation", "false");
}
std::string targetName; std::string targetName;
std::string targetNameSO; std::string targetNameSO;
std::string targetNameFull; std::string targetNameFull;
@ -1688,6 +1679,31 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
config.c_str()); config.c_str());
} }
linkOptions.AddFlag("Version", "");
if ( this->Target->GetPropertyAsBool("WIN32_EXECUTABLE") )
{
linkOptions.AddFlag("SubSystem", "Windows");
}
else
{
linkOptions.AddFlag("SubSystem", "Console");
}
if(const char* stackVal =
this->Makefile->GetDefinition("CMAKE_"+linkLanguage+"_STACK_SIZE"))
{
linkOptions.AddFlag("StackReserveSize", stackVal);
}
if(linkOptions.IsDebug() || flags.find("/debug") != flags.npos)
{
linkOptions.AddFlag("GenerateDebugInformation", "true");
}
else
{
linkOptions.AddFlag("GenerateDebugInformation", "false");
}
std::string pdb = this->Target->GetPDBDirectory(config.c_str()); std::string pdb = this->Target->GetPDBDirectory(config.c_str());
pdb += "/"; pdb += "/";
pdb += targetNamePDB; pdb += targetNamePDB;

6
Source/cmVisualStudio10TargetGenerator.h
View File

@ -23,6 +23,7 @@ class cmCustomCommand;
class cmLocalVisualStudio7Generator; class cmLocalVisualStudio7Generator;
class cmComputeLinkInformation; class cmComputeLinkInformation;
class cmVisualStudioGeneratorOptions; class cmVisualStudioGeneratorOptions;
struct cmIDEFlagTable;
#include "cmSourceGroup.h" #include "cmSourceGroup.h"
class cmVisualStudio10TargetGenerator class cmVisualStudio10TargetGenerator
@ -55,6 +56,7 @@ private:
void WriteString(const char* line, int indentLevel); void WriteString(const char* line, int indentLevel);
void WriteProjectConfigurations(); void WriteProjectConfigurations();
void WriteProjectConfigurationValues(); void WriteProjectConfigurationValues();
void WriteMSToolConfigurationValues(std::string const& config);
void WriteSource(const char* tool, cmSourceFile const* sf, void WriteSource(const char* tool, cmSourceFile const* sf,
const char* end = 0); const char* end = 0);
void WriteSources(const char* tool, void WriteSources(const char* tool,
@ -98,6 +100,10 @@ private:
const std::vector<cmSourceGroup>& allGroups); const std::vector<cmSourceGroup>& allGroups);
bool IsResxHeader(const std::string& headerFile); bool IsResxHeader(const std::string& headerFile);
cmIDEFlagTable const* GetClFlagTable() const;
cmIDEFlagTable const* GetLibFlagTable() const;
cmIDEFlagTable const* GetLinkFlagTable() const;
private: private:
typedef cmVisualStudioGeneratorOptions Options; typedef cmVisualStudioGeneratorOptions Options;
typedef std::map<std::string, Options*> OptionsMap; typedef std::map<std::string, Options*> OptionsMap;