CMake/Source/cmCommandArgumentsHelper.cxx

263 lines
6.3 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
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.
============================================================================*/
#include "cmCommandArgumentsHelper.h"
cmCommandArgument::cmCommandArgument(cmCommandArgumentsHelper* args,
const char* key,
cmCommandArgumentGroup* group)
: Key(key)
, Group(group)
, WasActive(false)
, ArgumentsBeforeEmpty(true)
, CurrentIndex(0)
{
if (args != 0) {
args->AddArgument(this);
}
if (this->Group != 0) {
this->Group->ContainedArguments.push_back(this);
}
}
void cmCommandArgument::Reset()
{
this->WasActive = false;
this->CurrentIndex = 0;
this->DoReset();
}
void cmCommandArgument::Follows(const cmCommandArgument* arg)
{
this->ArgumentsBeforeEmpty = false;
this->ArgumentsBefore.insert(arg);
}
void cmCommandArgument::FollowsGroup(const cmCommandArgumentGroup* group)
{
if (group != 0) {
this->ArgumentsBeforeEmpty = false;
this->ArgumentsBefore.insert(group->ContainedArguments.begin(),
group->ContainedArguments.end());
}
}
bool cmCommandArgument::MayFollow(const cmCommandArgument* current) const
{
if (this->ArgumentsBeforeEmpty) {
return true;
}
std::set<const cmCommandArgument*>::const_iterator argIt =
this->ArgumentsBefore.find(current);
if (argIt != this->ArgumentsBefore.end()) {
return true;
}
return false;
}
bool cmCommandArgument::KeyMatches(const std::string& key) const
{
if ((this->Key == 0) || (this->Key[0] == '\0')) {
return true;
}
return (key == this->Key);
}
void cmCommandArgument::ApplyOwnGroup()
{
if (this->Group != 0) {
for (std::vector<cmCommandArgument*>::const_iterator it =
this->Group->ContainedArguments.begin();
it != this->Group->ContainedArguments.end(); ++it) {
if (*it != this) {
this->ArgumentsBefore.insert(*it);
}
}
}
}
void cmCommandArgument::Activate()
{
this->WasActive = true;
this->CurrentIndex = 0;
}
bool cmCommandArgument::Consume(const std::string& arg)
{
bool res = this->DoConsume(arg, this->CurrentIndex);
this->CurrentIndex++;
return res;
}
cmCAStringVector::cmCAStringVector(cmCommandArgumentsHelper* args,
const char* key,
cmCommandArgumentGroup* group)
: cmCommandArgument(args, key, group)
, Ignore(0)
{
if ((key == 0) || (*key == 0)) {
this->DataStart = 0;
} else {
this->DataStart = 1;
}
}
bool cmCAStringVector::DoConsume(const std::string& arg, unsigned int index)
{
if (index >= this->DataStart) {
if ((this->Ignore == 0) || (arg != this->Ignore)) {
this->Vector.push_back(arg);
}
}
return false;
}
void cmCAStringVector::DoReset()
{
this->Vector.clear();
}
cmCAString::cmCAString(cmCommandArgumentsHelper* args, const char* key,
cmCommandArgumentGroup* group)
: cmCommandArgument(args, key, group)
{
if ((key == 0) || (*key == 0)) {
this->DataStart = 0;
} else {
this->DataStart = 1;
}
}
bool cmCAString::DoConsume(const std::string& arg, unsigned int index)
{
if (index == this->DataStart) {
this->String = arg;
}
return index >= this->DataStart;
}
void cmCAString::DoReset()
{
this->String = "";
}
cmCAEnabler::cmCAEnabler(cmCommandArgumentsHelper* args, const char* key,
cmCommandArgumentGroup* group)
: cmCommandArgument(args, key, group)
, Enabled(false)
{
}
2007-07-03 00:46:18 +04:00
bool cmCAEnabler::DoConsume(const std::string&, unsigned int index)
{
if (index == 0) {
this->Enabled = true;
}
return true;
}
void cmCAEnabler::DoReset()
{
this->Enabled = false;
}
cmCADisabler::cmCADisabler(cmCommandArgumentsHelper* args, const char* key,
cmCommandArgumentGroup* group)
: cmCommandArgument(args, key, group)
, Enabled(true)
{
}
2007-07-03 00:46:18 +04:00
bool cmCADisabler::DoConsume(const std::string&, unsigned int index)
{
if (index == 0) {
this->Enabled = false;
}
return true;
}
void cmCADisabler::DoReset()
{
this->Enabled = true;
}
void cmCommandArgumentGroup::Follows(const cmCommandArgument* arg)
{
for (std::vector<cmCommandArgument*>::iterator it =
this->ContainedArguments.begin();
it != this->ContainedArguments.end(); ++it) {
(*it)->Follows(arg);
}
}
void cmCommandArgumentGroup::FollowsGroup(const cmCommandArgumentGroup* group)
{
for (std::vector<cmCommandArgument*>::iterator it =
this->ContainedArguments.begin();
it != this->ContainedArguments.end(); ++it) {
(*it)->FollowsGroup(group);
}
}
void cmCommandArgumentsHelper::Parse(const std::vector<std::string>* args,
std::vector<std::string>* unconsumedArgs)
{
if (args == 0) {
return;
}
for (std::vector<cmCommandArgument*>::iterator argIt =
this->Arguments.begin();
argIt != this->Arguments.end(); ++argIt) {
(*argIt)->ApplyOwnGroup();
(*argIt)->Reset();
}
cmCommandArgument* activeArgument = 0;
const cmCommandArgument* previousArgument = 0;
for (std::vector<std::string>::const_iterator it = args->begin();
it != args->end(); ++it) {
for (std::vector<cmCommandArgument*>::iterator argIt =
this->Arguments.begin();
argIt != this->Arguments.end(); ++argIt) {
if ((*argIt)->KeyMatches(*it) &&
((*argIt)->MayFollow(previousArgument))) {
activeArgument = *argIt;
activeArgument->Activate();
break;
}
}
if (activeArgument) {
bool argDone = activeArgument->Consume(*it);
previousArgument = activeArgument;
if (argDone) {
activeArgument = 0;
}
} else {
if (unconsumedArgs != 0) {
unconsumedArgs->push_back(*it);
}
}
}
}
void cmCommandArgumentsHelper::AddArgument(cmCommandArgument* arg)
{
this->Arguments.push_back(arg);
}