Refactor: Prepare Ninja generator for multi-config

1 files changed, 73 insertions, 50 deletions

diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index 767f4e0..436503b 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -2,6 +2,7 @@
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmMakefileTargetGenerator.h"
 
+#include <cassert>
 #include <cstdio>
 #include <memory>
 #include <sstream>
@@ -85,6 +86,13 @@ cmMakefileTargetGenerator* cmMakefileTargetGenerator::New(
   return result;
 }
 
+std::string cmMakefileTargetGenerator::GetConfigName()
+{
+  auto const& configNames = this->LocalGenerator->GetConfigNames();
+  assert(configNames.size() == 1);
+  return configNames.front();
+}
+
 void cmMakefileTargetGenerator::GetTargetLinkFlags(
   std::string& flags, const std::string& linkLanguage)
 {
@@ -92,17 +100,18 @@ void cmMakefileTargetGenerator::GetTargetLinkFlags(
     flags, this->GeneratorTarget->GetSafeProperty("LINK_FLAGS"));
 
   std::string linkFlagsConfig =
-    cmStrCat("LINK_FLAGS_", cmSystemTools::UpperCase(this->ConfigName));
+    cmStrCat("LINK_FLAGS_", cmSystemTools::UpperCase(this->GetConfigName()));
   this->LocalGenerator->AppendFlags(
     flags, this->GeneratorTarget->GetSafeProperty(linkFlagsConfig));
 
   std::vector<std::string> opts;
-  this->GeneratorTarget->GetLinkOptions(opts, this->ConfigName, linkLanguage);
+  this->GeneratorTarget->GetLinkOptions(opts, this->GetConfigName(),
+                                        linkLanguage);
   // LINK_OPTIONS are escaped.
   this->LocalGenerator->AppendCompileOptions(flags, opts);
 
   this->LocalGenerator->AppendPositionIndependentLinkerFlags(
-    flags, this->GeneratorTarget, this->ConfigName, linkLanguage);
+    flags, this->GeneratorTarget, this->GetConfigName(), linkLanguage);
 }
 
 void cmMakefileTargetGenerator::CreateRuleFile()
@@ -154,10 +163,10 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
   auto evaluatedFiles =
     [this](const char* prop_value) -> std::vector<std::string> {
     std::vector<std::string> files;
-    cmExpandList(
-      cmGeneratorExpression::Evaluate(prop_value, this->LocalGenerator,
-                                      this->ConfigName, this->GeneratorTarget),
-      files);
+    cmExpandList(cmGeneratorExpression::Evaluate(
+                   prop_value, this->LocalGenerator, this->GetConfigName(),
+                   this->GeneratorTarget),
+                 files);
     return files;
   };
 
@@ -187,12 +196,13 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
   // First generate the object rule files.  Save a list of all object
   // files for this target.
   std::vector<cmSourceFile const*> customCommands;
-  this->GeneratorTarget->GetCustomCommands(customCommands, this->ConfigName);
+  this->GeneratorTarget->GetCustomCommands(customCommands,
+                                           this->GetConfigName());
   std::string currentBinDir =
     this->LocalGenerator->GetCurrentBinaryDirectory();
   for (cmSourceFile const* sf : customCommands) {
-    cmCustomCommandGenerator ccg(*sf->GetCustomCommand(), this->ConfigName,
-                                 this->LocalGenerator);
+    cmCustomCommandGenerator ccg(*sf->GetCustomCommand(),
+                                 this->GetConfigName(), this->LocalGenerator);
     this->GenerateCustomRuleFile(ccg);
     if (clean) {
       const std::vector<std::string>& outputs = ccg.GetOutputs();
@@ -220,7 +230,8 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
              this->GeneratorTarget->GetPostBuildCommands());
 
     for (const auto& be : buildEventCommands) {
-      cmCustomCommandGenerator beg(be, this->ConfigName, this->LocalGenerator);
+      cmCustomCommandGenerator beg(be, this->GetConfigName(),
+                                   this->LocalGenerator);
       const std::vector<std::string>& byproducts = beg.GetByproducts();
       for (std::string const& byproduct : byproducts) {
         this->CleanFiles.insert(
@@ -230,17 +241,19 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
     }
   }
   std::vector<cmSourceFile const*> headerSources;
-  this->GeneratorTarget->GetHeaderSources(headerSources, this->ConfigName);
+  this->GeneratorTarget->GetHeaderSources(headerSources,
+                                          this->GetConfigName());
   this->OSXBundleGenerator->GenerateMacOSXContentStatements(
-    headerSources, this->MacOSXContentGenerator);
+    headerSources, this->MacOSXContentGenerator, this->GetConfigName());
   std::vector<cmSourceFile const*> extraSources;
-  this->GeneratorTarget->GetExtraSources(extraSources, this->ConfigName);
+  this->GeneratorTarget->GetExtraSources(extraSources, this->GetConfigName());
   this->OSXBundleGenerator->GenerateMacOSXContentStatements(
-    extraSources, this->MacOSXContentGenerator);
+    extraSources, this->MacOSXContentGenerator, this->GetConfigName());
   const char* pchExtension =
     this->Makefile->GetDefinition("CMAKE_PCH_EXTENSION");
   std::vector<cmSourceFile const*> externalObjects;
-  this->GeneratorTarget->GetExternalObjects(externalObjects, this->ConfigName);
+  this->GeneratorTarget->GetExternalObjects(externalObjects,
+                                            this->GetConfigName());
   for (cmSourceFile const* sf : externalObjects) {
     auto const& objectFileName = sf->GetFullPath();
     if (!cmSystemTools::StringEndsWith(objectFileName, pchExtension)) {
@@ -248,7 +261,8 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
     }
   }
   std::vector<cmSourceFile const*> objectSources;
-  this->GeneratorTarget->GetObjectSources(objectSources, this->ConfigName);
+  this->GeneratorTarget->GetObjectSources(objectSources,
+                                          this->GetConfigName());
   for (cmSourceFile const* sf : objectSources) {
     // Generate this object file's rule file.
     this->WriteObjectRuleFiles(*sf);
@@ -334,9 +348,9 @@ void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
   }
 
   for (std::string const& language : languages) {
-    std::string flags = this->GetFlags(language);
-    std::string defines = this->GetDefines(language);
-    std::string includes = this->GetIncludes(language);
+    std::string flags = this->GetFlags(language, this->GetConfigName());
+    std::string defines = this->GetDefines(language, this->GetConfigName());
+    std::string includes = this->GetIncludes(language, this->GetConfigName());
     // Escape comment characters so they do not terminate assignment.
     cmSystemTools::ReplaceString(flags, "#", "\\#");
     cmSystemTools::ReplaceString(defines, "#", "\\#");
@@ -348,7 +362,7 @@ void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
 }
 
 void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(
-  cmSourceFile const& source, const char* pkgloc)
+  cmSourceFile const& source, const char* pkgloc, const std::string& config)
 {
   // Skip OS X content when not building a Framework or Bundle.
   if (!this->Generator->GetGeneratorTarget()->IsBundleOnApple()) {
@@ -356,7 +370,8 @@ void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(
   }
 
   std::string macdir =
-    this->Generator->OSXBundleGenerator->InitMacOSXContentDirectory(pkgloc);
+    this->Generator->OSXBundleGenerator->InitMacOSXContentDirectory(pkgloc,
+                                                                    config);
 
   // Get the input file location.
   std::string const& input = source.GetFullPath();
@@ -451,7 +466,7 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
   // generate the depend scanning rule
   this->WriteObjectDependRules(source, depends);
 
-  std::string config = this->LocalGenerator->GetConfigName();
+  std::string config = this->GetConfigName();
   std::string configUpper = cmSystemTools::UpperCase(config);
 
   // Add precompile headers dependencies
@@ -593,16 +608,17 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
   {
     std::string targetFullPathReal;
     std::string targetFullPathPDB;
-    std::string targetFullPathCompilePDB = this->ComputeTargetCompilePDB();
+    std::string targetFullPathCompilePDB =
+      this->ComputeTargetCompilePDB(this->GetConfigName());
     if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE ||
         this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY ||
         this->GeneratorTarget->GetType() == cmStateEnums::SHARED_LIBRARY ||
         this->GeneratorTarget->GetType() == cmStateEnums::MODULE_LIBRARY) {
       targetFullPathReal = this->GeneratorTarget->GetFullPath(
-        this->ConfigName, cmStateEnums::RuntimeBinaryArtifact, true);
-      targetFullPathPDB =
-        cmStrCat(this->GeneratorTarget->GetPDBDirectory(this->ConfigName), '/',
-                 this->GeneratorTarget->GetPDBName(this->ConfigName));
+        this->GetConfigName(), cmStateEnums::RuntimeBinaryArtifact, true);
+      targetFullPathPDB = cmStrCat(
+        this->GeneratorTarget->GetPDBDirectory(this->GetConfigName()), '/',
+        this->GeneratorTarget->GetPDBName(this->GetConfigName()));
     }
 
     targetOutPathReal = this->LocalGenerator->ConvertToOutputFormat(
@@ -708,13 +724,15 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
       std::string workingDirectory = cmSystemTools::CollapseFullPath(
         this->LocalGenerator->GetCurrentBinaryDirectory());
       compileCommand.replace(compileCommand.find(langFlags), langFlags.size(),
-                             this->GetFlags(lang));
+                             this->GetFlags(lang, this->GetConfigName()));
       std::string langDefines = std::string("$(") + lang + "_DEFINES)";
       compileCommand.replace(compileCommand.find(langDefines),
-                             langDefines.size(), this->GetDefines(lang));
+                             langDefines.size(),
+                             this->GetDefines(lang, this->GetConfigName()));
       std::string langIncludes = std::string("$(") + lang + "_INCLUDES)";
       compileCommand.replace(compileCommand.find(langIncludes),
-                             langIncludes.size(), this->GetIncludes(lang));
+                             langIncludes.size(),
+                             this->GetIncludes(lang, this->GetConfigName()));
 
       const char* eliminate[] = {
         this->Makefile->GetDefinition("CMAKE_START_TEMP_FILE"),
@@ -1068,7 +1086,8 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
     << "# Targets to which this target links.\n"
     << "set(CMAKE_TARGET_LINKED_INFO_FILES\n";
     /* clang-format on */
-    std::vector<std::string> dirs = this->GetLinkedTargetDirectories();
+    std::vector<std::string> dirs =
+      this->GetLinkedTargetDirectories(this->GetConfigName());
     for (std::string const& d : dirs) {
       *this->InfoFileStream << "  \"" << d << "/DependInfo.cmake\"\n";
     }
@@ -1171,7 +1190,7 @@ void cmMakefileTargetGenerator::DriveCustomCommands(
     sources, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
   for (cmSourceFile* source : sources) {
     if (cmCustomCommand* cc = source->GetCustomCommand()) {
-      cmCustomCommandGenerator ccg(*cc, this->ConfigName,
+      cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
                                    this->LocalGenerator);
       cmAppend(depends, ccg.GetOutputs());
     }
@@ -1429,7 +1448,7 @@ void cmMakefileTargetGenerator::AppendTargetDepends(
   }
 
   // Loop over all library dependencies.
-  const std::string& cfg = this->LocalGenerator->GetConfigName();
+  const std::string& cfg = this->GetConfigName();
   if (cmComputeLinkInformation* cli =
         this->GeneratorTarget->GetLinkInformation(cfg)) {
     cmAppend(depends, cli->GetDepends());
@@ -1474,13 +1493,13 @@ void cmMakefileTargetGenerator::AppendLinkDepends(
 
   // Add a dependency on user-specified manifest files, if any.
   std::vector<cmSourceFile const*> manifest_srcs;
-  this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
+  this->GeneratorTarget->GetManifests(manifest_srcs, this->GetConfigName());
   for (cmSourceFile const* manifest_src : manifest_srcs) {
     depends.push_back(manifest_src->GetFullPath());
   }
 
   // Add user-specified dependencies.
-  this->GeneratorTarget->GetLinkDepends(depends, this->ConfigName,
+  this->GeneratorTarget->GetLinkDepends(depends, this->GetConfigName(),
                                         linkLanguage);
 }
 
@@ -1488,10 +1507,11 @@ std::string cmMakefileTargetGenerator::GetLinkRule(
   const std::string& linkRuleVar)
 {
   std::string linkRule = this->Makefile->GetRequiredDefinition(linkRuleVar);
-  if (this->GeneratorTarget->HasImplibGNUtoMS(this->ConfigName)) {
-    std::string ruleVar = cmStrCat(
-      "CMAKE_", this->GeneratorTarget->GetLinkerLanguage(this->ConfigName),
-      "_GNUtoMS_RULE");
+  if (this->GeneratorTarget->HasImplibGNUtoMS(this->GetConfigName())) {
+    std::string ruleVar =
+      cmStrCat("CMAKE_",
+               this->GeneratorTarget->GetLinkerLanguage(this->GetConfigName()),
+               "_GNUtoMS_RULE");
     if (const char* rule = this->Makefile->GetDefinition(ruleVar)) {
       linkRule += rule;
     }
@@ -1630,7 +1650,7 @@ void cmMakefileTargetGenerator::CreateLinkLibs(
   std::string frameworkPath;
   std::string linkPath;
   cmComputeLinkInformation* pcli =
-    this->GeneratorTarget->GetLinkInformation(this->ConfigName);
+    this->GeneratorTarget->GetLinkInformation(this->GetConfigName());
   this->LocalGenerator->OutputLinkLibraries(pcli, linkLineComputer, linkLibs,
                                             frameworkPath, linkPath);
   linkLibs = frameworkPath + linkPath + linkLibs;
@@ -1638,9 +1658,10 @@ void cmMakefileTargetGenerator::CreateLinkLibs(
   if (useResponseFile &&
       linkLibs.find_first_not_of(' ') != std::string::npos) {
     // Lookup the response file reference flag.
-    std::string responseFlagVar = cmStrCat(
-      "CMAKE_", this->GeneratorTarget->GetLinkerLanguage(this->ConfigName),
-      "_RESPONSE_FILE_LINK_FLAG");
+    std::string responseFlagVar =
+      cmStrCat("CMAKE_",
+               this->GeneratorTarget->GetLinkerLanguage(this->GetConfigName()),
+               "_RESPONSE_FILE_LINK_FLAG");
     const char* responseFlag = this->Makefile->GetDefinition(responseFlagVar);
     if (!responseFlag) {
       responseFlag = "@";
@@ -1675,9 +1696,10 @@ void cmMakefileTargetGenerator::CreateObjectLists(
     this->WriteObjectsStrings(object_strings, responseFileLimit);
 
     // Lookup the response file reference flag.
-    std::string responseFlagVar = cmStrCat(
-      "CMAKE_", this->GeneratorTarget->GetLinkerLanguage(this->ConfigName),
-      "_RESPONSE_FILE_LINK_FLAG");
+    std::string responseFlagVar =
+      cmStrCat("CMAKE_",
+               this->GeneratorTarget->GetLinkerLanguage(this->GetConfigName()),
+               "_RESPONSE_FILE_LINK_FLAG");
     const char* responseFlag = this->Makefile->GetDefinition(responseFlagVar);
     if (!responseFlag) {
       responseFlag = "@";
@@ -1716,7 +1738,8 @@ void cmMakefileTargetGenerator::CreateObjectLists(
 }
 
 void cmMakefileTargetGenerator::AddIncludeFlags(std::string& flags,
-                                                const std::string& lang)
+                                                const std::string& lang,
+                                                const std::string& /*config*/)
 {
   std::string responseVar =
     cmStrCat("CMAKE_", lang, "_USE_RESPONSE_FILE_FOR_INCLUDES");
@@ -1724,11 +1747,11 @@ void cmMakefileTargetGenerator::AddIncludeFlags(std::string& flags,
 
   std::vector<std::string> includes;
   this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
-                                              lang, this->ConfigName);
+                                              lang, this->GetConfigName());
 
   std::string includeFlags = this->LocalGenerator->GetIncludeFlags(
     includes, this->GeneratorTarget, lang, false, useResponseFile,
-    this->ConfigName);
+    this->GetConfigName());
   if (includeFlags.empty()) {
     return;
   }