Merge topic 'ninja-mingw-lang'

2271ca3 Ninja: the Ninja generator does not support Fortran yet.
751f712 Ninja: use MinGW generator code in EnableLanguage()

Source/cmGlobalGenerator.cxx

@@ -2081,6 +2081,38 @@ bool cmGlobalGenerator::UseFolderProperty()
   return false;
 }
 
+//----------------------------------------------------------------------------
+void cmGlobalGenerator::EnableMinGWLanguage(cmMakefile *mf)
+{
+  this->FindMakeProgram(mf);
+  std::string makeProgram = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
+  std::vector<std::string> locations;
+  locations.push_back(cmSystemTools::GetProgramPath(makeProgram.c_str()));
+  locations.push_back("/mingw/bin");
+  locations.push_back("c:/mingw/bin");
+  std::string tgcc = cmSystemTools::FindProgram("gcc", locations);
+  std::string gcc = "gcc.exe";
+  if(tgcc.size())
+    {
+    gcc = tgcc;
+    }
+  std::string tgxx = cmSystemTools::FindProgram("g++", locations);
+  std::string gxx = "g++.exe";
+  if(tgxx.size())
+    {
+    gxx = tgxx;
+    }
+  std::string trc = cmSystemTools::FindProgram("windres", locations);
+  std::string rc = "windres.exe";
+  if(trc.size())
+    {
+    rc = trc;
+    }
+  mf->AddDefinition("CMAKE_GENERATOR_CC", gcc.c_str());
+  mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx.c_str());
+  mf->AddDefinition("CMAKE_GENERATOR_RC", rc.c_str());
+}
+
 //----------------------------------------------------------------------------
 cmTarget cmGlobalGenerator::CreateGlobalTarget(
   const char* name, const char* message,

Source/cmGlobalGenerator.h

@@ -340,6 +340,7 @@ protected:
 
   virtual const char* GetPredefinedTargetsFolder();
   virtual bool UseFolderProperty();
+  void EnableMinGWLanguage(cmMakefile *mf);
 
 private:
   cmMakefile* TryCompileOuterMakefile;

Source/cmGlobalMinGWMakefileGenerator.cxx

@@ -26,33 +26,7 @@ void cmGlobalMinGWMakefileGenerator
                  cmMakefile *mf,
                  bool optional)
 {
-  this->FindMakeProgram(mf);
+  this->EnableMinGWLanguage(mf);
-  std::string makeProgram = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
-  std::vector<std::string> locations;
-  locations.push_back(cmSystemTools::GetProgramPath(makeProgram.c_str()));
-  locations.push_back("/mingw/bin");
-  locations.push_back("c:/mingw/bin");
-  std::string tgcc = cmSystemTools::FindProgram("gcc", locations);
-  std::string gcc = "gcc.exe";
-  if(tgcc.size())
-    {
-    gcc = tgcc;
-    }
-  std::string tgxx = cmSystemTools::FindProgram("g++", locations);
-  std::string gxx = "g++.exe";
-  if(tgxx.size())
-    {
-    gxx = tgxx;
-    }
-  std::string trc = cmSystemTools::FindProgram("windres", locations);
-  std::string rc = "windres.exe";
-  if(trc.size())
-    {
-    rc = trc;
-    }
-  mf->AddDefinition("CMAKE_GENERATOR_CC", gcc.c_str());
-  mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx.c_str());
-  mf->AddDefinition("CMAKE_GENERATOR_RC", rc.c_str());
   this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional);
 }
 

Source/cmGlobalNinjaGenerator.cxx

@@ -17,6 +17,8 @@
 #include "cmGeneratorTarget.h"
 #include "cmVersion.h"
 
+#include <algorithm>
+
 const char* cmGlobalNinjaGenerator::NINJA_BUILD_FILE = "build.ninja";
 const char* cmGlobalNinjaGenerator::NINJA_RULES_FILE = "rules.ninja";
 const char* cmGlobalNinjaGenerator::INDENT = "  ";
@@ -491,69 +493,20 @@ void cmGlobalNinjaGenerator::Generate()
 // Used in:
 //   Source/cmMakefile.cxx:
 void cmGlobalNinjaGenerator
-::EnableLanguage(std::vector<std::string>const& languages,
+::EnableLanguage(std::vector<std::string>const& langs,
-                 cmMakefile *mf,
+                 cmMakefile* makefile,
                  bool optional)
 {
-  std::string path;
+  if (makefile->IsOn("CMAKE_COMPILER_IS_MINGW"))
-  for(std::vector<std::string>::const_iterator l = languages.begin();
-      l != languages.end(); ++l)
     {
-    std::vector<std::string> language;
+    UsingMinGW = true;
-    language.push_back(*l);
+    this->EnableMinGWLanguage(makefile);
-
-    if(*l == "NONE")
-      {
-      this->cmGlobalGenerator::EnableLanguage(language, mf, optional);
-      continue;
-      }
-    else if(*l == "Fortran")
-      {
-      std::string message = "The \"";
-      message += this->GetName();
-      message += "\" generator does not support the language \"";
-      message += *l;
-      message += "\" yet.";
-      cmSystemTools::Error(message.c_str());
-      }
-    else if(*l == "RC")
-      {
-      // check if mingw is used
-      if(mf->IsOn("CMAKE_COMPILER_IS_MINGW"))
-        {
-        UsingMinGW = true;
-        if(!mf->GetDefinition("CMAKE_RC_COMPILER"))
-          {
-          std::string windres = cmSystemTools::FindProgram("windres");
-          if(windres.empty())
-            {
-            std::string compiler_path;
-            std::string::size_type prefix = std::string::npos;
-            if (mf->GetDefinition("CMAKE_C_COMPILER"))
-              {
-              compiler_path = mf->GetDefinition("CMAKE_C_COMPILER");
-              prefix = compiler_path.rfind("gcc");
-              }
-            else if (mf->GetDefinition("CMAKE_CXX_COMPILER"))
-              {
-              compiler_path = mf->GetDefinition("CMAKE_CXX_COMPILER");
-              prefix = compiler_path.rfind("++");
-              prefix--;
-              }
-            if (prefix != std::string::npos)
-              {
-              windres = compiler_path.substr(0, prefix) + "windres";
-              windres = cmSystemTools::FindProgram(windres.c_str());
-              }
-            }
-          if(!windres.empty())
-            mf->AddDefinition("CMAKE_RC_COMPILER", windres.c_str());
-          }
-        }
-      }
-    this->cmGlobalGenerator::EnableLanguage(language, mf, optional);
-    this->ResolveLanguageCompiler(*l, mf, optional);
     }
+  if (std::find(langs.begin(), langs.end(), "Fortran") != langs.end())
+    {
+    cmSystemTools::Error("The Ninja generator does not support Fortran yet.");
+    }
+  this->cmGlobalGenerator::EnableLanguage(langs, makefile, optional);
 }
 
 bool cmGlobalNinjaGenerator::UsingMinGW = false;