Source/cmFunctionCommand.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmFunctionCommand.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-01-22 18:16:47 $
   7   Version:   $Revision: 1.11 $
   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 "cmFunctionCommand.h"
  18
  19 #include "cmake.h"
  20
  21 // define the class for function commands
  22 class cmFunctionHelperCommand : public cmCommand
  23 {
  24 public:
  25   cmFunctionHelperCommand() {}
  26
  27   ///! clean up any memory allocated by the function
  28   ~cmFunctionHelperCommand() {};
  29
  30   /**
  31    * This is a virtual constructor for the command.
  32    */
  33   virtual cmCommand* Clone()
  34   {
  35     cmFunctionHelperCommand *newC = new cmFunctionHelperCommand;
  36     // we must copy when we clone
  37     newC->Args = this->Args;
  38     newC->Functions = this->Functions;
  39     newC->Policies = this->Policies;
  40     return newC;
  41   }
  42
  43   /**
  44    * This determines if the command is invoked when in script mode.
  45    */
  46   virtual bool IsScriptable() { return true; }
  47
  48   /**
  49    * This is called when the command is first encountered in
  50    * the CMakeLists.txt file.
  51    */
  52   virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
  53                                  cmExecutionStatus &);
  54
  55   virtual bool InitialPass(std::vector<std::string> const&,
  56                            cmExecutionStatus &) { return false; };
  57
  58   /**
  59    * The name of the command as specified in CMakeList.txt.
  60    */
  61   virtual const char* GetName() { return this->Args[0].c_str(); }
  62
  63   /**
  64    * Succinct documentation.
  65    */
  66   virtual const char* GetTerseDocumentation()
  67   {
  68     std::string docs = "Function named: ";
  69     docs += this->GetName();
  70     return docs.c_str();
  71   }
  72
  73   /**
  74    * More documentation.
  75    */
  76   virtual const char* GetFullDocumentation()
  77   {
  78     return this->GetTerseDocumentation();
  79   }
  80
  81   cmTypeMacro(cmFunctionHelperCommand, cmCommand);
  82
  83   std::vector<std::string> Args;
  84   std::vector<cmListFileFunction> Functions;
  85   cmPolicies::PolicyMap Policies;
  86 };
  87
  88
  89 bool cmFunctionHelperCommand::InvokeInitialPass
  90 (const std::vector<cmListFileArgument>& args,
  91  cmExecutionStatus & inStatus)
  92 {
  93   // Expand the argument list to the function.
  94   std::vector<std::string> expandedArgs;
  95   this->Makefile->ExpandArguments(args, expandedArgs);
  96
  97   // make sure the number of arguments passed is at least the number
  98   // required by the signature
  99   if (expandedArgs.size() < this->Args.size() - 1)
 100     {
 101     std::string errorMsg =
 102       "Function invoked with incorrect arguments for function named: ";
 103     errorMsg += this->Args[0];
 104     this->SetError(errorMsg.c_str());
 105     return false;
 106     }
 107
 108   // we push a scope on the makefile
 109   cmMakefile::LexicalPushPop lexScope(this->Makefile);
 110   cmMakefile::ScopePushPop varScope(this->Makefile);
 111   static_cast<void>(varScope);
 112
 113   // Push a weak policy scope which restores the policies recorded at
 114   // function creation.
 115   cmMakefile::PolicyPushPop polScope(this->Makefile, true, this->Policies);
 116
 117   // set the value of argc
 118   cmOStringStream strStream;
 119   strStream << expandedArgs.size();
 120   this->Makefile->AddDefinition("ARGC",strStream.str().c_str());
 121
 122   // set the values for ARGV0 ARGV1 ...
 123   for (unsigned int t = 0; t < expandedArgs.size(); ++t)
 124     {
 125     cmOStringStream tmpStream;
 126     tmpStream << "ARGV" << t;
 127     this->Makefile->AddDefinition(tmpStream.str().c_str(),
 128                                   expandedArgs[t].c_str());
 129     }
 130
 131   // define the formal arguments
 132   for (unsigned int j = 1; j < this->Args.size(); ++j)
 133     {
 134     this->Makefile->AddDefinition(this->Args[j].c_str(),
 135                                   expandedArgs[j-1].c_str());
 136     }
 137
 138   // define ARGV and ARGN
 139   std::vector<std::string>::const_iterator eit;
 140   std::string argvDef;
 141   std::string argnDef;
 142   unsigned int cnt = 0;
 143   for ( eit = expandedArgs.begin(); eit != expandedArgs.end(); ++eit )
 144     {
 145     if ( argvDef.size() > 0 )
 146       {
 147       argvDef += ";";
 148       }
 149     argvDef += *eit;
 150     if ( cnt >= this->Args.size()-1 )
 151       {
 152       if ( argnDef.size() > 0 )
 153         {
 154         argnDef += ";";
 155         }
 156       argnDef += *eit;
 157       }
 158     cnt ++;
 159     }
 160   this->Makefile->AddDefinition("ARGV", argvDef.c_str());
 161   this->Makefile->AddDefinition("ARGN", argnDef.c_str());
 162
 163   // Invoke all the functions that were collected in the block.
 164   // for each function
 165   for(unsigned int c = 0; c < this->Functions.size(); ++c)
 166     {
 167     cmExecutionStatus status;
 168     if (!this->Makefile->ExecuteCommand(this->Functions[c],status) ||
 169         status.GetNestedError())
 170       {
 171       // The error message should have already included the call stack
 172       // so we do not need to report an error here.
 173       lexScope.Quiet();
 174       polScope.Quiet();
 175       inStatus.SetNestedError(true);
 176       return false;
 177       }
 178     if (status.GetReturnInvoked())
 179       {
 180       return true;
 181       }
 182     }
 183
 184   // pop scope on the makefile
 185   return true;
 186 }
 187
 188 bool cmFunctionFunctionBlocker::
 189 IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
 190                   cmExecutionStatus &)
 191 {
 192   // record commands until we hit the ENDFUNCTION
 193   // at the ENDFUNCTION call we shift gears and start looking for invocations
 194   if(!cmSystemTools::Strucmp(lff.Name.c_str(),"function"))
 195     {
 196     this->Depth++;
 197     }
 198   else if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endfunction"))
 199     {
 200     // if this is the endfunction for this function then execute
 201     if (!this->Depth)
 202       {
 203       std::string name = this->Args[0];
 204       std::vector<std::string>::size_type cc;
 205       name += "(";
 206       for ( cc = 0; cc < this->Args.size(); cc ++ )
 207         {
 208         name += " " + this->Args[cc];
 209         }
 210       name += " )";
 211
 212       // create a new command and add it to cmake
 213       cmFunctionHelperCommand *f = new cmFunctionHelperCommand();
 214       f->Args = this->Args;
 215       f->Functions = this->Functions;
 216       mf.RecordPolicies(f->Policies);
 217
 218       // Set the FilePath on the arguments to match the function since it is
 219       // not stored and the original values may be freed
 220       for (unsigned int i = 0; i < f->Functions.size(); ++i)
 221         {
 222         for (unsigned int j = 0; j < f->Functions[i].Arguments.size(); ++j)
 223           {
 224           f->Functions[i].Arguments[j].FilePath =
 225             f->Functions[i].FilePath.c_str();
 226           }
 227         }
 228
 229       std::string newName = "_" + this->Args[0];
 230       mf.GetCMakeInstance()->RenameCommand(this->Args[0].c_str(),
 231                                            newName.c_str());
 232       mf.AddCommand(f);
 233
 234       // remove the function blocker now that the function is defined
 235       mf.RemoveFunctionBlocker(this, lff);
 236       return true;
 237       }
 238     else
 239       {
 240       // decrement for each nested function that ends
 241       this->Depth--;
 242       }
 243     }
 244
 245   // if it wasn't an endfunction and we are not executing then we must be
 246   // recording
 247   this->Functions.push_back(lff);
 248   return true;
 249 }
 250
 251
 252 bool cmFunctionFunctionBlocker::
 253 ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
 254 {
 255   if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endfunction"))
 256     {
 257     std::vector<std::string> expandedArguments;
 258     mf.ExpandArguments(lff.Arguments, expandedArguments);
 259     // if the endfunction has arguments then make sure
 260     // they match the ones in the openeing function command
 261     if ((expandedArguments.empty() ||
 262          (expandedArguments[0] == this->Args[0])))
 263       {
 264       return true;
 265       }
 266     }
 267
 268   return false;
 269 }
 270
 271 bool cmFunctionCommand
 272 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 273 {
 274   if(args.size() < 1)
 275     {
 276     this->SetError("called with incorrect number of arguments");
 277     return false;
 278     }
 279
 280   // create a function blocker
 281   cmFunctionFunctionBlocker *f = new cmFunctionFunctionBlocker();
 282   for(std::vector<std::string>::const_iterator j = args.begin();
 283       j != args.end(); ++j)
 284     {
 285     f->Args.push_back(*j);
 286     }
 287   this->Makefile->AddFunctionBlocker(f);
 288   return true;
 289 }
 290