/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmVisualStudio10TargetGenerator.h"
#include "cmAlgorithms.h"
#include "cmComputeLinkInformation.h"
#include "cmCustomCommandGenerator.h"
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalVisualStudio10Generator.h"
#include "cmLocalVisualStudio7Generator.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmSystemTools.h"
#include "cmVisualStudioGeneratorOptions.h"
#include "windows.h"
#include "cm_auto_ptr.hxx"
static std::string cmVS10EscapeXML(std::string arg)
{
cmSystemTools::ReplaceString(arg, "&", "&");
cmSystemTools::ReplaceString(arg, "<", "<");
cmSystemTools::ReplaceString(arg, ">", ">");
return arg;
}
static std::string cmVS10EscapeComment(std::string comment)
{
// MSBuild takes the CDATA of a element and just
// does "echo $CDATA" with no escapes. We must encode the string.
// http://technet.microsoft.com/en-us/library/cc772462%28WS.10%29.aspx
std::string echoable;
for (std::string::iterator c = comment.begin(); c != comment.end(); ++c) {
switch (*c) {
case '\r':
break;
case '\n':
echoable += '\t';
break;
case '"': /* no break */
case '|': /* no break */
case '&': /* no break */
case '<': /* no break */
case '>': /* no break */
case '^':
echoable += '^'; /* no break */
default:
echoable += *c;
break;
}
}
return echoable;
}
static bool cmVS10IsTargetsFile(std::string const& path)
{
std::string const ext = cmSystemTools::GetFilenameLastExtension(path);
return cmSystemTools::Strucmp(ext.c_str(), ".targets") == 0;
}
static std::string computeProjectFileExtension(cmGeneratorTarget const* t)
{
std::string res;
res = ".vcxproj";
if (cmGlobalVisualStudioGenerator::TargetIsCSharpOnly(t)) {
res = ".csproj";
}
return res;
}
cmVisualStudio10TargetGenerator::cmVisualStudio10TargetGenerator(
cmGeneratorTarget* target, cmGlobalVisualStudio10Generator* gg)
{
this->GlobalGenerator = gg;
this->GeneratorTarget = target;
this->Makefile = target->Target->GetMakefile();
this->Makefile->GetConfigurations(this->Configurations);
this->LocalGenerator =
(cmLocalVisualStudio7Generator*)this->GeneratorTarget->GetLocalGenerator();
this->Name = this->GeneratorTarget->GetName();
this->GUID = this->GlobalGenerator->GetGUID(this->Name.c_str());
this->Platform = gg->GetPlatformName();
this->NsightTegra = gg->IsNsightTegra();
for (int i = 0; i < 4; ++i) {
this->NsightTegraVersion[i] = 0;
}
sscanf(gg->GetNsightTegraVersion().c_str(), "%u.%u.%u.%u",
&this->NsightTegraVersion[0], &this->NsightTegraVersion[1],
&this->NsightTegraVersion[2], &this->NsightTegraVersion[3]);
this->MSTools = !this->NsightTegra;
this->Managed = false;
this->TargetCompileAsWinRT = false;
this->BuildFileStream = 0;
this->IsMissingFiles = false;
this->DefaultArtifactDir =
this->LocalGenerator->GetCurrentBinaryDirectory() + std::string("/") +
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->InSourceBuild =
(strcmp(this->Makefile->GetCurrentSourceDirectory(),
this->Makefile->GetCurrentBinaryDirectory()) == 0);
}
cmVisualStudio10TargetGenerator::~cmVisualStudio10TargetGenerator()
{
for (OptionsMap::iterator i = this->ClOptions.begin();
i != this->ClOptions.end(); ++i) {
delete i->second;
}
for (OptionsMap::iterator i = this->LinkOptions.begin();
i != this->LinkOptions.end(); ++i) {
delete i->second;
}
for (OptionsMap::iterator i = this->CudaOptions.begin();
i != this->CudaOptions.end(); ++i) {
delete i->second;
}
for (OptionsMap::iterator i = this->CudaLinkOptions.begin();
i != this->CudaLinkOptions.end(); ++i) {
delete i->second;
}
if (!this->BuildFileStream) {
return;
}
if (this->BuildFileStream->Close()) {
this->GlobalGenerator->FileReplacedDuringGenerate(this->PathToProjectFile);
}
delete this->BuildFileStream;
}
void cmVisualStudio10TargetGenerator::WritePlatformConfigTag(
const char* tag, const std::string& config, int indentLevel,
const char* attribute, const char* end, std::ostream* stream)
{
if (!stream) {
stream = this->BuildFileStream;
}
stream->fill(' ');
stream->width(indentLevel * 2);
(*stream) << ""; // applies indentation
(*stream) << "<" << tag << " Condition=\"";
(*stream) << "'$(Configuration)|$(Platform)'=='";
(*stream) << config << "|" << this->Platform;
(*stream) << "'";
// handle special case for 32 bit C# targets
if (csproj == this->ProjectType && this->Platform == "Win32") {
(*stream) << " Or ";
(*stream) << "'$(Configuration)|$(Platform)'=='";
(*stream) << config << "|x86";
(*stream) << "'";
}
(*stream) << "\"";
if (attribute) {
(*stream) << attribute;
}
// close the tag
(*stream) << ">";
if (end) {
(*stream) << end;
}
}
void cmVisualStudio10TargetGenerator::WriteString(const char* line,
int indentLevel)
{
this->BuildFileStream->fill(' ');
this->BuildFileStream->width(indentLevel * 2);
// write an empty string to get the fill level indent to print
(*this->BuildFileStream) << "";
(*this->BuildFileStream) << line;
}
#define VS10_CXX_DEFAULT_PROPS "$(VCTargetsPath)\\Microsoft.Cpp.Default.props"
#define VS10_CXX_PROPS "$(VCTargetsPath)\\Microsoft.Cpp.props"
#define VS10_CXX_USER_PROPS \
"$(UserRootDir)\\Microsoft.Cpp.$(Platform).user.props"
#define VS10_CXX_TARGETS "$(VCTargetsPath)\\Microsoft.Cpp.targets"
#define VS10_CSharp_DEFAULT_PROPS \
"$(MSBuildExtensionsPath)\\$(MSBuildToolsVersion)\\Microsoft.Common.props"
// This does not seem to exist by default, it's just provided for consistency
// in case users want to have default custom props for C# targets
#define VS10_CSharp_USER_PROPS \
"$(UserRootDir)\\Microsoft.CSharp.$(Platform).user.props"
#define VS10_CSharp_TARGETS "$(MSBuildToolsPath)\\Microsoft.CSharp.targets"
void cmVisualStudio10TargetGenerator::Generate()
{
// do not generate external ms projects
if (this->GeneratorTarget->GetType() == cmStateEnums::INTERFACE_LIBRARY ||
this->GeneratorTarget->GetProperty("EXTERNAL_MSPROJECT")) {
return;
}
this->ProjectFileExtension =
computeProjectFileExtension(this->GeneratorTarget);
if (this->ProjectFileExtension == ".vcxproj") {
this->ProjectType = vcxproj;
this->Managed = false;
} else if (this->ProjectFileExtension == ".csproj") {
this->ProjectType = csproj;
this->Managed = true;
}
// Tell the global generator the name of the project file
this->GeneratorTarget->Target->SetProperty("GENERATOR_FILE_NAME",
this->Name.c_str());
this->GeneratorTarget->Target->SetProperty(
"GENERATOR_FILE_NAME_EXT", this->ProjectFileExtension.c_str());
if (this->GeneratorTarget->GetType() <= cmStateEnums::OBJECT_LIBRARY) {
if (!this->ComputeClOptions()) {
return;
}
if (!this->ComputeRcOptions()) {
return;
}
if (!this->ComputeCudaOptions()) {
return;
}
if (!this->ComputeCudaLinkOptions()) {
return;
}
if (!this->ComputeMasmOptions()) {
return;
}
if (!this->ComputeNasmOptions()) {
return;
}
if (!this->ComputeLinkOptions()) {
return;
}
if (!this->ComputeLibOptions()) {
return;
}
}
std::string path = this->LocalGenerator->GetCurrentBinaryDirectory();
path += "/";
path += this->Name;
path += this->ProjectFileExtension;
this->BuildFileStream = new cmGeneratedFileStream(path.c_str());
this->PathToProjectFile = path;
this->BuildFileStream->SetCopyIfDifferent(true);
// Write the encoding header into the file
char magic[] = { char(0xEF), char(0xBB), char(0xBF) };
this->BuildFileStream->write(magic, 3);
// get the tools version to use
const std::string toolsVer(this->GlobalGenerator->GetToolsVersion());
std::string project_defaults = "GlobalGenerator->Encoding() + "\"?>\n";
project_defaults.append("\n");
this->WriteString(project_defaults.c_str(), 0);
if (this->NsightTegra) {
this->WriteString("\n", 1);
const int nsightTegraMajorVersion = this->NsightTegraVersion[0];
const int nsightTegraMinorVersion = this->NsightTegraVersion[1];
if (nsightTegraMajorVersion >= 2) {
this->WriteString("", 2);
if (nsightTegraMajorVersion > 3 ||
(nsightTegraMajorVersion == 3 && nsightTegraMinorVersion >= 1)) {
(*this->BuildFileStream) << "11";
} else {
// Nsight Tegra 2.0 uses project revision 9.
(*this->BuildFileStream) << "9";
}
(*this->BuildFileStream) << "\n";
// Tell newer versions to upgrade silently when loading.
this->WriteString(""
"true"
"\n",
2);
} else {
// Require Nsight Tegra 1.6 for JCompile support.
this->WriteString(""
"7"
"\n",
2);
}
this->WriteString("\n", 1);
}
if (const char* hostArch =
this->GlobalGenerator->GetPlatformToolsetHostArchitecture()) {
this->WriteString("\n", 1);
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(hostArch)
<< "\n";
this->WriteString("\n", 1);
}
if (csproj != this->ProjectType) {
this->WriteProjectConfigurations();
}
this->WriteString("\n", 1);
this->WriteString("", 2);
(*this->BuildFileStream) << "{" << this->GUID << "}\n";
if (this->MSTools &&
this->GeneratorTarget->GetType() <= cmStateEnums::GLOBAL_TARGET) {
this->WriteApplicationTypeSettings();
this->VerifyNecessaryFiles();
}
const char* vsProjectTypes =
this->GeneratorTarget->GetProperty("VS_GLOBAL_PROJECT_TYPES");
if (vsProjectTypes) {
std::string tagName = "ProjectTypes";
if (csproj == this->ProjectType) {
tagName = "ProjectTypeGuids";
}
this->WriteString("", 2);
(*this->BuildFileStream) << "<" << tagName << ">"
<< cmVS10EscapeXML(vsProjectTypes) << ""
<< tagName << ">\n";
}
const char* vsProjectName =
this->GeneratorTarget->GetProperty("VS_SCC_PROJECTNAME");
const char* vsLocalPath =
this->GeneratorTarget->GetProperty("VS_SCC_LOCALPATH");
const char* vsProvider =
this->GeneratorTarget->GetProperty("VS_SCC_PROVIDER");
if (vsProjectName && vsLocalPath && vsProvider) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(vsProjectName)
<< "\n";
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(vsLocalPath)
<< "\n";
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(vsProvider)
<< "\n";
const char* vsAuxPath =
this->GeneratorTarget->GetProperty("VS_SCC_AUXPATH");
if (vsAuxPath) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(vsAuxPath)
<< "\n";
}
}
if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT")) {
this->WriteString("true\n", 2);
}
const char* vsGlobalKeyword =
this->GeneratorTarget->GetProperty("VS_GLOBAL_KEYWORD");
if (!vsGlobalKeyword) {
this->WriteString("Win32Proj\n", 2);
} else {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(vsGlobalKeyword)
<< "\n";
}
const char* vsGlobalRootNamespace =
this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE");
if (vsGlobalRootNamespace) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(vsGlobalRootNamespace)
<< "\n";
}
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(this->Platform)
<< "\n";
const char* projLabel = this->GeneratorTarget->GetProperty("PROJECT_LABEL");
if (!projLabel) {
projLabel = this->Name.c_str();
}
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(projLabel) << "\n";
if (const char* targetFrameworkVersion = this->GeneratorTarget->GetProperty(
"VS_DOTNET_TARGET_FRAMEWORK_VERSION")) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(targetFrameworkVersion)
<< "\n";
}
// Disable the project upgrade prompt that is displayed the first time a
// project using an older toolset version is opened in a newer version of
// the IDE (respected by VS 2013 and above).
if (this->GlobalGenerator->GetVersion() >=
cmGlobalVisualStudioGenerator::VS12) {
this->WriteString("NoUpgrade"
"\n",
2);
}
std::vector keys = this->GeneratorTarget->GetPropertyKeys();
for (std::vector::const_iterator keyIt = keys.begin();
keyIt != keys.end(); ++keyIt) {
static const char* prefix = "VS_GLOBAL_";
if (keyIt->find(prefix) != 0)
continue;
std::string globalKey = keyIt->substr(strlen(prefix));
// Skip invalid or separately-handled properties.
if (globalKey == "" || globalKey == "PROJECT_TYPES" ||
globalKey == "ROOTNAMESPACE" || globalKey == "KEYWORD") {
continue;
}
const char* value = this->GeneratorTarget->GetProperty(keyIt->c_str());
if (!value)
continue;
this->WriteString("<", 2);
(*this->BuildFileStream) << globalKey << ">" << cmVS10EscapeXML(value)
<< "" << globalKey << ">\n";
}
if (this->Managed) {
std::string outputType = "";
switch (this->GeneratorTarget->GetType()) {
case cmStateEnums::OBJECT_LIBRARY:
case cmStateEnums::STATIC_LIBRARY:
case cmStateEnums::SHARED_LIBRARY:
outputType += "Library";
break;
case cmStateEnums::MODULE_LIBRARY:
outputType += "Module";
break;
case cmStateEnums::EXECUTABLE:
if (this->GeneratorTarget->Target->GetPropertyAsBool(
"WIN32_EXECUTABLE")) {
outputType += "WinExe";
} else {
outputType += "Exe";
}
break;
case cmStateEnums::UTILITY:
case cmStateEnums::GLOBAL_TARGET:
outputType += "Utility";
break;
case cmStateEnums::UNKNOWN_LIBRARY:
case cmStateEnums::INTERFACE_LIBRARY:
break;
}
outputType += "\n";
this->WriteString(outputType.c_str(), 2);
this->WriteString("Properties\n",
2);
}
this->WriteString("\n", 1);
switch (this->ProjectType) {
case vcxproj:
this->WriteString("\n",
1);
break;
case csproj:
this->WriteString("\n",
1);
break;
}
this->WriteProjectConfigurationValues();
if (vcxproj == this->ProjectType) {
this->WriteString("\n", 1);
}
this->WriteString("\n", 1);
if (this->GlobalGenerator->IsCudaEnabled()) {
this->WriteString("BuildFileStream)
<< cmVS10EscapeXML(this->GlobalGenerator->GetPlatformToolsetCudaString())
<< ".props\" />\n";
}
if (this->GlobalGenerator->IsMasmEnabled()) {
this->WriteString("\n",
2);
}
if (this->GlobalGenerator->IsNasmEnabled()) {
// Always search in the standard modules location.
std::string propsTemplate =
GetCMakeFilePath("Templates/MSBuild/nasm.props.in");
std::string propsLocal;
propsLocal += this->DefaultArtifactDir;
propsLocal += "\\nasm.props";
this->ConvertToWindowsSlash(propsLocal);
this->Makefile->ConfigureFile(propsTemplate.c_str(), propsLocal.c_str(),
false, true, true);
std::string import = std::string("\n";
this->WriteString(import.c_str(), 2);
}
this->WriteString("\n", 1);
this->WriteString("\n", 1);
{
std::string props;
switch (this->ProjectType) {
case vcxproj:
props = VS10_CXX_USER_PROPS;
break;
case csproj:
props = VS10_CSharp_USER_PROPS;
break;
}
if (const char* p = this->GeneratorTarget->GetProperty("VS_USER_PROPS")) {
props = p;
}
if (!props.empty()) {
this->ConvertToWindowsSlash(props);
this->WriteString("", 2);
(*this->BuildFileStream)
<< "\n";
}
}
this->WritePlatformExtensions();
this->WriteString("\n", 1);
this->WriteString("\n", 1);
this->WriteWinRTPackageCertificateKeyFile();
this->WritePathAndIncrementalLinkOptions();
this->WriteItemDefinitionGroups();
this->WriteCustomCommands();
this->WriteAllSources();
this->WriteDotNetReferences();
this->WriteEmbeddedResourceGroup();
this->WriteXamlFilesGroup();
this->WriteWinRTReferences();
this->WriteProjectReferences();
this->WriteSDKReferences();
switch (this->ProjectType) {
case vcxproj:
this->WriteString("\n", 1);
break;
case csproj:
this->WriteString("\n", 1);
break;
}
this->WriteTargetSpecificReferences();
this->WriteString("\n", 1);
this->WriteTargetsFileReferences();
if (this->GlobalGenerator->IsCudaEnabled()) {
this->WriteString("BuildFileStream)
<< cmVS10EscapeXML(this->GlobalGenerator->GetPlatformToolsetCudaString())
<< ".targets\" />\n";
}
if (this->GlobalGenerator->IsMasmEnabled()) {
this->WriteString("\n",
2);
}
if (this->GlobalGenerator->IsNasmEnabled()) {
std::string nasmTargets =
GetCMakeFilePath("Templates/MSBuild/nasm.targets");
std::string import = "\n";
this->WriteString(import.c_str(), 2);
}
this->WriteString("\n", 1);
if (csproj == this->ProjectType) {
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
this->WriteString("BuildFileStream) << *i << "'\">\n";
this->WriteEvents(*i);
this->WriteString("\n", 1);
}
}
this->WriteString("", 0);
// The groups are stored in a separate file for VS 10
this->WriteGroups();
}
void cmVisualStudio10TargetGenerator::WriteDotNetReferences()
{
std::vector references;
typedef std::pair HintReference;
std::vector hintReferences;
if (const char* vsDotNetReferences =
this->GeneratorTarget->GetProperty("VS_DOTNET_REFERENCES")) {
cmSystemTools::ExpandListArgument(vsDotNetReferences, references);
}
cmPropertyMap const& props = this->GeneratorTarget->Target->GetProperties();
for (cmPropertyMap::const_iterator i = props.begin(); i != props.end();
++i) {
if (i->first.find("VS_DOTNET_REFERENCE_") == 0) {
std::string name = i->first.substr(20);
if (name != "") {
std::string path = i->second.GetValue();
if (!cmsys::SystemTools::FileIsFullPath(path)) {
path = std::string(this->GeneratorTarget->Target->GetMakefile()
->GetCurrentSourceDirectory()) +
"/" + path;
}
this->ConvertToWindowsSlash(path);
hintReferences.push_back(HintReference(name, path));
}
}
}
if (!references.empty() || !hintReferences.empty()) {
this->WriteString("\n", 1);
for (std::vector::iterator ri = references.begin();
ri != references.end(); ++ri) {
// if the entry from VS_DOTNET_REFERENCES is an existing file, generate
// a new hint-reference and name it from the filename
if (cmsys::SystemTools::FileExists(*ri, true)) {
std::string name =
cmsys::SystemTools::GetFilenameWithoutExtension(*ri);
std::string path = *ri;
this->ConvertToWindowsSlash(path);
hintReferences.push_back(HintReference(name, path));
} else {
this->WriteDotNetReference(*ri, "");
}
}
for (std::vector >::const_iterator i =
hintReferences.begin();
i != hintReferences.end(); ++i) {
this->WriteDotNetReference(i->first, i->second);
}
this->WriteString("\n", 1);
}
}
void cmVisualStudio10TargetGenerator::WriteDotNetReference(
std::string const& ref, std::string const& hint)
{
this->WriteString("BuildFileStream) << cmVS10EscapeXML(ref) << "\">\n";
this->WriteString("true"
"\n",
3);
this->WriteString("true"
"\n",
3);
if (!hint.empty()) {
const char* privateReference = "True";
if (const char* value = this->GeneratorTarget->GetProperty(
"VS_DOTNET_REFERENCES_COPY_LOCAL")) {
if (cmSystemTools::IsOff(value)) {
privateReference = "False";
}
}
this->WriteString("", 3);
(*this->BuildFileStream) << privateReference << "\n";
this->WriteString("", 3);
(*this->BuildFileStream) << hint << "\n";
}
this->WriteString("\n", 2);
}
void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
{
std::vector resxObjs;
this->GeneratorTarget->GetResxSources(resxObjs, "");
if (!resxObjs.empty()) {
this->WriteString("\n", 1);
std::string srcDir = this->Makefile->GetCurrentSourceDirectory();
this->ConvertToWindowsSlash(srcDir);
for (std::vector::const_iterator oi =
resxObjs.begin();
oi != resxObjs.end(); ++oi) {
std::string obj = (*oi)->GetFullPath();
this->WriteString("ConvertToWindowsSlash(obj);
bool useRelativePath = false;
if (csproj == this->ProjectType && this->InSourceBuild) {
// If we do an in-source build and the resource file is in a
// subdirectory
// of the .csproj file, we have to use relative pathnames, otherwise
// visual studio does not show the file in the IDE. Sorry.
if (obj.find(srcDir) == 0) {
obj = this->ConvertPath(obj, true);
this->ConvertToWindowsSlash(obj);
useRelativePath = true;
}
}
(*this->BuildFileStream) << obj << "\">\n";
if (csproj != this->ProjectType) {
this->WriteString("", 3);
std::string hFileName = obj.substr(0, obj.find_last_of(".")) + ".h";
(*this->BuildFileStream) << hFileName << "\n";
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
this->WritePlatformConfigTag("LogicalName", i->c_str(), 3);
if (this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE") ||
// Handle variant of VS_GLOBAL_ for RootNamespace.
this->GeneratorTarget->GetProperty("VS_GLOBAL_RootNamespace")) {
(*this->BuildFileStream) << "$(RootNamespace).";
}
(*this->BuildFileStream) << "%(Filename)";
(*this->BuildFileStream) << ".resources";
(*this->BuildFileStream) << "\n";
}
} else {
std::string binDir = this->Makefile->GetCurrentBinaryDirectory();
this->ConvertToWindowsSlash(binDir);
// If the resource was NOT added using a relative path (which should
// be the default), we have to provide a link here
if (!useRelativePath) {
std::string link;
if (obj.find(srcDir) == 0) {
link = obj.substr(srcDir.length() + 1);
} else if (obj.find(binDir) == 0) {
link = obj.substr(binDir.length() + 1);
} else {
link = cmsys::SystemTools::GetFilenameName(obj);
}
if (!link.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << link << "\n";
}
}
// Determine if this is a generated resource from a .Designer.cs file
std::string designerResource =
cmSystemTools::GetFilenamePath((*oi)->GetFullPath()) + "/" +
cmSystemTools::GetFilenameWithoutLastExtension(
(*oi)->GetFullPath()) +
".Designer.cs";
if (cmsys::SystemTools::FileExists(designerResource)) {
std::string generator = "PublicResXFileCodeGenerator";
if (const char* g = (*oi)->GetProperty("VS_RESOURCE_GENERATOR")) {
generator = g;
}
if (!generator.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(generator)
<< "\n";
if (designerResource.find(srcDir) == 0) {
designerResource = designerResource.substr(srcDir.length() + 1);
} else if (designerResource.find(binDir) == 0) {
designerResource = designerResource.substr(binDir.length() + 1);
} else {
designerResource =
cmsys::SystemTools::GetFilenameName(designerResource);
}
this->ConvertToWindowsSlash(designerResource);
this->WriteString("", 3);
(*this->BuildFileStream) << designerResource
<< "\n";
}
}
const cmPropertyMap& props = (*oi)->GetProperties();
for (cmPropertyMap::const_iterator p = props.begin(); p != props.end();
++p) {
static const std::string propNamePrefix = "VS_CSHARP_";
if (p->first.find(propNamePrefix.c_str()) == 0) {
std::string tagName = p->first.substr(propNamePrefix.length());
if (!tagName.empty()) {
std::string value = props.GetPropertyValue(p->first);
if (!value.empty()) {
this->WriteString("<", 3);
(*this->BuildFileStream) << tagName << ">";
(*this->BuildFileStream) << cmVS10EscapeXML(value);
(*this->BuildFileStream) << "" << tagName << ">\n";
}
}
}
}
}
this->WriteString("\n", 2);
}
this->WriteString("\n", 1);
}
}
void cmVisualStudio10TargetGenerator::WriteXamlFilesGroup()
{
std::vector xamlObjs;
this->GeneratorTarget->GetXamlSources(xamlObjs, "");
if (!xamlObjs.empty()) {
this->WriteString("\n", 1);
for (std::vector::const_iterator oi =
xamlObjs.begin();
oi != xamlObjs.end(); ++oi) {
std::string obj = (*oi)->GetFullPath();
std::string xamlType;
const char* xamlTypeProperty = (*oi)->GetProperty("VS_XAML_TYPE");
if (xamlTypeProperty) {
xamlType = xamlTypeProperty;
} else {
xamlType = "Page";
}
this->WriteSource(xamlType, *oi, ">\n");
if (csproj == this->ProjectType && !this->InSourceBuild) {
// add tag to written XAML source if necessary
const std::string srcDir = this->Makefile->GetCurrentSourceDirectory();
const std::string binDir = this->Makefile->GetCurrentBinaryDirectory();
std::string link;
if (obj.find(srcDir) == 0) {
link = obj.substr(srcDir.length() + 1);
} else if (obj.find(binDir) == 0) {
link = obj.substr(binDir.length() + 1);
} else {
link = cmsys::SystemTools::GetFilenameName(obj);
}
if (!link.empty()) {
this->ConvertToWindowsSlash(link);
this->WriteString("", 3);
(*this->BuildFileStream) << link << "\n";
}
}
this->WriteString("Designer\n", 3);
this->WriteString("", 2);
(*this->BuildFileStream) << xamlType << ">\n";
}
this->WriteString("\n", 1);
}
}
void cmVisualStudio10TargetGenerator::WriteTargetSpecificReferences()
{
if (this->MSTools) {
if (this->GlobalGenerator->TargetsWindowsPhone() &&
this->GlobalGenerator->GetSystemVersion() == "8.0") {
this->WriteString("\n",
1);
}
}
}
void cmVisualStudio10TargetGenerator::WriteTargetsFileReferences()
{
for (std::vector::iterator i =
this->TargetsFileAndConfigsVec.begin();
i != this->TargetsFileAndConfigsVec.end(); ++i) {
TargetsFileAndConfigs const& tac = *i;
this->WriteString("BuildFileStream) << tac.File << "\" ";
(*this->BuildFileStream) << "Condition=\"";
(*this->BuildFileStream) << "Exists('" << tac.File << "')";
if (!tac.Configs.empty()) {
(*this->BuildFileStream) << " And (";
for (size_t j = 0; j < tac.Configs.size(); ++j) {
if (j > 0) {
(*this->BuildFileStream) << " Or ";
}
(*this->BuildFileStream) << "'$(Configuration)'=='" << tac.Configs[j]
<< "'";
}
(*this->BuildFileStream) << ")";
}
(*this->BuildFileStream) << "\" />\n";
}
}
void cmVisualStudio10TargetGenerator::WriteWinRTReferences()
{
std::vector references;
if (const char* vsWinRTReferences =
this->GeneratorTarget->GetProperty("VS_WINRT_REFERENCES")) {
cmSystemTools::ExpandListArgument(vsWinRTReferences, references);
}
if (this->GlobalGenerator->TargetsWindowsPhone() &&
this->GlobalGenerator->GetSystemVersion() == "8.0" &&
references.empty()) {
references.push_back("platform.winmd");
}
if (!references.empty()) {
this->WriteString("\n", 1);
for (std::vector::iterator ri = references.begin();
ri != references.end(); ++ri) {
this->WriteString("BuildFileStream) << cmVS10EscapeXML(*ri) << "\">\n";
this->WriteString("true\n", 3);
this->WriteString("\n", 2);
}
this->WriteString("\n", 1);
}
}
// ConfigurationType Application, Utility StaticLibrary DynamicLibrary
void cmVisualStudio10TargetGenerator::WriteProjectConfigurations()
{
this->WriteString("\n", 1);
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
this->WriteString("BuildFileStream) << *i << "|" << this->Platform << "\">\n";
this->WriteString("", 3);
(*this->BuildFileStream) << *i << "\n";
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(this->Platform)
<< "\n";
this->WriteString("\n", 2);
}
this->WriteString("\n", 1);
}
void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues()
{
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
this->WritePlatformConfigTag("PropertyGroup", i->c_str(), 1,
" Label=\"Configuration\"", "\n");
if (csproj != this->ProjectType) {
std::string configType = "";
if (const char* vsConfigurationType =
this->GeneratorTarget->GetProperty("VS_CONFIGURATION_TYPE")) {
configType += cmVS10EscapeXML(vsConfigurationType);
} else {
switch (this->GeneratorTarget->GetType()) {
case cmStateEnums::SHARED_LIBRARY:
case cmStateEnums::MODULE_LIBRARY:
configType += "DynamicLibrary";
break;
case cmStateEnums::OBJECT_LIBRARY:
case cmStateEnums::STATIC_LIBRARY:
configType += "StaticLibrary";
break;
case cmStateEnums::EXECUTABLE:
if (this->NsightTegra &&
!this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI")) {
// Android executables are .so too.
configType += "DynamicLibrary";
} else {
configType += "Application";
}
break;
case cmStateEnums::UTILITY:
case cmStateEnums::GLOBAL_TARGET:
if (this->NsightTegra) {
// Tegra-Android platform does not understand "Utility".
configType += "StaticLibrary";
} else {
configType += "Utility";
}
break;
case cmStateEnums::UNKNOWN_LIBRARY:
case cmStateEnums::INTERFACE_LIBRARY:
break;
}
}
configType += "\n";
this->WriteString(configType.c_str(), 2);
}
if (this->MSTools) {
if (!this->Managed) {
this->WriteMSToolConfigurationValues(*i);
} else {
this->WriteMSToolConfigurationValuesManaged(*i);
}
} else if (this->NsightTegra) {
this->WriteNsightTegraConfigurationValues(*i);
}
this->WriteString("\n", 1);
}
}
void cmVisualStudio10TargetGenerator::WriteMSToolConfigurationValues(
std::string const& config)
{
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
const char* mfcFlag =
this->GeneratorTarget->Target->GetMakefile()->GetDefinition(
"CMAKE_MFC_FLAG");
if (mfcFlag) {
std::string const mfcFlagValue = mfcFlag;
std::string useOfMfcValue = "false";
if (this->GeneratorTarget->GetType() <= cmStateEnums::OBJECT_LIBRARY) {
if (mfcFlagValue == "1") {
useOfMfcValue = "Static";
} else if (mfcFlagValue == "2") {
useOfMfcValue = "Dynamic";
}
}
std::string mfcLine = "";
mfcLine += useOfMfcValue + "\n";
this->WriteString(mfcLine.c_str(), 2);
}
if ((this->GeneratorTarget->GetType() <= cmStateEnums::OBJECT_LIBRARY &&
this->ClOptions[config]->UsingUnicode()) ||
this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
this->GlobalGenerator->TargetsWindowsPhone() ||
this->GlobalGenerator->TargetsWindowsStore() ||
this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) {
this->WriteString("Unicode\n", 2);
} else if (this->GeneratorTarget->GetType() <=
cmStateEnums::MODULE_LIBRARY &&
this->ClOptions[config]->UsingSBCS()) {
this->WriteString("NotSet\n", 2);
} else {
this->WriteString("MultiByte\n", 2);
}
if (const char* toolset = gg->GetPlatformToolset()) {
std::string pts = "";
pts += toolset;
pts += "\n";
this->WriteString(pts.c_str(), 2);
}
if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) {
this->WriteString("true"
"\n",
2);
}
}
void cmVisualStudio10TargetGenerator::WriteMSToolConfigurationValuesManaged(
std::string const& config)
{
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
Options& o = *(this->ClOptions[config]);
if (o.IsDebug()) {
this->WriteString("true\n", 2);
this->WriteString("true\n", 2);
}
std::string outDir =
this->GeneratorTarget->GetDirectory(config.c_str()) + "/";
this->ConvertToWindowsSlash(outDir);
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(outDir) << "\n";
if (o.HasFlag("Platform")) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(o.GetFlag("Platform"))
<< "\n";
o.RemoveFlag("Platform");
}
if (const char* toolset = gg->GetPlatformToolset()) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(toolset)
<< "\n";
}
std::string postfixName = cmSystemTools::UpperCase(config);
postfixName += "_POSTFIX";
std::string assemblyName = this->GeneratorTarget->GetOutputName(
config, cmStateEnums::RuntimeBinaryArtifact);
if (const char* postfix = this->GeneratorTarget->GetProperty(postfixName)) {
assemblyName += postfix;
}
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(assemblyName)
<< "\n";
if (cmStateEnums::EXECUTABLE == this->GeneratorTarget->GetType()) {
this->WriteString("Program\n", 2);
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(outDir)
<< cmVS10EscapeXML(assemblyName)
<< ".exe\n";
}
o.OutputFlagMap(*this->BuildFileStream, " ");
}
//----------------------------------------------------------------------------
void cmVisualStudio10TargetGenerator::WriteNsightTegraConfigurationValues(
std::string const&)
{
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
const char* toolset = gg->GetPlatformToolset();
std::string ntv = "";
ntv += toolset ? toolset : "Default";
ntv += "\n";
this->WriteString(ntv.c_str(), 2);
if (const char* minApi =
this->GeneratorTarget->GetProperty("ANDROID_API_MIN")) {
this->WriteString("", 2);
(*this->BuildFileStream) << "android-" << cmVS10EscapeXML(minApi)
<< "\n";
}
if (const char* api = this->GeneratorTarget->GetProperty("ANDROID_API")) {
this->WriteString("", 2);
(*this->BuildFileStream) << "android-" << cmVS10EscapeXML(api)
<< "\n";
}
if (const char* cpuArch =
this->GeneratorTarget->GetProperty("ANDROID_ARCH")) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(cpuArch) << "\n";
}
if (const char* stlType =
this->GeneratorTarget->GetProperty("ANDROID_STL_TYPE")) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(stlType)
<< "\n";
}
}
void cmVisualStudio10TargetGenerator::WriteCustomCommands()
{
this->SourcesVisited.clear();
std::vector customCommands;
this->GeneratorTarget->GetCustomCommands(customCommands, "");
for (std::vector::const_iterator si =
customCommands.begin();
si != customCommands.end(); ++si) {
this->WriteCustomCommand(*si);
}
}
void cmVisualStudio10TargetGenerator::WriteCustomCommand(
cmSourceFile const* sf)
{
if (this->SourcesVisited.insert(sf).second) {
if (std::vector const* depends =
this->GeneratorTarget->GetSourceDepends(sf)) {
for (std::vector::const_iterator di = depends->begin();
di != depends->end(); ++di) {
this->WriteCustomCommand(*di);
}
}
if (cmCustomCommand const* command = sf->GetCustomCommand()) {
this->WriteString("\n", 1);
this->WriteCustomRule(sf, *command);
this->WriteString("\n", 1);
}
}
}
void cmVisualStudio10TargetGenerator::WriteCustomRule(
cmSourceFile const* source, cmCustomCommand const& command)
{
std::string sourcePath = source->GetFullPath();
// VS 10 will always rebuild a custom command attached to a .rule
// file that doesn't exist so create the file explicitly.
if (source->GetPropertyAsBool("__CMAKE_RULE")) {
if (!cmSystemTools::FileExists(sourcePath.c_str())) {
// Make sure the path exists for the file
std::string path = cmSystemTools::GetFilenamePath(sourcePath);
cmSystemTools::MakeDirectory(path.c_str());
cmsys::ofstream fout(sourcePath.c_str());
if (fout) {
fout << "# generated from CMake\n";
fout.flush();
fout.close();
// Force given file to have a very old timestamp, thus
// preventing dependent rebuilds.
this->ForceOld(sourcePath);
} else {
std::string error = "Could not create file: [";
error += sourcePath;
error += "] ";
cmSystemTools::Error(error.c_str(),
cmSystemTools::GetLastSystemError().c_str());
}
}
}
cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
this->WriteSource("CustomBuild", source, ">\n");
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
cmCustomCommandGenerator ccg(command, *i, this->LocalGenerator);
std::string comment = lg->ConstructComment(ccg);
comment = cmVS10EscapeComment(comment);
std::string script = cmVS10EscapeXML(lg->ConstructScript(ccg));
this->WritePlatformConfigTag("Message", i->c_str(), 3);
(*this->BuildFileStream) << cmVS10EscapeXML(comment) << "\n";
this->WritePlatformConfigTag("Command", i->c_str(), 3);
(*this->BuildFileStream) << script << "\n";
this->WritePlatformConfigTag("AdditionalInputs", i->c_str(), 3);
(*this->BuildFileStream) << cmVS10EscapeXML(source->GetFullPath());
for (std::vector::const_iterator d = ccg.GetDepends().begin();
d != ccg.GetDepends().end(); ++d) {
std::string dep;
if (this->LocalGenerator->GetRealDependency(d->c_str(), i->c_str(),
dep)) {
this->ConvertToWindowsSlash(dep);
(*this->BuildFileStream) << ";" << cmVS10EscapeXML(dep);
}
}
(*this->BuildFileStream) << ";%(AdditionalInputs)\n";
this->WritePlatformConfigTag("Outputs", i->c_str(), 3);
const char* sep = "";
for (std::vector::const_iterator o = ccg.GetOutputs().begin();
o != ccg.GetOutputs().end(); ++o) {
std::string out = *o;
this->ConvertToWindowsSlash(out);
(*this->BuildFileStream) << sep << cmVS10EscapeXML(out);
sep = ";";
}
(*this->BuildFileStream) << "\n";
if (this->LocalGenerator->GetVersion() >
cmGlobalVisualStudioGenerator::VS10) {
// VS >= 11 let us turn off linking of custom command outputs.
this->WritePlatformConfigTag("LinkObjects", i->c_str(), 3);
(*this->BuildFileStream) << "false\n";
}
}
this->WriteString("\n", 2);
}
std::string cmVisualStudio10TargetGenerator::ConvertPath(
std::string const& path, bool forceRelative)
{
return forceRelative
? cmSystemTools::RelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), path.c_str())
: path.c_str();
}
void cmVisualStudio10TargetGenerator::ConvertToWindowsSlash(std::string& s)
{
// first convert all of the slashes
std::string::size_type pos = 0;
while ((pos = s.find('/', pos)) != std::string::npos) {
s[pos] = '\\';
pos++;
}
}
void cmVisualStudio10TargetGenerator::WriteGroups()
{
if (csproj == this->ProjectType) {
return;
}
// collect up group information
std::vector sourceGroups = this->Makefile->GetSourceGroups();
std::vector const& sources =
this->GeneratorTarget->GetAllConfigSources();
std::set groupsUsed;
for (std::vector::const_iterator si =
sources.begin();
si != sources.end(); ++si) {
std::string const& source = si->Source->GetFullPath();
cmSourceGroup* sourceGroup =
this->Makefile->FindSourceGroup(source.c_str(), sourceGroups);
groupsUsed.insert(sourceGroup);
}
this->AddMissingSourceGroups(groupsUsed, sourceGroups);
// Write out group file
std::string path = this->LocalGenerator->GetCurrentBinaryDirectory();
path += "/";
path += this->Name;
path += computeProjectFileExtension(this->GeneratorTarget);
path += ".filters";
cmGeneratedFileStream fout(path.c_str());
fout.SetCopyIfDifferent(true);
char magic[] = { char(0xEF), char(0xBB), char(0xBF) };
fout.write(magic, 3);
cmGeneratedFileStream* save = this->BuildFileStream;
this->BuildFileStream = &fout;
// get the tools version to use
const std::string toolsVer(this->GlobalGenerator->GetToolsVersion());
std::string project_defaults = "GlobalGenerator->Encoding() + "\"?>\n";
project_defaults.append("\n");
this->WriteString(project_defaults.c_str(), 0);
for (ToolSourceMap::const_iterator ti = this->Tools.begin();
ti != this->Tools.end(); ++ti) {
this->WriteGroupSources(ti->first.c_str(), ti->second, sourceGroups);
}
// Added files are images and the manifest.
if (!this->AddedFiles.empty()) {
this->WriteString("\n", 1);
for (std::vector::const_iterator oi =
this->AddedFiles.begin();
oi != this->AddedFiles.end(); ++oi) {
std::string fileName =
cmSystemTools::LowerCase(cmSystemTools::GetFilenameName(*oi));
if (fileName == "wmappmanifest.xml") {
this->WriteString("BuildFileStream) << *oi << "\">\n";
this->WriteString("Resource Files\n", 3);
this->WriteString("\n", 2);
} else if (cmSystemTools::GetFilenameExtension(fileName) ==
".appxmanifest") {
this->WriteString("BuildFileStream) << *oi << "\">\n";
this->WriteString("Resource Files\n", 3);
this->WriteString("\n", 2);
} else if (cmSystemTools::GetFilenameExtension(fileName) == ".pfx") {
this->WriteString("BuildFileStream) << *oi << "\">\n";
this->WriteString("Resource Files\n", 3);
this->WriteString("\n", 2);
} else {
this->WriteString("BuildFileStream) << *oi << "\">\n";
this->WriteString("Resource Files\n", 3);
this->WriteString("\n", 2);
}
}
this->WriteString("\n", 1);
}
std::vector resxObjs;
this->GeneratorTarget->GetResxSources(resxObjs, "");
if (!resxObjs.empty()) {
this->WriteString("\n", 1);
for (std::vector::const_iterator oi =
resxObjs.begin();
oi != resxObjs.end(); ++oi) {
std::string obj = (*oi)->GetFullPath();
this->WriteString("ConvertToWindowsSlash(obj);
(*this->BuildFileStream) << cmVS10EscapeXML(obj) << "\">\n";
this->WriteString("Resource Files\n", 3);
this->WriteString("\n", 2);
}
this->WriteString("\n", 1);
}
this->WriteString("\n", 1);
for (std::set::iterator g = groupsUsed.begin();
g != groupsUsed.end(); ++g) {
cmSourceGroup* sg = *g;
const char* name = sg->GetFullName();
if (strlen(name) != 0) {
this->WriteString("BuildFileStream) << name << "\">\n";
std::string guidName = "SG_Filter_";
guidName += name;
this->WriteString("", 3);
std::string guid = this->GlobalGenerator->GetGUID(guidName.c_str());
(*this->BuildFileStream) << "{" << guid << "}"
<< "\n";
this->WriteString("\n", 2);
}
}
if (!resxObjs.empty() || !this->AddedFiles.empty()) {
this->WriteString("\n", 2);
std::string guidName = "SG_Filter_Resource Files";
this->WriteString("", 3);
std::string guid = this->GlobalGenerator->GetGUID(guidName.c_str());
(*this->BuildFileStream) << "{" << guid << "}"
<< "\n";
this->WriteString("rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;", 3);
(*this->BuildFileStream) << "gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;";
(*this->BuildFileStream) << "mfcribbon-ms\n";
this->WriteString("\n", 2);
}
this->WriteString("\n", 1);
this->WriteString("\n", 0);
// restore stream pointer
this->BuildFileStream = save;
if (fout.Close()) {
this->GlobalGenerator->FileReplacedDuringGenerate(path);
}
}
// Add to groupsUsed empty source groups that have non-empty children.
void cmVisualStudio10TargetGenerator::AddMissingSourceGroups(
std::set& groupsUsed,
const std::vector& allGroups)
{
for (std::vector::const_iterator current = allGroups.begin();
current != allGroups.end(); ++current) {
std::vector const& children = current->GetGroupChildren();
if (children.empty()) {
continue; // the group is really empty
}
this->AddMissingSourceGroups(groupsUsed, children);
cmSourceGroup* current_ptr = const_cast(&(*current));
if (groupsUsed.find(current_ptr) != groupsUsed.end()) {
continue; // group has already been added to set
}
// check if it least one of the group's descendants is not empty
// (at least one child must already have been added)
std::vector::const_iterator child_it = children.begin();
while (child_it != children.end()) {
cmSourceGroup* child_ptr = const_cast(&(*child_it));
if (groupsUsed.find(child_ptr) != groupsUsed.end()) {
break; // found a child that was already added => add current group too
}
child_it++;
}
if (child_it == children.end()) {
continue; // no descendants have source files => ignore this group
}
groupsUsed.insert(current_ptr);
}
}
void cmVisualStudio10TargetGenerator::WriteGroupSources(
const char* name, ToolSources const& sources,
std::vector& sourceGroups)
{
this->WriteString("\n", 1);
for (ToolSources::const_iterator s = sources.begin(); s != sources.end();
++s) {
cmSourceFile const* sf = s->SourceFile;
std::string const& source = sf->GetFullPath();
cmSourceGroup* sourceGroup =
this->Makefile->FindSourceGroup(source.c_str(), sourceGroups);
const char* filter = sourceGroup->GetFullName();
this->WriteString("<", 2);
std::string path = this->ConvertPath(source, s->RelativePath);
this->ConvertToWindowsSlash(path);
(*this->BuildFileStream) << name << " Include=\"" << cmVS10EscapeXML(path);
if (strlen(filter)) {
(*this->BuildFileStream) << "\">\n";
this->WriteString("", 3);
(*this->BuildFileStream) << filter << "\n";
this->WriteString("", 2);
(*this->BuildFileStream) << name << ">\n";
} else {
(*this->BuildFileStream) << "\" />\n";
}
}
this->WriteString("\n", 1);
}
void cmVisualStudio10TargetGenerator::WriteHeaderSource(cmSourceFile const* sf)
{
std::string const& fileName = sf->GetFullPath();
if (this->IsResxHeader(fileName)) {
this->WriteSource("ClInclude", sf, ">\n");
this->WriteString("CppForm\n", 3);
this->WriteString("\n", 2);
} else if (this->IsXamlHeader(fileName)) {
this->WriteSource("ClInclude", sf, ">\n");
this->WriteString("", 3);
std::string xamlFileName = fileName.substr(0, fileName.find_last_of("."));
(*this->BuildFileStream) << xamlFileName << "\n";
this->WriteString("\n", 2);
} else {
this->WriteSource("ClInclude", sf);
}
}
void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf)
{
bool toolHasSettings = false;
std::string tool = "None";
std::string shaderType;
std::string shaderEntryPoint;
std::string shaderModel;
std::string shaderAdditionalFlags;
std::string settingsGenerator;
std::string settingsLastGenOutput;
std::string sourceLink;
std::string subType;
std::string copyToOutDir;
std::string includeInVsix;
std::string ext = cmSystemTools::LowerCase(sf->GetExtension());
if (csproj == this->ProjectType) {
// EVERY extra source file must have a , otherwise it might not
// be visible in Visual Studio at all. The path relative to current
// source- or binary-dir is used within the link, if the file is
// in none of these paths, it is added with the plain filename without
// any path. This means the file will show up at root-level of the csproj
// (where CMakeLists.txt etc. are).
if (!this->InSourceBuild) {
toolHasSettings = true;
std::string fullFileName = sf->GetFullPath();
std::string srcDir = this->Makefile->GetCurrentSourceDirectory();
std::string binDir = this->Makefile->GetCurrentBinaryDirectory();
if (fullFileName.find(binDir) != std::string::npos) {
sourceLink = "";
} else if (fullFileName.find(srcDir) != std::string::npos) {
sourceLink = fullFileName.substr(srcDir.length() + 1);
} else {
// fallback: add plain filename without any path
sourceLink = cmsys::SystemTools::GetFilenameName(fullFileName);
}
if (!sourceLink.empty()) {
this->ConvertToWindowsSlash(sourceLink);
}
}
}
if (ext == "hlsl") {
tool = "FXCompile";
// Figure out the type of shader compiler to use.
if (const char* st = sf->GetProperty("VS_SHADER_TYPE")) {
shaderType = st;
toolHasSettings = true;
}
// Figure out which entry point to use if any
if (const char* se = sf->GetProperty("VS_SHADER_ENTRYPOINT")) {
shaderEntryPoint = se;
toolHasSettings = true;
}
// Figure out which shader model to use if any
if (const char* sm = sf->GetProperty("VS_SHADER_MODEL")) {
shaderModel = sm;
toolHasSettings = true;
}
// Figure out if there's any additional flags to use
if (const char* saf = sf->GetProperty("VS_SHADER_FLAGS")) {
shaderAdditionalFlags = saf;
toolHasSettings = true;
}
} else if (ext == "jpg" || ext == "png") {
tool = "Image";
} else if (ext == "resw") {
tool = "PRIResource";
} else if (ext == "xml") {
tool = "XML";
} else if (ext == "natvis") {
tool = "Natvis";
} else if (ext == "settings") {
// remove path to current source dir (if files are in current source dir)
if (!sourceLink.empty()) {
settingsLastGenOutput = sourceLink;
} else {
settingsLastGenOutput = sf->GetFullPath();
}
std::size_t pos = settingsLastGenOutput.find(".settings");
settingsLastGenOutput.replace(pos, 9, ".Designer.cs");
settingsGenerator = "SettingsSingleFileGenerator";
toolHasSettings = true;
} else if (ext == "vsixmanifest") {
subType = "Designer";
}
if (const char* c = sf->GetProperty("VS_COPY_TO_OUT_DIR")) {
copyToOutDir = c;
toolHasSettings = true;
}
if (sf->GetPropertyAsBool("VS_INCLUDE_IN_VSIX")) {
includeInVsix = "True";
tool = "Content";
toolHasSettings = true;
}
if (this->NsightTegra) {
// Nsight Tegra needs specific file types to check up-to-dateness.
std::string name = cmSystemTools::LowerCase(sf->GetLocation().GetName());
if (name == "androidmanifest.xml" || name == "build.xml" ||
name == "proguard.cfg" || name == "proguard-project.txt" ||
ext == "properties") {
tool = "AndroidBuild";
} else if (ext == "java") {
tool = "JCompile";
} else if (ext == "asm" || ext == "s") {
tool = "ClCompile";
}
}
const char* toolOverride = sf->GetProperty("VS_TOOL_OVERRIDE");
if (toolOverride && *toolOverride) {
tool = toolOverride;
}
std::string deployContent;
std::string deployLocation;
if (this->GlobalGenerator->TargetsWindowsPhone() ||
this->GlobalGenerator->TargetsWindowsStore()) {
const char* content = sf->GetProperty("VS_DEPLOYMENT_CONTENT");
if (content && *content) {
toolHasSettings = true;
deployContent = content;
const char* location = sf->GetProperty("VS_DEPLOYMENT_LOCATION");
if (location && *location) {
deployLocation = location;
}
}
}
if (toolHasSettings) {
this->WriteSource(tool, sf, ">\n");
if (!deployContent.empty()) {
cmGeneratorExpression ge;
CM_AUTO_PTR cge = ge.Parse(deployContent);
// Deployment location cannot be set on a configuration basis
if (!deployLocation.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << deployLocation
<< "\\%(FileName)%(Extension)";
this->WriteString("\n", 0);
}
for (size_t i = 0; i != this->Configurations.size(); ++i) {
if (0 == strcmp(cge->Evaluate(this->LocalGenerator,
this->Configurations[i]),
"1")) {
this->WriteString("BuildFileStream) << this->Configurations[i] << "|"
<< this->Platform << "'\">true";
this->WriteString("\n", 0);
} else {
this->WriteString("BuildFileStream) << this->Configurations[i] << "|"
<< this->Platform << "'\">true";
this->WriteString("\n", 0);
}
}
}
if (!shaderType.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(shaderType)
<< "\n";
}
if (!shaderEntryPoint.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(shaderEntryPoint)
<< "\n";
}
if (!shaderModel.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(shaderModel)
<< "\n";
}
if (!shaderAdditionalFlags.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(shaderAdditionalFlags)
<< "\n";
}
if (!settingsGenerator.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(settingsGenerator)
<< "\n";
}
if (!settingsLastGenOutput.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(settingsLastGenOutput)
<< "\n";
}
if (!sourceLink.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(sourceLink) << "\n";
}
if (!subType.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(subType) << "\n";
}
if (!copyToOutDir.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(copyToOutDir)
<< "\n";
}
if (!includeInVsix.empty()) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(includeInVsix)
<< "\n";
}
this->WriteString("", 2);
(*this->BuildFileStream) << tool << ">\n";
} else {
this->WriteSource(tool, sf);
}
}
void cmVisualStudio10TargetGenerator::WriteSource(std::string const& tool,
cmSourceFile const* sf,
const char* end)
{
// Visual Studio tools append relative paths to the current dir, as in:
//
// c:\path\to\current\dir\..\..\..\relative\path\to\source.c
//
// and fail if this exceeds the maximum allowed path length. Our path
// conversion uses full paths when possible to allow deeper trees.
// However, CUDA 8.0 msbuild rules fail on absolute paths so for CUDA
// we must use relative paths.
bool forceRelative = sf->GetLanguage() == "CUDA";
std::string sourceFile = this->ConvertPath(sf->GetFullPath(), forceRelative);
if (this->LocalGenerator->GetVersion() ==
cmGlobalVisualStudioGenerator::VS10 &&
cmSystemTools::FileIsFullPath(sourceFile.c_str())) {
// Normal path conversion resulted in a full path. VS 10 (but not 11)
// refuses to show the property page in the IDE for a source file with a
// full path (not starting in a '.' or '/' AFAICT). CMake <= 2.8.4 used a
// relative path but to allow deeper build trees CMake 2.8.[5678] used a
// full path except for custom commands. Custom commands do not work
// without a relative path, but they do not seem to be involved in tools
// with the above behavior. For other sources we now use a relative path
// when the combined path will not be too long so property pages appear.
std::string sourceRel = this->ConvertPath(sf->GetFullPath(), true);
size_t const maxLen = 250;
if (sf->GetCustomCommand() ||
((strlen(this->LocalGenerator->GetCurrentBinaryDirectory()) + 1 +
sourceRel.length()) <= maxLen)) {
forceRelative = true;
sourceFile = sourceRel;
} else {
this->GlobalGenerator->PathTooLong(this->GeneratorTarget, sf, sourceRel);
}
}
this->ConvertToWindowsSlash(sourceFile);
this->WriteString("<", 2);
(*this->BuildFileStream) << tool << " Include=\""
<< cmVS10EscapeXML(sourceFile) << "\""
<< (end ? end : " />\n");
ToolSource toolSource = { sf, forceRelative };
this->Tools[tool].push_back(toolSource);
}
void cmVisualStudio10TargetGenerator::WriteAllSources()
{
if (this->GeneratorTarget->GetType() > cmStateEnums::UTILITY) {
return;
}
this->WriteString("\n", 1);
std::vector all_configs;
for (size_t ci = 0; ci < this->Configurations.size(); ++ci) {
all_configs.push_back(ci);
}
std::vector const& sources =
this->GeneratorTarget->GetAllConfigSources();
for (std::vector::const_iterator si =
sources.begin();
si != sources.end(); ++si) {
std::string tool;
switch (si->Kind) {
case cmGeneratorTarget::SourceKindAppManifest:
tool = "AppxManifest";
break;
case cmGeneratorTarget::SourceKindCertificate:
tool = "None";
break;
case cmGeneratorTarget::SourceKindCustomCommand:
// Handled elsewhere.
break;
case cmGeneratorTarget::SourceKindExternalObject:
tool = "Object";
if (this->LocalGenerator->GetVersion() <
cmGlobalVisualStudioGenerator::VS11) {
// For VS == 10 we cannot use LinkObjects to avoid linking custom
// command outputs. If an object file is generated in this target,
// then vs10 will use it in the build, and we have to list it as
// None instead of Object.
std::vector const* d =
this->GeneratorTarget->GetSourceDepends(si->Source);
if (d && !d->empty()) {
tool = "None";
}
}
break;
case cmGeneratorTarget::SourceKindExtra:
this->WriteExtraSource(si->Source);
break;
case cmGeneratorTarget::SourceKindHeader:
this->WriteHeaderSource(si->Source);
break;
case cmGeneratorTarget::SourceKindIDL:
tool = "Midl";
break;
case cmGeneratorTarget::SourceKindManifest:
// Handled elsewhere.
break;
case cmGeneratorTarget::SourceKindModuleDefinition:
tool = "None";
break;
case cmGeneratorTarget::SourceKindObjectSource: {
const std::string& lang = si->Source->GetLanguage();
if (lang == "C" || lang == "CXX") {
tool = "ClCompile";
} else if (lang == "ASM_MASM" &&
this->GlobalGenerator->IsMasmEnabled()) {
tool = "MASM";
} else if (lang == "ASM_NASM" &&
this->GlobalGenerator->IsNasmEnabled()) {
tool = "NASM";
} else if (lang == "RC") {
tool = "ResourceCompile";
} else if (lang == "CSharp") {
tool = "Compile";
} else if (lang == "CUDA" && this->GlobalGenerator->IsCudaEnabled()) {
tool = "CudaCompile";
} else {
tool = "None";
}
} break;
case cmGeneratorTarget::SourceKindResx:
// Handled elsewhere.
break;
case cmGeneratorTarget::SourceKindXaml:
// Handled elsewhere.
break;
}
if (!tool.empty()) {
// Compute set of configurations to exclude, if any.
std::vector const& include_configs = si->Configs;
std::vector exclude_configs;
std::set_difference(all_configs.begin(), all_configs.end(),
include_configs.begin(), include_configs.end(),
std::back_inserter(exclude_configs));
if (si->Kind == cmGeneratorTarget::SourceKindObjectSource) {
// FIXME: refactor generation to avoid tracking XML syntax state.
this->WriteSource(tool, si->Source, " ");
bool have_nested = this->OutputSourceSpecificFlags(si->Source);
if (!exclude_configs.empty()) {
if (!have_nested) {
(*this->BuildFileStream) << ">\n";
}
this->WriteExcludeFromBuild(exclude_configs);
have_nested = true;
}
if (have_nested) {
this->WriteString("", 2);
(*this->BuildFileStream) << tool << ">\n";
} else {
(*this->BuildFileStream) << " />\n";
}
} else if (!exclude_configs.empty()) {
this->WriteSource(tool, si->Source, ">\n");
this->WriteExcludeFromBuild(exclude_configs);
this->WriteString("", 2);
(*this->BuildFileStream) << tool << ">\n";
} else {
this->WriteSource(tool, si->Source);
}
}
}
if (this->IsMissingFiles) {
this->WriteMissingFiles();
}
this->WriteString("\n", 1);
}
bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
cmSourceFile const* source)
{
cmSourceFile const& sf = *source;
std::string objectName;
if (this->GeneratorTarget->HasExplicitObjectName(&sf)) {
objectName = this->GeneratorTarget->GetObjectName(&sf);
}
std::string flags;
bool configDependentFlags = false;
std::string defines;
if (const char* cflags = sf.GetProperty("COMPILE_FLAGS")) {
if (cmGeneratorExpression::Find(cflags) != std::string::npos) {
configDependentFlags = true;
}
flags += cflags;
}
if (const char* cdefs = sf.GetProperty("COMPILE_DEFINITIONS")) {
defines += cdefs;
}
std::string lang =
this->GlobalGenerator->GetLanguageFromExtension(sf.GetExtension().c_str());
std::string sourceLang = this->LocalGenerator->GetSourceFileLanguage(sf);
const std::string& linkLanguage =
this->GeneratorTarget->GetLinkerLanguage("");
bool needForceLang = false;
// source file does not match its extension language
if (lang != sourceLang) {
needForceLang = true;
lang = sourceLang;
}
// if the source file does not match the linker language
// then force c or c++
const char* compileAs = 0;
if (needForceLang || (linkLanguage != lang)) {
if (lang == "CXX") {
// force a C++ file type
compileAs = "CompileAsCpp";
} else if (lang == "C") {
// force to c
compileAs = "CompileAsC";
}
}
bool noWinRT = this->TargetCompileAsWinRT && lang == "C";
bool hasFlags = false;
// for the first time we need a new line if there is something
// produced here.
const char* firstString = ">\n";
if (!objectName.empty()) {
(*this->BuildFileStream) << firstString;
firstString = "";
hasFlags = true;
this->WriteString("", 3);
(*this->BuildFileStream) << "$(IntDir)/" << objectName
<< "\n";
}
for (std::vector::const_iterator config =
this->Configurations.begin();
config != this->Configurations.end(); ++config) {
std::string configUpper = cmSystemTools::UpperCase(*config);
std::string configDefines = defines;
std::string defPropName = "COMPILE_DEFINITIONS_";
defPropName += configUpper;
if (const char* ccdefs = sf.GetProperty(defPropName.c_str())) {
if (!configDefines.empty()) {
configDefines += ";";
}
configDefines += ccdefs;
}
// if we have flags or defines for this config then
// use them
if (!flags.empty() || configDependentFlags || !configDefines.empty() ||
compileAs || noWinRT) {
(*this->BuildFileStream) << firstString;
firstString = ""; // only do firstString once
hasFlags = true;
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
cmIDEFlagTable const* flagtable = CM_NULLPTR;
const std::string& srclang = source->GetLanguage();
if (srclang == "C" || srclang == "CXX") {
flagtable = gg->GetClFlagTable();
} else if (srclang == "ASM_MASM" &&
this->GlobalGenerator->IsMasmEnabled()) {
flagtable = gg->GetMasmFlagTable();
} else if (lang == "ASM_NASM" &&
this->GlobalGenerator->IsNasmEnabled()) {
flagtable = gg->GetNasmFlagTable();
} else if (srclang == "RC") {
flagtable = gg->GetRcFlagTable();
} else if (srclang == "CSharp") {
flagtable = gg->GetCSharpFlagTable();
}
cmVisualStudioGeneratorOptions clOptions(
this->LocalGenerator, cmVisualStudioGeneratorOptions::Compiler,
flagtable, 0, this);
if (compileAs) {
clOptions.AddFlag("CompileAs", compileAs);
}
if (noWinRT) {
clOptions.AddFlag("CompileAsWinRT", "false");
}
if (configDependentFlags) {
cmGeneratorExpression ge;
CM_AUTO_PTR cge = ge.Parse(flags);
std::string evaluatedFlags =
cge->Evaluate(this->LocalGenerator, *config);
clOptions.Parse(evaluatedFlags.c_str());
} else {
clOptions.Parse(flags.c_str());
}
if (clOptions.HasFlag("AdditionalIncludeDirectories")) {
clOptions.AppendFlag("AdditionalIncludeDirectories",
"%(AdditionalIncludeDirectories)");
}
if (clOptions.HasFlag("DisableSpecificWarnings")) {
clOptions.AppendFlag("DisableSpecificWarnings",
"%(DisableSpecificWarnings)");
}
clOptions.AddDefines(configDefines.c_str());
clOptions.SetConfiguration((*config).c_str());
clOptions.PrependInheritedString("AdditionalOptions");
clOptions.OutputFlagMap(*this->BuildFileStream, " ");
clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ",
"\n", lang);
}
}
if (this->IsXamlSource(source->GetFullPath())) {
(*this->BuildFileStream) << firstString;
firstString = ""; // only do firstString once
hasFlags = true;
this->WriteString("", 3);
const std::string& fileName = source->GetFullPath();
std::string xamlFileName = fileName.substr(0, fileName.find_last_of("."));
(*this->BuildFileStream) << xamlFileName << "\n";
}
if (csproj == this->ProjectType) {
std::string f = source->GetFullPath();
typedef std::map CsPropMap;
CsPropMap sourceFileTags;
// set tag if necessary
if (!this->InSourceBuild) {
const std::string stripFromPath =
this->Makefile->GetCurrentSourceDirectory();
if (f.find(stripFromPath) != std::string::npos) {
std::string link = f.substr(stripFromPath.length() + 1);
this->ConvertToWindowsSlash(link);
sourceFileTags["Link"] = link;
}
}
const cmPropertyMap& props = sf.GetProperties();
for (cmPropertyMap::const_iterator p = props.begin(); p != props.end();
++p) {
static const std::string propNamePrefix = "VS_CSHARP_";
if (p->first.find(propNamePrefix.c_str()) == 0) {
std::string tagName = p->first.substr(propNamePrefix.length());
if (!tagName.empty()) {
const std::string val = props.GetPropertyValue(p->first);
if (!val.empty()) {
sourceFileTags[tagName] = val;
} else {
sourceFileTags.erase(tagName);
}
}
}
}
// write source file specific tags
if (!sourceFileTags.empty()) {
hasFlags = true;
(*this->BuildFileStream) << firstString;
firstString = "";
for (CsPropMap::const_iterator i = sourceFileTags.begin();
i != sourceFileTags.end(); ++i) {
this->WriteString("<", 3);
(*this->BuildFileStream)
<< i->first << ">" << cmVS10EscapeXML(i->second) << "" << i->first
<< ">\n";
}
}
}
return hasFlags;
}
void cmVisualStudio10TargetGenerator::WriteExcludeFromBuild(
std::vector const& exclude_configs)
{
for (std::vector::const_iterator ci = exclude_configs.begin();
ci != exclude_configs.end(); ++ci) {
this->WriteString("", 3);
(*this->BuildFileStream)
<< "Configurations[*ci]) << "|"
<< cmVS10EscapeXML(this->Platform) << "'\">true\n";
}
}
void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions()
{
cmStateEnums::TargetType ttype = this->GeneratorTarget->GetType();
if (ttype > cmStateEnums::GLOBAL_TARGET) {
return;
}
if (csproj == this->ProjectType) {
return;
}
this->WriteString("\n", 1);
this->WriteString("<_ProjectFileVersion>10.0.20506.1"
"\n",
2);
for (std::vector::const_iterator config =
this->Configurations.begin();
config != this->Configurations.end(); ++config) {
if (ttype >= cmStateEnums::UTILITY) {
this->WritePlatformConfigTag("IntDir", config->c_str(), 2);
*this->BuildFileStream
<< "$(Platform)\\$(Configuration)\\$(ProjectName)\\"
<< "\n";
} else {
std::string intermediateDir =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
intermediateDir += "/";
intermediateDir += *config;
intermediateDir += "/";
std::string outDir;
std::string targetNameFull;
if (ttype == cmStateEnums::OBJECT_LIBRARY) {
outDir = intermediateDir;
targetNameFull = this->GeneratorTarget->GetName();
targetNameFull += ".lib";
} else {
outDir = this->GeneratorTarget->GetDirectory(config->c_str()) + "/";
targetNameFull = this->GeneratorTarget->GetFullName(config->c_str());
}
this->ConvertToWindowsSlash(intermediateDir);
this->ConvertToWindowsSlash(outDir);
this->WritePlatformConfigTag("OutDir", config->c_str(), 2);
*this->BuildFileStream << cmVS10EscapeXML(outDir) << "\n";
this->WritePlatformConfigTag("IntDir", config->c_str(), 2);
*this->BuildFileStream << cmVS10EscapeXML(intermediateDir)
<< "\n";
if (const char* workingDir = this->GeneratorTarget->GetProperty(
"VS_DEBUGGER_WORKING_DIRECTORY")) {
this->WritePlatformConfigTag("LocalDebuggerWorkingDirectory",
config->c_str(), 2);
*this->BuildFileStream << cmVS10EscapeXML(workingDir)
<< "\n";
}
std::string name =
cmSystemTools::GetFilenameWithoutLastExtension(targetNameFull);
this->WritePlatformConfigTag("TargetName", config->c_str(), 2);
*this->BuildFileStream << cmVS10EscapeXML(name) << "\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(), 2);
*this->BuildFileStream << cmVS10EscapeXML(ext) << "\n";
this->OutputLinkIncremental(*config);
}
}
this->WriteString("\n", 1);
}
void cmVisualStudio10TargetGenerator::OutputLinkIncremental(
std::string const& configName)
{
if (!this->MSTools) {
return;
}
if (csproj == this->ProjectType) {
return;
}
// static libraries and things greater than modules do not need
// to set this option
if (this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY ||
this->GeneratorTarget->GetType() > cmStateEnums::MODULE_LIBRARY) {
return;
}
Options& linkOptions = *(this->LinkOptions[configName]);
const char* incremental = linkOptions.GetFlag("LinkIncremental");
this->WritePlatformConfigTag("LinkIncremental", configName.c_str(), 2);
*this->BuildFileStream << (incremental ? incremental : "true")
<< "\n";
linkOptions.RemoveFlag("LinkIncremental");
const char* manifest = linkOptions.GetFlag("GenerateManifest");
this->WritePlatformConfigTag("GenerateManifest", configName.c_str(), 2);
*this->BuildFileStream << (manifest ? manifest : "true")
<< "\n";
linkOptions.RemoveFlag("GenerateManifest");
// Some link options belong here. Use them now and remove them so that
// WriteLinkOptions does not use them.
const char* flags[] = { "LinkDelaySign", "LinkKeyFile", 0 };
for (const char** f = flags; *f; ++f) {
const char* flag = *f;
if (const char* value = linkOptions.GetFlag(flag)) {
this->WritePlatformConfigTag(flag, configName.c_str(), 2);
*this->BuildFileStream << value << "" << flag << ">\n";
linkOptions.RemoveFlag(flag);
}
}
}
bool cmVisualStudio10TargetGenerator::ComputeClOptions()
{
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
if (!this->ComputeClOptions(*i)) {
return false;
}
}
return true;
}
bool cmVisualStudio10TargetGenerator::ComputeClOptions(
std::string const& configName)
{
// much of this was copied from here:
// copied from cmLocalVisualStudio7Generator.cxx 805
// TODO: Integrate code below with cmLocalVisualStudio7Generator.
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
CM_AUTO_PTR pOptions;
switch (this->ProjectType) {
case vcxproj:
pOptions = CM_AUTO_PTR(new Options(
this->LocalGenerator, Options::Compiler, gg->GetClFlagTable()));
break;
case csproj:
pOptions = CM_AUTO_PTR(new Options(this->LocalGenerator,
Options::CSharpCompiler,
gg->GetCSharpFlagTable()));
break;
}
Options& clOptions = *pOptions;
std::string flags;
const std::string& linkLanguage =
this->GeneratorTarget->GetLinkerLanguage(configName.c_str());
if (linkLanguage.empty()) {
cmSystemTools::Error(
"CMake can not determine linker language for target: ",
this->Name.c_str());
return false;
}
// Choose a language whose flags to use for ClCompile.
static const char* clLangs[] = { "CXX", "C", "Fortran", "CSharp" };
std::string langForClCompile;
if (std::find(cmArrayBegin(clLangs), cmArrayEnd(clLangs), linkLanguage) !=
cmArrayEnd(clLangs)) {
langForClCompile = linkLanguage;
} else {
std::set languages;
this->GeneratorTarget->GetLanguages(languages, configName);
for (const char* const* l = cmArrayBegin(clLangs);
l != cmArrayEnd(clLangs); ++l) {
if (languages.find(*l) != languages.end()) {
langForClCompile = *l;
break;
}
}
}
if (!langForClCompile.empty()) {
std::string baseFlagVar = "CMAKE_";
baseFlagVar += langForClCompile;
baseFlagVar += "_FLAGS";
flags =
this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
baseFlagVar.c_str());
std::string flagVar =
baseFlagVar + std::string("_") + cmSystemTools::UpperCase(configName);
flags += " ";
flags +=
this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
flagVar.c_str());
this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget,
langForClCompile, configName);
}
// set the correct language
if (linkLanguage == "C") {
clOptions.AddFlag("CompileAs", "CompileAsC");
}
if (linkLanguage == "CXX") {
clOptions.AddFlag("CompileAs", "CompileAsCpp");
}
// Check IPO related warning/error.
this->GeneratorTarget->IsIPOEnabled(linkLanguage, configName);
// Get preprocessor definitions for this directory.
std::string defineFlags =
this->GeneratorTarget->Target->GetMakefile()->GetDefineFlags();
if (this->MSTools) {
if (vcxproj == this->ProjectType) {
clOptions.FixExceptionHandlingDefault();
clOptions.AddFlag("PrecompiledHeader", "NotUsing");
std::string asmLocation = configName + "/";
clOptions.AddFlag("AssemblerListingLocation", asmLocation.c_str());
}
}
clOptions.Parse(flags.c_str());
clOptions.Parse(defineFlags.c_str());
std::vector targetDefines;
switch (this->ProjectType) {
case vcxproj:
this->GeneratorTarget->GetCompileDefinitions(targetDefines,
configName.c_str(), "CXX");
break;
case csproj:
this->GeneratorTarget->GetCompileDefinitions(
targetDefines, configName.c_str(), "CSharp");
break;
}
clOptions.AddDefines(targetDefines);
if (this->MSTools) {
clOptions.SetVerboseMakefile(
this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"));
}
// Add a definition for the configuration name.
std::string configDefine = "CMAKE_INTDIR=\"";
configDefine += configName;
configDefine += "\"";
clOptions.AddDefine(configDefine);
if (const char* exportMacro = this->GeneratorTarget->GetExportMacro()) {
clOptions.AddDefine(exportMacro);
}
if (this->MSTools) {
// If we have the VS_WINRT_COMPONENT set then force Compile as WinRT.
if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT")) {
clOptions.AddFlag("CompileAsWinRT", "true");
// For WinRT components, add the _WINRT_DLL define to produce a lib
if (this->GeneratorTarget->GetType() == cmStateEnums::SHARED_LIBRARY ||
this->GeneratorTarget->GetType() == cmStateEnums::MODULE_LIBRARY) {
clOptions.AddDefine("_WINRT_DLL");
}
} else if (this->GlobalGenerator->TargetsWindowsStore() ||
this->GlobalGenerator->TargetsWindowsPhone()) {
if (!clOptions.IsWinRt()) {
clOptions.AddFlag("CompileAsWinRT", "false");
}
}
if (const char* winRT = clOptions.GetFlag("CompileAsWinRT")) {
if (cmSystemTools::IsOn(winRT)) {
this->TargetCompileAsWinRT = true;
}
}
}
if (csproj != this->ProjectType && clOptions.IsManaged()) {
this->Managed = true;
std::string managedType = clOptions.GetFlag("CompileAsManaged");
if (managedType == "Safe") {
// force empty calling convention if safe clr is used
clOptions.AddFlag("CallingConvention", "");
}
}
this->ClOptions[configName] = pOptions.release();
return true;
}
void cmVisualStudio10TargetGenerator::WriteClOptions(
std::string const& configName, std::vector const& includes)
{
Options& clOptions = *(this->ClOptions[configName]);
if (this->ProjectType == csproj) {
return;
}
this->WriteString("\n", 2);
clOptions.PrependInheritedString("AdditionalOptions");
clOptions.AppendFlag("AdditionalIncludeDirectories", includes);
clOptions.AppendFlag("AdditionalIncludeDirectories",
"%(AdditionalIncludeDirectories)");
clOptions.OutputFlagMap(*this->BuildFileStream, " ");
clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ",
"\n", "CXX");
if (this->NsightTegra) {
if (const char* processMax =
this->GeneratorTarget->GetProperty("ANDROID_PROCESS_MAX")) {
this->WriteString("", 3);
*this->BuildFileStream << cmVS10EscapeXML(processMax)
<< "\n";
}
}
if (this->MSTools) {
cmsys::RegularExpression clangToolset(
"(v[0-9]+_clang_.*|LLVM-vs[0-9]+.*)");
const char* toolset = this->GlobalGenerator->GetPlatformToolset();
if (toolset && clangToolset.find(toolset)) {
this->WriteString(""
"$(IntDir)%(filename).obj"
"\n",
3);
} else {
this->WriteString("$(IntDir)\n", 3);
}
// If not in debug mode, write the DebugInformationFormat field
// without value so PDBs don't get generated uselessly.
if (!clOptions.IsDebug()) {
this->WriteString(""
"\n",
3);
}
// Specify the compiler program database file if configured.
std::string pdb =
this->GeneratorTarget->GetCompilePDBPath(configName.c_str());
if (!pdb.empty()) {
this->ConvertToWindowsSlash(pdb);
this->WriteString("", 3);
*this->BuildFileStream << cmVS10EscapeXML(pdb)
<< "\n";
}
}
this->WriteString("\n", 2);
}
bool cmVisualStudio10TargetGenerator::ComputeRcOptions()
{
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
if (!this->ComputeRcOptions(*i)) {
return false;
}
}
return true;
}
bool cmVisualStudio10TargetGenerator::ComputeRcOptions(
std::string const& configName)
{
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
CM_AUTO_PTR pOptions(new Options(
this->LocalGenerator, Options::ResourceCompiler, gg->GetRcFlagTable()));
Options& rcOptions = *pOptions;
std::string CONFIG = cmSystemTools::UpperCase(configName);
std::string rcConfigFlagsVar = std::string("CMAKE_RC_FLAGS_") + CONFIG;
std::string flags =
std::string(this->Makefile->GetSafeDefinition("CMAKE_RC_FLAGS")) +
std::string(" ") +
std::string(this->Makefile->GetSafeDefinition(rcConfigFlagsVar));
rcOptions.Parse(flags.c_str());
// For historical reasons, add the C preprocessor defines to RC.
Options& clOptions = *(this->ClOptions[configName]);
rcOptions.AddDefines(clOptions.GetDefines());
this->RcOptions[configName] = pOptions.release();
return true;
}
void cmVisualStudio10TargetGenerator::WriteRCOptions(
std::string const& configName, std::vector const& includes)
{
if (!this->MSTools) {
return;
}
this->WriteString("\n", 2);
Options& rcOptions = *(this->RcOptions[configName]);
rcOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ",
"\n", "RC");
rcOptions.AppendFlag("AdditionalIncludeDirectories", includes);
rcOptions.AppendFlag("AdditionalIncludeDirectories",
"%(AdditionalIncludeDirectories)");
rcOptions.PrependInheritedString("AdditionalOptions");
rcOptions.OutputFlagMap(*this->BuildFileStream, " ");
this->WriteString("\n", 2);
}
bool cmVisualStudio10TargetGenerator::ComputeCudaOptions()
{
if (!this->GlobalGenerator->IsCudaEnabled()) {
return true;
}
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
if (!this->ComputeCudaOptions(*i)) {
return false;
}
}
return true;
}
bool cmVisualStudio10TargetGenerator::ComputeCudaOptions(
std::string const& configName)
{
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
CM_AUTO_PTR pOptions(new Options(
this->LocalGenerator, Options::CudaCompiler, gg->GetCudaFlagTable()));
Options& cudaOptions = *pOptions;
// Get compile flags for CUDA in this directory.
std::string CONFIG = cmSystemTools::UpperCase(configName);
std::string configFlagsVar = std::string("CMAKE_CUDA_FLAGS_") + CONFIG;
std::string flags =
std::string(this->Makefile->GetSafeDefinition("CMAKE_CUDA_FLAGS")) +
std::string(" ") +
std::string(this->Makefile->GetSafeDefinition(configFlagsVar));
this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, "CUDA",
configName);
// Get preprocessor definitions for this directory.
std::string defineFlags =
this->GeneratorTarget->Target->GetMakefile()->GetDefineFlags();
cudaOptions.Parse(flags.c_str());
cudaOptions.Parse(defineFlags.c_str());
cudaOptions.ParseFinish();
if (this->GeneratorTarget->GetPropertyAsBool("CUDA_SEPARABLE_COMPILATION")) {
cudaOptions.AddFlag("GenerateRelocatableDeviceCode", "true");
} else if (this->GeneratorTarget->GetPropertyAsBool(
"CUDA_PTX_COMPILATION")) {
cudaOptions.AddFlag("NvccCompilation", "ptx");
// We drop the %(Extension) component as CMake expects all PTX files
// to not have the source file extension at all
cudaOptions.AddFlag("CompileOut", "$(IntDir)%(Filename).ptx");
}
// Convert the host compiler options to the toolset's abstractions
// using a secondary flag table.
cudaOptions.ClearTables();
cudaOptions.AddTable(gg->GetCudaHostFlagTable());
cudaOptions.Reparse("AdditionalCompilerOptions");
// `CUDA 8.0.targets` places AdditionalCompilerOptions before nvcc!
// Pass them through -Xcompiler in AdditionalOptions instead.
if (const char* acoPtr = cudaOptions.GetFlag("AdditionalCompilerOptions")) {
std::string aco = acoPtr;
cudaOptions.RemoveFlag("AdditionalCompilerOptions");
if (!aco.empty()) {
aco = this->LocalGenerator->EscapeForShell(aco, false);
cudaOptions.AppendFlagString("AdditionalOptions", "-Xcompiler=" + aco);
}
}
cudaOptions.FixCudaCodeGeneration();
std::vector targetDefines;
this->GeneratorTarget->GetCompileDefinitions(targetDefines,
configName.c_str(), "CUDA");
cudaOptions.AddDefines(targetDefines);
// Add a definition for the configuration name.
std::string configDefine = "CMAKE_INTDIR=\"";
configDefine += configName;
configDefine += "\"";
cudaOptions.AddDefine(configDefine);
if (const char* exportMacro = this->GeneratorTarget->GetExportMacro()) {
cudaOptions.AddDefine(exportMacro);
}
this->CudaOptions[configName] = pOptions.release();
return true;
}
void cmVisualStudio10TargetGenerator::WriteCudaOptions(
std::string const& configName, std::vector const& includes)
{
if (!this->MSTools || !this->GlobalGenerator->IsCudaEnabled()) {
return;
}
this->WriteString("\n", 2);
Options& cudaOptions = *(this->CudaOptions[configName]);
cudaOptions.AppendFlag("Include", includes);
cudaOptions.AppendFlag("Include", "%(Include)");
cudaOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ",
"\n", "CUDA");
cudaOptions.PrependInheritedString("AdditionalOptions");
cudaOptions.OutputFlagMap(*this->BuildFileStream, " ");
this->WriteString("\n", 2);
}
bool cmVisualStudio10TargetGenerator::ComputeCudaLinkOptions()
{
if (!this->GlobalGenerator->IsCudaEnabled()) {
return true;
}
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
if (!this->ComputeCudaLinkOptions(*i)) {
return false;
}
}
return true;
}
bool cmVisualStudio10TargetGenerator::ComputeCudaLinkOptions(
std::string const& configName)
{
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
CM_AUTO_PTR pOptions(new Options(
this->LocalGenerator, Options::CudaCompiler, gg->GetCudaFlagTable()));
Options& cudaLinkOptions = *pOptions;
// Determine if we need to do a device link
bool doDeviceLinking = false;
switch (this->GeneratorTarget->GetType()) {
case cmStateEnums::SHARED_LIBRARY:
case cmStateEnums::MODULE_LIBRARY:
case cmStateEnums::EXECUTABLE:
doDeviceLinking = true;
break;
case cmStateEnums::STATIC_LIBRARY:
doDeviceLinking = this->GeneratorTarget->GetPropertyAsBool(
"CUDA_RESOLVE_DEVICE_SYMBOLS");
break;
default:
break;
}
cudaLinkOptions.AddFlag("PerformDeviceLink",
doDeviceLinking ? "true" : "false");
// Suppress deprecation warnings for default GPU targets during device link.
if (cmSystemTools::VersionCompareGreaterEq(
this->GlobalGenerator->GetPlatformToolsetCudaString(), "8.0")) {
cudaLinkOptions.AppendFlagString("AdditionalOptions",
"-Wno-deprecated-gpu-targets");
}
this->CudaLinkOptions[configName] = pOptions.release();
return true;
}
void cmVisualStudio10TargetGenerator::WriteCudaLinkOptions(
std::string const& configName)
{
if (this->GeneratorTarget->GetType() > cmStateEnums::MODULE_LIBRARY) {
return;
}
if (!this->MSTools || !this->GlobalGenerator->IsCudaEnabled()) {
return;
}
this->WriteString("\n", 2);
Options& cudaLinkOptions = *(this->CudaLinkOptions[configName]);
cudaLinkOptions.OutputFlagMap(*this->BuildFileStream, " ");
this->WriteString("\n", 2);
}
bool cmVisualStudio10TargetGenerator::ComputeMasmOptions()
{
if (!this->GlobalGenerator->IsMasmEnabled()) {
return true;
}
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
if (!this->ComputeMasmOptions(*i)) {
return false;
}
}
return true;
}
bool cmVisualStudio10TargetGenerator::ComputeMasmOptions(
std::string const& configName)
{
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
CM_AUTO_PTR pOptions(new Options(
this->LocalGenerator, Options::MasmCompiler, gg->GetMasmFlagTable()));
Options& masmOptions = *pOptions;
std::string CONFIG = cmSystemTools::UpperCase(configName);
std::string configFlagsVar = std::string("CMAKE_ASM_MASM_FLAGS_") + CONFIG;
std::string flags =
std::string(this->Makefile->GetSafeDefinition("CMAKE_ASM_MASM_FLAGS")) +
std::string(" ") +
std::string(this->Makefile->GetSafeDefinition(configFlagsVar));
masmOptions.Parse(flags.c_str());
this->MasmOptions[configName] = pOptions.release();
return true;
}
void cmVisualStudio10TargetGenerator::WriteMasmOptions(
std::string const& configName, std::vector const& includes)
{
if (!this->MSTools || !this->GlobalGenerator->IsMasmEnabled()) {
return;
}
this->WriteString("\n", 2);
// Preprocessor definitions and includes are shared with clOptions.
Options& clOptions = *(this->ClOptions[configName]);
clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ",
"\n", "ASM_MASM");
Options& masmOptions = *(this->MasmOptions[configName]);
masmOptions.AppendFlag("IncludePaths", includes);
masmOptions.AppendFlag("IncludePaths", "%(IncludePaths)");
masmOptions.PrependInheritedString("AdditionalOptions");
masmOptions.OutputFlagMap(*this->BuildFileStream, " ");
this->WriteString("\n", 2);
}
bool cmVisualStudio10TargetGenerator::ComputeNasmOptions()
{
if (!this->GlobalGenerator->IsNasmEnabled()) {
return true;
}
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
if (!this->ComputeNasmOptions(*i)) {
return false;
}
}
return true;
}
bool cmVisualStudio10TargetGenerator::ComputeNasmOptions(
std::string const& configName)
{
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
CM_AUTO_PTR pOptions(new Options(
this->LocalGenerator, Options::NasmCompiler, gg->GetNasmFlagTable()));
Options& nasmOptions = *pOptions;
std::string CONFIG = cmSystemTools::UpperCase(configName);
std::string configFlagsVar = std::string("CMAKE_ASM_NASM_FLAGS_") + CONFIG;
std::string flags =
std::string(this->Makefile->GetSafeDefinition("CMAKE_ASM_NASM_FLAGS")) +
std::string(" -f") + std::string(this->Makefile->GetSafeDefinition(
"CMAKE_ASM_NASM_OBJECT_FORMAT")) +
std::string(" ") +
std::string(this->Makefile->GetSafeDefinition(configFlagsVar));
nasmOptions.Parse(flags.c_str());
this->NasmOptions[configName] = pOptions.release();
return true;
}
void cmVisualStudio10TargetGenerator::WriteNasmOptions(
std::string const& configName, std::vector includes)
{
if (!this->GlobalGenerator->IsNasmEnabled()) {
return;
}
this->WriteString("\n", 2);
Options& nasmOptions = *(this->NasmOptions[configName]);
for (size_t i = 0; i < includes.size(); i++) {
includes[i] += "\\";
}
nasmOptions.AppendFlag("IncludePaths", includes);
nasmOptions.AppendFlag("IncludePaths", "%(IncludePaths)");
nasmOptions.OutputFlagMap(*this->BuildFileStream, " ");
nasmOptions.PrependInheritedString("AdditionalOptions");
nasmOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ",
"\n", "ASM_NASM");
// Preprocessor definitions and includes are shared with clOptions.
Options& clOptions = *(this->ClOptions[configName]);
clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ",
"\n", "ASM_NASM");
this->WriteString("\n", 2);
}
void cmVisualStudio10TargetGenerator::WriteLibOptions(
std::string const& config)
{
if (this->GeneratorTarget->GetType() != cmStateEnums::STATIC_LIBRARY &&
this->GeneratorTarget->GetType() != cmStateEnums::OBJECT_LIBRARY) {
return;
}
std::string libflags;
this->LocalGenerator->GetStaticLibraryFlags(
libflags, cmSystemTools::UpperCase(config), this->GeneratorTarget);
if (!libflags.empty()) {
this->WriteString("\n", 2);
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
cmVisualStudioGeneratorOptions libOptions(
this->LocalGenerator, cmVisualStudioGeneratorOptions::Linker,
gg->GetLibFlagTable(), 0, this);
libOptions.Parse(libflags.c_str());
libOptions.PrependInheritedString("AdditionalOptions");
libOptions.OutputFlagMap(*this->BuildFileStream, " ");
this->WriteString("\n", 2);
}
// We cannot generate metadata for static libraries. WindowsPhone
// and WindowsStore tools look at GenerateWindowsMetadata in the
// Link tool options even for static libraries.
if (this->GlobalGenerator->TargetsWindowsPhone() ||
this->GlobalGenerator->TargetsWindowsStore()) {
this->WriteString("\n", 2);
this->WriteString("false"
"\n",
3);
this->WriteString("\n", 2);
}
}
void cmVisualStudio10TargetGenerator::WriteManifestOptions(
std::string const& config)
{
if (this->GeneratorTarget->GetType() != cmStateEnums::EXECUTABLE &&
this->GeneratorTarget->GetType() != cmStateEnums::SHARED_LIBRARY &&
this->GeneratorTarget->GetType() != cmStateEnums::MODULE_LIBRARY) {
return;
}
std::vector manifest_srcs;
this->GeneratorTarget->GetManifests(manifest_srcs, config);
if (!manifest_srcs.empty()) {
this->WriteString("\n", 2);
this->WriteString("", 3);
for (std::vector::const_iterator mi =
manifest_srcs.begin();
mi != manifest_srcs.end(); ++mi) {
std::string m = this->ConvertPath((*mi)->GetFullPath(), false);
this->ConvertToWindowsSlash(m);
(*this->BuildFileStream) << m << ";";
}
(*this->BuildFileStream) << "\n";
this->WriteString("\n", 2);
}
}
void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
std::string const& configName)
{
// Look through the sources for AndroidManifest.xml and use
// its location as the root source directory.
std::string rootDir = this->LocalGenerator->GetCurrentSourceDirectory();
{
std::vector extraSources;
this->GeneratorTarget->GetExtraSources(extraSources, "");
for (std::vector::const_iterator si =
extraSources.begin();
si != extraSources.end(); ++si) {
if ("androidmanifest.xml" ==
cmSystemTools::LowerCase((*si)->GetLocation().GetName())) {
rootDir = (*si)->GetLocation().GetDirectory();
break;
}
}
}
// Tell MSBuild to launch Ant.
{
std::string antBuildPath = rootDir;
this->WriteString("\n", 2);
this->WriteString("", 3);
this->ConvertToWindowsSlash(antBuildPath);
(*this->BuildFileStream) << cmVS10EscapeXML(antBuildPath)
<< "\n";
}
if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_SKIP_ANT_STEP")) {
this->WriteString("true\n", 3);
}
if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_PROGUARD")) {
this->WriteString("true\n", 3);
}
if (const char* proGuardConfigLocation =
this->GeneratorTarget->GetProperty("ANDROID_PROGUARD_CONFIG_PATH")) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(proGuardConfigLocation)
<< "\n";
}
if (const char* securePropertiesLocation =
this->GeneratorTarget->GetProperty("ANDROID_SECURE_PROPS_PATH")) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(securePropertiesLocation)
<< "\n";
}
if (const char* nativeLibDirectoriesExpression =
this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES")) {
cmGeneratorExpression ge;
CM_AUTO_PTR cge =
ge.Parse(nativeLibDirectoriesExpression);
std::string nativeLibDirs =
cge->Evaluate(this->LocalGenerator, configName);
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDirs)
<< "\n";
}
if (const char* nativeLibDependenciesExpression =
this->GeneratorTarget->GetProperty(
"ANDROID_NATIVE_LIB_DEPENDENCIES")) {
cmGeneratorExpression ge;
CM_AUTO_PTR cge =
ge.Parse(nativeLibDependenciesExpression);
std::string nativeLibDeps =
cge->Evaluate(this->LocalGenerator, configName);
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDeps)
<< "\n";
}
if (const char* javaSourceDir =
this->GeneratorTarget->GetProperty("ANDROID_JAVA_SOURCE_DIR")) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(javaSourceDir)
<< "\n";
}
if (const char* jarDirectoriesExpression =
this->GeneratorTarget->GetProperty("ANDROID_JAR_DIRECTORIES")) {
cmGeneratorExpression ge;
CM_AUTO_PTR cge =
ge.Parse(jarDirectoriesExpression);
std::string jarDirectories =
cge->Evaluate(this->LocalGenerator, configName);
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(jarDirectories)
<< "\n";
}
if (const char* jarDeps =
this->GeneratorTarget->GetProperty("ANDROID_JAR_DEPENDENCIES")) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(jarDeps)
<< "\n";
}
if (const char* assetsDirectories =
this->GeneratorTarget->GetProperty("ANDROID_ASSETS_DIRECTORIES")) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(assetsDirectories)
<< "\n";
}
{
std::string manifest_xml = rootDir + "/AndroidManifest.xml";
this->ConvertToWindowsSlash(manifest_xml);
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(manifest_xml)
<< "\n";
}
if (const char* antAdditionalOptions =
this->GeneratorTarget->GetProperty("ANDROID_ANT_ADDITIONAL_OPTIONS")) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(antAdditionalOptions)
<< " %(AdditionalOptions)\n";
}
this->WriteString("\n", 2);
}
bool cmVisualStudio10TargetGenerator::ComputeLinkOptions()
{
if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE ||
this->GeneratorTarget->GetType() == cmStateEnums::SHARED_LIBRARY ||
this->GeneratorTarget->GetType() == cmStateEnums::MODULE_LIBRARY) {
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
if (!this->ComputeLinkOptions(*i)) {
return false;
}
}
}
return true;
}
bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
std::string const& config)
{
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
CM_AUTO_PTR pOptions(new Options(
this->LocalGenerator, Options::Linker, gg->GetLinkFlagTable(), 0, this));
Options& linkOptions = *pOptions;
cmGeneratorTarget::LinkClosure const* linkClosure =
this->GeneratorTarget->GetLinkClosure(config);
const std::string& linkLanguage = linkClosure->LinkerLanguage;
if (linkLanguage.empty()) {
cmSystemTools::Error(
"CMake can not determine linker language for target: ",
this->Name.c_str());
return false;
}
std::string CONFIG = cmSystemTools::UpperCase(config);
const char* linkType = "SHARED";
if (this->GeneratorTarget->GetType() == cmStateEnums::MODULE_LIBRARY) {
linkType = "MODULE";
}
if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE) {
linkType = "EXE";
}
std::string flags;
std::string linkFlagVarBase = "CMAKE_";
linkFlagVarBase += linkType;
linkFlagVarBase += "_LINKER_FLAGS";
flags += " ";
flags += this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
linkFlagVarBase.c_str());
std::string linkFlagVar = linkFlagVarBase + "_" + CONFIG;
flags += " ";
flags += this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
linkFlagVar.c_str());
const char* targetLinkFlags =
this->GeneratorTarget->GetProperty("LINK_FLAGS");
if (targetLinkFlags) {
flags += " ";
flags += targetLinkFlags;
}
std::string flagsProp = "LINK_FLAGS_";
flagsProp += CONFIG;
if (const char* flagsConfig =
this->GeneratorTarget->GetProperty(flagsProp.c_str())) {
flags += " ";
flags += flagsConfig;
}
cmComputeLinkInformation* pcli =
this->GeneratorTarget->GetLinkInformation(config.c_str());
if (!pcli) {
cmSystemTools::Error(
"CMake can not compute cmComputeLinkInformation for target: ",
this->Name.c_str());
return false;
}
cmComputeLinkInformation& cli = *pcli;
std::vector libVec;
std::vector vsTargetVec;
this->AddLibraries(cli, libVec, vsTargetVec);
if (std::find(linkClosure->Languages.begin(), linkClosure->Languages.end(),
"CUDA") != linkClosure->Languages.end()) {
switch (this->CudaOptions[config]->GetCudaRuntime()) {
case cmVisualStudioGeneratorOptions::CudaRuntimeStatic:
libVec.push_back("cudart_static.lib");
break;
case cmVisualStudioGeneratorOptions::CudaRuntimeShared:
libVec.push_back("cudart.lib");
break;
case cmVisualStudioGeneratorOptions::CudaRuntimeNone:
break;
}
}
std::string standardLibsVar = "CMAKE_";
standardLibsVar += linkLanguage;
standardLibsVar += "_STANDARD_LIBRARIES";
std::string const libs =
this->Makefile->GetSafeDefinition(standardLibsVar.c_str());
cmSystemTools::ParseWindowsCommandLine(libs.c_str(), libVec);
linkOptions.AddFlag("AdditionalDependencies", libVec);
// Populate TargetsFileAndConfigsVec
for (std::vector::iterator ti = vsTargetVec.begin();
ti != vsTargetVec.end(); ++ti) {
this->AddTargetsFileAndConfigPair(*ti, config);
}
std::vector const& ldirs = cli.GetDirectories();
std::vector linkDirs;
for (std::vector::const_iterator d = ldirs.begin();
d != ldirs.end(); ++d) {
// first just full path
linkDirs.push_back(*d);
// next path with configuration type Debug, Release, etc
linkDirs.push_back(*d + "/$(Configuration)");
}
linkDirs.push_back("%(AdditionalLibraryDirectories)");
linkOptions.AddFlag("AdditionalLibraryDirectories", linkDirs);
std::string targetName;
std::string targetNameSO;
std::string targetNameFull;
std::string targetNameImport;
std::string targetNamePDB;
if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE) {
this->GeneratorTarget->GetExecutableNames(targetName, targetNameFull,
targetNameImport, targetNamePDB,
config.c_str());
} else {
this->GeneratorTarget->GetLibraryNames(targetName, targetNameSO,
targetNameFull, targetNameImport,
targetNamePDB, config.c_str());
}
if (this->MSTools) {
linkOptions.AddFlag("Version", "");
if (this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE")) {
if (this->GlobalGenerator->TargetsWindowsCE()) {
linkOptions.AddFlag("SubSystem", "WindowsCE");
if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE) {
if (this->ClOptions[config]->UsingUnicode()) {
linkOptions.AddFlag("EntryPointSymbol", "wWinMainCRTStartup");
} else {
linkOptions.AddFlag("EntryPointSymbol", "WinMainCRTStartup");
}
}
} else {
linkOptions.AddFlag("SubSystem", "Windows");
}
} else {
if (this->GlobalGenerator->TargetsWindowsCE()) {
linkOptions.AddFlag("SubSystem", "WindowsCE");
if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE) {
if (this->ClOptions[config]->UsingUnicode()) {
linkOptions.AddFlag("EntryPointSymbol", "mainWCRTStartup");
} else {
linkOptions.AddFlag("EntryPointSymbol", "mainACRTStartup");
}
}
} else {
linkOptions.AddFlag("SubSystem", "Console");
};
}
if (const char* stackVal = this->Makefile->GetDefinition(
"CMAKE_" + linkLanguage + "_STACK_SIZE")) {
linkOptions.AddFlag("StackReserveSize", stackVal);
}
linkOptions.AddFlag("GenerateDebugInformation", "false");
std::string pdb = this->GeneratorTarget->GetPDBDirectory(config.c_str());
pdb += "/";
pdb += targetNamePDB;
std::string imLib = this->GeneratorTarget->GetDirectory(
config.c_str(), cmStateEnums::ImportLibraryArtifact);
imLib += "/";
imLib += targetNameImport;
linkOptions.AddFlag("ImportLibrary", imLib.c_str());
linkOptions.AddFlag("ProgramDataBaseFile", pdb.c_str());
// A Windows Runtime component uses internal .NET metadata,
// so does not have an import library.
if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") &&
this->GeneratorTarget->GetType() != cmStateEnums::EXECUTABLE) {
linkOptions.AddFlag("GenerateWindowsMetadata", "true");
} else if (this->GlobalGenerator->TargetsWindowsPhone() ||
this->GlobalGenerator->TargetsWindowsStore()) {
// WindowsPhone and WindowsStore components are in an app container
// and produce WindowsMetadata. If we are not producing a WINRT
// component, then do not generate the metadata here.
linkOptions.AddFlag("GenerateWindowsMetadata", "false");
}
if (this->GlobalGenerator->TargetsWindowsPhone() &&
this->GlobalGenerator->GetSystemVersion() == "8.0") {
// WindowsPhone 8.0 does not have ole32.
linkOptions.AppendFlag("IgnoreSpecificDefaultLibraries", "ole32.lib");
}
} else if (this->NsightTegra) {
linkOptions.AddFlag("SoName", targetNameSO.c_str());
}
linkOptions.Parse(flags.c_str());
if (this->MSTools) {
cmGeneratorTarget::ModuleDefinitionInfo const* mdi =
this->GeneratorTarget->GetModuleDefinitionInfo(config);
if (mdi && !mdi->DefFile.empty()) {
linkOptions.AddFlag("ModuleDefinitionFile", mdi->DefFile.c_str());
}
linkOptions.AppendFlag("IgnoreSpecificDefaultLibraries",
"%(IgnoreSpecificDefaultLibraries)");
}
// VS 2015 without all updates has a v140 toolset whose
// GenerateDebugInformation expects No/Debug instead of false/true.
if (gg->GetPlatformToolsetNeedsDebugEnum()) {
if (const char* debug = linkOptions.GetFlag("GenerateDebugInformation")) {
if (strcmp(debug, "false") == 0) {
linkOptions.AddFlag("GenerateDebugInformation", "No");
} else if (strcmp(debug, "true") == 0) {
linkOptions.AddFlag("GenerateDebugInformation", "Debug");
}
}
}
this->LinkOptions[config] = pOptions.release();
return true;
}
bool cmVisualStudio10TargetGenerator::ComputeLibOptions()
{
if (this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY) {
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
if (!this->ComputeLibOptions(*i)) {
return false;
}
}
}
return true;
}
bool cmVisualStudio10TargetGenerator::ComputeLibOptions(
std::string const& config)
{
cmComputeLinkInformation* pcli =
this->GeneratorTarget->GetLinkInformation(config.c_str());
if (!pcli) {
cmSystemTools::Error(
"CMake can not compute cmComputeLinkInformation for target: ",
this->Name.c_str());
return false;
}
cmComputeLinkInformation& cli = *pcli;
typedef cmComputeLinkInformation::ItemVector ItemVector;
const ItemVector& libs = cli.GetItems();
std::string currentBinDir =
this->LocalGenerator->GetCurrentBinaryDirectory();
for (ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l) {
if (l->IsPath && cmVS10IsTargetsFile(l->Value)) {
std::string path = this->LocalGenerator->ConvertToRelativePath(
currentBinDir, l->Value.c_str());
this->ConvertToWindowsSlash(path);
this->AddTargetsFileAndConfigPair(path, config);
}
}
return true;
}
void cmVisualStudio10TargetGenerator::WriteLinkOptions(
std::string const& config)
{
if (this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY ||
this->GeneratorTarget->GetType() > cmStateEnums::MODULE_LIBRARY) {
return;
}
if (csproj == this->ProjectType) {
return;
}
Options& linkOptions = *(this->LinkOptions[config]);
this->WriteString("\n", 2);
linkOptions.PrependInheritedString("AdditionalOptions");
linkOptions.OutputFlagMap(*this->BuildFileStream, " ");
this->WriteString("\n", 2);
if (!this->GlobalGenerator->NeedLinkLibraryDependencies(
this->GeneratorTarget)) {
this->WriteString("\n", 2);
this->WriteString(
"false\n", 3);
this->WriteString("\n", 2);
}
}
void cmVisualStudio10TargetGenerator::AddLibraries(
cmComputeLinkInformation& cli, std::vector& libVec,
std::vector& vsTargetVec)
{
typedef cmComputeLinkInformation::ItemVector ItemVector;
ItemVector const& libs = cli.GetItems();
std::string currentBinDir =
this->LocalGenerator->GetCurrentBinaryDirectory();
for (ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l) {
if (l->IsPath) {
std::string path = this->LocalGenerator->ConvertToRelativePath(
currentBinDir, l->Value.c_str());
this->ConvertToWindowsSlash(path);
if (cmVS10IsTargetsFile(l->Value)) {
vsTargetVec.push_back(path);
} else {
libVec.push_back(path);
}
} else if (!l->Target ||
l->Target->GetType() != cmStateEnums::INTERFACE_LIBRARY) {
libVec.push_back(l->Value);
}
}
}
void cmVisualStudio10TargetGenerator::AddTargetsFileAndConfigPair(
std::string const& targetsFile, std::string const& config)
{
for (std::vector::iterator i =
this->TargetsFileAndConfigsVec.begin();
i != this->TargetsFileAndConfigsVec.end(); ++i) {
if (cmSystemTools::ComparePath(targetsFile, i->File)) {
if (std::find(i->Configs.begin(), i->Configs.end(), config) ==
i->Configs.end()) {
i->Configs.push_back(config);
}
return;
}
}
TargetsFileAndConfigs entry;
entry.File = targetsFile;
entry.Configs.push_back(config);
this->TargetsFileAndConfigsVec.push_back(entry);
}
void cmVisualStudio10TargetGenerator::WriteMidlOptions(
std::string const& /*config*/, std::vector const& includes)
{
if (!this->MSTools) {
return;
}
if (csproj == this->ProjectType) {
return;
}
// This processes *any* of the .idl files specified in the project's file
// list (and passed as the item metadata %(Filename) expressing the rule
// input filename) into output files at the per-config *build* dir
// ($(IntDir)) each.
//
// IOW, this MIDL section is intended to provide a fully generic syntax
// content suitable for most cases (read: if you get errors, then it's quite
// probable that the error is on your side of the .idl setup).
//
// Also, note that the marked-as-generated _i.c file in the Visual Studio
// generator case needs to be referred to as $(IntDir)\foo_i.c at the
// project's file list, otherwise the compiler-side processing won't pick it
// up (for non-directory form, it ends up looking in project binary dir
// only). Perhaps there's something to be done to make this more automatic
// on the CMake side?
this->WriteString("\n", 2);
this->WriteString("", 3);
for (std::vector::const_iterator i = includes.begin();
i != includes.end(); ++i) {
*this->BuildFileStream << cmVS10EscapeXML(*i) << ";";
}
this->WriteString("%(AdditionalIncludeDirectories)"
"\n",
0);
this->WriteString("$(ProjectDir)/$(IntDir)"
"\n",
3);
this->WriteString("%(Filename).h\n", 3);
this->WriteString("%(Filename).tlb\n", 3);
this->WriteString(""
"%(Filename)_i.c\n",
3);
this->WriteString("%(Filename)_p.c\n", 3);
this->WriteString("\n", 2);
}
void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups()
{
for (std::vector::const_iterator i =
this->Configurations.begin();
i != this->Configurations.end(); ++i) {
std::vector includes;
this->LocalGenerator->GetIncludeDirectories(
includes, this->GeneratorTarget, "C", i->c_str());
for (std::vector::iterator ii = includes.begin();
ii != includes.end(); ++ii) {
this->ConvertToWindowsSlash(*ii);
}
this->WritePlatformConfigTag("ItemDefinitionGroup", i->c_str(), 1);
*this->BuildFileStream << "\n";
// output cl compile flags
if (this->GeneratorTarget->GetType() <= cmStateEnums::OBJECT_LIBRARY) {
this->WriteClOptions(*i, includes);
// output rc compile flags
this->WriteRCOptions(*i, includes);
this->WriteCudaOptions(*i, includes);
this->WriteMasmOptions(*i, includes);
this->WriteNasmOptions(*i, includes);
}
// output midl flags
this->WriteMidlOptions(*i, includes);
// write events
if (csproj != this->ProjectType) {
this->WriteEvents(*i);
}
// output link flags
this->WriteLinkOptions(*i);
this->WriteCudaLinkOptions(*i);
// output lib flags
this->WriteLibOptions(*i);
// output manifest flags
this->WriteManifestOptions(*i);
if (this->NsightTegra &&
this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE &&
this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI")) {
this->WriteAntBuildOptions(*i);
}
this->WriteString("\n", 1);
}
}
void cmVisualStudio10TargetGenerator::WriteEvents(
std::string const& configName)
{
bool addedPrelink = false;
cmGeneratorTarget::ModuleDefinitionInfo const* mdi =
this->GeneratorTarget->GetModuleDefinitionInfo(configName);
if (mdi && mdi->DefFileGenerated) {
addedPrelink = true;
std::vector commands =
this->GeneratorTarget->GetPreLinkCommands();
this->GlobalGenerator->AddSymbolExportCommand(this->GeneratorTarget,
commands, configName);
this->WriteEvent("PreLinkEvent", commands, configName);
}
if (!addedPrelink) {
this->WriteEvent("PreLinkEvent",
this->GeneratorTarget->GetPreLinkCommands(), configName);
}
this->WriteEvent("PreBuildEvent",
this->GeneratorTarget->GetPreBuildCommands(), configName);
this->WriteEvent("PostBuildEvent",
this->GeneratorTarget->GetPostBuildCommands(), configName);
}
void cmVisualStudio10TargetGenerator::WriteEvent(
const char* name, std::vector const& commands,
std::string const& configName)
{
if (commands.empty()) {
return;
}
this->WriteString("<", 2);
(*this->BuildFileStream) << name << ">\n";
cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
std::string script;
const char* pre = "";
std::string comment;
for (std::vector::const_iterator i = commands.begin();
i != commands.end(); ++i) {
cmCustomCommandGenerator ccg(*i, configName, this->LocalGenerator);
comment += pre;
comment += lg->ConstructComment(ccg);
script += pre;
pre = "\n";
script += cmVS10EscapeXML(lg->ConstructScript(ccg));
}
comment = cmVS10EscapeComment(comment);
if (csproj != this->ProjectType) {
this->WriteString("", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(comment) << "\n";
this->WriteString("", 3);
} else {
if (!comment.empty()) {
(*this->BuildFileStream) << "echo " << cmVS10EscapeXML(comment) << "\n";
}
}
(*this->BuildFileStream) << script;
if (csproj != this->ProjectType) {
(*this->BuildFileStream) << "";
}
(*this->BuildFileStream) << "\n";
this->WriteString("", 2);
(*this->BuildFileStream) << name << ">\n";
}
void cmVisualStudio10TargetGenerator::WriteProjectReferences()
{
cmGlobalGenerator::TargetDependSet const& unordered =
this->GlobalGenerator->GetTargetDirectDepends(this->GeneratorTarget);
typedef cmGlobalVisualStudioGenerator::OrderedTargetDependSet
OrderedTargetDependSet;
OrderedTargetDependSet depends(unordered, CMAKE_CHECK_BUILD_SYSTEM_TARGET);
this->WriteString("\n", 1);
for (OrderedTargetDependSet::const_iterator i = depends.begin();
i != depends.end(); ++i) {
cmGeneratorTarget const* dt = *i;
if (dt->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
// skip fortran targets as they can not be processed by MSBuild
// the only reference will be in the .sln file
if (static_cast(this->GlobalGenerator)
->TargetIsFortranOnly(dt)) {
continue;
}
this->WriteString("GetLocalGenerator();
std::string name = dt->GetName();
std::string path;
const char* p = dt->GetProperty("EXTERNAL_MSPROJECT");
if (p) {
path = p;
} else {
path = lg->GetCurrentBinaryDirectory();
path += "/";
path += dt->GetName();
path += computeProjectFileExtension(dt);
}
this->ConvertToWindowsSlash(path);
(*this->BuildFileStream) << cmVS10EscapeXML(path) << "\">\n";
this->WriteString("", 3);
(*this->BuildFileStream)
<< "{" << this->GlobalGenerator->GetGUID(name.c_str()) << "}";
(*this->BuildFileStream) << "\n";
this->WriteString("", 3);
(*this->BuildFileStream) << name << "\n";
if (csproj == this->ProjectType) {
if (!static_cast(this->GlobalGenerator)
->TargetCanBeReferenced(dt)) {
this->WriteString(
"false\n", 3);
}
}
this->WriteString("\n", 2);
}
this->WriteString("\n", 1);
}
void cmVisualStudio10TargetGenerator::WritePlatformExtensions()
{
// This only applies to Windows 10 apps
if (this->GlobalGenerator->TargetsWindowsStore() &&
cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0")) {
const char* desktopExtensionsVersion =
this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION");
if (desktopExtensionsVersion) {
this->WriteSinglePlatformExtension("WindowsDesktop",
desktopExtensionsVersion);
}
const char* mobileExtensionsVersion =
this->GeneratorTarget->GetProperty("VS_MOBILE_EXTENSIONS_VERSION");
if (mobileExtensionsVersion) {
this->WriteSinglePlatformExtension("WindowsMobile",
mobileExtensionsVersion);
}
}
}
void cmVisualStudio10TargetGenerator::WriteSinglePlatformExtension(
std::string const& extension, std::string const& version)
{
this->WriteString("\n";
}
void cmVisualStudio10TargetGenerator::WriteSDKReferences()
{
std::vector sdkReferences;
bool hasWrittenItemGroup = false;
if (const char* vsSDKReferences =
this->GeneratorTarget->GetProperty("VS_SDK_REFERENCES")) {
cmSystemTools::ExpandListArgument(vsSDKReferences, sdkReferences);
this->WriteString("\n", 1);
hasWrittenItemGroup = true;
for (std::vector::iterator ri = sdkReferences.begin();
ri != sdkReferences.end(); ++ri) {
this->WriteString("BuildFileStream) << cmVS10EscapeXML(*ri) << "\"/>\n";
}
}
// This only applies to Windows 10 apps
if (this->GlobalGenerator->TargetsWindowsStore() &&
cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0")) {
const char* desktopExtensionsVersion =
this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION");
const char* mobileExtensionsVersion =
this->GeneratorTarget->GetProperty("VS_MOBILE_EXTENSIONS_VERSION");
const char* iotExtensionsVersion =
this->GeneratorTarget->GetProperty("VS_IOT_EXTENSIONS_VERSION");
if (desktopExtensionsVersion || mobileExtensionsVersion ||
iotExtensionsVersion) {
if (!hasWrittenItemGroup) {
this->WriteString("\n", 1);
hasWrittenItemGroup = true;
}
if (desktopExtensionsVersion) {
this->WriteSingleSDKReference("WindowsDesktop",
desktopExtensionsVersion);
}
if (mobileExtensionsVersion) {
this->WriteSingleSDKReference("WindowsMobile",
mobileExtensionsVersion);
}
if (iotExtensionsVersion) {
this->WriteSingleSDKReference("WindowsIoT", iotExtensionsVersion);
}
}
if (hasWrittenItemGroup) {
this->WriteString("\n", 1);
}
}
}
void cmVisualStudio10TargetGenerator::WriteSingleSDKReference(
std::string const& extension, std::string const& version)
{
this->WriteString("BuildFileStream) << extension << ", Version=" << version
<< "\" />\n";
}
void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile()
{
if ((this->GlobalGenerator->TargetsWindowsStore() ||
this->GlobalGenerator->TargetsWindowsPhone()) &&
(cmStateEnums::EXECUTABLE == this->GeneratorTarget->GetType())) {
std::string pfxFile;
std::vector certificates;
this->GeneratorTarget->GetCertificates(certificates, "");
for (std::vector::const_iterator si =
certificates.begin();
si != certificates.end(); ++si) {
pfxFile = this->ConvertPath((*si)->GetFullPath(), false);
this->ConvertToWindowsSlash(pfxFile);
break;
}
if (this->IsMissingFiles &&
!(this->GlobalGenerator->TargetsWindowsPhone() &&
this->GlobalGenerator->GetSystemVersion() == "8.0")) {
// Move the manifest to a project directory to avoid clashes
std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
this->WriteString("\n", 1);
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(artifactDir)
<< "\\\n";
this->WriteString("", 2);
std::string resourcePriFile =
this->DefaultArtifactDir + "/resources.pri";
this->ConvertToWindowsSlash(resourcePriFile);
(*this->BuildFileStream) << resourcePriFile << "\n";
// If we are missing files and we don't have a certificate and
// aren't targeting WP8.0, add a default certificate
if (pfxFile.empty()) {
std::string templateFolder =
cmSystemTools::GetCMakeRoot() + "/Templates/Windows";
pfxFile = this->DefaultArtifactDir + "/Windows_TemporaryKey.pfx";
cmSystemTools::CopyAFile(templateFolder + "/Windows_TemporaryKey.pfx",
pfxFile, false);
this->ConvertToWindowsSlash(pfxFile);
this->AddedFiles.push_back(pfxFile);
}
this->WriteString("<", 2);
(*this->BuildFileStream) << "PackageCertificateKeyFile>" << pfxFile
<< "\n";
std::string thumb = cmSystemTools::ComputeCertificateThumbprint(pfxFile);
if (!thumb.empty()) {
this->WriteString("", 2);
(*this->BuildFileStream) << thumb
<< "\n";
}
this->WriteString("\n", 1);
} else if (!pfxFile.empty()) {
this->WriteString("\n", 1);
this->WriteString("<", 2);
(*this->BuildFileStream) << "PackageCertificateKeyFile>" << pfxFile
<< "\n";
std::string thumb = cmSystemTools::ComputeCertificateThumbprint(pfxFile);
if (!thumb.empty()) {
this->WriteString("", 2);
(*this->BuildFileStream) << thumb
<< "\n";
}
this->WriteString("\n", 1);
}
}
}
bool cmVisualStudio10TargetGenerator::IsResxHeader(
const std::string& headerFile)
{
std::set expectedResxHeaders;
this->GeneratorTarget->GetExpectedResxHeaders(expectedResxHeaders, "");
std::set::const_iterator it =
expectedResxHeaders.find(headerFile);
return it != expectedResxHeaders.end();
}
bool cmVisualStudio10TargetGenerator::IsXamlHeader(
const std::string& headerFile)
{
std::set expectedXamlHeaders;
this->GeneratorTarget->GetExpectedXamlHeaders(expectedXamlHeaders, "");
std::set::const_iterator it =
expectedXamlHeaders.find(headerFile);
return it != expectedXamlHeaders.end();
}
bool cmVisualStudio10TargetGenerator::IsXamlSource(
const std::string& sourceFile)
{
std::set expectedXamlSources;
this->GeneratorTarget->GetExpectedXamlSources(expectedXamlSources, "");
std::set::const_iterator it =
expectedXamlSources.find(sourceFile);
return it != expectedXamlSources.end();
}
void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings()
{
cmGlobalVisualStudio10Generator* gg =
static_cast(this->GlobalGenerator);
bool isAppContainer = false;
bool const isWindowsPhone = this->GlobalGenerator->TargetsWindowsPhone();
bool const isWindowsStore = this->GlobalGenerator->TargetsWindowsStore();
std::string const& v = this->GlobalGenerator->GetSystemVersion();
if (isWindowsPhone || isWindowsStore) {
this->WriteString("", 2);
(*this->BuildFileStream)
<< (isWindowsPhone ? "Windows Phone" : "Windows Store")
<< "\n";
this->WriteString("en-US"
"\n",
2);
if (cmHasLiteralPrefix(v, "10.0")) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML("10.0")
<< "\n";
// Visual Studio 14.0 is necessary for building 10.0 apps
this->WriteString("14.0"
"\n",
2);
if (this->GeneratorTarget->GetType() < cmStateEnums::UTILITY) {
isAppContainer = true;
}
} else if (v == "8.1") {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(v)
<< "\n";
// Visual Studio 12.0 is necessary for building 8.1 apps
this->WriteString("12.0"
"\n",
2);
if (this->GeneratorTarget->GetType() < cmStateEnums::UTILITY) {
isAppContainer = true;
}
} else if (v == "8.0") {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(v)
<< "\n";
// Visual Studio 11.0 is necessary for building 8.0 apps
this->WriteString("11.0"
"\n",
2);
if (isWindowsStore &&
this->GeneratorTarget->GetType() < cmStateEnums::UTILITY) {
isAppContainer = true;
} else if (isWindowsPhone &&
this->GeneratorTarget->GetType() ==
cmStateEnums::EXECUTABLE) {
this->WriteString("true\n", 2);
this->WriteString("", 2);
(*this->BuildFileStream)
<< cmVS10EscapeXML(this->Name.c_str())
<< "_$(Configuration)_$(Platform).xap\n";
}
}
}
if (isAppContainer) {
this->WriteString("true"
"\n",
2);
} else if (this->Platform == "ARM") {
this->WriteString("true"
"\n",
2);
}
std::string const& targetPlatformVersion =
gg->GetWindowsTargetPlatformVersion();
if (!targetPlatformVersion.empty()) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformVersion)
<< "\n";
}
const char* targetPlatformMinVersion = this->GeneratorTarget->GetProperty(
"VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION");
if (targetPlatformMinVersion) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformMinVersion)
<< "\n";
} else if (isWindowsStore && cmHasLiteralPrefix(v, "10.0")) {
// If the min version is not set, then use the TargetPlatformVersion
if (!targetPlatformVersion.empty()) {
this->WriteString("", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformVersion)
<< "\n";
}
}
// Added IoT Startup Task support
if (this->GeneratorTarget->GetPropertyAsBool("VS_IOT_STARTUP_TASK")) {
this->WriteString("true\n", 2);
}
}
void cmVisualStudio10TargetGenerator::VerifyNecessaryFiles()
{
// For Windows and Windows Phone executables, we will assume that if a
// manifest is not present that we need to add all the necessary files
if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE) {
std::vector manifestSources;
this->GeneratorTarget->GetAppManifest(manifestSources, "");
{
std::string const& v = this->GlobalGenerator->GetSystemVersion();
if (this->GlobalGenerator->TargetsWindowsPhone()) {
if (v == "8.0") {
// Look through the sources for WMAppManifest.xml
std::vector extraSources;
this->GeneratorTarget->GetExtraSources(extraSources, "");
bool foundManifest = false;
for (std::vector::const_iterator si =
extraSources.begin();
si != extraSources.end(); ++si) {
// Need to do a lowercase comparison on the filename
if ("wmappmanifest.xml" ==
cmSystemTools::LowerCase((*si)->GetLocation().GetName())) {
foundManifest = true;
break;
}
}
if (!foundManifest) {
this->IsMissingFiles = true;
}
} else if (v == "8.1") {
if (manifestSources.empty()) {
this->IsMissingFiles = true;
}
}
} else if (this->GlobalGenerator->TargetsWindowsStore()) {
if (manifestSources.empty()) {
if (v == "8.0") {
this->IsMissingFiles = true;
} else if (v == "8.1" || cmHasLiteralPrefix(v, "10.0")) {
this->IsMissingFiles = true;
}
}
}
}
}
}
void cmVisualStudio10TargetGenerator::WriteMissingFiles()
{
std::string const& v = this->GlobalGenerator->GetSystemVersion();
if (this->GlobalGenerator->TargetsWindowsPhone()) {
if (v == "8.0") {
this->WriteMissingFilesWP80();
} else if (v == "8.1") {
this->WriteMissingFilesWP81();
}
} else if (this->GlobalGenerator->TargetsWindowsStore()) {
if (v == "8.0") {
this->WriteMissingFilesWS80();
} else if (v == "8.1") {
this->WriteMissingFilesWS81();
} else if (cmHasLiteralPrefix(v, "10.0")) {
this->WriteMissingFilesWS10_0();
}
}
}
void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80()
{
std::string templateFolder =
cmSystemTools::GetCMakeRoot() + "/Templates/Windows";
// For WP80, the manifest needs to be in the same folder as the project
// this can cause an overwrite problem if projects aren't organized in
// folders
std::string manifestFile =
this->LocalGenerator->GetCurrentBinaryDirectory() +
std::string("/WMAppManifest.xml");
std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML =
cmVS10EscapeXML(this->GeneratorTarget->GetName());
cmGeneratedFileStream fout(manifestFile.c_str());
fout.SetCopyIfDifferent(true);
/* clang-format off */
fout <<
"\n"
"\n"
"\t\n"
"\tGUID << "}\""
" Title=\"CMake Test Program\" RuntimeType=\"Modern Native\""
" Version=\"1.0.0.0\" Genre=\"apps.normal\" Author=\"CMake\""
" Description=\"Default CMake App\" Publisher=\"CMake\""
" PublisherID=\"{" << this->GUID << "}\">\n"
"\t\t"
<< artifactDirXML << "\\ApplicationIcon.png\n"
"\t\t\n"
"\t\t\n"
"\t\t\t\n"
"\t\t\n"
"\t\t\n"
"\t\t\t\n"
"\t\t\t\t\n"
"\t\t\t\t\t"
<< artifactDirXML << "\\SmallLogo.png\n"
"\t\t\t\t\t0\n"
"\t\t\t\t\t"
<< artifactDirXML << "\\Logo.png\n"
"\t\t\t\t\n"
"\t\t\t\n"
"\t\t\n"
"\t\t\n"
"\t\t\t\n"
"\t\t\n"
"\t\n"
"\n";
/* clang-format on */
std::string sourceFile = this->ConvertPath(manifestFile, false);
this->ConvertToWindowsSlash(sourceFile);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(sourceFile) << "\">\n";
this->WriteString("Designer\n", 3);
this->WriteString("\n", 2);
this->AddedFiles.push_back(sourceFile);
std::string smallLogo = this->DefaultArtifactDir + "/SmallLogo.png";
cmSystemTools::CopyAFile(templateFolder + "/SmallLogo.png", smallLogo,
false);
this->ConvertToWindowsSlash(smallLogo);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(smallLogo) << "\" />\n";
this->AddedFiles.push_back(smallLogo);
std::string logo = this->DefaultArtifactDir + "/Logo.png";
cmSystemTools::CopyAFile(templateFolder + "/Logo.png", logo, false);
this->ConvertToWindowsSlash(logo);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(logo) << "\" />\n";
this->AddedFiles.push_back(logo);
std::string applicationIcon =
this->DefaultArtifactDir + "/ApplicationIcon.png";
cmSystemTools::CopyAFile(templateFolder + "/ApplicationIcon.png",
applicationIcon, false);
this->ConvertToWindowsSlash(applicationIcon);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(applicationIcon) << "\" />\n";
this->AddedFiles.push_back(applicationIcon);
}
void cmVisualStudio10TargetGenerator::WriteMissingFilesWP81()
{
std::string manifestFile =
this->DefaultArtifactDir + "/package.appxManifest";
std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML =
cmVS10EscapeXML(this->GeneratorTarget->GetName());
cmGeneratedFileStream fout(manifestFile.c_str());
fout.SetCopyIfDifferent(true);
/* clang-format off */
fout <<
"\n"
"\n"
"\tGUID << "\" Publisher=\"CN=CMake\""
" Version=\"1.0.0.0\" />\n"
"\tGUID << "\""
" PhonePublisherId=\"00000000-0000-0000-0000-000000000000\"/>\n"
"\t\n"
"\t\t" << targetNameXML << "\n"
"\t\tCMake\n"
"\t\t" << artifactDirXML << "\\StoreLogo.png\n"
"\t\n"
"\t\n"
"\t\t6.3.1\n"
"\t\t6.3.1\n"
"\t\n"
"\t\n"
"\t\t\n"
"\t\n"
"\t\n"
"\t\t\n"
"\t\t\t\n"
"\t\t\t\t\n"
"\t\t\t\t\t\n"
"\t\t\t\t\t\t\n"
"\t\t\t\t\t\n"
"\t\t\t\t\n"
"\t\t\t\t\n"
"\t\t\t\n"
"\t\t\n"
"\t\n"
"\n";
/* clang-format on */
this->WriteCommonMissingFiles(manifestFile);
}
void cmVisualStudio10TargetGenerator::WriteMissingFilesWS80()
{
std::string manifestFile =
this->DefaultArtifactDir + "/package.appxManifest";
std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML =
cmVS10EscapeXML(this->GeneratorTarget->GetName());
cmGeneratedFileStream fout(manifestFile.c_str());
fout.SetCopyIfDifferent(true);
/* clang-format off */
fout <<
"\n"
"\n"
"\tGUID << "\" Publisher=\"CN=CMake\""
" Version=\"1.0.0.0\" />\n"
"\t\n"
"\t\t" << targetNameXML << "\n"
"\t\tCMake\n"
"\t\t" << artifactDirXML << "\\StoreLogo.png\n"
"\t\n"
"\t\n"
"\t\t6.2.1\n"
"\t\t6.2.1\n"
"\t\n"
"\t\n"
"\t\t\n"
"\t\n"
"\t\n"
"\t\t\n"
"\t\t\t\n"
"\t\t\t\t\n"
"\t\t\t\t\n"
"\t\t\t\n"
"\t\t\n"
"\t\n"
"\n";
/* clang-format on */
this->WriteCommonMissingFiles(manifestFile);
}
void cmVisualStudio10TargetGenerator::WriteMissingFilesWS81()
{
std::string manifestFile =
this->DefaultArtifactDir + "/package.appxManifest";
std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML =
cmVS10EscapeXML(this->GeneratorTarget->GetName());
cmGeneratedFileStream fout(manifestFile.c_str());
fout.SetCopyIfDifferent(true);
/* clang-format off */
fout <<
"\n"
"\n"
"\tGUID << "\" Publisher=\"CN=CMake\""
" Version=\"1.0.0.0\" />\n"
"\t\n"
"\t\t" << targetNameXML << "\n"
"\t\tCMake\n"
"\t\t" << artifactDirXML << "\\StoreLogo.png\n"
"\t\n"
"\t\n"
"\t\t6.3\n"
"\t\t6.3\n"
"\t\n"
"\t\n"
"\t\t\n"
"\t\n"
"\t\n"
"\t\t\n"
"\t\t\t\n"
"\t\t\t\t\n"
"\t\t\t\t\t\n"
"\t\t\t\t\t\t\n"
"\t\t\t\t\t\n"
"\t\t\t\t\n"
"\t\t\t\t\n"
"\t\t\t\n"
"\t\t\n"
"\t\n"
"\n";
/* clang-format on */
this->WriteCommonMissingFiles(manifestFile);
}
void cmVisualStudio10TargetGenerator::WriteMissingFilesWS10_0()
{
std::string manifestFile =
this->DefaultArtifactDir + "/package.appxManifest";
std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML =
cmVS10EscapeXML(this->GeneratorTarget->GetName());
cmGeneratedFileStream fout(manifestFile.c_str());
fout.SetCopyIfDifferent(true);
/* clang-format off */
fout <<
"\n"
"\n\n"
"\tGUID << "\" Publisher=\"CN=CMake\""
" Version=\"1.0.0.0\" />\n"
"\tGUID <<
"\" PhonePublisherId=\"00000000-0000-0000-0000-000000000000\"/>\n"
"\t\n"
"\t\t" << targetNameXML << "\n"
"\t\tCMake\n"
"\t\t" << artifactDirXML << "\\StoreLogo.png\n"
"\t\n"
"\t\n"
"\t\t\n"
"\t\n"
"\t\n"
"\t\t\n"
"\t\n"
"\t\n"
"\t\t\n"
"\t\t\t\n"
"\t\t\t\t\n"
"\t\t\t\n"
"\t\t\n"
"\t\n"
"\n";
/* clang-format on */
this->WriteCommonMissingFiles(manifestFile);
}
void cmVisualStudio10TargetGenerator::WriteCommonMissingFiles(
const std::string& manifestFile)
{
std::string templateFolder =
cmSystemTools::GetCMakeRoot() + "/Templates/Windows";
std::string sourceFile = this->ConvertPath(manifestFile, false);
this->ConvertToWindowsSlash(sourceFile);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(sourceFile) << "\">\n";
this->WriteString("Designer\n", 3);
this->WriteString("\n", 2);
this->AddedFiles.push_back(sourceFile);
std::string smallLogo = this->DefaultArtifactDir + "/SmallLogo.png";
cmSystemTools::CopyAFile(templateFolder + "/SmallLogo.png", smallLogo,
false);
this->ConvertToWindowsSlash(smallLogo);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(smallLogo) << "\" />\n";
this->AddedFiles.push_back(smallLogo);
std::string smallLogo44 = this->DefaultArtifactDir + "/SmallLogo44x44.png";
cmSystemTools::CopyAFile(templateFolder + "/SmallLogo44x44.png", smallLogo44,
false);
this->ConvertToWindowsSlash(smallLogo44);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(smallLogo44) << "\" />\n";
this->AddedFiles.push_back(smallLogo44);
std::string logo = this->DefaultArtifactDir + "/Logo.png";
cmSystemTools::CopyAFile(templateFolder + "/Logo.png", logo, false);
this->ConvertToWindowsSlash(logo);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(logo) << "\" />\n";
this->AddedFiles.push_back(logo);
std::string storeLogo = this->DefaultArtifactDir + "/StoreLogo.png";
cmSystemTools::CopyAFile(templateFolder + "/StoreLogo.png", storeLogo,
false);
this->ConvertToWindowsSlash(storeLogo);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(storeLogo) << "\" />\n";
this->AddedFiles.push_back(storeLogo);
std::string splashScreen = this->DefaultArtifactDir + "/SplashScreen.png";
cmSystemTools::CopyAFile(templateFolder + "/SplashScreen.png", splashScreen,
false);
this->ConvertToWindowsSlash(splashScreen);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(splashScreen) << "\" />\n";
this->AddedFiles.push_back(splashScreen);
// This file has already been added to the build so don't copy it
std::string keyFile = this->DefaultArtifactDir + "/Windows_TemporaryKey.pfx";
this->ConvertToWindowsSlash(keyFile);
this->WriteString("BuildFileStream) << cmVS10EscapeXML(keyFile) << "\" />\n";
}
bool cmVisualStudio10TargetGenerator::ForceOld(const std::string& source) const
{
HANDLE h =
CreateFileW(cmSystemTools::ConvertToWindowsExtendedPath(source).c_str(),
FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, 0, OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS, 0);
if (!h) {
return false;
}
FILETIME const ftime_20010101 = { 3365781504u, 29389701u };
if (!SetFileTime(h, &ftime_20010101, &ftime_20010101, &ftime_20010101)) {
CloseHandle(h);
return false;
}
CloseHandle(h);
return true;
}
std::string cmVisualStudio10TargetGenerator::GetCMakeFilePath(
const char* relativeFilePath) const
{
// Always search in the standard modules location.
std::string path = cmSystemTools::GetCMakeRoot() + "/";
path += relativeFilePath;
this->ConvertToWindowsSlash(path);
return path;
}