Source/cmMacroCommand.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmMacroCommand.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2008-03-07 13:40:36 $
   7   Version:   $Revision: 1.36 $
   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 "cmMacroCommand.h"
  18
  19 #include "cmake.h"
  20
  21 // define the class for macro commands
  22 class cmMacroHelperCommand : public cmCommand
  23 {
  24 public:
  25   cmMacroHelperCommand() {}
  26
  27   ///! clean up any memory allocated by the macro
  28   ~cmMacroHelperCommand() {};
  29
  30   /**
  31    * This is a virtual constructor for the command.
  32    */
  33   virtual cmCommand* Clone()
  34   {
  35     cmMacroHelperCommand *newC = new cmMacroHelperCommand;
  36     // we must copy when we clone
  37     newC->Args = this->Args;
  38     newC->Functions = this->Functions;
  39     return newC;
  40   }
  41
  42   /**
  43    * This determines if the command is invoked when in script mode.
  44    */
  45   virtual bool IsScriptable() { return true; }
  46
  47   /**
  48    * This is called when the command is first encountered in
  49    * the CMakeLists.txt file.
  50    */
  51   virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
  52                                  cmExecutionStatus &);
  53
  54   virtual bool InitialPass(std::vector<std::string> const&,
  55                            cmExecutionStatus &) { return false; };
  56
  57   /**
  58    * The name of the command as specified in CMakeList.txt.
  59    */
  60   virtual const char* GetName() { return this->Args[0].c_str(); }
  61
  62   /**
  63    * Succinct documentation.
  64    */
  65   virtual const char* GetTerseDocumentation()
  66   {
  67     std::string docs = "Macro named: ";
  68     docs += this->GetName();
  69     return docs.c_str();
  70   }
  71
  72   /**
  73    * More documentation.
  74    */
  75   virtual const char* GetFullDocumentation()
  76   {
  77     return this->GetTerseDocumentation();
  78   }
  79
  80   cmTypeMacro(cmMacroHelperCommand, cmCommand);
  81
  82   std::vector<std::string> Args;
  83   std::vector<cmListFileFunction> Functions;
  84 };
  85
  86
  87 bool cmMacroHelperCommand::InvokeInitialPass
  88 (const std::vector<cmListFileArgument>& args,
  89  cmExecutionStatus &inStatus)
  90 {
  91   // Expand the argument list to the macro.
  92   std::vector<std::string> expandedArgs;
  93   this->Makefile->ExpandArguments(args, expandedArgs);
  94
  95   std::string tmps;
  96   cmListFileArgument arg;
  97   std::string variable;
  98
  99   // make sure the number of arguments passed is at least the number
 100   // required by the signature
 101   if (expandedArgs.size() < this->Args.size() - 1)
 102     {
 103     std::string errorMsg =
 104       "Macro invoked with incorrect arguments for macro named: ";
 105     errorMsg += this->Args[0];
 106     this->SetError(errorMsg.c_str());
 107     return false;
 108     }
 109
 110   // set the value of argc
 111   cmOStringStream argcDefStream;
 112   argcDefStream << expandedArgs.size();
 113   std::string argcDef = argcDefStream.str();
 114
 115   // declare varuiables for ARGV ARGN but do not compute until needed
 116   std::string argvDef;
 117   std::string argnDef;
 118   bool argnDefInitialized = false;
 119   bool argvDefInitialized = false;
 120
 121   // Invoke all the functions that were collected in the block.
 122   cmListFileFunction newLFF;
 123   // for each function
 124   for(unsigned int c = 0; c < this->Functions.size(); ++c)
 125     {
 126     // Replace the formal arguments and then invoke the command.
 127     newLFF.Arguments.clear();
 128     newLFF.Arguments.reserve(this->Functions[c].Arguments.size());
 129     newLFF.Name = this->Functions[c].Name;
 130     newLFF.FilePath = this->Functions[c].FilePath;
 131     newLFF.Line = this->Functions[c].Line;
 132     const char* def = this->Makefile->GetDefinition
 133       ("CMAKE_MACRO_REPORT_DEFINITION_LOCATION");
 134     bool macroReportLocation = false;
 135     if(def && !cmSystemTools::IsOff(def))
 136       {
 137       macroReportLocation = true;
 138       }
 139
 140     // for each argument of the current function
 141     for (std::vector<cmListFileArgument>::const_iterator k =
 142            this->Functions[c].Arguments.begin();
 143          k != this->Functions[c].Arguments.end(); ++k)
 144       {
 145       tmps = k->Value;
 146       // replace formal arguments
 147       for (unsigned int j = 1; j < this->Args.size(); ++j)
 148         {
 149         variable = "${";
 150         variable += this->Args[j];
 151         variable += "}";
 152         cmSystemTools::ReplaceString(tmps, variable.c_str(),
 153                                      expandedArgs[j-1].c_str());
 154         }
 155       // replace argc
 156       cmSystemTools::ReplaceString(tmps, "${ARGC}",argcDef.c_str());
 157
 158       // repleace ARGN
 159       if (tmps.find("${ARGN}") != std::string::npos)
 160         {
 161         if (!argnDefInitialized)
 162           {
 163           std::vector<std::string>::const_iterator eit;
 164           std::vector<std::string>::size_type cnt = 0;
 165           for ( eit = expandedArgs.begin(); eit != expandedArgs.end(); ++eit )
 166             {
 167             if ( cnt >= this->Args.size()-1 )
 168               {
 169               if ( argnDef.size() > 0 )
 170                 {
 171                 argnDef += ";";
 172                 }
 173               argnDef += *eit;
 174               }
 175             cnt ++;
 176             }
 177           argnDefInitialized = true;
 178           }
 179         cmSystemTools::ReplaceString(tmps, "${ARGN}", argnDef.c_str());
 180         }
 181
 182       // if the current argument of the current function has ${ARGV in it
 183       // then try replacing ARGV values
 184       if (tmps.find("${ARGV") != std::string::npos)
 185         {
 186         char argvName[60];
 187
 188         // repleace ARGV, compute it only once
 189         if (!argvDefInitialized)
 190           {
 191           std::vector<std::string>::const_iterator eit;
 192           for ( eit = expandedArgs.begin(); eit != expandedArgs.end(); ++eit )
 193             {
 194             if ( argvDef.size() > 0 )
 195               {
 196               argvDef += ";";
 197               }
 198             argvDef += *eit;
 199             }
 200           argvDefInitialized = true;
 201           }
 202         cmSystemTools::ReplaceString(tmps, "${ARGV}", argvDef.c_str());
 203
 204         // also replace the ARGV1 ARGV2 ... etc
 205         for (unsigned int t = 0; t < expandedArgs.size(); ++t)
 206           {
 207           sprintf(argvName,"${ARGV%i}",t);
 208           cmSystemTools::ReplaceString(tmps, argvName,
 209                                        expandedArgs[t].c_str());
 210           }
 211         }
 212
 213       arg.Value = tmps;
 214       arg.Quoted = k->Quoted;
 215       if(macroReportLocation)
 216         {
 217         // Report the location of the argument where the macro was
 218         // defined.
 219         arg.FilePath = k->FilePath;
 220         arg.Line = k->Line;
 221         }
 222       else
 223         {
 224         // Report the location of the argument where the macro was
 225         // invoked.
 226         if (args.size())
 227           {
 228           arg.FilePath = args[0].FilePath;
 229           arg.Line = args[0].Line;
 230           }
 231         else
 232           {
 233           arg.FilePath = "Unknown";
 234           arg.Line = 0;
 235           }
 236         }
 237       newLFF.Arguments.push_back(arg);
 238       }
 239     cmExecutionStatus status;
 240     if(!this->Makefile->ExecuteCommand(newLFF, status) ||
 241        status.GetNestedError())
 242       {
 243       // The error message should have already included the call stack
 244       // so we do not need to report an error here.
 245       inStatus.SetNestedError(true);
 246       return false;
 247       }
 248     if (status.GetReturnInvoked())
 249       {
 250       inStatus.SetReturnInvoked(true);
 251       return true;
 252       }
 253     if (status.GetBreakInvoked())
 254       {
 255       inStatus.SetBreakInvoked(true);
 256       return true;
 257       }
 258     }
 259   return true;
 260 }
 261
 262 bool cmMacroFunctionBlocker::
 263 IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
 264                   cmExecutionStatus &)
 265 {
 266   // record commands until we hit the ENDMACRO
 267   // at the ENDMACRO call we shift gears and start looking for invocations
 268   if(!cmSystemTools::Strucmp(lff.Name.c_str(),"macro"))
 269     {
 270     this->Depth++;
 271     }
 272   else if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endmacro"))
 273     {
 274     // if this is the endmacro for this macro then execute
 275     if (!this->Depth)
 276       {
 277       std::string name = this->Args[0];
 278       std::vector<std::string>::size_type cc;
 279       name += "(";
 280       for ( cc = 0; cc < this->Args.size(); cc ++ )
 281         {
 282         name += " " + this->Args[cc];
 283         }
 284       name += " )";
 285       mf.AddMacro(this->Args[0].c_str(), name.c_str());
 286       // create a new command and add it to cmake
 287       cmMacroHelperCommand *f = new cmMacroHelperCommand();
 288       f->Args = this->Args;
 289       f->Functions = this->Functions;
 290       std::string newName = "_" + this->Args[0];
 291       mf.GetCMakeInstance()->RenameCommand(this->Args[0].c_str(),
 292                                            newName.c_str());
 293       mf.AddCommand(f);
 294
 295       // remove the function blocker now that the macro is defined
 296       mf.RemoveFunctionBlocker(lff);
 297       return true;
 298       }
 299     else
 300       {
 301       // decrement for each nested macro that ends
 302       this->Depth--;
 303       }
 304     }
 305
 306   // if it wasn't an endmacro and we are not executing then we must be
 307   // recording
 308   this->Functions.push_back(lff);
 309   return true;
 310 }
 311
 312
 313 bool cmMacroFunctionBlocker::
 314 ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
 315 {
 316   if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endmacro"))
 317     {
 318     std::vector<std::string> expandedArguments;
 319     mf.ExpandArguments(lff.Arguments, expandedArguments);
 320     // if the endmacro has arguments make sure they
 321     // match the arguments of the macro
 322     if ((expandedArguments.empty() ||
 323          (expandedArguments[0] == this->Args[0])))
 324       {
 325       return true;
 326       }
 327     }
 328
 329   return false;
 330 }
 331
 332 void cmMacroFunctionBlocker::
 333 ScopeEnded(cmMakefile &mf)
 334 {
 335   // macros should end with an EndMacro
 336   cmSystemTools::Error(
 337     "The end of a CMakeLists file was reached with a MACRO statement that "
 338     "was not closed properly. Within the directory: ",
 339     mf.GetCurrentDirectory(), " with macro ",
 340     this->Args[0].c_str());
 341 }
 342
 343 bool cmMacroCommand::InitialPass(std::vector<std::string> const& args,
 344                                  cmExecutionStatus &)
 345 {
 346   if(args.size() < 1)
 347     {
 348     this->SetError("called with incorrect number of arguments");
 349     return false;
 350     }
 351
 352   // create a function blocker
 353   cmMacroFunctionBlocker *f = new cmMacroFunctionBlocker();
 354   for(std::vector<std::string>::const_iterator j = args.begin();
 355       j != args.end(); ++j)
 356     {
 357     f->Args.push_back(*j);
 358     }
 359   this->Makefile->AddFunctionBlocker(f);
 360   return true;
 361 }
 362