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

Merge topic 'clean-up-cmListFileArgument'

Browse Source 
782657db cmListFileArgument: Remove FilePath member.
a863c59f cmMakefile: Use GetExecutionFileStack method.
076760a6 cmMakefile: Add filename context to ExpandArguments.
569f4785 cmFunctionCommand: Store the FilePath when creating the prototype.
f971ab04 cmMacroCommand: Store the FilePath when creating the prototype.
This commit is contained in:
Brad King 2015-06-22 13:00:29 -04:00 committed by CMake Topic Stage
commit c7180e822b
8 changed files with 52 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Source/cmCPluginAPI.cxx
View File

@ -426,8 +426,7 @@ int CCONV cmExecuteCommand(void *arg, const char *name,
{
// Assume all arguments are quoted.
lff.Arguments.push_back(
cmListFileArgument(args[i], cmListFileArgument::Quoted,
"[CMake-Plugin]", 0));
cmListFileArgument(args[i], cmListFileArgument::Quoted, 0));
}
cmExecutionStatus status;
return mf->ExecuteCommand(lff,status);

17
Source/cmFunctionCommand.cxx
View File

@ -43,6 +43,7 @@ public:
newC->Args = this->Args;
newC->Functions = this->Functions;
newC->Policies = this->Policies;
newC->FilePath = this->FilePath;
return newC;
}
@ -71,6 +72,7 @@ public:
std::vector<std::string> Args;
std::vector<cmListFileFunction> Functions;
cmPolicies::PolicyMap Policies;
std::string FilePath;
};
bool cmFunctionHelperCommand::InvokeInitialPass
@ -171,19 +173,9 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
cmFunctionHelperCommand *f = new cmFunctionHelperCommand();
f->Args = this->Args;
f->Functions = this->Functions;
f->FilePath = this->GetStartingContext().FilePath;
mf.RecordPolicies(f->Policies);
// Set the FilePath on the arguments to match the function since it is
// not stored and the original values may be freed
for (unsigned int i = 0; i < f->Functions.size(); ++i)
{
for (unsigned int j = 0; j < f->Functions[i].Arguments.size(); ++j)
{
f->Functions[i].Arguments[j].FilePath =
f->Functions[i].FilePath.c_str();
}
}
std::string newName = "_" + this->Args[0];
mf.GetState()->RenameCommand(this->Args[0], newName);
mf.GetState()->AddCommand(f);
@ -212,7 +204,8 @@ ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endfunction"))
{
std::vector<std::string> expandedArguments;
mf.ExpandArguments(lff.Arguments, expandedArguments);
mf.ExpandArguments(lff.Arguments, expandedArguments,
this->GetStartingContext().FilePath.c_str());
// if the endfunction has arguments then make sure
// they match the ones in the opening function command
if ((expandedArguments.empty() ||

5
Source/cmListFileCache.cxx
View File

@ -234,8 +234,7 @@ bool cmListFile::ParseFile(const char* filename,
{
cmListFileFunction project;
project.Name = "PROJECT";
cmListFileArgument prj("Project", cmListFileArgument::Unquoted,
filename, 0);
cmListFileArgument prj("Project", cmListFileArgument::Unquoted, 0);
project.Arguments.push_back(prj);
this->Functions.insert(this->Functions.begin(),project);
}
@ -375,7 +374,7 @@ bool cmListFileParser::ParseFunction(const char* name, long line)
bool cmListFileParser::AddArgument(cmListFileLexer_Token* token,
cmListFileArgument::Delimiter delim)
{
cmListFileArgument a(token->text, delim, this->FileName, token->line);
cmListFileArgument a(token->text, delim, token->line);
this->Function.Arguments.push_back(a);
if(this->Separation == SeparationOkay)
{

12
Source/cmListFileCache.h
View File

@ -33,12 +33,11 @@ struct cmListFileArgument
Quoted,
Bracket
};
cmListFileArgument(): Value(), Delim(Unquoted), FilePath(0), Line(0) {}
cmListFileArgument(const cmListFileArgument& r):
Value(r.Value), Delim(r.Delim), FilePath(r.FilePath), Line(r.Line) {}
cmListFileArgument(const std::string& v, Delimiter d, const char* file,
long line): Value(v), Delim(d),
FilePath(file), Line(line) {}
cmListFileArgument(): Value(), Delim(Unquoted), Line(0) {}
cmListFileArgument(const cmListFileArgument& r)
: Value(r.Value), Delim(r.Delim), Line(r.Line) {}
cmListFileArgument(const std::string& v, Delimiter d, long line)
: Value(v), Delim(d), Line(line) {}
bool operator == (const cmListFileArgument& r) const
{
return (this->Value == r.Value) && (this->Delim == r.Delim);
@ -49,7 +48,6 @@ struct cmListFileArgument
}
std::string Value;
Delimiter Delim;
const char* FilePath;
long Line;
};

13
Source/cmMacroCommand.cxx
View File

@ -122,10 +122,6 @@ bool cmMacroHelperCommand::InvokeInitialPass
sprintf(argvName,"${ARGV%i}",j);
argVs.push_back(argvName);
}
if(!this->Functions.empty())
{
this->FilePath = this->Functions[0].FilePath;
}
// Invoke all the functions that were collected in the block.
cmListFileFunction newLFF;
// for each function
@ -143,10 +139,6 @@ bool cmMacroHelperCommand::InvokeInitialPass
this->Functions[c].Arguments.begin();
k != this->Functions[c].Arguments.end(); ++k)
{
// Set the FilePath on the arguments to match the function since it is
// not stored and the original values may be freed
k->FilePath = this->FilePath.c_str();
cmListFileArgument arg;
arg.Value = k->Value;
if(k->Delim != cmListFileArgument::Bracket)
@ -177,7 +169,6 @@ bool cmMacroHelperCommand::InvokeInitialPass
}
}
arg.Delim = k->Delim;
arg.FilePath = k->FilePath;
arg.Line = k->Line;
newLFF.Arguments.push_back(arg);
}
@ -225,6 +216,7 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
cmMacroHelperCommand *f = new cmMacroHelperCommand();
f->Args = this->Args;
f->Functions = this->Functions;
f->FilePath = this->GetStartingContext().FilePath;
mf.RecordPolicies(f->Policies);
std::string newName = "_" + this->Args[0];
mf.GetState()->RenameCommand(this->Args[0], newName);
@ -254,7 +246,8 @@ ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endmacro"))
{
std::vector<std::string> expandedArguments;
mf.ExpandArguments(lff.Arguments, expandedArguments);
mf.ExpandArguments(lff.Arguments, expandedArguments,
this->GetStartingContext().FilePath.c_str());
// if the endmacro has arguments make sure they
// match the arguments of the macro
if ((expandedArguments.empty() ||

31
Source/cmMakefile.cxx
View File

@ -308,7 +308,7 @@ cmListFileContext cmMakefile::GetExecutionContext() const
void cmMakefile::PrintCommandTrace(const cmListFileFunction& lff) const
{
std::ostringstream msg;
msg << lff.FilePath << "(" << lff.Line << "): ";
msg << this->GetExecutionFilePath() << "(" << lff.Line << "): ";
msg << lff.Name << "(";
for(std::vector<cmListFileArgument>::const_iterator i =
lff.Arguments.begin(); i != lff.Arguments.end(); ++i)
@ -3313,11 +3313,25 @@ bool cmMakefile::IsLoopBlock() const
return !this->LoopBlockCounter.empty() && this->LoopBlockCounter.top() > 0;
}
std::string cmMakefile::GetExecutionFilePath() const
{
if (this->CallStack.empty())
{
return std::string();
}
return this->CallStack.back().Context->FilePath;
}
//----------------------------------------------------------------------------
bool cmMakefile::ExpandArguments(
std::vector<cmListFileArgument> const& inArgs,
std::vector<std::string>& outArgs) const
std::vector<std::string>& outArgs, const char* filename) const
{
std::string efp = this->GetExecutionFilePath();
if (!filename)
{
filename = efp.c_str();
}
std::vector<cmListFileArgument>::const_iterator i;
std::string value;
outArgs.reserve(inArgs.size());
@ -3332,8 +3346,7 @@ bool cmMakefile::ExpandArguments(
// Expand the variables in the argument.
value = i->Value;
this->ExpandVariablesInString(value, false, false, false,
i->FilePath, i->Line,
false, false);
filename, i->Line, false, false);
// If the argument is quoted, it should be one argument.
// Otherwise, it may be a list of arguments.
@ -3352,8 +3365,13 @@ bool cmMakefile::ExpandArguments(
//----------------------------------------------------------------------------
bool cmMakefile::ExpandArguments(
std::vector<cmListFileArgument> const& inArgs,
std::vector<cmExpandedCommandArgument>& outArgs) const
std::vector<cmExpandedCommandArgument>& outArgs, const char* filename) const
{
std::string efp = this->GetExecutionFilePath();
if (!filename)
{
filename = efp.c_str();
}
std::vector<cmListFileArgument>::const_iterator i;
std::string value;
outArgs.reserve(inArgs.size());
@ -3368,8 +3386,7 @@ bool cmMakefile::ExpandArguments(
// Expand the variables in the argument.
value = i->Value;
this->ExpandVariablesInString(value, false, false, false,
i->FilePath, i->Line,
false, false);
filename, i->Line, false, false);
// If the argument is quoted, it should be one argument.
// Otherwise, it may be a list of arguments.

8
Source/cmMakefile.h
View File

@ -662,10 +662,12 @@ public:
* variable replacement and list expansion.
*/
bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
std::vector<std::string>& outArgs) const;
std::vector<std::string>& outArgs,
const char* filename = 0) const;
bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
std::vector<cmExpandedCommandArgument>& outArgs) const;
std::vector<cmExpandedCommandArgument>& outArgs,
const char* filename = 0) const;
/**
* Get the instance
@ -840,6 +842,8 @@ public:
const char* GetDefineFlagsCMP0059() const;
std::string GetExecutionFilePath() const;
protected:
// add link libraries and directories to the target
void AddGlobalLinkInformation(const std::string& name, cmTarget& target);

12
Source/cmVariableWatchCommand.cxx
View File

@ -49,21 +49,21 @@ static void cmVariableWatchCommandVariableAccessed(
newLFF.Arguments.clear();
newLFF.Arguments.push_back(
cmListFileArgument(variable, cmListFileArgument::Quoted,
"unknown", 9999));
9999));
newLFF.Arguments.push_back(
cmListFileArgument(accessString, cmListFileArgument::Quoted,
"unknown", 9999));
9999));
newLFF.Arguments.push_back(
cmListFileArgument(newValue?newValue:"", cmListFileArgument::Quoted,
"unknown", 9999));
9999));
newLFF.Arguments.push_back(
cmListFileArgument(currentListFile, cmListFileArgument::Quoted,
"unknown", 9999));
9999));
newLFF.Arguments.push_back(
cmListFileArgument(stack, cmListFileArgument::Quoted,
"unknown", 9999));
9999));
newLFF.Name = data->Command;
newLFF.FilePath = "Some weird path";
newLFF.FilePath = "unknown";
newLFF.Line = 9999;
cmExecutionStatus status;
if(!makefile->ExecuteCommand(newLFF,status))