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-05-13 15:08:28 $
   7   Version:   $Revision: 1.32 $
   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           if(cmSystemTools::GetFatalErrorOccured() )
  76             {
  77             return true;
  78             }
  79           }
  80         }
  81       // restore the variable to its prior value
  82       mf.AddDefinition(this->Args[0].c_str(),oldDef.c_str());
  83       return true;
  84       }
  85     else
  86       {
  87       // close out a nested foreach
  88       this->Depth--;
  89       }
  90     }
  91
  92   // record the command
  93   this->Functions.push_back(lff);
  94
  95   // always return true
  96   return true;
  97 }
  98
  99 bool cmForEachFunctionBlocker::
 100 ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf)
 101 {
 102   if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endforeach"))
 103     {
 104     std::vector<std::string> expandedArguments;
 105     mf.ExpandArguments(lff.Arguments, expandedArguments);
 106     // if the endforeach has arguments then make sure
 107     // they match the begin foreach arguments
 108     if ((expandedArguments.empty() ||
 109          (expandedArguments[0] == this->Args[0])))
 110       {
 111       return true;
 112       }
 113     }
 114   return false;
 115 }
 116
 117 bool cmForEachCommand
 118 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 119 {
 120   if(args.size() < 1)
 121     {
 122     this->SetError("called with incorrect number of arguments");
 123     return false;
 124     }
 125   if(args.size() > 1 && args[1] == "IN")
 126     {
 127     return this->HandleInMode(args);
 128     }
 129
 130   // create a function blocker
 131   cmForEachFunctionBlocker *f = new cmForEachFunctionBlocker();
 132   if ( args.size() > 1 )
 133     {
 134     if ( args[1] == "RANGE" )
 135       {
 136       int start = 0;
 137       int stop = 0;
 138       int step = 0;
 139       if ( args.size() == 3 )
 140         {
 141         stop = atoi(args[2].c_str());
 142         }
 143       if ( args.size() == 4 )
 144         {
 145         start = atoi(args[2].c_str());
 146         stop = atoi(args[3].c_str());
 147         }
 148       if ( args.size() == 5 )
 149         {
 150         start = atoi(args[2].c_str());
 151         stop = atoi(args[3].c_str());
 152         step = atoi(args[4].c_str());
 153         }
 154       if ( step == 0 )
 155         {
 156         if ( start > stop )
 157           {
 158           step = -1;
 159           }
 160         else
 161           {
 162           step = 1;
 163           }
 164         }
 165       if (
 166         (start > stop && step > 0) ||
 167         (start < stop && step < 0) ||
 168         step == 0
 169         )
 170         {
 171         cmOStringStream str;
 172         str << "called with incorrect range specification: start ";
 173         str << start << ", stop " << stop << ", step " << step;
 174         this->SetError(str.str().c_str());
 175         return false;
 176         }
 177       std::vector<std::string> range;
 178       char buffer[100];
 179       range.push_back(args[0]);
 180       int cc;
 181       for ( cc = start; ; cc += step )
 182         {
 183         if ( (step > 0 && cc > stop) || (step < 0 && cc < stop) )
 184           {
 185           break;
 186           }
 187         sprintf(buffer, "%d", cc);
 188         range.push_back(buffer);
 189         if ( cc == stop )
 190           {
 191           break;
 192           }
 193         }
 194       f->Args = range;
 195       }
 196     else
 197       {
 198       f->Args = args;
 199       }
 200     }
 201   else
 202     {
 203     f->Args = args;
 204     }
 205   this->Makefile->AddFunctionBlocker(f);
 206
 207   return true;
 208 }
 209
 210 //----------------------------------------------------------------------------
 211 bool cmForEachCommand::HandleInMode(std::vector<std::string> const& args)
 212 {
 213   cmsys::auto_ptr<cmForEachFunctionBlocker> f(new cmForEachFunctionBlocker());
 214   f->Args.push_back(args[0]);
 215
 216   enum Doing { DoingNone, DoingLists, DoingItems };
 217   Doing doing = DoingNone;
 218   for(unsigned int i=2; i < args.size(); ++i)
 219     {
 220     if(doing == DoingItems)
 221       {
 222       f->Args.push_back(args[i]);
 223       }
 224     else if(args[i] == "LISTS")
 225       {
 226       doing = DoingLists;
 227       }
 228     else if(args[i] == "ITEMS")
 229       {
 230       doing = DoingItems;
 231       }
 232     else if(doing == DoingLists)
 233       {
 234       const char* value = this->Makefile->GetDefinition(args[i].c_str());
 235       if(value && *value)
 236         {
 237         cmSystemTools::ExpandListArgument(value, f->Args, true);
 238         }
 239       }
 240     else
 241       {
 242       cmOStringStream e;
 243       e << "Unknown argument:\n" << "  " << args[i] << "\n";
 244       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 245       return true;
 246       }
 247     }
 248
 249   this->Makefile->AddFunctionBlocker(f.release()); // TODO: pass auto_ptr
 250   return true;
 251 }