VS: Move toolset flag table lookup to global generator

Move `Get*FlagTable` methods to the global generator and have each VS
generator version pre-populate its default flag table.

Source/cmGlobalVisualStudio10Generator.cxx

@@ -9,6 +9,11 @@
 #include "cmLocalVisualStudio10Generator.h"
 #include "cmMakefile.h"
 #include "cmSourceFile.h"
+#include "cmVS10CLFlagTable.h"
+#include "cmVS10LibFlagTable.h"
+#include "cmVS10LinkFlagTable.h"
+#include "cmVS10MASMFlagTable.h"
+#include "cmVS10RCFlagTable.h"
 #include "cmVisualStudioSlnData.h"
 #include "cmVisualStudioSlnParser.h"
 #include "cmake.h"
@@ -94,6 +99,11 @@ cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(
   this->SystemIsWindowsStore = false;
   this->MSBuildCommandInitialized = false;
   this->DefaultPlatformToolset = "v100";
+  this->DefaultClFlagTable = cmVS10CLFlagTable;
+  this->DefaultLibFlagTable = cmVS10LibFlagTable;
+  this->DefaultLinkFlagTable = cmVS10LinkFlagTable;
+  this->DefaultMasmFlagTable = cmVS10MASMFlagTable;
+  this->DefaultRcFlagTable = cmVS10RCFlagTable;
   this->Version = VS10;
 }
 
@@ -604,3 +614,28 @@ std::string cmGlobalVisualStudio10Generator::GetInstalledNsightTegraVersion()
     version, cmSystemTools::KeyWOW64_32);
   return version;
 }
+
+cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetClFlagTable() const
+{
+  return this->DefaultClFlagTable;
+}
+
+cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetRcFlagTable() const
+{
+  return this->DefaultRcFlagTable;
+}
+
+cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetLibFlagTable() const
+{
+  return this->DefaultLibFlagTable;
+}
+
+cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetLinkFlagTable() const
+{
+  return this->DefaultLinkFlagTable;
+}
+
+cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetMasmFlagTable() const
+{
+  return this->DefaultMasmFlagTable;
+}

Source/cmGlobalVisualStudio10Generator.h

@@ -89,6 +89,12 @@ public:
 
   static std::string GetInstalledNsightTegraVersion();
 
+  cmIDEFlagTable const* GetClFlagTable() const;
+  cmIDEFlagTable const* GetRcFlagTable() const;
+  cmIDEFlagTable const* GetLibFlagTable() const;
+  cmIDEFlagTable const* GetLinkFlagTable() const;
+  cmIDEFlagTable const* GetMasmFlagTable() const;
+
 protected:
   virtual void Generate();
   virtual bool InitializeSystem(cmMakefile* mf);
@@ -112,6 +118,11 @@ protected:
   std::string SystemName;
   std::string SystemVersion;
   std::string NsightTegraVersion;
+  cmIDEFlagTable const* DefaultClFlagTable;
+  cmIDEFlagTable const* DefaultLibFlagTable;
+  cmIDEFlagTable const* DefaultLinkFlagTable;
+  cmIDEFlagTable const* DefaultMasmFlagTable;
+  cmIDEFlagTable const* DefaultRcFlagTable;
   bool SystemIsWindowsCE;
   bool SystemIsWindowsPhone;
   bool SystemIsWindowsStore;

Source/cmGlobalVisualStudio11Generator.cxx

@@ -5,6 +5,11 @@
 #include "cmAlgorithms.h"
 #include "cmLocalVisualStudio10Generator.h"
 #include "cmMakefile.h"
+#include "cmVS11CLFlagTable.h"
+#include "cmVS11LibFlagTable.h"
+#include "cmVS11LinkFlagTable.h"
+#include "cmVS11MASMFlagTable.h"
+#include "cmVS11RCFlagTable.h"
 
 static const char vs11generatorName[] = "Visual Studio 11 2012";
 
@@ -101,6 +106,11 @@ cmGlobalVisualStudio11Generator::cmGlobalVisualStudio11Generator(
     "ProductDir",
     vc11Express, cmSystemTools::KeyWOW64_32);
   this->DefaultPlatformToolset = "v110";
+  this->DefaultClFlagTable = cmVS11CLFlagTable;
+  this->DefaultLibFlagTable = cmVS11LibFlagTable;
+  this->DefaultLinkFlagTable = cmVS11LinkFlagTable;
+  this->DefaultMasmFlagTable = cmVS11MASMFlagTable;
+  this->DefaultRcFlagTable = cmVS11RCFlagTable;
   this->Version = VS11;
 }
 

Source/cmGlobalVisualStudio12Generator.cxx

@@ -5,6 +5,11 @@
 #include "cmAlgorithms.h"
 #include "cmLocalVisualStudio10Generator.h"
 #include "cmMakefile.h"
+#include "cmVS12CLFlagTable.h"
+#include "cmVS12LibFlagTable.h"
+#include "cmVS12LinkFlagTable.h"
+#include "cmVS12MASMFlagTable.h"
+#include "cmVS12RCFlagTable.h"
 
 static const char vs12generatorName[] = "Visual Studio 12 2013";
 
@@ -83,6 +88,11 @@ cmGlobalVisualStudio12Generator::cmGlobalVisualStudio12Generator(
     "ProductDir",
     vc12Express, cmSystemTools::KeyWOW64_32);
   this->DefaultPlatformToolset = "v120";
+  this->DefaultClFlagTable = cmVS12CLFlagTable;
+  this->DefaultLibFlagTable = cmVS12LibFlagTable;
+  this->DefaultLinkFlagTable = cmVS12LinkFlagTable;
+  this->DefaultMasmFlagTable = cmVS12MASMFlagTable;
+  this->DefaultRcFlagTable = cmVS12RCFlagTable;
   this->Version = VS12;
 }
 

Source/cmGlobalVisualStudio14Generator.cxx

@@ -5,6 +5,11 @@
 #include "cmAlgorithms.h"
 #include "cmLocalVisualStudio10Generator.h"
 #include "cmMakefile.h"
+#include "cmVS140CLFlagTable.h"
+#include "cmVS14LibFlagTable.h"
+#include "cmVS14LinkFlagTable.h"
+#include "cmVS14MASMFlagTable.h"
+#include "cmVS14RCFlagTable.h"
 
 static const char vs14generatorName[] = "Visual Studio 14 2015";
 
@@ -83,6 +88,11 @@ cmGlobalVisualStudio14Generator::cmGlobalVisualStudio14Generator(
     "ProductDir",
     vc14Express, cmSystemTools::KeyWOW64_32);
   this->DefaultPlatformToolset = "v140";
+  this->DefaultClFlagTable = cmVS140CLFlagTable;
+  this->DefaultLibFlagTable = cmVS14LibFlagTable;
+  this->DefaultLinkFlagTable = cmVS14LinkFlagTable;
+  this->DefaultMasmFlagTable = cmVS14MASMFlagTable;
+  this->DefaultRcFlagTable = cmVS14RCFlagTable;
   this->Version = VS14;
 }
 

Source/cmGlobalVisualStudio15Generator.cxx

@@ -5,6 +5,7 @@
 #include "cmAlgorithms.h"
 #include "cmLocalVisualStudio10Generator.h"
 #include "cmMakefile.h"
+#include "cmVS141CLFlagTable.h"
 
 static const char vs15generatorName[] = "Visual Studio 15";
 
@@ -80,6 +81,7 @@ cmGlobalVisualStudio15Generator::cmGlobalVisualStudio15Generator(
     "ProductDir",
     vc15Express, cmSystemTools::KeyWOW64_32);
   this->DefaultPlatformToolset = "v141";
+  this->DefaultClFlagTable = cmVS141CLFlagTable;
   this->Version = VS15;
 }
 

Source/cmVisualStudio10TargetGenerator.cxx

@@ -10,27 +10,6 @@
 #include "cmLocalVisualStudio7Generator.h"
 #include "cmMakefile.h"
 #include "cmSourceFile.h"
-#include "cmVS10CLFlagTable.h"
-#include "cmVS10LibFlagTable.h"
-#include "cmVS10LinkFlagTable.h"
-#include "cmVS10MASMFlagTable.h"
-#include "cmVS10RCFlagTable.h"
-#include "cmVS11CLFlagTable.h"
-#include "cmVS11LibFlagTable.h"
-#include "cmVS11LinkFlagTable.h"
-#include "cmVS11MASMFlagTable.h"
-#include "cmVS11RCFlagTable.h"
-#include "cmVS12CLFlagTable.h"
-#include "cmVS12LibFlagTable.h"
-#include "cmVS12LinkFlagTable.h"
-#include "cmVS12MASMFlagTable.h"
-#include "cmVS12RCFlagTable.h"
-#include "cmVS140CLFlagTable.h"
-#include "cmVS141CLFlagTable.h"
-#include "cmVS14LibFlagTable.h"
-#include "cmVS14LinkFlagTable.h"
-#include "cmVS14MASMFlagTable.h"
-#include "cmVS14RCFlagTable.h"
 #include "cmVisualStudioGeneratorOptions.h"
 #include "windows.h"
 
@@ -38,102 +17,6 @@
 
 static std::string const kWINDOWS_7_1_SDK = "Windows7.1SDK";
 
-cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetClFlagTable() const
-{
-  if (this->MSTools) {
-    cmGlobalVisualStudioGenerator::VSVersion v =
-      this->LocalGenerator->GetVersion();
-    if (v >= cmGlobalVisualStudioGenerator::VS14) {
-      // FIXME: All flag table selection should be based on the toolset name.
-      // See issue #16153.  For now, treat VS 15's toolset as a special case.
-      const char* toolset = this->GlobalGenerator->GetPlatformToolset();
-      if (toolset && cmHasLiteralPrefix(toolset, "v141")) {
-        return cmVS141CLFlagTable;
-      }
-      return cmVS140CLFlagTable;
-    } else if (v >= cmGlobalVisualStudioGenerator::VS12) {
-      return cmVS12CLFlagTable;
-    } else if (v == cmGlobalVisualStudioGenerator::VS11) {
-      return cmVS11CLFlagTable;
-    } else {
-      return cmVS10CLFlagTable;
-    }
-  }
-  return 0;
-}
-
-cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetRcFlagTable() const
-{
-  if (this->MSTools) {
-    cmGlobalVisualStudioGenerator::VSVersion v =
-      this->LocalGenerator->GetVersion();
-    if (v >= cmGlobalVisualStudioGenerator::VS14) {
-      return cmVS14RCFlagTable;
-    } else if (v >= cmGlobalVisualStudioGenerator::VS12) {
-      return cmVS12RCFlagTable;
-    } else if (v == cmGlobalVisualStudioGenerator::VS11) {
-      return cmVS11RCFlagTable;
-    } else {
-      return cmVS10RCFlagTable;
-    }
-  }
-  return 0;
-}
-
-cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetLibFlagTable() const
-{
-  if (this->MSTools) {
-    cmGlobalVisualStudioGenerator::VSVersion v =
-      this->LocalGenerator->GetVersion();
-    if (v >= cmGlobalVisualStudioGenerator::VS14) {
-      return cmVS14LibFlagTable;
-    } else if (v >= cmGlobalVisualStudioGenerator::VS12) {
-      return cmVS12LibFlagTable;
-    } else if (v == cmGlobalVisualStudioGenerator::VS11) {
-      return cmVS11LibFlagTable;
-    } else {
-      return cmVS10LibFlagTable;
-    }
-  }
-  return 0;
-}
-
-cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetLinkFlagTable() const
-{
-  if (this->MSTools) {
-    cmGlobalVisualStudioGenerator::VSVersion v =
-      this->LocalGenerator->GetVersion();
-    if (v >= cmGlobalVisualStudioGenerator::VS14) {
-      return cmVS14LinkFlagTable;
-    } else if (v >= cmGlobalVisualStudioGenerator::VS12) {
-      return cmVS12LinkFlagTable;
-    } else if (v == cmGlobalVisualStudioGenerator::VS11) {
-      return cmVS11LinkFlagTable;
-    } else {
-      return cmVS10LinkFlagTable;
-    }
-  }
-  return 0;
-}
-
-cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetMasmFlagTable() const
-{
-  if (this->MSTools) {
-    cmGlobalVisualStudioGenerator::VSVersion v =
-      this->LocalGenerator->GetVersion();
-    if (v >= cmGlobalVisualStudioGenerator::VS14) {
-      return cmVS14MASMFlagTable;
-    } else if (v >= cmGlobalVisualStudioGenerator::VS12) {
-      return cmVS12MASMFlagTable;
-    } else if (v == cmGlobalVisualStudioGenerator::VS11) {
-      return cmVS11MASMFlagTable;
-    } else {
-      return cmVS10MASMFlagTable;
-    }
-  }
-  return 0;
-}
-
 static std::string cmVS10EscapeXML(std::string arg)
 {
   cmSystemTools::ReplaceString(arg, "&", "&");
@@ -1533,9 +1416,11 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
       (*this->BuildFileStream) << firstString;
       firstString = ""; // only do firstString once
       hasFlags = true;
+      cmGlobalVisualStudio10Generator* gg =
+        static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
       cmVisualStudioGeneratorOptions clOptions(
         this->LocalGenerator, cmVisualStudioGeneratorOptions::Compiler,
-        this->GetClFlagTable(), 0, this);
+        gg->GetClFlagTable(), 0, this);
       if (compileAs) {
         clOptions.AddFlag("CompileAs", compileAs);
       }
@@ -1696,8 +1581,10 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
   // copied from cmLocalVisualStudio7Generator.cxx 805
   // TODO: Integrate code below with cmLocalVisualStudio7Generator.
 
+  cmGlobalVisualStudio10Generator* gg =
+    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
   CM_AUTO_PTR<Options> pOptions(new Options(
-    this->LocalGenerator, Options::Compiler, this->GetClFlagTable()));
+    this->LocalGenerator, Options::Compiler, gg->GetClFlagTable()));
   Options& clOptions = *pOptions;
 
   std::string flags;
@@ -1861,8 +1748,10 @@ bool cmVisualStudio10TargetGenerator::ComputeRcOptions()
 bool cmVisualStudio10TargetGenerator::ComputeRcOptions(
   std::string const& configName)
 {
+  cmGlobalVisualStudio10Generator* gg =
+    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
   CM_AUTO_PTR<Options> pOptions(new Options(
-    this->LocalGenerator, Options::ResourceCompiler, this->GetRcFlagTable()));
+    this->LocalGenerator, Options::ResourceCompiler, gg->GetRcFlagTable()));
   Options& rcOptions = *pOptions;
 
   std::string CONFIG = cmSystemTools::UpperCase(configName);
@@ -1918,8 +1807,10 @@ bool cmVisualStudio10TargetGenerator::ComputeMasmOptions()
 bool cmVisualStudio10TargetGenerator::ComputeMasmOptions(
   std::string const& configName)
 {
+  cmGlobalVisualStudio10Generator* gg =
+    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
   CM_AUTO_PTR<Options> pOptions(new Options(
-    this->LocalGenerator, Options::MasmCompiler, this->GetMasmFlagTable()));
+    this->LocalGenerator, Options::MasmCompiler, gg->GetMasmFlagTable()));
   Options& masmOptions = *pOptions;
 
   std::string CONFIG = cmSystemTools::UpperCase(configName);
@@ -1968,9 +1859,11 @@ void cmVisualStudio10TargetGenerator::WriteLibOptions(
     libflags, cmSystemTools::UpperCase(config), this->GeneratorTarget);
   if (!libflags.empty()) {
     this->WriteString("<Lib>\n", 2);
+    cmGlobalVisualStudio10Generator* gg =
+      static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
     cmVisualStudioGeneratorOptions libOptions(
       this->LocalGenerator, cmVisualStudioGeneratorOptions::Linker,
-      this->GetLibFlagTable(), 0, this);
+      gg->GetLibFlagTable(), 0, this);
     libOptions.Parse(libflags.c_str());
     libOptions.OutputAdditionalOptions(*this->BuildFileStream, "      ", "");
     libOptions.OutputFlagMap(*this->BuildFileStream, "      ");
@@ -2163,8 +2056,10 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions()
 bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
   std::string const& config)
 {
+  cmGlobalVisualStudio10Generator* gg =
+    static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
   CM_AUTO_PTR<Options> pOptions(new Options(
-    this->LocalGenerator, Options::Linker, this->GetLinkFlagTable(), 0, this));
+    this->LocalGenerator, Options::Linker, gg->GetLinkFlagTable(), 0, this));
   Options& linkOptions = *pOptions;
 
   const std::string& linkLanguage =

Source/cmVisualStudio10TargetGenerator.h

@@ -121,12 +121,6 @@ private:
   bool IsXamlHeader(const std::string& headerFile);
   bool IsXamlSource(const std::string& headerFile);
 
-  cmIDEFlagTable const* GetClFlagTable() const;
-  cmIDEFlagTable const* GetRcFlagTable() const;
-  cmIDEFlagTable const* GetLibFlagTable() const;
-  cmIDEFlagTable const* GetLinkFlagTable() const;
-  cmIDEFlagTable const* GetMasmFlagTable() const;
-
   bool ForceOld(const std::string& source) const;
 
 private: