kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'include-flags-response-file' 

86cb17b Pass include directories with response files to GNU on Windows
9a0b9bc Optionally pass include directories with response files
6e8a67f Generate target-wide flags before individual build rules
d099546 Factor old-style -D flags out from -I flag generation
This commit is contained in:
Brad King 2011-03-22 14:45:44 -04:00 committed by CMake Topic Stage
parent 685d893500 86cb17b18d
commit 1c3233a850
10 changed files with 93 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Modules/Platform/Windows-GNU.cmake
View File

@ -79,6 +79,7 @@ macro(__windows_compiler_gnu lang)
set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "") # No -fPIC on Windows
set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS ${__WINDOWS_GNU_LD_RESPONSE})
set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_INCLUDES 1)
# We prefer "@" for response files but it is not supported by gcc 3.
execute_process(COMMAND ${CMAKE_${lang}_COMPILER} --version OUTPUT_VARIABLE _ver ERROR_VARIABLE _ver)
@ -92,6 +93,8 @@ macro(__windows_compiler_gnu lang)
# Use "-Wl,@" to pass the response file to the linker.
set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "-Wl,@")
endif()
# The GNU 3.x compilers do not support response files (only linkers).
set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_INCLUDES 0)
elseif(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS)
# Use "@" to pass the response file to the front-end.
set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "@")

2
Source/cmDocumentVariables.cxx
View File

@ -1475,6 +1475,8 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
cmProperty::VARIABLE,0,0);
cm->DefineProperty("CMAKE_<LANG>_STANDARD_LIBRARIES_INIT",
cmProperty::VARIABLE,0,0);
cm->DefineProperty("CMAKE_<LANG>_USE_RESPONSE_FILE_FOR_INCLUDES",
cmProperty::VARIABLE,0,0);
cm->DefineProperty("CMAKE_<LANG>_USE_RESPONSE_FILE_FOR_OBJECTS",
cmProperty::VARIABLE,0,0);
cm->DefineProperty("CMAKE_EXECUTABLE_SUFFIX_<LANG>",

31
Source/cmLocalGenerator.cxx
View File

@ -575,6 +575,7 @@ void cmLocalGenerator::AddCustomCommandToCreateObject(const char* ofname,
flags += this->Makefile->GetSafeDefinition(varString.c_str());
flags += " ";
flags += this->GetIncludeFlags(lang);
flags += this->Makefile->GetDefineFlags();
// Construct the command lines.
cmCustomCommandLines commandLines;
@ -1184,15 +1185,18 @@ cmLocalGenerator::ConvertToOutputForExisting(RelativeRoot remote,
}
//----------------------------------------------------------------------------
const char* cmLocalGenerator::GetIncludeFlags(const char* lang)
const char* cmLocalGenerator::GetIncludeFlags(const char* lang,
bool forResponseFile)
{
if(!lang)
{
return "";
}
if(this->LanguageToIncludeFlags.count(lang))
std::string key = lang;
key += forResponseFile? "@" : "";
if(this->LanguageToIncludeFlags.count(key))
{
return this->LanguageToIncludeFlags[lang].c_str();
return this->LanguageToIncludeFlags[key].c_str();
}
cmOStringStream includeFlags;
@ -1250,10 +1254,10 @@ const char* cmLocalGenerator::GetIncludeFlags(const char* lang)
frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir.c_str());
if(emitted.insert(frameworkDir).second)
{
OutputFormat format = forResponseFile? RESPONSE : SHELL;
includeFlags
<< "-F" << this->Convert(frameworkDir.c_str(),
cmLocalGenerator::START_OUTPUT,
cmLocalGenerator::SHELL, true)
START_OUTPUT, format, true)
<< " ";
}
continue;
@ -1273,7 +1277,16 @@ const char* cmLocalGenerator::GetIncludeFlags(const char* lang)
}
flagUsed = true;
}
std::string includePath = this->ConvertToOutputForExisting(i->c_str());
std::string includePath;
if(forResponseFile)
{
includePath = this->Convert(i->c_str(), START_OUTPUT,
RESPONSE, true);
}
else
{
includePath = this->ConvertToOutputForExisting(i->c_str());
}
if(quotePaths && includePath.size() && includePath[0] != '\"')
{
includeFlags << "\"";
@ -1291,13 +1304,11 @@ const char* cmLocalGenerator::GetIncludeFlags(const char* lang)
{
flags[flags.size()-1] = ' ';
}
std::string defineFlags = this->Makefile->GetDefineFlags();
flags += defineFlags;
this->LanguageToIncludeFlags[lang] = flags;
this->LanguageToIncludeFlags[key] = flags;
// Use this temorary variable for the return value to work-around a
// bogus GCC 2.95 warning.
const char* ret = this->LanguageToIncludeFlags[lang].c_str();
const char* ret = this->LanguageToIncludeFlags[key].c_str();
return ret;
}

3
Source/cmLocalGenerator.h
View File

@ -143,7 +143,8 @@ public:
const char* config);
virtual void AppendFlags(std::string& flags, const char* newFlags);
///! Get the include flags for the current makefile and language
const char* GetIncludeFlags(const char* lang);
const char* GetIncludeFlags(const char* lang,
bool forResponseFile = false);
/**
* Encode a list of preprocessor definitions for the compiler

14
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -880,6 +880,20 @@ cmLocalUnixMakefileGenerator3
}
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::AppendRuleDepends(std::vector<std::string>& depends,
std::vector<std::string> const& ruleFiles)
{
// Add a dependency on the rule file itself unless an option to skip
// it is specifically enabled by the user or project.
if(!this->Makefile->IsOn("CMAKE_SKIP_RULE_DEPENDENCY"))
{
depends.insert(depends.end(), ruleFiles.begin(), ruleFiles.end());
}
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3

2
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -320,6 +320,8 @@ protected:
void AppendRuleDepend(std::vector<std::string>& depends,
const char* ruleFileName);
void AppendRuleDepends(std::vector<std::string>& depends,
std::vector<std::string> const& ruleFiles);
void AppendCustomDepends(std::vector<std::string>& depends,
const std::vector<cmCustomCommand>& ccs);
void AppendCustomDepend(std::vector<std::string>& depends,

6
Source/cmMakefileExecutableTargetGenerator.cxx
View File

@ -47,12 +47,12 @@ void cmMakefileExecutableTargetGenerator::WriteRuleFiles()
// write rules used to help build object files
this->WriteCommonCodeRules();
// write in rules for object files and custom commands
this->WriteTargetBuildRules();
// write the per-target per-language flags
this->WriteTargetLanguageFlags();
// write in rules for object files and custom commands
this->WriteTargetBuildRules();
// write the link rules
this->WriteExecutableRule(false);
if(this->Target->NeedRelinkBeforeInstall(this->ConfigName))

6
Source/cmMakefileLibraryTargetGenerator.cxx
View File

@ -72,12 +72,12 @@ void cmMakefileLibraryTargetGenerator::WriteRuleFiles()
// write rules used to help build object files
this->WriteCommonCodeRules();
// write in rules for object files and custom commands
this->WriteTargetBuildRules();
// write the per-target per-language flags
this->WriteTargetLanguageFlags();
// write in rules for object files and custom commands
this->WriteTargetBuildRules();
// write the link rules
// Write the rule for this target type.
switch(this->Target->GetType())

40
Source/cmMakefileTargetGenerator.cxx
View File

@ -310,8 +310,12 @@ void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
this->LocalGenerator->AddSharedFlags(flags, lang, shared);
// Add include directory flags.
this->AddIncludeFlags(flags, lang);
// Append old-style preprocessor definition flags.
this->LocalGenerator->
AppendFlags(flags, this->LocalGenerator->GetIncludeFlags(lang));
AppendFlags(flags, this->Makefile->GetDefineFlags());
// Add include directory flags.
this->LocalGenerator->
AppendFlags(flags,this->GetFrameworkFlags().c_str());
@ -482,6 +486,8 @@ cmMakefileTargetGenerator
{
this->LocalGenerator->AppendRuleDepend(depends,
this->FlagFileNameFull.c_str());
this->LocalGenerator->AppendRuleDepends(depends,
this->FlagFileDepends[lang]);
// generate the depend scanning rule
this->WriteObjectDependRules(source, depends);
@ -1719,6 +1725,38 @@ cmMakefileTargetGenerator
}
}
//----------------------------------------------------------------------------
void cmMakefileTargetGenerator::AddIncludeFlags(std::string& flags,
const char* lang)
{
std::string responseVar = "CMAKE_";
responseVar += lang;
responseVar += "_USE_RESPONSE_FILE_FOR_INCLUDES";
bool useResponseFile = this->Makefile->IsOn(responseVar.c_str());
std::string includeFlags =
this->LocalGenerator->GetIncludeFlags(lang, useResponseFile);
if(includeFlags.empty())
{
return;
}
if(useResponseFile)
{
std::string name = "includes_";
name += lang;
name += ".rsp";
std::string arg = "@" +
this->CreateResponseFile(name.c_str(), includeFlags,
this->FlagFileDepends[lang]);
this->LocalGenerator->AppendFlags(flags, arg.c_str());
}
else
{
this->LocalGenerator->AppendFlags(flags, includeFlags.c_str());
}
}
//----------------------------------------------------------------------------
const char* cmMakefileTargetGenerator::GetFortranModuleDirectory()
{

4
Source/cmMakefileTargetGenerator.h
View File

@ -146,6 +146,8 @@ protected:
bool useResponseFile, std::string& buildObjs,
std::vector<std::string>& makefile_depends);
void AddIncludeFlags(std::string& flags, const char* lang);
virtual void CloseFileStreams();
void RemoveForbiddenFlags(const char* flagVar, const char* linkLang,
std::string& linkFlags);
@ -177,6 +179,8 @@ protected:
// the stream for the flag file
std::string FlagFileNameFull;
cmGeneratedFileStream *FlagFileStream;
class StringList: public std::vector<std::string> {};
std::map<cmStdString, StringList> FlagFileDepends;
// the stream for the info file
std::string InfoFileNameFull;