CMakeLua/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/01/23 15:27:59 $
   7   Version:   $Revision: 1.34 $
   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       {
 242       if(args.size())
 243         {
 244         arg.FilePath = args[0].FilePath;
 245         arg.Line = args[0].Line;
 246         }
 247       else
 248         {
 249         arg.FilePath =  "Unknown";
 250         arg.Line = 0;
 251         }
 252       cmOStringStream error;
 253       error << "Error in cmake code at\n"
 254             << arg.FilePath << ":" << arg.Line << ":\n"
 255             << "A command failed during the invocation of macro \""
 256             << this->Args[0].c_str() << "\".";
 257       cmSystemTools::Error(error.str().c_str());
 258       return false;
 259       }
 260     if (status.GetReturnInvoked())
 261       {
 262       inStatus.SetReturnInvoked(true);
 263       return true;
 264       }
 265     if (status.GetBreakInvoked())
 266       {
 267       inStatus.SetBreakInvoked(true);
 268       return true;
 269       }
 270     }
 271   return true;
 272 }
 273
 274 bool cmMacroFunctionBlocker::
 275 IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
 276                   cmExecutionStatus &)
 277 {
 278   // record commands until we hit the ENDMACRO
 279   // at the ENDMACRO call we shift gears and start looking for invocations
 280   if(!cmSystemTools::Strucmp(lff.Name.c_str(),"macro"))
 281     {
 282     this->Depth++;
 283     }
 284   else if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endmacro"))
 285     {
 286     // if this is the endmacro for this macro then execute
 287     if (!this->Depth)
 288       {
 289       std::string name = this->Args[0];
 290       std::vector<std::string>::size_type cc;
 291       name += "(";
 292       for ( cc = 0; cc < this->Args.size(); cc ++ )
 293         {
 294         name += " " + this->Args[cc];
 295         }
 296       name += " )";
 297       mf.AddMacro(this->Args[0].c_str(), name.c_str());
 298       // create a new command and add it to cmake
 299       cmMacroHelperCommand *f = new cmMacroHelperCommand();
 300       f->Args = this->Args;
 301       f->Functions = this->Functions;
 302       std::string newName = "_" + this->Args[0];
 303       mf.GetCMakeInstance()->RenameCommand(this->Args[0].c_str(),
 304                                            newName.c_str());
 305       mf.AddCommand(f);
 306
 307       // remove the function blocker now that the macro is defined
 308       mf.RemoveFunctionBlocker(lff);
 309       return true;
 310       }
 311     else
 312       {
 313       // decrement for each nested macro that ends
 314       this->Depth--;
 315       }
 316     }
 317
 318   // if it wasn't an endmacro and we are not executing then we must be
 319   // recording
 320   this->Functions.push_back(lff);
 321   return true;
 322 }
 323
 324
 325 bool cmMacroFunctionBlocker::
 326 ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
 327 {
 328   if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endmacro"))
 329     {
 330     std::vector<std::string> expandedArguments;
 331     mf.ExpandArguments(lff.Arguments, expandedArguments);
 332     if ((!expandedArguments.empty() &&
 333         (expandedArguments[0] == this->Args[0]))
 334         || cmSystemTools::IsOn
 335         (mf.GetPropertyOrDefinition("CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS")))
 336       {
 337       return true;
 338       }
 339     }
 340
 341   return false;
 342 }
 343
 344 void cmMacroFunctionBlocker::
 345 ScopeEnded(cmMakefile &mf)
 346 {
 347   // macros should end with an EndMacro
 348   cmSystemTools::Error(
 349     "The end of a CMakeLists file was reached with a MACRO statement that "
 350     "was not closed properly. Within the directory: ",
 351     mf.GetCurrentDirectory(), " with macro ",
 352     this->Args[0].c_str());
 353 }
 354
 355 bool cmMacroCommand::InitialPass(std::vector<std::string> const& args,
 356                                  cmExecutionStatus &)
 357 {
 358   if(args.size() < 1)
 359     {
 360     this->SetError("called with incorrect number of arguments");
 361     return false;
 362     }
 363
 364   // create a function blocker
 365   cmMacroFunctionBlocker *f = new cmMacroFunctionBlocker();
 366   for(std::vector<std::string>::const_iterator j = args.begin();
 367       j != args.end(); ++j)
 368     {
 369     f->Args.push_back(*j);
 370     }
 371   this->Makefile->AddFunctionBlocker(f);
 372   return true;
 373 }
 374