CMakeLua/Source/cmForEachCommand.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmForEachCommand.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-03-17 19:10:15 $
   7   Version:   $Revision: 1.31 $
   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 #include "cmForEachCommand.h"
  18
  19 #include <cmsys/auto_ptr.hxx>
  20
  21 bool cmForEachFunctionBlocker::
  22 IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
  23                   cmExecutionStatus &inStatus)
  24 {
  25   if (!cmSystemTools::Strucmp(lff.Name.c_str(),"foreach"))
  26     {
  27     // record the number of nested foreach commands
  28     this->Depth++;
  29     }
  30   else if (!cmSystemTools::Strucmp(lff.Name.c_str(),"endforeach"))
  31     {
  32     // if this is the endofreach for this statement
  33     if (!this->Depth)
  34       {
  35       // Remove the function blocker for this scope or bail.
  36       cmsys::auto_ptr<cmFunctionBlocker>
  37         fb(mf.RemoveFunctionBlocker(this, lff));
  38       if(!fb.get()) { return false; }
  39
  40       // at end of for each execute recorded commands
  41       // store the old value
  42       std::string oldDef;
  43       if (mf.GetDefinition(this->Args[0].c_str()))
  44         {
  45         oldDef = mf.GetDefinition(this->Args[0].c_str());
  46         }
  47       std::vector<std::string>::const_iterator j = this->Args.begin();
  48       ++j;
  49
  50       std::string tmps;
  51       cmListFileArgument arg;
  52       for( ; j != this->Args.end(); ++j)
  53         {
  54         // set the variable to the loop value
  55         mf.AddDefinition(this->Args[0].c_str(),j->c_str());
  56         // Invoke all the functions that were collected in the block.
  57         cmExecutionStatus status;
  58         for(unsigned int c = 0; c < this->Functions.size(); ++c)
  59           {
  60           status.Clear();
  61           mf.ExecuteCommand(this->Functions[c],status);
  62           if (status.GetReturnInvoked())
  63             {
  64             inStatus.SetReturnInvoked(true);
  65             // restore the variable to its prior value
  66             mf.AddDefinition(this->Args[0].c_str(),oldDef.c_str());
  67             return true;
  68             }
  69           if (status.GetBreakInvoked())
  70             {
  71             // restore the variable to its prior value
  72             mf.AddDefinition(this->Args[0].c_str(),oldDef.c_str());
  73             return true;
  74             }
  75           }
  76         }
  77       // restore the variable to its prior value
  78       mf.AddDefinition(this->Args[0].c_str(),oldDef.c_str());
  79       return true;
  80       }
  81     else
  82       {
  83       // close out a nested foreach
  84       this->Depth--;
  85       }
  86     }
  87
  88   // record the command
  89   this->Functions.push_back(lff);
  90
  91   // always return true
  92   return true;
  93 }
  94
  95 bool cmForEachFunctionBlocker::
  96 ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf)
  97 {
  98   if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endforeach"))
  99     {
 100     std::vector<std::string> expandedArguments;
 101     mf.ExpandArguments(lff.Arguments, expandedArguments);
 102     // if the endforeach has arguments then make sure
 103     // they match the begin foreach arguments
 104     if ((expandedArguments.empty() ||
 105          (expandedArguments[0] == this->Args[0])))
 106       {
 107       return true;
 108       }
 109     }
 110   return false;
 111 }
 112
 113 bool cmForEachCommand
 114 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 115 {
 116   if(args.size() < 1)
 117     {
 118     this->SetError("called with incorrect number of arguments");
 119     return false;
 120     }
 121   if(args.size() > 1 && args[1] == "IN")
 122     {
 123     return this->HandleInMode(args);
 124     }
 125
 126   // create a function blocker
 127   cmForEachFunctionBlocker *f = new cmForEachFunctionBlocker();
 128   if ( args.size() > 1 )
 129     {
 130     if ( args[1] == "RANGE" )
 131       {
 132       int start = 0;
 133       int stop = 0;
 134       int step = 0;
 135       if ( args.size() == 3 )
 136         {
 137         stop = atoi(args[2].c_str());
 138         }
 139       if ( args.size() == 4 )
 140         {
 141         start = atoi(args[2].c_str());
 142         stop = atoi(args[3].c_str());
 143         }
 144       if ( args.size() == 5 )
 145         {
 146         start = atoi(args[2].c_str());
 147         stop = atoi(args[3].c_str());
 148         step = atoi(args[4].c_str());
 149         }
 150       if ( step == 0 )
 151         {
 152         if ( start > stop )
 153           {
 154           step = -1;
 155           }
 156         else
 157           {
 158           step = 1;
 159           }
 160         }
 161       if (
 162         (start > stop && step > 0) ||
 163         (start < stop && step < 0) ||
 164         step == 0
 165         )
 166         {
 167         cmOStringStream str;
 168         str << "called with incorrect range specification: start ";
 169         str << start << ", stop " << stop << ", step " << step;
 170         this->SetError(str.str().c_str());
 171         return false;
 172         }
 173       std::vector<std::string> range;
 174       char buffer[100];
 175       range.push_back(args[0]);
 176       int cc;
 177       for ( cc = start; ; cc += step )
 178         {
 179         if ( (step > 0 && cc > stop) || (step < 0 && cc < stop) )
 180           {
 181           break;
 182           }
 183         sprintf(buffer, "%d", cc);
 184         range.push_back(buffer);
 185         if ( cc == stop )
 186           {
 187           break;
 188           }
 189         }
 190       f->Args = range;
 191       }
 192     else
 193       {
 194       f->Args = args;
 195       }
 196     }
 197   else
 198     {
 199     f->Args = args;
 200     }
 201   this->Makefile->AddFunctionBlocker(f);
 202
 203   return true;
 204 }
 205
 206 //----------------------------------------------------------------------------
 207 bool cmForEachCommand::HandleInMode(std::vector<std::string> const& args)
 208 {
 209   cmsys::auto_ptr<cmForEachFunctionBlocker> f(new cmForEachFunctionBlocker());
 210   f->Args.push_back(args[0]);
 211
 212   enum Doing { DoingNone, DoingLists, DoingItems };
 213   Doing doing = DoingNone;
 214   for(unsigned int i=2; i < args.size(); ++i)
 215     {
 216     if(doing == DoingItems)
 217       {
 218       f->Args.push_back(args[i]);
 219       }
 220     else if(args[i] == "LISTS")
 221       {
 222       doing = DoingLists;
 223       }
 224     else if(args[i] == "ITEMS")
 225       {
 226       doing = DoingItems;
 227       }
 228     else if(doing == DoingLists)
 229       {
 230       const char* value = this->Makefile->GetDefinition(args[i].c_str());
 231       if(value && *value)
 232         {
 233         cmSystemTools::ExpandListArgument(value, f->Args, true);
 234         }
 235       }
 236     else
 237       {
 238       cmOStringStream e;
 239       e << "Unknown argument:\n" << "  " << args[i] << "\n";
 240       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 241       return true;
 242       }
 243     }
 244
 245   this->Makefile->AddFunctionBlocker(f.release()); // TODO: pass auto_ptr
 246   return true;
 247 }