Merge topic 'extend-compile-language-genex'

506fda1c Genex: Enable COMPILE_LANGUAGE for INCLUDE_DIRECTORIES with VS and Xcode
c2f79c98 Genex: Enable COMPILE_LANGUAGE for COMPILE_DEFINITIONS with VS and Xcode
0795d25b cmVisualStudio10TargetGenerator: Factor out include dir computation
1ab4d186 cmLocalVisualStudio7Generator: Clarify variable name of compiled language
07e1a743 cmLocalVisualStudio7Generator: Clarify condition for target that compiles

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !1657

5 files changed, 102 insertions, 79 deletions

diff --git a/Source/cmGeneratorExpressionNode.cxx b/Source/cmGeneratorExpressionNode.cxx
index 3d311d6..34ef45f 100644
--- a/Source/cmGeneratorExpressionNode.cxx
+++ b/Source/cmGeneratorExpressionNode.cxx
@@ -805,7 +805,7 @@ static const struct CompileLanguageNode : public cmGeneratorExpressionNode
     const std::vector<std::string>& parameters,
     cmGeneratorExpressionContext* context,
     const GeneratorExpressionContent* content,
-    cmGeneratorExpressionDAGChecker* dagChecker) const override
+    cmGeneratorExpressionDAGChecker* /*dagChecker*/) const override
   {
     if (context->Language.empty()) {
       reportError(
@@ -827,33 +827,14 @@ static const struct CompileLanguageNode : public cmGeneratorExpressionNode
       return std::string();
     }
     std::string genName = gg->GetName();
-    if (genName.find("Visual Studio") != std::string::npos) {
-      if (dagChecker && (dagChecker->EvaluatingCompileDefinitions() ||
-                         dagChecker->EvaluatingIncludeDirectories())) {
-        reportError(
-          context, content->GetOriginalExpression(),
-          "$<COMPILE_LANGUAGE:...> may only be used for COMPILE_OPTIONS "
-          "and file(GENERATE) with the Visual Studio generator.");
-        return std::string();
-      }
-    } else if (genName.find("Xcode") != std::string::npos) {
-      if (dagChecker && (dagChecker->EvaluatingCompileDefinitions() ||
-                         dagChecker->EvaluatingIncludeDirectories())) {
-        reportError(
-          context, content->GetOriginalExpression(),
-          "$<COMPILE_LANGUAGE:...> may only be used for COMPILE_OPTIONS "
-          "and file(GENERATE) with the Xcode generator.");
-        return std::string();
-      }
-    } else {
-      if (genName.find("Makefiles") == std::string::npos &&
-          genName.find("Ninja") == std::string::npos &&
-          genName.find("Watcom WMake") == std::string::npos) {
-        reportError(
-          context, content->GetOriginalExpression(),
-          "$<COMPILE_LANGUAGE:...> not supported for this generator.");
-        return std::string();
-      }
+    if (genName.find("Makefiles") == std::string::npos &&
+        genName.find("Ninja") == std::string::npos &&
+        genName.find("Visual Studio") == std::string::npos &&
+        genName.find("Xcode") == std::string::npos &&
+        genName.find("Watcom WMake") == std::string::npos) {
+      reportError(context, content->GetOriginalExpression(),
+                  "$<COMPILE_LANGUAGE:...> not supported for this generator.");
+      return std::string();
     }
     if (parameters.empty()) {
       return context->Language;
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 338c2b4..bd51f60 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -1703,6 +1703,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
       gtgt->GetName().c_str());
     return;
   }
+  std::string const& langForPreprocessor = llang;
 
   if (gtgt->IsIPOEnabled(llang, configName)) {
     const char* ltoValue =
@@ -1723,7 +1724,10 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
     this->AppendDefines(ppDefs, exportMacro);
   }
   std::vector<std::string> targetDefines;
-  gtgt->GetCompileDefinitions(targetDefines, configName, "C");
+  if (!langForPreprocessor.empty()) {
+    gtgt->GetCompileDefinitions(targetDefines, configName,
+                                langForPreprocessor);
+  }
   this->AppendDefines(ppDefs, targetDefines);
   buildSettings->AddAttribute("GCC_PREPROCESSOR_DEFINITIONS",
                               ppDefs.CreateList());
@@ -1996,8 +2000,10 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
   const bool emitSystemIncludes = this->XcodeVersion >= 83;
 
   std::vector<std::string> includes;
-  this->CurrentLocalGenerator->GetIncludeDirectories(includes, gtgt, "C",
-                                                     configName);
+  if (!langForPreprocessor.empty()) {
+    this->CurrentLocalGenerator->GetIncludeDirectories(
+      includes, gtgt, langForPreprocessor, configName);
+  }
   std::set<std::string> emitted;
   emitted.insert("/System/Library/Frameworks");
 
diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx
index eccd4d0..59c20a9 100644
--- a/Source/cmLocalVisualStudio7Generator.cxx
+++ b/Source/cmLocalVisualStudio7Generator.cxx
@@ -637,7 +637,8 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
     configType = projectType;
   }
   std::string flags;
-  if (strcmp(configType, "10") != 0) {
+  std::string langForClCompile;
+  if (target->GetType() <= cmStateEnums::OBJECT_LIBRARY) {
     const std::string& linkLanguage =
       (this->FortranProject ? std::string("Fortran")
                             : target->GetLinkerLanguage(configName));
@@ -647,10 +648,11 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
         target->GetName().c_str());
       return;
     }
-    if (linkLanguage == "C" || linkLanguage == "CXX" ||
-        linkLanguage == "Fortran") {
+    langForClCompile = linkLanguage;
+    if (langForClCompile == "C" || langForClCompile == "CXX" ||
+        langForClCompile == "Fortran") {
       std::string baseFlagVar = "CMAKE_";
-      baseFlagVar += linkLanguage;
+      baseFlagVar += langForClCompile;
       baseFlagVar += "_FLAGS";
       flags = this->Makefile->GetRequiredDefinition(baseFlagVar.c_str());
       std::string flagVar =
@@ -667,7 +669,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
     }
 
     // Add the target-specific flags.
-    this->AddCompileOptions(flags, target, linkLanguage, configName);
+    this->AddCompileOptions(flags, target, langForClCompile, configName);
 
     // Check IPO related warning/error.
     target->IsIPOEnabled(linkLanguage, configName);
@@ -703,7 +705,9 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
   targetOptions.Parse(defineFlags.c_str());
   targetOptions.ParseFinish();
   std::vector<std::string> targetDefines;
-  target->GetCompileDefinitions(targetDefines, configName, "CXX");
+  if (!langForClCompile.empty()) {
+    target->GetCompileDefinitions(targetDefines, configName, langForClCompile);
+  }
   targetOptions.AddDefines(targetDefines);
   targetOptions.SetVerboseMakefile(
     this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"));
@@ -792,10 +796,13 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
          << "\\$(ConfigurationName)\"\n";
   }
   fout << "\t\t\t\tAdditionalIncludeDirectories=\"";
-  std::vector<std::string> includes;
-  this->GetIncludeDirectories(includes, target, "C", configName);
-  std::vector<std::string>::iterator i = includes.begin();
-  for (; i != includes.end(); ++i) {
+  std::vector<std::string> includes_cl;
+  if (!langForClCompile.empty()) {
+    this->GetIncludeDirectories(includes_cl, target, langForClCompile,
+                                configName);
+  }
+  std::vector<std::string>::iterator i = includes_cl.begin();
+  for (; i != includes_cl.end(); ++i) {
     // output the include path
     std::string ipath = this->ConvertToXMLOutputPath(i->c_str());
     fout << ipath << ";";
@@ -810,7 +817,8 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
   }
   fout << "\"\n";
   targetOptions.OutputFlagMap(fout, "\t\t\t\t");
-  targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n", "CXX");
+  targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n",
+                                              langForClCompile);
   fout << "\t\t\t\tObjectFile=\"$(IntDir)\\\"\n";
   if (target->GetType() <= cmStateEnums::OBJECT_LIBRARY) {
     // Specify the compiler program database file if configured.
@@ -829,9 +837,12 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
       "\t\t\t\tName=\"MASM\"\n"
       "\t\t\t\tIncludePaths=\""
       ;
+    std::vector<std::string> includes_masm;
+    this->GetIncludeDirectories(includes_masm, target, "ASM_MASM",
+                                configName);
     /* clang-format on */
     const char* sep = "";
-    for (i = includes.begin(); i != includes.end(); ++i) {
+    for (i = includes_masm.begin(); i != includes_masm.end(); ++i) {
       std::string inc = *i;
       cmConvertToWindowsSlash(inc);
       fout << sep << this->EscapeForXML(inc);
@@ -859,7 +870,9 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
   }
   fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"\n"
        << "\t\t\t\tAdditionalIncludeDirectories=\"";
-  for (i = includes.begin(); i != includes.end(); ++i) {
+  std::vector<std::string> includes_rc;
+  this->GetIncludeDirectories(includes_rc, target, "RC", configName);
+  for (i = includes_rc.begin(); i != includes_rc.end(); ++i) {
     std::string ipath = this->ConvertToXMLOutputPath(i->c_str());
     fout << ipath << ";";
   }
@@ -873,7 +886,9 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
   }
   fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"\n";
   fout << "\t\t\t\tAdditionalIncludeDirectories=\"";
-  for (i = includes.begin(); i != includes.end(); ++i) {
+  std::vector<std::string> includes_midl;
+  this->GetIncludeDirectories(includes_midl, target, "MIDL", configName);
+  for (i = includes_midl.begin(); i != includes_midl.end(); ++i) {
     std::string ipath = this->ConvertToXMLOutputPath(i->c_str());
     fout << ipath << ";";
   }
diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx
index ee9db43..6d81f95 100644
--- a/Source/cmVisualStudio10TargetGenerator.cxx
+++ b/Source/cmVisualStudio10TargetGenerator.cxx
@@ -2319,6 +2319,18 @@ void cmVisualStudio10TargetGenerator::OutputLinkIncremental(
   }
 }
 
+std::vector<std::string> cmVisualStudio10TargetGenerator::GetIncludes(
+  std::string const& config, std::string const& lang) const
+{
+  std::vector<std::string> includes;
+  this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
+                                              lang, config);
+  for (std::string& i : includes) {
+    this->ConvertToWindowsSlash(i);
+  }
+  return includes;
+}
+
 bool cmVisualStudio10TargetGenerator::ComputeClOptions()
 {
   for (std::string const& i : this->Configurations) {
@@ -2379,6 +2391,7 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
       }
     }
   }
+  this->LangForClCompile = langForClCompile;
   if (!langForClCompile.empty()) {
     std::string baseFlagVar = "CMAKE_";
     baseFlagVar += langForClCompile;
@@ -2422,8 +2435,10 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
   std::vector<std::string> targetDefines;
   switch (this->ProjectType) {
     case vcxproj:
-      this->GeneratorTarget->GetCompileDefinitions(targetDefines, configName,
-                                                   "CXX");
+      if (!langForClCompile.empty()) {
+        this->GeneratorTarget->GetCompileDefinitions(targetDefines, configName,
+                                                     langForClCompile);
+      }
       break;
     case csproj:
       this->GeneratorTarget->GetCompileDefinitions(targetDefines, configName,
@@ -2487,7 +2502,7 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteClOptions(
-  std::string const& configName, std::vector<std::string> const& includes)
+  std::string const& configName)
 {
   Options& clOptions = *(this->ClOptions[configName]);
   if (this->ProjectType == csproj) {
@@ -2495,12 +2510,16 @@ void cmVisualStudio10TargetGenerator::WriteClOptions(
   }
   this->WriteString("<ClCompile>\n", 2);
   clOptions.PrependInheritedString("AdditionalOptions");
-  clOptions.AppendFlag("AdditionalIncludeDirectories", includes);
+  if (!this->LangForClCompile.empty()) {
+    std::vector<std::string> const includes =
+      this->GetIncludes(configName, this->LangForClCompile);
+    clOptions.AppendFlag("AdditionalIncludeDirectories", includes);
+  }
   clOptions.AppendFlag("AdditionalIncludeDirectories",
                        "%(AdditionalIncludeDirectories)");
   clOptions.OutputFlagMap(*this->BuildFileStream, "      ");
   clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
-                                          "\n", "CXX");
+                                          "\n", this->LangForClCompile);
 
   if (this->NsightTegra) {
     if (const char* processMax =
@@ -2581,7 +2600,7 @@ bool cmVisualStudio10TargetGenerator::ComputeRcOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteRCOptions(
-  std::string const& configName, std::vector<std::string> const& includes)
+  std::string const& configName)
 {
   if (!this->MSTools) {
     return;
@@ -2591,6 +2610,8 @@ void cmVisualStudio10TargetGenerator::WriteRCOptions(
   Options& rcOptions = *(this->RcOptions[configName]);
   rcOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
                                           "\n", "RC");
+  std::vector<std::string> const includes =
+    this->GetIncludes(configName, "RC");
   rcOptions.AppendFlag("AdditionalIncludeDirectories", includes);
   rcOptions.AppendFlag("AdditionalIncludeDirectories",
                        "%(AdditionalIncludeDirectories)");
@@ -2701,7 +2722,7 @@ bool cmVisualStudio10TargetGenerator::ComputeCudaOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteCudaOptions(
-  std::string const& configName, std::vector<std::string> const& includes)
+  std::string const& configName)
 {
   if (!this->MSTools || !this->GlobalGenerator->IsCudaEnabled()) {
     return;
@@ -2709,6 +2730,8 @@ void cmVisualStudio10TargetGenerator::WriteCudaOptions(
   this->WriteString("<CudaCompile>\n", 2);
 
   Options& cudaOptions = *(this->CudaOptions[configName]);
+  std::vector<std::string> const includes =
+    this->GetIncludes(configName, "CUDA");
   cudaOptions.AppendFlag("Include", includes);
   cudaOptions.AppendFlag("Include", "%(Include)");
   cudaOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
@@ -2823,7 +2846,7 @@ bool cmVisualStudio10TargetGenerator::ComputeMasmOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteMasmOptions(
-  std::string const& configName, std::vector<std::string> const& includes)
+  std::string const& configName)
 {
   if (!this->MSTools || !this->GlobalGenerator->IsMasmEnabled()) {
     return;
@@ -2836,6 +2859,8 @@ void cmVisualStudio10TargetGenerator::WriteMasmOptions(
                                           "\n", "ASM_MASM");
 
   Options& masmOptions = *(this->MasmOptions[configName]);
+  std::vector<std::string> const includes =
+    this->GetIncludes(configName, "ASM_MASM");
   masmOptions.AppendFlag("IncludePaths", includes);
   masmOptions.AppendFlag("IncludePaths", "%(IncludePaths)");
   masmOptions.PrependInheritedString("AdditionalOptions");
@@ -2880,13 +2905,15 @@ bool cmVisualStudio10TargetGenerator::ComputeNasmOptions(
 }
 
 void cmVisualStudio10TargetGenerator::WriteNasmOptions(
-  std::string const& configName, std::vector<std::string> includes)
+  std::string const& configName)
 {
   if (!this->GlobalGenerator->IsNasmEnabled()) {
     return;
   }
   this->WriteString("<NASM>\n", 2);
 
+  std::vector<std::string> includes =
+    this->GetIncludes(configName, "ASM_NASM");
   Options& nasmOptions = *(this->NasmOptions[configName]);
   for (size_t i = 0; i < includes.size(); i++) {
     includes[i] += "\\";
@@ -3434,7 +3461,7 @@ void cmVisualStudio10TargetGenerator::AddTargetsFileAndConfigPair(
 }
 
 void cmVisualStudio10TargetGenerator::WriteMidlOptions(
-  std::string const& /*config*/, std::vector<std::string> const& includes)
+  std::string const& configName)
 {
   if (!this->MSTools) {
     return;
@@ -3460,6 +3487,8 @@ void cmVisualStudio10TargetGenerator::WriteMidlOptions(
   // on the CMake side?
   this->WriteString("<Midl>\n", 2);
   this->WriteString("<AdditionalIncludeDirectories>", 3);
+  std::vector<std::string> const includes =
+    this->GetIncludes(configName, "MIDL");
   for (std::string const& i : includes) {
     *this->BuildFileStream << cmVS10EscapeXML(i) << ";";
   }
@@ -3484,25 +3513,19 @@ void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups()
     return;
   }
   for (std::string const& i : this->Configurations) {
-    std::vector<std::string> includes;
-    this->LocalGenerator->GetIncludeDirectories(includes,
-                                                this->GeneratorTarget, "C", i);
-    for (std::string& ii : includes) {
-      this->ConvertToWindowsSlash(ii);
-    }
     this->WritePlatformConfigTag("ItemDefinitionGroup", i, 1);
     *this->BuildFileStream << "\n";
     //    output cl compile flags <ClCompile></ClCompile>
     if (this->GeneratorTarget->GetType() <= cmStateEnums::OBJECT_LIBRARY) {
-      this->WriteClOptions(i, includes);
+      this->WriteClOptions(i);
       //    output rc compile flags <ResourceCompile></ResourceCompile>
-      this->WriteRCOptions(i, includes);
-      this->WriteCudaOptions(i, includes);
-      this->WriteMasmOptions(i, includes);
-      this->WriteNasmOptions(i, includes);
+      this->WriteRCOptions(i);
+      this->WriteCudaOptions(i);
+      this->WriteMasmOptions(i);
+      this->WriteNasmOptions(i);
     }
     //    output midl flags       <Midl></Midl>
-    this->WriteMidlOptions(i, includes);
+    this->WriteMidlOptions(i);
     // write events
     if (this->ProjectType != csproj) {
       this->WriteEvents(i);
diff --git a/Source/cmVisualStudio10TargetGenerator.h b/Source/cmVisualStudio10TargetGenerator.h
index fb24f1a..c346164 100644
--- a/Source/cmVisualStudio10TargetGenerator.h
+++ b/Source/cmVisualStudio10TargetGenerator.h
@@ -90,18 +90,18 @@ private:
   void WriteTargetSpecificReferences();
   void WriteTargetsFileReferences();
 
+  std::vector<std::string> GetIncludes(std::string const& config,
+                                       std::string const& lang) const;
+
   bool ComputeClOptions();
   bool ComputeClOptions(std::string const& configName);
-  void WriteClOptions(std::string const& config,
-                      std::vector<std::string> const& includes);
+  void WriteClOptions(std::string const& config);
   bool ComputeRcOptions();
   bool ComputeRcOptions(std::string const& config);
-  void WriteRCOptions(std::string const& config,
-                      std::vector<std::string> const& includes);
+  void WriteRCOptions(std::string const& config);
   bool ComputeCudaOptions();
   bool ComputeCudaOptions(std::string const& config);
-  void WriteCudaOptions(std::string const& config,
-                        std::vector<std::string> const& includes);
+  void WriteCudaOptions(std::string const& config);
 
   bool ComputeCudaLinkOptions();
   bool ComputeCudaLinkOptions(std::string const& config);
@@ -109,20 +109,17 @@ private:
 
   bool ComputeMasmOptions();
   bool ComputeMasmOptions(std::string const& config);
-  void WriteMasmOptions(std::string const& config,
-                        std::vector<std::string> const& includes);
+  void WriteMasmOptions(std::string const& config);
   bool ComputeNasmOptions();
   bool ComputeNasmOptions(std::string const& config);
-  void WriteNasmOptions(std::string const& config,
-                        std::vector<std::string> includes);
+  void WriteNasmOptions(std::string const& config);
 
   bool ComputeLinkOptions();
   bool ComputeLinkOptions(std::string const& config);
   bool ComputeLibOptions();
   bool ComputeLibOptions(std::string const& config);
   void WriteLinkOptions(std::string const& config);
-  void WriteMidlOptions(std::string const& config,
-                        std::vector<std::string> const& includes);
+  void WriteMidlOptions(std::string const& config);
   void WriteAntBuildOptions(std::string const& config);
   void OutputLinkIncremental(std::string const& configName);
   void WriteCustomRule(cmSourceFile const* source,
@@ -180,6 +177,7 @@ private:
   OptionsMap MasmOptions;
   OptionsMap NasmOptions;
   OptionsMap LinkOptions;
+  std::string LangForClCompile;
   std::string PathToProjectFile;
   std::string ProjectFileExtension;
   enum VsProjectType