2009-06-26 00:41:57 +04:00
|
|
|
#include "cmVisualStudioGeneratorOptions.h"
|
2016-04-29 16:40:20 +03:00
|
|
|
|
2015-07-07 21:31:46 +03:00
|
|
|
#include "cmOutputConverter.h"
|
2009-06-26 00:41:57 +04:00
|
|
|
#include "cmSystemTools.h"
|
|
|
|
#include "cmVisualStudio10TargetGenerator.h"
|
|
|
|
|
2016-05-16 17:34:04 +03:00
|
|
|
static std::string cmVisualStudio10GeneratorOptionsEscapeForXML(
|
|
|
|
std::string ret)
|
2009-07-14 00:58:24 +04:00
|
|
|
{
|
2013-04-11 19:34:17 +04:00
|
|
|
cmSystemTools::ReplaceString(ret, ";", "%3B");
|
2009-07-14 00:58:24 +04:00
|
|
|
cmSystemTools::ReplaceString(ret, "&", "&");
|
|
|
|
cmSystemTools::ReplaceString(ret, "<", "<");
|
|
|
|
cmSystemTools::ReplaceString(ret, ">", ">");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-05-16 17:34:04 +03:00
|
|
|
static std::string cmVisualStudioGeneratorOptionsEscapeForXML(std::string ret)
|
2009-06-26 00:41:57 +04:00
|
|
|
{
|
|
|
|
cmSystemTools::ReplaceString(ret, "&", "&");
|
|
|
|
cmSystemTools::ReplaceString(ret, "\"", """);
|
|
|
|
cmSystemTools::ReplaceString(ret, "<", "<");
|
|
|
|
cmSystemTools::ReplaceString(ret, ">", ">");
|
|
|
|
cmSystemTools::ReplaceString(ret, "\n", "
");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-05-16 17:34:04 +03:00
|
|
|
cmVisualStudioGeneratorOptions::cmVisualStudioGeneratorOptions(
|
|
|
|
cmLocalVisualStudioGenerator* lg, Tool tool,
|
|
|
|
cmVisualStudio10TargetGenerator* g)
|
|
|
|
: cmIDEOptions()
|
|
|
|
, LocalGenerator(lg)
|
|
|
|
, Version(lg->GetVersion())
|
|
|
|
, CurrentTool(tool)
|
|
|
|
, TargetGenerator(g)
|
2014-11-14 21:47:00 +03:00
|
|
|
{
|
|
|
|
// Preprocessor definitions are not allowed for linker tools.
|
|
|
|
this->AllowDefine = (tool != Linker);
|
|
|
|
|
|
|
|
// Slash options are allowed for VS.
|
|
|
|
this->AllowSlash = true;
|
|
|
|
|
|
|
|
this->FortranRuntimeDebug = false;
|
|
|
|
this->FortranRuntimeDLL = false;
|
|
|
|
this->FortranRuntimeMT = false;
|
|
|
|
}
|
|
|
|
|
2016-05-16 17:34:04 +03:00
|
|
|
cmVisualStudioGeneratorOptions::cmVisualStudioGeneratorOptions(
|
|
|
|
cmLocalVisualStudioGenerator* lg, Tool tool, cmVS7FlagTable const* table,
|
|
|
|
cmVS7FlagTable const* extraTable, cmVisualStudio10TargetGenerator* g)
|
|
|
|
: cmIDEOptions()
|
|
|
|
, LocalGenerator(lg)
|
|
|
|
, Version(lg->GetVersion())
|
|
|
|
, CurrentTool(tool)
|
|
|
|
, TargetGenerator(g)
|
2009-06-26 00:41:57 +04:00
|
|
|
{
|
2009-07-29 19:29:08 +04:00
|
|
|
// Store the given flag tables.
|
2014-11-14 21:47:00 +03:00
|
|
|
this->AddTable(table);
|
|
|
|
this->AddTable(extraTable);
|
2009-07-29 19:29:08 +04:00
|
|
|
|
|
|
|
// Preprocessor definitions are not allowed for linker tools.
|
|
|
|
this->AllowDefine = (tool != Linker);
|
|
|
|
|
|
|
|
// Slash options are allowed for VS.
|
|
|
|
this->AllowSlash = true;
|
2010-11-10 01:54:40 +03:00
|
|
|
|
|
|
|
this->FortranRuntimeDebug = false;
|
|
|
|
this->FortranRuntimeDLL = false;
|
|
|
|
this->FortranRuntimeMT = false;
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
|
|
|
|
2014-11-14 21:47:00 +03:00
|
|
|
void cmVisualStudioGeneratorOptions::AddTable(cmVS7FlagTable const* table)
|
|
|
|
{
|
2016-05-16 17:34:04 +03:00
|
|
|
if (table) {
|
|
|
|
for (int i = 0; i < FlagTableCount; ++i) {
|
|
|
|
if (!this->FlagTable[i]) {
|
2014-11-14 21:47:00 +03:00
|
|
|
this->FlagTable[i] = table;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2014-11-14 21:47:00 +03:00
|
|
|
}
|
|
|
|
|
2009-06-26 00:41:57 +04:00
|
|
|
void cmVisualStudioGeneratorOptions::FixExceptionHandlingDefault()
|
|
|
|
{
|
|
|
|
// Exception handling is on by default because the platform file has
|
|
|
|
// "/EHsc" in the flags. Normally, that will override this
|
|
|
|
// initialization to off, but the user has the option of removing
|
|
|
|
// the flag to disable exception handling. When the user does
|
|
|
|
// remove the flag we need to override the IDE default of on.
|
2016-05-16 17:34:04 +03:00
|
|
|
switch (this->Version) {
|
2015-05-17 12:33:09 +03:00
|
|
|
case cmGlobalVisualStudioGenerator::VS7:
|
|
|
|
case cmGlobalVisualStudioGenerator::VS71:
|
2009-06-26 00:41:57 +04:00
|
|
|
this->FlagMap["ExceptionHandling"] = "FALSE";
|
|
|
|
break;
|
2015-05-17 12:33:09 +03:00
|
|
|
case cmGlobalVisualStudioGenerator::VS10:
|
|
|
|
case cmGlobalVisualStudioGenerator::VS11:
|
|
|
|
case cmGlobalVisualStudioGenerator::VS12:
|
|
|
|
case cmGlobalVisualStudioGenerator::VS14:
|
2016-09-02 23:15:11 +03:00
|
|
|
case cmGlobalVisualStudioGenerator::VS15:
|
2009-06-26 00:41:57 +04:00
|
|
|
// by default VS puts <ExceptionHandling></ExceptionHandling> empty
|
|
|
|
// for a project, to make our projects look the same put a new line
|
|
|
|
// and space over for the closing </ExceptionHandling> as the default
|
|
|
|
// value
|
|
|
|
this->FlagMap["ExceptionHandling"] = "\n ";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
this->FlagMap["ExceptionHandling"] = "0";
|
2016-05-16 17:34:04 +03:00
|
|
|
break;
|
|
|
|
}
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void cmVisualStudioGeneratorOptions::SetVerboseMakefile(bool verbose)
|
|
|
|
{
|
|
|
|
// If verbose makefiles have been requested and the /nologo option
|
|
|
|
// was not given explicitly in the flags we want to add an attribute
|
|
|
|
// to the generated project to disable logo suppression. Otherwise
|
|
|
|
// the GUI default is to enable suppression.
|
2010-12-17 23:43:16 +03:00
|
|
|
//
|
2011-10-12 00:48:41 +04:00
|
|
|
// On Visual Studio 10 (and later!), the value of this attribute should be
|
|
|
|
// an empty string, instead of "FALSE", in order to avoid a warning:
|
2010-12-17 23:43:16 +03:00
|
|
|
// "cl ... warning D9035: option 'nologo-' has been deprecated"
|
|
|
|
//
|
2016-05-16 17:34:04 +03:00
|
|
|
if (verbose &&
|
|
|
|
this->FlagMap.find("SuppressStartupBanner") == this->FlagMap.end()) {
|
2011-11-11 02:17:41 +04:00
|
|
|
this->FlagMap["SuppressStartupBanner"] =
|
2015-05-17 12:33:09 +03:00
|
|
|
this->Version < cmGlobalVisualStudioGenerator::VS10 ? "FALSE" : "";
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
|
|
|
|
2013-08-05 23:16:54 +04:00
|
|
|
bool cmVisualStudioGeneratorOptions::IsDebug() const
|
2009-06-26 00:41:57 +04:00
|
|
|
{
|
|
|
|
return this->FlagMap.find("DebugInformationFormat") != this->FlagMap.end();
|
|
|
|
}
|
|
|
|
|
2014-08-11 22:21:16 +04:00
|
|
|
bool cmVisualStudioGeneratorOptions::IsWinRt() const
|
|
|
|
{
|
|
|
|
return this->FlagMap.find("CompileAsWinRT") != this->FlagMap.end();
|
|
|
|
}
|
|
|
|
|
2013-08-05 23:16:54 +04:00
|
|
|
bool cmVisualStudioGeneratorOptions::UsingUnicode() const
|
2009-06-26 00:41:57 +04:00
|
|
|
{
|
|
|
|
// Look for the a _UNICODE definition.
|
2016-05-16 17:34:04 +03:00
|
|
|
for (std::vector<std::string>::const_iterator di = this->Defines.begin();
|
|
|
|
di != this->Defines.end(); ++di) {
|
|
|
|
if (*di == "_UNICODE") {
|
2009-06-26 00:41:57 +04:00
|
|
|
return true;
|
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2009-06-26 00:41:57 +04:00
|
|
|
return false;
|
|
|
|
}
|
2013-08-05 23:16:54 +04:00
|
|
|
bool cmVisualStudioGeneratorOptions::UsingSBCS() const
|
2012-02-17 01:27:05 +04:00
|
|
|
{
|
|
|
|
// Look for the a _SBCS definition.
|
2016-05-16 17:34:04 +03:00
|
|
|
for (std::vector<std::string>::const_iterator di = this->Defines.begin();
|
|
|
|
di != this->Defines.end(); ++di) {
|
|
|
|
if (*di == "_SBCS") {
|
2012-02-17 01:27:05 +04:00
|
|
|
return true;
|
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2012-02-17 01:27:05 +04:00
|
|
|
return false;
|
|
|
|
}
|
2009-06-26 00:41:57 +04:00
|
|
|
|
|
|
|
void cmVisualStudioGeneratorOptions::Parse(const char* flags)
|
|
|
|
{
|
|
|
|
// Parse the input string as a windows command line since the string
|
|
|
|
// is intended for writing directly into the build files.
|
|
|
|
std::vector<std::string> args;
|
|
|
|
cmSystemTools::ParseWindowsCommandLine(flags, args);
|
|
|
|
|
|
|
|
// Process flags that need to be represented specially in the IDE
|
|
|
|
// project file.
|
2016-05-16 17:34:04 +03:00
|
|
|
for (std::vector<std::string>::iterator ai = args.begin(); ai != args.end();
|
|
|
|
++ai) {
|
2009-06-26 00:41:57 +04:00
|
|
|
this->HandleFlag(ai->c_str());
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
|
|
|
|
2010-11-10 01:54:40 +03:00
|
|
|
void cmVisualStudioGeneratorOptions::ParseFinish()
|
|
|
|
{
|
2016-05-16 17:34:04 +03:00
|
|
|
if (this->CurrentTool == FortranCompiler) {
|
2010-11-10 01:54:40 +03:00
|
|
|
// "RuntimeLibrary" attribute values:
|
|
|
|
// "rtMultiThreaded", "0", /threads /libs:static
|
|
|
|
// "rtMultiThreadedDLL", "2", /threads /libs:dll
|
|
|
|
// "rtMultiThreadedDebug", "1", /threads /dbglibs /libs:static
|
|
|
|
// "rtMultiThreadedDebugDLL", "3", /threads /dbglibs /libs:dll
|
|
|
|
// These seem unimplemented by the IDE:
|
|
|
|
// "rtSingleThreaded", "4", /libs:static
|
|
|
|
// "rtSingleThreadedDLL", "10", /libs:dll
|
|
|
|
// "rtSingleThreadedDebug", "5", /dbglibs /libs:static
|
|
|
|
// "rtSingleThreadedDebugDLL", "11", /dbglibs /libs:dll
|
|
|
|
std::string rl = "rtMultiThreaded";
|
2016-05-16 17:34:04 +03:00
|
|
|
rl += this->FortranRuntimeDebug ? "Debug" : "";
|
|
|
|
rl += this->FortranRuntimeDLL ? "DLL" : "";
|
2010-11-10 01:54:40 +03:00
|
|
|
this->FlagMap["RuntimeLibrary"] = rl;
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2010-11-10 01:54:40 +03:00
|
|
|
}
|
|
|
|
|
2009-07-29 19:29:08 +04:00
|
|
|
void cmVisualStudioGeneratorOptions::StoreUnknownFlag(const char* flag)
|
2009-06-26 00:41:57 +04:00
|
|
|
{
|
2010-11-10 01:54:40 +03:00
|
|
|
// Look for Intel Fortran flags that do not map well in the flag table.
|
2016-05-16 17:34:04 +03:00
|
|
|
if (this->CurrentTool == FortranCompiler) {
|
|
|
|
if (strcmp(flag, "/dbglibs") == 0) {
|
2010-11-10 01:54:40 +03:00
|
|
|
this->FortranRuntimeDebug = true;
|
|
|
|
return;
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
|
|
|
if (strcmp(flag, "/threads") == 0) {
|
2010-11-10 01:54:40 +03:00
|
|
|
this->FortranRuntimeMT = true;
|
|
|
|
return;
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
|
|
|
if (strcmp(flag, "/libs:dll") == 0) {
|
2010-11-10 01:54:40 +03:00
|
|
|
this->FortranRuntimeDLL = true;
|
|
|
|
return;
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
|
|
|
if (strcmp(flag, "/libs:static") == 0) {
|
2010-11-10 01:54:40 +03:00
|
|
|
this->FortranRuntimeDLL = false;
|
|
|
|
return;
|
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2010-11-10 01:54:40 +03:00
|
|
|
|
2009-06-26 00:41:57 +04:00
|
|
|
// This option is not known. Store it in the output flags.
|
|
|
|
this->FlagString += " ";
|
2016-05-16 17:34:04 +03:00
|
|
|
this->FlagString += cmOutputConverter::EscapeWindowsShellArgument(
|
|
|
|
flag, cmOutputConverter::Shell_Flag_AllowMakeVariables |
|
2015-07-07 22:06:44 +03:00
|
|
|
cmOutputConverter::Shell_Flag_VSIDE);
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void cmVisualStudioGeneratorOptions::SetConfiguration(const char* config)
|
|
|
|
{
|
|
|
|
this->Configuration = config;
|
|
|
|
}
|
|
|
|
|
2016-05-16 17:34:04 +03:00
|
|
|
void cmVisualStudioGeneratorOptions::OutputPreprocessorDefinitions(
|
|
|
|
std::ostream& fout, const char* prefix, const char* suffix,
|
|
|
|
const std::string& lang)
|
2009-06-26 00:41:57 +04:00
|
|
|
{
|
2016-05-16 17:34:04 +03:00
|
|
|
if (this->Defines.empty()) {
|
2009-06-26 00:41:57 +04:00
|
|
|
return;
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
|
|
|
if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
|
2012-11-07 20:13:09 +04:00
|
|
|
// if there are configuration specific flags, then
|
2009-06-26 00:41:57 +04:00
|
|
|
// use the configuration specific tag for PreprocessorDefinitions
|
2016-05-16 17:34:04 +03:00
|
|
|
if (!this->Configuration.empty()) {
|
2009-06-26 00:41:57 +04:00
|
|
|
fout << prefix;
|
|
|
|
this->TargetGenerator->WritePlatformConfigTag(
|
2016-05-16 17:34:04 +03:00
|
|
|
"PreprocessorDefinitions", this->Configuration.c_str(), 0, 0, 0,
|
|
|
|
&fout);
|
|
|
|
} else {
|
2009-06-26 00:41:57 +04:00
|
|
|
fout << prefix << "<PreprocessorDefinitions>";
|
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
} else {
|
|
|
|
fout << prefix << "PreprocessorDefinitions=\"";
|
|
|
|
}
|
2010-06-28 23:51:13 +04:00
|
|
|
const char* sep = "";
|
2016-05-16 17:34:04 +03:00
|
|
|
for (std::vector<std::string>::const_iterator di = this->Defines.begin();
|
|
|
|
di != this->Defines.end(); ++di) {
|
2009-06-26 00:41:57 +04:00
|
|
|
// Escape the definition for the compiler.
|
|
|
|
std::string define;
|
2016-05-16 17:34:04 +03:00
|
|
|
if (this->Version < cmGlobalVisualStudioGenerator::VS10) {
|
|
|
|
define = this->LocalGenerator->EscapeForShell(di->c_str(), true);
|
|
|
|
} else {
|
2009-06-26 00:41:57 +04:00
|
|
|
define = *di;
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2009-06-26 00:41:57 +04:00
|
|
|
// Escape this flag for the IDE.
|
2016-05-16 17:34:04 +03:00
|
|
|
if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
|
2014-07-23 21:58:22 +04:00
|
|
|
define = cmVisualStudio10GeneratorOptionsEscapeForXML(define);
|
2011-01-26 02:54:36 +03:00
|
|
|
|
2016-05-16 17:34:04 +03:00
|
|
|
if (lang == "RC") {
|
2011-01-26 02:54:36 +03:00
|
|
|
cmSystemTools::ReplaceString(define, "\"", "\\\"");
|
2009-07-14 00:58:24 +04:00
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
} else {
|
2014-07-23 21:58:22 +04:00
|
|
|
define = cmVisualStudioGeneratorOptionsEscapeForXML(define);
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2009-06-26 00:41:57 +04:00
|
|
|
// Store the flag in the project file.
|
2010-06-28 23:51:13 +04:00
|
|
|
fout << sep << define;
|
|
|
|
sep = ";";
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
|
|
|
if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
|
|
|
|
fout << ";%(PreprocessorDefinitions)</PreprocessorDefinitions>" << suffix;
|
|
|
|
} else {
|
2009-06-26 00:41:57 +04:00
|
|
|
fout << "\"" << suffix;
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
|
|
|
|
2016-05-16 17:34:04 +03:00
|
|
|
void cmVisualStudioGeneratorOptions::OutputFlagMap(std::ostream& fout,
|
|
|
|
const char* indent)
|
2009-06-26 00:41:57 +04:00
|
|
|
{
|
2016-05-16 17:34:04 +03:00
|
|
|
if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
|
|
|
|
for (std::map<std::string, FlagValue>::iterator m = this->FlagMap.begin();
|
|
|
|
m != this->FlagMap.end(); ++m) {
|
2009-06-26 00:41:57 +04:00
|
|
|
fout << indent;
|
2016-05-16 17:34:04 +03:00
|
|
|
if (!this->Configuration.empty()) {
|
2009-06-26 00:41:57 +04:00
|
|
|
this->TargetGenerator->WritePlatformConfigTag(
|
2016-05-16 17:34:04 +03:00
|
|
|
m->first.c_str(), this->Configuration.c_str(), 0, 0, 0, &fout);
|
|
|
|
} else {
|
2009-06-26 00:41:57 +04:00
|
|
|
fout << "<" << m->first << ">";
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2014-07-23 19:13:13 +04:00
|
|
|
const char* sep = "";
|
2016-05-16 17:34:04 +03:00
|
|
|
for (std::vector<std::string>::iterator i = m->second.begin();
|
|
|
|
i != m->second.end(); ++i) {
|
2014-07-23 22:59:23 +04:00
|
|
|
fout << sep << cmVisualStudio10GeneratorOptionsEscapeForXML(*i);
|
2014-07-23 19:13:13 +04:00
|
|
|
sep = ";";
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
fout << "</" << m->first << ">\n";
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
} else {
|
|
|
|
for (std::map<std::string, FlagValue>::iterator m = this->FlagMap.begin();
|
|
|
|
m != this->FlagMap.end(); ++m) {
|
2014-07-23 19:13:13 +04:00
|
|
|
fout << indent << m->first << "=\"";
|
|
|
|
const char* sep = "";
|
2016-05-16 17:34:04 +03:00
|
|
|
for (std::vector<std::string>::iterator i = m->second.begin();
|
|
|
|
i != m->second.end(); ++i) {
|
2014-07-23 22:59:23 +04:00
|
|
|
fout << sep << cmVisualStudioGeneratorOptionsEscapeForXML(*i);
|
2014-07-23 19:13:13 +04:00
|
|
|
sep = ";";
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
fout << "\"\n";
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|
|
|
|
|
2016-05-16 17:34:04 +03:00
|
|
|
void cmVisualStudioGeneratorOptions::OutputAdditionalOptions(
|
|
|
|
std::ostream& fout, const char* prefix, const char* suffix)
|
2009-06-26 00:41:57 +04:00
|
|
|
{
|
2016-05-16 17:34:04 +03:00
|
|
|
if (!this->FlagString.empty()) {
|
|
|
|
if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
|
2009-06-26 00:41:57 +04:00
|
|
|
fout << prefix;
|
2016-05-16 17:34:04 +03:00
|
|
|
if (!this->Configuration.empty()) {
|
2009-06-26 00:41:57 +04:00
|
|
|
this->TargetGenerator->WritePlatformConfigTag(
|
2016-05-16 17:34:04 +03:00
|
|
|
"AdditionalOptions", this->Configuration.c_str(), 0, 0, 0, &fout);
|
|
|
|
} else {
|
2009-06-26 00:41:57 +04:00
|
|
|
fout << "<AdditionalOptions>";
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2014-07-23 22:59:23 +04:00
|
|
|
fout << cmVisualStudio10GeneratorOptionsEscapeForXML(this->FlagString)
|
2009-06-26 00:41:57 +04:00
|
|
|
<< " %(AdditionalOptions)</AdditionalOptions>\n";
|
2016-05-16 17:34:04 +03:00
|
|
|
} else {
|
2009-06-26 00:41:57 +04:00
|
|
|
fout << prefix << "AdditionalOptions=\"";
|
2014-07-23 21:58:22 +04:00
|
|
|
fout << cmVisualStudioGeneratorOptionsEscapeForXML(this->FlagString);
|
2009-06-26 00:41:57 +04:00
|
|
|
fout << "\"" << suffix;
|
|
|
|
}
|
2016-05-16 17:34:04 +03:00
|
|
|
}
|
2009-06-26 00:41:57 +04:00
|
|
|
}
|