reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-25 12:40:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge topic 'ninja-mingw-lang'

Browse Source 
2271ca3 Ninja: the Ninja generator does not support Fortran yet.
751f712 Ninja: use MinGW generator code in EnableLanguage()
This commit is contained in:
Brad King 2013-03-12 13:46:55 -04:00 committed by CMake Topic Stage
commit 451ddcbf73
4 changed files with 46 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Source/cmGlobalGenerator.cxx
View File

@ -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,

1
Source/cmGlobalGenerator.h
View File

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

28
Source/cmGlobalMinGWMakefileGenerator.cxx
View File

@ -26,33 +26,7 @@ void cmGlobalMinGWMakefileGenerator
cmMakefile *mf,
bool optional)
{
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());
this->EnableMinGWLanguage(mf);
this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional);
}

71
Source/cmGlobalNinjaGenerator.cxx
View File

@ -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,
cmMakefile *mf,
::EnableLanguage(std::vector<std::string>const& langs,
cmMakefile* makefile,
bool optional)
{
std::string path;
for(std::vector<std::string>::const_iterator l = languages.begin();
l != languages.end(); ++l)
if (makefile->IsOn("CMAKE_COMPILER_IS_MINGW"))
{
std::vector<std::string> language;
language.push_back(*l);
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);
UsingMinGW = true;
this->EnableMinGWLanguage(makefile);
}
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;