Source/cmCommandArgumentsHelper.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmCommandArgumentsHelper.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2007-08-23 20:13:15 $
   7   Version:   $Revision: 1.4 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17
  18 #include "cmCommandArgumentsHelper.h"
  19
  20 cmCommandArgument::cmCommandArgument(cmCommandArgumentsHelper* args,
  21                                      const char* key,
  22                                      cmCommandArgumentGroup* group)
  23 :Key(key)
  24 ,Group(group)
  25 ,WasActive(false)
  26 ,ArgumentsBeforeEmpty(true)
  27 ,CurrentIndex(0)
  28 {
  29   if (args!=0)
  30     {
  31     args->AddArgument(this);
  32     }
  33
  34   if (this->Group!=0)
  35     {
  36     this->Group->ContainedArguments.push_back(this);
  37     }
  38 }
  39
  40 void cmCommandArgument::Reset()
  41 {
  42   this->WasActive =false;
  43   this->CurrentIndex = 0;
  44   this->DoReset();
  45 }
  46
  47 void cmCommandArgument::Follows(const cmCommandArgument* arg)
  48 {
  49   this->ArgumentsBeforeEmpty = false;
  50   this->ArgumentsBefore.insert(arg);
  51 }
  52
  53 void cmCommandArgument::FollowsGroup(const cmCommandArgumentGroup* group)
  54 {
  55   if (group!=0)
  56     {
  57     this->ArgumentsBeforeEmpty = false;
  58     for(std::vector<cmCommandArgument*>::const_iterator
  59         argIt= group->ContainedArguments.begin();
  60         argIt != group->ContainedArguments.end();
  61         ++argIt)
  62       {
  63       this->ArgumentsBefore.insert(*argIt);
  64       }
  65     }
  66 }
  67
  68 bool cmCommandArgument::MayFollow(const cmCommandArgument* current) const
  69 {
  70   if (this->ArgumentsBeforeEmpty)
  71     {
  72     return true;
  73     }
  74
  75   std::set<const cmCommandArgument*>::const_iterator argIt
  76                                          = this->ArgumentsBefore.find(current);
  77   if (argIt != this->ArgumentsBefore.end())
  78     {
  79     return true;
  80     }
  81
  82   return false;
  83 }
  84
  85 bool cmCommandArgument::KeyMatches(const std::string& key) const
  86 {
  87   if ((this->Key==0) || (this->Key[0]=='\0'))
  88     {
  89     return true;
  90     }
  91   return (key==this->Key);
  92 }
  93
  94 void cmCommandArgument::ApplyOwnGroup()
  95 {
  96   if (this->Group!=0)
  97     {
  98     for (std::vector<cmCommandArgument*>::const_iterator
  99          it = this->Group->ContainedArguments.begin();
 100          it != this->Group->ContainedArguments.end();
 101          ++it)
 102       {
 103       if(*it != this)
 104         {
 105         this->ArgumentsBefore.insert(*it);
 106         }
 107       }
 108     }
 109 }
 110
 111 void cmCommandArgument::Activate()
 112 {
 113   this->WasActive = true;
 114   this->CurrentIndex = 0;
 115 }
 116
 117 bool cmCommandArgument::Consume(const std::string& arg)
 118 {
 119   bool res=this->DoConsume(arg, this->CurrentIndex);
 120   this->CurrentIndex++;
 121   return res;
 122 }
 123
 124
 125 cmCAStringVector::cmCAStringVector(cmCommandArgumentsHelper* args,
 126                                    const char* key,
 127                                    cmCommandArgumentGroup* group)
 128 :cmCommandArgument(args, key, group)
 129 ,Ignore(0)
 130 {
 131   if ((key==0) || (*key==0))
 132     {
 133     this->DataStart = 0;
 134     }
 135   else
 136     {
 137     this->DataStart = 1;
 138     }
 139 }
 140
 141 bool cmCAStringVector::DoConsume(const std::string& arg,unsigned int index)
 142 {
 143   if (index >= this->DataStart)
 144     {
 145     if ((this->Ignore==0) || (arg != this->Ignore))
 146       {
 147       this->Vector.push_back(arg);
 148       }
 149     }
 150
 151   return false;
 152 }
 153
 154 void cmCAStringVector::DoReset()
 155 {
 156   this->Vector.clear();
 157 }
 158
 159 cmCAString::cmCAString(cmCommandArgumentsHelper* args,
 160                        const char* key,
 161                        cmCommandArgumentGroup* group)
 162 :cmCommandArgument(args, key, group)
 163 {
 164   if ((key==0) || (*key==0))
 165     {
 166     this->DataStart = 0;
 167     }
 168   else
 169     {
 170     this->DataStart = 1;
 171     }
 172 }
 173
 174 bool cmCAString::DoConsume(const std::string& arg, unsigned int index)
 175 {
 176   if (index == this->DataStart)
 177     {
 178     this->String = arg;
 179     }
 180
 181   return index >= this->DataStart;
 182 }
 183
 184 void cmCAString::DoReset()
 185 {
 186   this->String = this->DefaultString;
 187 }
 188
 189 cmCAEnabler::cmCAEnabler(cmCommandArgumentsHelper* args,
 190                          const char* key,
 191                          cmCommandArgumentGroup* group)
 192 :cmCommandArgument(args, key, group)
 193 ,Enabled(false)
 194 {}
 195
 196 bool cmCAEnabler::DoConsume(const std::string&, unsigned int index)
 197 {
 198   if (index==0)
 199     {
 200     this->Enabled = true;
 201     }
 202   return true;
 203 }
 204
 205 void cmCAEnabler::DoReset()
 206 {
 207   this->Enabled = false;
 208 }
 209
 210 cmCADisabler::cmCADisabler(cmCommandArgumentsHelper* args,
 211                            const char* key,
 212                            cmCommandArgumentGroup* group)
 213 :cmCommandArgument(args, key, group)
 214 ,Enabled(true)
 215 {}
 216
 217 bool cmCADisabler::DoConsume(const std::string&, unsigned int index)
 218 {
 219   if (index==0)
 220     {
 221     this->Enabled = false;
 222     }
 223   return true;
 224 }
 225
 226 void cmCADisabler::DoReset()
 227 {
 228   this->Enabled = true;
 229 }
 230
 231 void cmCommandArgumentGroup::Follows(const cmCommandArgument* arg)
 232 {
 233   for(std::vector<cmCommandArgument*>::iterator
 234       it = this->ContainedArguments.begin();
 235       it != this->ContainedArguments.end();
 236       ++it)
 237     {
 238     (*it)->Follows(arg);
 239     }
 240 }
 241
 242 void cmCommandArgumentGroup::FollowsGroup(const cmCommandArgumentGroup* group)
 243 {
 244   for(std::vector<cmCommandArgument*>::iterator
 245       it = this->ContainedArguments.begin();
 246       it != this->ContainedArguments.end();
 247       ++it)
 248     {
 249     (*it)->FollowsGroup(group);
 250     }
 251 }
 252
 253 void cmCommandArgumentsHelper::Parse(const std::vector<std::string>* args,
 254                                      std::vector<std::string>* unconsumedArgs)
 255 {
 256   if(args==0)
 257     {
 258     return;
 259     }
 260
 261   for(std::vector<cmCommandArgument*>::iterator
 262       argIt = this->Arguments.begin();
 263       argIt != this->Arguments.end();
 264       ++argIt)
 265     {
 266     (*argIt)->ApplyOwnGroup();
 267     (*argIt)->Reset();
 268     }
 269
 270   cmCommandArgument* activeArgument = 0;
 271   const cmCommandArgument* previousArgument = 0;
 272   for(std::vector<std::string>::const_iterator it = args->begin();
 273       it != args->end();
 274       ++it)
 275     {
 276     for(std::vector<cmCommandArgument*>::iterator
 277         argIt = this->Arguments.begin();
 278         argIt != this->Arguments.end();
 279         ++argIt)
 280       {
 281       if ((*argIt)->KeyMatches(*it) && ((*argIt)->MayFollow(previousArgument)))
 282         {
 283         activeArgument = *argIt;
 284         activeArgument->Activate();
 285         break;
 286         }
 287       }
 288
 289     if (activeArgument)
 290       {
 291       bool argDone = activeArgument->Consume(*it);
 292       previousArgument = activeArgument;
 293       if (argDone)
 294         {
 295         activeArgument = 0;
 296         }
 297       }
 298     else
 299       {
 300       if (unconsumedArgs!=0)
 301         {
 302         unconsumedArgs->push_back(*it);
 303         }
 304       }
 305     }
 306 }
 307
 308 void cmCommandArgumentsHelper::AddArgument(cmCommandArgument* arg)
 309 {
 310   this->Arguments.push_back(arg);
 311 }
 312