Commit 99a224e3 authored by Brad King's avatar Brad King Committed by Kitware Robot

Merge topic 'vs-json-flag-table'

8107508b Remove old flag table headers
6d855fbf Replace header flag tables with json reading
9c60ae5f VS: Add flag table entry for -JMC
584ad067 VS: Fix flag table entry for -Qspectre
8df25f94 VS: connect /Y- compiler option with "Not Using Precompiled Headers"
f1223e34 VS: Add v140 flag table entries for `-Zc:inline[-]`
efc90eed VS: Fix regressed mapping for the cl `/Os` compiler flag
36b7fc7d VS 14: Add flag map for -std= to CppLanguageStandard tag in project files
...
Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
Merge-request: !2611
parents ce1ac9b9 8107508b
Pipeline #125660 failed with stage
in 0 seconds
......@@ -96,7 +96,6 @@ def read_msbuild_json(path, values=[]):
return values
def main():
"""Script entrypoint."""
# Parse the arguments
......@@ -213,6 +212,14 @@ def __find_and_remove_value(list, compare):
return found
def __normalize_switch(switch, separator):
new = switch
if switch.startswith("/") or switch.startswith("-"):
new = switch[1:]
if new and separator:
new = new + separator
return new
###########################################################################################
# private xml functions
def __convert(root, tag, values, func):
......@@ -257,6 +264,8 @@ def __convert_bool(node):
reverse_switch = __get_attribute(node, 'ReverseSwitch')
if reverse_switch:
__with_argument(node, converted)
converted_reverse = copy.deepcopy(converted)
converted_reverse['switch'] = reverse_switch
......@@ -303,7 +312,11 @@ def __convert_node(node, default_value='', default_flags=vsflags()):
converted = {}
converted['name'] = name
converted['switch'] = __get_attribute(node, 'Switch')
switch = __get_attribute(node, 'Switch')
separator = __get_attribute(node, 'Separator')
converted['switch'] = __normalize_switch(switch, separator)
converted['comment'] = __get_attribute(node, 'DisplayName')
converted['value'] = default_value
......@@ -435,7 +448,7 @@ def __write_json_file(path, values):
with open(path, 'w') as f:
json.dump(sorted_values, f, indent=2, separators=(',', ': '))
f.write("\n")
###########################################################################################
# private list helpers
......
......@@ -8,19 +8,11 @@
#include "cmLocalVisualStudio10Generator.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmVS10CLFlagTable.h"
#include "cmVS10CSharpFlagTable.h"
#include "cmVS10CudaFlagTable.h"
#include "cmVS10CudaHostFlagTable.h"
#include "cmVS10LibFlagTable.h"
#include "cmVS10LinkFlagTable.h"
#include "cmVS10MASMFlagTable.h"
#include "cmVS10NASMFlagTable.h"
#include "cmVS10RCFlagTable.h"
#include "cmVersion.h"
#include "cmVisualStudioSlnData.h"
#include "cmVisualStudioSlnParser.h"
#include "cmXMLWriter.h"
#include "cm_jsoncpp_reader.h"
#include "cmake.h"
#include "cmsys/FStream.hxx"
......@@ -30,6 +22,7 @@
#include <algorithm>
static const char vs10generatorName[] = "Visual Studio 10 2010";
static std::map<std::string, std::vector<cmIDEFlagTable>> loadedFlagJsonFiles;
// Map generator name without year to name with year.
static const char* cmVS10GenName(const std::string& name, std::string& genName)
......@@ -120,15 +113,16 @@ cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(
this->DefaultPlatformToolset = "v100";
}
}
this->DefaultClFlagTable = cmVS10CLFlagTable;
this->DefaultCSharpFlagTable = cmVS10CSharpFlagTable;
this->DefaultLibFlagTable = cmVS10LibFlagTable;
this->DefaultLinkFlagTable = cmVS10LinkFlagTable;
this->DefaultCudaFlagTable = cmVS10CudaFlagTable;
this->DefaultCudaHostFlagTable = cmVS10CudaHostFlagTable;
this->DefaultMasmFlagTable = cmVS10MASMFlagTable;
this->DefaultNasmFlagTable = cmVS10NASMFlagTable;
this->DefaultRcFlagTable = cmVS10RCFlagTable;
this->DefaultCLFlagTableName = "v10";
this->DefaultCSharpFlagTableName = "v10";
this->DefaultLibFlagTableName = "v10";
this->DefaultLinkFlagTableName = "v10";
this->DefaultCudaFlagTableName = "v10";
this->DefaultCudaHostFlagTableName = "v10";
this->DefaultMasmFlagTableName = "v10";
this->DefaultNasmFlagTableName = "v10";
this->DefaultRCFlagTableName = "v10";
this->Version = VS10;
this->PlatformToolsetNeedsDebugEnum = false;
}
......@@ -1050,67 +1044,174 @@ std::string cmGlobalVisualStudio10Generator::GetInstalledNsightTegraVersion()
return version;
}
static std::string cmLoadFlagTableString(Json::Value entry, const char* field)
{
if (entry.isMember(field)) {
auto string = entry[field];
if (string.isConvertibleTo(Json::ValueType::stringValue)) {
return string.asString();
}
}
return "";
}
static unsigned int cmLoadFlagTableSpecial(Json::Value entry,
const char* field)
{
unsigned int value = 0;
if (entry.isMember(field)) {
auto specials = entry[field];
if (specials.isArray()) {
for (auto const& special : specials) {
std::string s = special.asString();
if (s == "UserValue") {
value |= cmIDEFlagTable::UserValue;
} else if (s == "UserIgnored") {
value |= cmIDEFlagTable::UserIgnored;
} else if (s == "UserRequired") {
value |= cmIDEFlagTable::UserRequired;
} else if (s == "Continue") {
value |= cmIDEFlagTable::Continue;
} else if (s == "SemicolonAppendable") {
value |= cmIDEFlagTable::SemicolonAppendable;
} else if (s == "UserFollowing") {
value |= cmIDEFlagTable::UserFollowing;
} else if (s == "CaseInsensitive") {
value |= cmIDEFlagTable::CaseInsensitive;
} else if (s == "SpaceAppendable") {
value |= cmIDEFlagTable::SpaceAppendable;
}
}
}
}
return value;
}
static cmIDEFlagTable const* cmLoadFlagTableJson(
std::string const& flagJsonPath)
{
cmIDEFlagTable* ret = nullptr;
auto savedFlagIterator = loadedFlagJsonFiles.find(flagJsonPath);
if (savedFlagIterator != loadedFlagJsonFiles.end()) {
ret = savedFlagIterator->second.data();
} else {
Json::Reader reader;
cmsys::ifstream stream;
stream.open(flagJsonPath.c_str(), std::ios_base::in);
if (stream) {
Json::Value flags;
if (reader.parse(stream, flags, false) && flags.isArray()) {
std::vector<cmIDEFlagTable> flagTable;
for (auto const& flag : flags) {
cmIDEFlagTable flagEntry;
flagEntry.IDEName = cmLoadFlagTableString(flag, "name");
flagEntry.commandFlag = cmLoadFlagTableString(flag, "switch");
flagEntry.comment = cmLoadFlagTableString(flag, "comment");
flagEntry.value = cmLoadFlagTableString(flag, "value");
flagEntry.special = cmLoadFlagTableSpecial(flag, "flags");
flagTable.push_back(flagEntry);
}
cmIDEFlagTable endFlag{ "", "", "", "", 0 };
flagTable.push_back(endFlag);
loadedFlagJsonFiles[flagJsonPath] = flagTable;
ret = loadedFlagJsonFiles[flagJsonPath].data();
}
}
}
return ret;
}
cmIDEFlagTable const* cmGlobalVisualStudio10Generator::LoadFlagTable(
std::string const& flagTableName, std::string const& table) const
{
cmIDEFlagTable const* ret = nullptr;
std::string filename = cmSystemTools::GetCMakeRoot() +
"/Templates/MSBuild/FlagTables/" + flagTableName + "_" + table + ".json";
ret = cmLoadFlagTableJson(filename);
if (!ret) {
cmMakefile* mf = this->GetCurrentMakefile();
std::ostringstream e;
/* clang-format off */
e << "JSON flag table \"" << filename <<
"\" could not be loaded.\n";
/* clang-format on */
mf->IssueMessage(cmake::FATAL_ERROR, e.str().c_str());
}
return ret;
}
cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetClFlagTable() const
{
cmIDEFlagTable const* table = this->ToolsetOptions.GetClFlagTable(
this->GetPlatformName(), this->GetPlatformToolsetString());
std::string flagTableName = this->ToolsetOptions.GetClFlagTableName(
this->GetPlatformName(), this->GetPlatformToolsetString(),
this->DefaultCLFlagTableName);
return (table != nullptr) ? table : this->DefaultClFlagTable;
return LoadFlagTable(flagTableName, "CL");
}
cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetCSharpFlagTable()
const
{
cmIDEFlagTable const* table = this->ToolsetOptions.GetCSharpFlagTable(
this->GetPlatformName(), this->GetPlatformToolsetString());
std::string flagTableName = this->ToolsetOptions.GetCSharpFlagTableName(
this->GetPlatformName(), this->GetPlatformToolsetString(),
this->DefaultCSharpFlagTableName);
return (table != nullptr) ? table : this->DefaultCSharpFlagTable;
return LoadFlagTable(flagTableName, "CSharp");
}
cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetRcFlagTable() const
{
cmIDEFlagTable const* table = this->ToolsetOptions.GetRcFlagTable(
this->GetPlatformName(), this->GetPlatformToolsetString());
std::string flagTableName = this->ToolsetOptions.GetRcFlagTableName(
this->GetPlatformName(), this->GetPlatformToolsetString(),
this->DefaultRCFlagTableName);
return (table != nullptr) ? table : this->DefaultRcFlagTable;
return LoadFlagTable(flagTableName, "RC");
}
cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetLibFlagTable() const
{
cmIDEFlagTable const* table = this->ToolsetOptions.GetLibFlagTable(
this->GetPlatformName(), this->GetPlatformToolsetString());
std::string flagTableName = this->ToolsetOptions.GetLibFlagTableName(
this->GetPlatformName(), this->GetPlatformToolsetString(),
this->DefaultLibFlagTableName);
return (table != nullptr) ? table : this->DefaultLibFlagTable;
return LoadFlagTable(flagTableName, "LIB");
}
cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetLinkFlagTable() const
{
cmIDEFlagTable const* table = this->ToolsetOptions.GetLinkFlagTable(
this->GetPlatformName(), this->GetPlatformToolsetString());
std::string flagTableName = this->ToolsetOptions.GetLinkFlagTableName(
this->GetPlatformName(), this->GetPlatformToolsetString(),
this->DefaultLinkFlagTableName);
return (table != nullptr) ? table : this->DefaultLinkFlagTable;
return LoadFlagTable(flagTableName, "Link");
}
cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetCudaFlagTable() const
{
return this->DefaultCudaFlagTable;
return LoadFlagTable(this->DefaultCudaFlagTableName, "Cuda");
}
cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetCudaHostFlagTable()
const
{
return this->DefaultCudaHostFlagTable;
return LoadFlagTable(this->DefaultCudaHostFlagTableName, "CudaHost");
}
cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetMasmFlagTable() const
{
cmIDEFlagTable const* table = this->ToolsetOptions.GetMasmFlagTable(
this->GetPlatformName(), this->GetPlatformToolsetString());
std::string flagTableName = this->ToolsetOptions.GetMasmFlagTableName(
this->GetPlatformName(), this->GetPlatformToolsetString(),
this->DefaultMasmFlagTableName);
return (table != nullptr) ? table : this->DefaultMasmFlagTable;
return LoadFlagTable(flagTableName, "MASM");
}
cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetNasmFlagTable() const
{
return this->DefaultNasmFlagTable;
return LoadFlagTable(this->DefaultNasmFlagTableName, "NASM");
}
......@@ -144,6 +144,9 @@ protected:
std::string const& GetMSBuildCommand();
cmIDEFlagTable const* LoadFlagTable(std::string const& flagTableName,
std::string const& table) const;
std::string GeneratorToolset;
std::string GeneratorToolsetVersion;
std::string GeneratorToolsetHostArchitecture;
......@@ -153,15 +156,15 @@ protected:
std::string SystemName;
std::string SystemVersion;
std::string NsightTegraVersion;
cmIDEFlagTable const* DefaultClFlagTable;
cmIDEFlagTable const* DefaultCSharpFlagTable;
cmIDEFlagTable const* DefaultLibFlagTable;
cmIDEFlagTable const* DefaultLinkFlagTable;
cmIDEFlagTable const* DefaultCudaFlagTable;
cmIDEFlagTable const* DefaultCudaHostFlagTable;
cmIDEFlagTable const* DefaultMasmFlagTable;
cmIDEFlagTable const* DefaultNasmFlagTable;
cmIDEFlagTable const* DefaultRcFlagTable;
std::string DefaultCLFlagTableName;
std::string DefaultCSharpFlagTableName;
std::string DefaultLibFlagTableName;
std::string DefaultLinkFlagTableName;
std::string DefaultCudaFlagTableName;
std::string DefaultCudaHostFlagTableName;
std::string DefaultMasmFlagTableName;
std::string DefaultNasmFlagTableName;
std::string DefaultRCFlagTableName;
bool SystemIsWindowsCE;
bool SystemIsWindowsPhone;
bool SystemIsWindowsStore;
......
......@@ -6,12 +6,6 @@
#include "cmDocumentationEntry.h"
#include "cmLocalVisualStudio10Generator.h"
#include "cmMakefile.h"
#include "cmVS11CLFlagTable.h"
#include "cmVS11CSharpFlagTable.h"
#include "cmVS11LibFlagTable.h"
#include "cmVS11LinkFlagTable.h"
#include "cmVS11MASMFlagTable.h"
#include "cmVS11RCFlagTable.h"
static const char vs11generatorName[] = "Visual Studio 11 2012";
......@@ -107,12 +101,12 @@ cmGlobalVisualStudio11Generator::cmGlobalVisualStudio11Generator(
"ProductDir",
vc11Express, cmSystemTools::KeyWOW64_32);
this->DefaultPlatformToolset = "v110";
this->DefaultClFlagTable = cmVS11CLFlagTable;
this->DefaultCSharpFlagTable = cmVS11CSharpFlagTable;
this->DefaultLibFlagTable = cmVS11LibFlagTable;
this->DefaultLinkFlagTable = cmVS11LinkFlagTable;
this->DefaultMasmFlagTable = cmVS11MASMFlagTable;
this->DefaultRcFlagTable = cmVS11RCFlagTable;
this->DefaultCLFlagTableName = "v11";
this->DefaultCSharpFlagTableName = "v11";
this->DefaultLibFlagTableName = "v11";
this->DefaultLinkFlagTableName = "v11";
this->DefaultMasmFlagTableName = "v11";
this->DefaultRCFlagTableName = "v11";
this->Version = VS11;
}
......
......@@ -6,12 +6,6 @@
#include "cmDocumentationEntry.h"
#include "cmLocalVisualStudio10Generator.h"
#include "cmMakefile.h"
#include "cmVS12CLFlagTable.h"
#include "cmVS12CSharpFlagTable.h"
#include "cmVS12LibFlagTable.h"
#include "cmVS12LinkFlagTable.h"
#include "cmVS12MASMFlagTable.h"
#include "cmVS12RCFlagTable.h"
static const char vs12generatorName[] = "Visual Studio 12 2013";
......@@ -90,12 +84,12 @@ cmGlobalVisualStudio12Generator::cmGlobalVisualStudio12Generator(
"ProductDir",
vc12Express, cmSystemTools::KeyWOW64_32);
this->DefaultPlatformToolset = "v120";
this->DefaultClFlagTable = cmVS12CLFlagTable;
this->DefaultCSharpFlagTable = cmVS12CSharpFlagTable;
this->DefaultLibFlagTable = cmVS12LibFlagTable;
this->DefaultLinkFlagTable = cmVS12LinkFlagTable;
this->DefaultMasmFlagTable = cmVS12MASMFlagTable;
this->DefaultRcFlagTable = cmVS12RCFlagTable;
this->DefaultCLFlagTableName = "v12";
this->DefaultCSharpFlagTableName = "v12";
this->DefaultLibFlagTableName = "v12";
this->DefaultLinkFlagTableName = "v12";
this->DefaultMasmFlagTableName = "v12";
this->DefaultRCFlagTableName = "v12";
this->Version = VS12;
}
......
......@@ -6,12 +6,6 @@
#include "cmDocumentationEntry.h"
#include "cmLocalVisualStudio10Generator.h"
#include "cmMakefile.h"
#include "cmVS140CLFlagTable.h"
#include "cmVS140CSharpFlagTable.h"
#include "cmVS140LinkFlagTable.h"
#include "cmVS14LibFlagTable.h"
#include "cmVS14MASMFlagTable.h"
#include "cmVS14RCFlagTable.h"
static const char vs14generatorName[] = "Visual Studio 14 2015";
......@@ -90,12 +84,12 @@ cmGlobalVisualStudio14Generator::cmGlobalVisualStudio14Generator(
"ProductDir",
vc14Express, cmSystemTools::KeyWOW64_32);
this->DefaultPlatformToolset = "v140";
this->DefaultClFlagTable = cmVS140CLFlagTable;
this->DefaultCSharpFlagTable = cmVS140CSharpFlagTable;
this->DefaultLibFlagTable = cmVS14LibFlagTable;
this->DefaultLinkFlagTable = cmVS140LinkFlagTable;
this->DefaultMasmFlagTable = cmVS14MASMFlagTable;
this->DefaultRcFlagTable = cmVS14RCFlagTable;
this->DefaultCLFlagTableName = "v140";
this->DefaultCSharpFlagTableName = "v140";
this->DefaultLibFlagTableName = "v14";
this->DefaultLinkFlagTableName = "v140";
this->DefaultMasmFlagTableName = "v14";
this->DefaultRCFlagTableName = "v14";
this->Version = VS14;
}
......
......@@ -6,9 +6,6 @@
#include "cmDocumentationEntry.h"
#include "cmLocalVisualStudio10Generator.h"
#include "cmMakefile.h"
#include "cmVS141CLFlagTable.h"
#include "cmVS141CSharpFlagTable.h"
#include "cmVS141LinkFlagTable.h"
#include "cmVSSetupHelper.h"
static const char vs15generatorName[] = "Visual Studio 15 2017";
......@@ -84,9 +81,9 @@ cmGlobalVisualStudio15Generator::cmGlobalVisualStudio15Generator(
{
this->ExpressEdition = false;
this->DefaultPlatformToolset = "v141";
this->DefaultClFlagTable = cmVS141CLFlagTable;
this->DefaultCSharpFlagTable = cmVS141CSharpFlagTable;
this->DefaultLinkFlagTable = cmVS141LinkFlagTable;
this->DefaultCLFlagTableName = "v141";
this->DefaultCSharpFlagTableName = "v141";
this->DefaultLinkFlagTableName = "v141";
this->Version = VS15;
}
......
......@@ -37,7 +37,7 @@ static cmVS7FlagTable cmVS7ExtraFlagTable[] = {
// and have EHa passed on the command line by leaving out the table
// entry.
{ 0, 0, 0, 0, 0 }
{ "", "", "", "", 0 }
};
cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator(
......
......@@ -362,7 +362,7 @@ static cmVS7FlagTable cmVS8ExtraFlagTable[] = {
{ "TreatWChar_tAsBuiltInType", "Zc:wchar_t-",
"wchar_t is not a built-in type", "false", 0 },
{ 0, 0, 0, 0, 0 }
{ "", "", "", "", 0 }
};
cmIDEFlagTable const* cmGlobalVisualStudio8Generator::GetExtraFlagTableVS8()
{
......
......@@ -3,13 +3,15 @@
#ifndef cmIDEFlagTable_h
#define cmIDEFlagTable_h
#include <string>
// This is a table mapping XML tag IDE names to command line options
struct cmIDEFlagTable
{
const char* IDEName; // name used in the IDE xml file
const char* commandFlag; // command line flag
const char* comment; // comment
const char* value; // string value
std::string IDEName; // name used in the IDE xml file
std::string commandFlag; // command line flag
std::string comment; // comment
std::string value; // string value
unsigned int special; // flags for special handling requests
enum
{
......
......@@ -97,24 +97,24 @@ bool cmIDEOptions::CheckFlagTable(cmIDEFlagTable const* table,
{
const char* pf = flag.c_str() + 1;
// Look for an entry in the flag table matching this flag.
for (cmIDEFlagTable const* entry = table; entry->IDEName; ++entry) {
for (cmIDEFlagTable const* entry = table; !entry->IDEName.empty(); ++entry) {
bool entry_found = false;
if (entry->special & cmIDEFlagTable::UserValue) {
// This flag table entry accepts a user-specified value. If
// the entry specifies UserRequired we must match only if a
// non-empty value is given.
int n = static_cast<int>(strlen(entry->commandFlag));
if ((strncmp(pf, entry->commandFlag, n) == 0 ||
int n = static_cast<int>(entry->commandFlag.length());
if ((strncmp(pf, entry->commandFlag.c_str(), n) == 0 ||
(entry->special & cmIDEFlagTable::CaseInsensitive &&
cmsysString_strncasecmp(pf, entry->commandFlag, n))) &&
cmsysString_strncasecmp(pf, entry->commandFlag.c_str(), n))) &&
(!(entry->special & cmIDEFlagTable::UserRequired) ||
static_cast<int>(strlen(pf)) > n)) {
this->FlagMapUpdate(entry, std::string(pf + n));
entry_found = true;
}
} else if (strcmp(pf, entry->commandFlag) == 0 ||
} else if (strcmp(pf, entry->commandFlag.c_str()) == 0 ||
(entry->special & cmIDEFlagTable::CaseInsensitive &&
cmsysString_strcasecmp(pf, entry->commandFlag) == 0)) {
cmsysString_strcasecmp(pf, entry->commandFlag.c_str()) == 0)) {
if (entry->special & cmIDEFlagTable::UserFollowing) {
// This flag expects a value in the following argument.
this->DoingFollowing = entry;
......
......@@ -362,7 +362,7 @@ cmVS7FlagTable cmLocalVisualStudio7GeneratorFortranFlagTable[] = {
{ "EnableRecursion", "recursive", "", "true", 0 },
{ "ReentrantCode", "reentrancy", "", "true", 0 },
// done up to Language
{ 0, 0, 0, 0, 0 }
{ "", "", "", "", 0 }
};
// fill the table here currently the comment field is not used for
// anything other than documentation NOTE: Make sure the longer
......@@ -472,7 +472,7 @@ cmVS7FlagTable cmLocalVisualStudio7GeneratorFlagTable[] = {
{ "WarnAsError", "WX", "Treat warnings as errors", "true", 0 },
{ "BrowseInformation", "FR", "Generate browse information", "1", 0 },
{ "StringPooling", "GF", "Enable StringPooling", "true", 0 },
{ 0, 0, 0, 0, 0 }
{ "", "", "", "", 0 }
};
cmVS7FlagTable cmLocalVisualStudio7GeneratorLinkFlagTable[] = {
......@@ -537,7 +537,7 @@ cmVS7FlagTable cmLocalVisualStudio7GeneratorLinkFlagTable[] = {
{ "ModuleDefinitionFile", "DEF:", "add an export def file", "",
cmVS7FlagTable::UserValue },
{ "GenerateMapFile", "MAP", "enable generation of map file", "true", 0 },
{ 0, 0, 0, 0, 0 }
{ "", "", "", "", 0 }
};
cmVS7FlagTable cmLocalVisualStudio7GeneratorFortranLinkFlagTable[] = {
......@@ -545,7 +545,7 @@ cmVS7FlagTable cmLocalVisualStudio7GeneratorFortranLinkFlagTable[] = {
"linkIncrementalNo", 0 },
{ "LinkIncremental", "INCREMENTAL:YES", "link incremental",
"linkIncrementalYes", 0 },
{ 0, 0, 0, 0, 0 }
{ "", "", "", "", 0 }
};
// Helper class to write build event <Tool .../> elements.
......
This diff is collapsed.
static cmVS7FlagTable cmVS10CSharpFlagTable[] = {
{ "ProjectName", "out:", "", "", cmIDEFlagTable::UserValueRequired },
{ "OutputType", "target:exe", "", "Exe", 0 },
{ "OutputType", "target:winexe", "", "Winexe", 0 },
{ "OutputType", "target:library", "", "Library", 0 },
{ "OutputType", "target:module", "", "Module", 0 },
{ "DocumentationFile", "doc", "", "", cmIDEFlagTable::UserValueRequired },
{ "Platform", "platform:x86", "", "x86", 0 },
{ "Platform", "platform:Itanium", "", "Itanium", 0 },
{ "Platform", "platform:x64", "", "x64", 0 },
{ "Platform", "platform:arm", "", "arm", 0 },
{ "Platform", "platform:anycpu32bitpreferred", "", "anycpu32bitpreferred",
0 },
{ "Platform", "platform:anycpu", "", "anycpu", 0 },
{ "References", "reference:", "mit alias", "", 0 },
{ "References", "reference:", "dateiliste", "", 0 },
{ "AddModules", "addmodule:", "", "", cmIDEFlagTable::SemicolonAppendable },
{ "", "link", "", "", 0 },
{ "Win32Resource", "win32res:", "", "", cmIDEFlagTable::UserValueRequired },
{ "ApplicationIcon", "win32icon:", "", "",
cmIDEFlagTable::UserValueRequired },
{ "ApplicationManifest", "win32manifest:", "", "",
cmIDEFlagTable::UserValueRequired },
{ "NoWin32Manifest", "nowin32manifest", "", "true", 0 },
{ "DefineDebug", "debug", "", "true", cmIDEFlagTable::Continue },
{ "DebugSymbols", "debug", "", "true", 0 },
{ "DebugSymbols", "debug-", "", "false", 0 },
{ "DebugSymbols", "debug+", "", "true", 0 },
{ "DebugType", "debug:none", "", "none", 0 },
{ "DebugType", "debug:full", "", "full", 0 },
{ "DebugType", "debug:pdbonly", "", "pdbonly", 0 },
{ "Optimize", "optimize", "", "true", 0 },
{ "Optimize", "optimize-", "", "false", 0 },
{ "Optimize", "optimize+", "", "true", 0 },
{ "TreatWarningsAsErrors", "warnaserror", "", "true", 0 },
{ "TreatWarningsAsErrors", "warnaserror-", "", "false", 0 },
{ "TreatWarningsAsErrors", "warnaserror+", "", "true", 0 },
{ "WarningsAsErrors", "warnaserror", "", "", 0 },
{ "WarningsAsErrors", "warnaserror-", "", "", 0 },