CMake/Source/cmForEachCommand.cxx

221 lines
6.5 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2001-07-26 00:52:51 +04:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2001-07-26 00:52:51 +04:00
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
2001-07-26 00:52:51 +04:00
#include "cmForEachCommand.h"
#include <cm_auto_ptr.hxx>
cmForEachFunctionBlocker::cmForEachFunctionBlocker(cmMakefile* mf)
: Makefile(mf)
, Depth(0)
{
this->Makefile->PushLoopBlock();
}
cmForEachFunctionBlocker::~cmForEachFunctionBlocker()
{
this->Makefile->PopLoopBlock();
}
bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
cmMakefile& mf,
cmExecutionStatus& inStatus)
2001-07-26 00:52:51 +04:00
{
if (!cmSystemTools::Strucmp(lff.Name.c_str(), "foreach")) {
2006-05-18 21:50:01 +04:00
// record the number of nested foreach commands
this->Depth++;
} else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endforeach")) {
2006-05-18 21:50:01 +04:00
// if this is the endofreach for this statement
if (!this->Depth) {
// Remove the function blocker for this scope or bail.
CM_AUTO_PTR<cmFunctionBlocker> fb(mf.RemoveFunctionBlocker(this, lff));
if (!fb.get()) {
return false;
}
2006-05-18 21:50:01 +04:00
// at end of for each execute recorded commands
// store the old value
std::string oldDef;
if (mf.GetDefinition(this->Args[0])) {
oldDef = mf.GetDefinition(this->Args[0]);
}
2006-03-15 19:02:08 +03:00
std::vector<std::string>::const_iterator j = this->Args.begin();
++j;
for (; j != this->Args.end(); ++j) {
// set the variable to the loop value
mf.AddDefinition(this->Args[0], j->c_str());
// Invoke all the functions that were collected in the block.
cmExecutionStatus status;
for (unsigned int c = 0; c < this->Functions.size(); ++c) {
status.Clear();
mf.ExecuteCommand(this->Functions[c], status);
if (status.GetReturnInvoked()) {
inStatus.SetReturnInvoked(true);
// restore the variable to its prior value
mf.AddDefinition(this->Args[0], oldDef.c_str());
return true;
}
if (status.GetBreakInvoked()) {
// restore the variable to its prior value
mf.AddDefinition(this->Args[0], oldDef.c_str());
return true;
}
if (status.GetContinueInvoked()) {
break;
}
if (cmSystemTools::GetFatalErrorOccured()) {
return true;
2001-07-26 00:52:51 +04:00
}
}
}
// restore the variable to its prior value
mf.AddDefinition(this->Args[0], oldDef.c_str());
2004-05-12 22:32:25 +04:00
return true;
2001-07-26 00:52:51 +04:00
}
2016-09-16 23:45:24 +03:00
// close out a nested foreach
this->Depth--;
}
2001-07-26 00:52:51 +04:00
// record the command
2006-03-15 19:02:08 +03:00
this->Functions.push_back(lff);
2001-07-26 00:52:51 +04:00
// always return true
return true;
}
bool cmForEachFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
cmMakefile& mf)
2001-07-26 00:52:51 +04:00
{
if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endforeach")) {
std::vector<std::string> expandedArguments;
2006-03-15 19:02:08 +03:00
mf.ExpandArguments(lff.Arguments, expandedArguments);
// if the endforeach has arguments then make sure
// they match the begin foreach arguments
if ((expandedArguments.empty() ||
(expandedArguments[0] == this->Args[0]))) {
return true;
2001-07-26 00:52:51 +04:00
}
}
2001-07-26 00:52:51 +04:00
return false;
}
bool cmForEachCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
2001-07-26 00:52:51 +04:00
{
if (args.empty()) {
2001-07-26 00:52:51 +04:00
this->SetError("called with incorrect number of arguments");
return false;
}
if (args.size() > 1 && args[1] == "IN") {
return this->HandleInMode(args);
}
2001-07-26 00:52:51 +04:00
// create a function blocker
cmForEachFunctionBlocker* f = new cmForEachFunctionBlocker(this->Makefile);
if (args.size() > 1) {
if (args[1] == "RANGE") {
2004-04-29 23:12:40 +04:00
int start = 0;
int stop = 0;
int step = 0;
if (args.size() == 3) {
2004-04-29 23:12:40 +04:00
stop = atoi(args[2].c_str());
}
if (args.size() == 4) {
2004-04-29 23:12:40 +04:00
start = atoi(args[2].c_str());
stop = atoi(args[3].c_str());
}
if (args.size() == 5) {
2004-04-29 23:12:40 +04:00
start = atoi(args[2].c_str());
stop = atoi(args[3].c_str());
step = atoi(args[4].c_str());
}
if (step == 0) {
if (start > stop) {
2004-04-29 23:12:40 +04:00
step = -1;
} else {
2004-04-29 23:12:40 +04:00
step = 1;
}
}
if ((start > stop && step > 0) || (start < stop && step < 0) ||
step == 0) {
std::ostringstream str;
2004-04-29 23:12:40 +04:00
str << "called with incorrect range specification: start ";
str << start << ", stop " << stop << ", step " << step;
this->SetError(str.str());
2004-04-29 23:12:40 +04:00
return false;
}
2004-04-29 23:12:40 +04:00
std::vector<std::string> range;
char buffer[100];
range.push_back(args[0]);
int cc;
for (cc = start;; cc += step) {
if ((step > 0 && cc > stop) || (step < 0 && cc < stop)) {
2004-04-29 23:12:40 +04:00
break;
}
2004-04-29 23:12:40 +04:00
sprintf(buffer, "%d", cc);
range.push_back(buffer);
if (cc == stop) {
2004-04-29 23:12:40 +04:00
break;
}
}
f->Args = range;
} else {
2006-03-15 19:02:08 +03:00
f->Args = args;
2004-04-29 23:12:40 +04:00
}
} else {
2006-03-15 19:02:08 +03:00
f->Args = args;
}
2006-03-15 19:02:08 +03:00
this->Makefile->AddFunctionBlocker(f);
2001-07-26 00:52:51 +04:00
return true;
}
bool cmForEachCommand::HandleInMode(std::vector<std::string> const& args)
{
CM_AUTO_PTR<cmForEachFunctionBlocker> f(
new cmForEachFunctionBlocker(this->Makefile));
f->Args.push_back(args[0]);
enum Doing
{
DoingNone,
DoingLists,
DoingItems
};
Doing doing = DoingNone;
for (unsigned int i = 2; i < args.size(); ++i) {
if (doing == DoingItems) {
f->Args.push_back(args[i]);
} else if (args[i] == "LISTS") {
doing = DoingLists;
} else if (args[i] == "ITEMS") {
doing = DoingItems;
} else if (doing == DoingLists) {
const char* value = this->Makefile->GetDefinition(args[i]);
if (value && *value) {
cmSystemTools::ExpandListArgument(value, f->Args, true);
}
} else {
std::ostringstream e;
e << "Unknown argument:\n"
<< " " << args[i] << "\n";
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
return true;
}
}
this->Makefile->AddFunctionBlocker(f.release()); // TODO: pass auto_ptr
return true;
}