Source/cmListCommand.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmListCommand.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2008-01-23 15:27:59 $
   7   Version:   $Revision: 1.17 $
   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 "cmListCommand.h"
  18 #include <cmsys/RegularExpression.hxx>
  19 #include <cmsys/SystemTools.hxx>
  20
  21 #include <stdlib.h> // required for atoi
  22 #include <ctype.h>
  23 //----------------------------------------------------------------------------
  24 bool cmListCommand
  25 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
  26 {
  27   if(args.size() < 1)
  28     {
  29     this->SetError("must be called with at least one argument.");
  30     return false;
  31     }
  32
  33   const std::string &subCommand = args[0];
  34   if(subCommand == "LENGTH")
  35     {
  36     return this->HandleLengthCommand(args);
  37     }
  38   if(subCommand == "GET")
  39     {
  40     return this->HandleGetCommand(args);
  41     }
  42   if(subCommand == "APPEND")
  43     {
  44     return this->HandleAppendCommand(args);
  45     }
  46   if(subCommand == "FIND")
  47     {
  48     return this->HandleFindCommand(args);
  49     }
  50   if(subCommand == "INSERT")
  51     {
  52     return this->HandleInsertCommand(args);
  53     }
  54   if(subCommand == "REMOVE_AT")
  55     {
  56     return this->HandleRemoveAtCommand(args);
  57     }
  58   if(subCommand == "REMOVE_ITEM")
  59     {
  60     return this->HandleRemoveItemCommand(args);
  61     }
  62   if(subCommand == "SORT")
  63     {
  64     return this->HandleSortCommand(args);
  65     }
  66   if(subCommand == "REVERSE")
  67     {
  68     return this->HandleReverseCommand(args);
  69     }
  70
  71   std::string e = "does not recognize sub-command "+subCommand;
  72   this->SetError(e.c_str());
  73   return false;
  74 }
  75
  76 //----------------------------------------------------------------------------
  77 bool cmListCommand::GetListString(std::string& listString, const char* var)
  78 {
  79   if ( !var )
  80     {
  81     return false;
  82     }
  83   // get the old value
  84   const char* cacheValue
  85     = this->Makefile->GetDefinition(var);
  86   if(!cacheValue)
  87     {
  88     return false;
  89     }
  90   listString = cacheValue;
  91   return true;
  92 }
  93
  94 //----------------------------------------------------------------------------
  95 bool cmListCommand::GetList(std::vector<std::string>& list, const char* var)
  96 {
  97   std::string listString;
  98   if ( !this->GetListString(listString, var) )
  99     {
 100     return false;
 101     }
 102   // expand the variable
 103   cmSystemTools::ExpandListArgument(listString, list);
 104   return true;
 105 }
 106
 107 //----------------------------------------------------------------------------
 108 bool cmListCommand::HandleLengthCommand(std::vector<std::string> const& args)
 109 {
 110   if(args.size() != 3)
 111     {
 112     this->SetError("sub-command LENGTH requires two arguments.");
 113     return false;
 114     }
 115
 116   const std::string& listName = args[1];
 117   const std::string& variableName = args[args.size() - 1];
 118   std::vector<std::string> varArgsExpanded;
 119   // do not check the return value here
 120   // if the list var is not found varArgsExpanded will have size 0
 121   // and we will return 0
 122   this->GetList(varArgsExpanded, listName.c_str());
 123   size_t length = varArgsExpanded.size();
 124   char buffer[1024];
 125   sprintf(buffer, "%d", static_cast<int>(length));
 126
 127   this->Makefile->AddDefinition(variableName.c_str(), buffer);
 128   return true;
 129 }
 130
 131 //----------------------------------------------------------------------------
 132 bool cmListCommand::HandleGetCommand(std::vector<std::string> const& args)
 133 {
 134   if(args.size() < 4)
 135     {
 136     this->SetError("sub-command GET requires at least three arguments.");
 137     return false;
 138     }
 139
 140   const std::string& listName = args[1];
 141   const std::string& variableName = args[args.size() - 1];
 142   // expand the variable
 143   std::vector<std::string> varArgsExpanded;
 144   if ( !this->GetList(varArgsExpanded, listName.c_str()) )
 145     {
 146     this->Makefile->AddDefinition(variableName.c_str(), "NOTFOUND");
 147     return true;
 148     }
 149
 150   std::string value;
 151   size_t cc;
 152   for ( cc = 2; cc < args.size()-1; cc ++ )
 153     {
 154     int item = atoi(args[cc].c_str());
 155     if (value.size())
 156       {
 157       value += ";";
 158       }
 159     size_t nitem = varArgsExpanded.size();
 160     if ( item < 0 )
 161       {
 162       item = (int)nitem + item;
 163       }
 164     if ( item < 0 || nitem <= (size_t)item )
 165       {
 166       cmOStringStream str;
 167       str << "index: " << item << " out of range (-"
 168           << varArgsExpanded.size() << ", "
 169           << varArgsExpanded.size()-1 << ")";
 170       this->SetError(str.str().c_str());
 171       return false;
 172       }
 173     value += varArgsExpanded[item];
 174     }
 175
 176   this->Makefile->AddDefinition(variableName.c_str(), value.c_str());
 177   return true;
 178 }
 179
 180 //----------------------------------------------------------------------------
 181 bool cmListCommand::HandleAppendCommand(std::vector<std::string> const& args)
 182 {
 183   if(args.size() < 2)
 184     {
 185     this->SetError("sub-command APPEND requires at least one argument.");
 186     return false;
 187     }
 188
 189   // Skip if nothing to append.
 190   if(args.size() < 3)
 191     {
 192     return true;
 193     }
 194
 195   const std::string& listName = args[1];
 196   // expand the variable
 197   std::string listString;
 198   this->GetListString(listString, listName.c_str());
 199   size_t cc;
 200   for ( cc = 2; cc < args.size(); ++ cc )
 201     {
 202     if ( listString.size() )
 203       {
 204       listString += ";";
 205       }
 206     listString += args[cc];
 207     }
 208
 209   this->Makefile->AddDefinition(listName.c_str(), listString.c_str());
 210   return true;
 211 }
 212
 213 //----------------------------------------------------------------------------
 214 bool cmListCommand::HandleFindCommand(std::vector<std::string> const& args)
 215 {
 216   if(args.size() != 4)
 217     {
 218     this->SetError("sub-command FIND requires three arguments.");
 219     return false;
 220     }
 221
 222   const std::string& listName = args[1];
 223   const std::string& variableName = args[args.size() - 1];
 224   // expand the variable
 225   std::vector<std::string> varArgsExpanded;
 226   if ( !this->GetList(varArgsExpanded, listName.c_str()) )
 227     {
 228     this->Makefile->AddDefinition(variableName.c_str(), "-1");
 229     return true;
 230     }
 231
 232   std::vector<std::string>::iterator it;
 233   unsigned int index = 0;
 234   for ( it = varArgsExpanded.begin(); it != varArgsExpanded.end(); ++ it )
 235     {
 236     if ( *it == args[2] )
 237       {
 238       char indexString[32];
 239       sprintf(indexString, "%d", index);
 240       this->Makefile->AddDefinition(variableName.c_str(), indexString);
 241       return true;
 242       }
 243     index++;
 244     }
 245
 246   this->Makefile->AddDefinition(variableName.c_str(), "-1");
 247   return true;
 248 }
 249
 250 //----------------------------------------------------------------------------
 251 bool cmListCommand::HandleInsertCommand(std::vector<std::string> const& args)
 252 {
 253   if(args.size() < 4)
 254     {
 255     this->SetError("sub-command INSERT requires at least three arguments.");
 256     return false;
 257     }
 258
 259   const std::string& listName = args[1];
 260
 261   // expand the variable
 262   int item = atoi(args[2].c_str());
 263   std::vector<std::string> varArgsExpanded;
 264   if ( !this->GetList(varArgsExpanded, listName.c_str()) && item != 0)
 265     {
 266     cmOStringStream str;
 267     str << "index: " << item << " out of range (0, 0)";
 268     this->SetError(str.str().c_str());
 269     return false;
 270     }
 271
 272   if ( varArgsExpanded.size() != 0 )
 273     {
 274     size_t nitem = varArgsExpanded.size();
 275     if ( item < 0 )
 276       {
 277       item = (int)nitem + item;
 278       }
 279     if ( item < 0 || nitem <= (size_t)item )
 280       {
 281       cmOStringStream str;
 282       str << "index: " << item << " out of range (-"
 283         << varArgsExpanded.size() << ", "
 284         << (varArgsExpanded.size() == 0?0:(varArgsExpanded.size()-1)) << ")";
 285       this->SetError(str.str().c_str());
 286       return false;
 287       }
 288     }
 289   size_t cc;
 290   size_t cnt = 0;
 291   for ( cc = 3; cc < args.size(); ++ cc )
 292     {
 293     varArgsExpanded.insert(varArgsExpanded.begin()+item+cnt, args[cc]);
 294     cnt ++;
 295     }
 296
 297   std::string value;
 298   for ( cc = 0; cc < varArgsExpanded.size(); cc ++ )
 299     {
 300     if (value.size())
 301       {
 302       value += ";";
 303       }
 304     value += varArgsExpanded[cc];
 305     }
 306
 307   this->Makefile->AddDefinition(listName.c_str(), value.c_str());
 308   return true;
 309 }
 310
 311 //----------------------------------------------------------------------------
 312 bool cmListCommand
 313 ::HandleRemoveItemCommand(std::vector<std::string> const& args)
 314 {
 315   if(args.size() < 3)
 316     {
 317     this->SetError("sub-command REMOVE_ITEM requires two or more arguments.");
 318     return false;
 319     }
 320
 321   const std::string& listName = args[1];
 322   // expand the variable
 323   std::vector<std::string> varArgsExpanded;
 324   if ( !this->GetList(varArgsExpanded, listName.c_str()) )
 325     {
 326     this->SetError("sub-command REMOVE_ITEM requires list to be present.");
 327     return false;
 328     }
 329
 330   size_t cc;
 331   for ( cc = 2; cc < args.size(); ++ cc )
 332     {
 333     size_t kk = 0;
 334     while ( kk < varArgsExpanded.size() )
 335       {
 336       if ( varArgsExpanded[kk] == args[cc] )
 337         {
 338         varArgsExpanded.erase(varArgsExpanded.begin()+kk);
 339         }
 340       else
 341         {
 342         kk ++;
 343         }
 344       }
 345     }
 346
 347   std::string value;
 348   for ( cc = 0; cc < varArgsExpanded.size(); cc ++ )
 349     {
 350     if (value.size())
 351       {
 352       value += ";";
 353       }
 354     value += varArgsExpanded[cc];
 355     }
 356
 357   this->Makefile->AddDefinition(listName.c_str(), value.c_str());
 358   return true;
 359 }
 360
 361 //----------------------------------------------------------------------------
 362 bool cmListCommand
 363 ::HandleReverseCommand(std::vector<std::string> const& args)
 364 {
 365   if(args.size() < 2)
 366     {
 367     this->SetError("sub-command REVERSE requires a list as an argument.");
 368     return false;
 369     }
 370
 371   const std::string& listName = args[1];
 372   // expand the variable
 373   std::vector<std::string> varArgsExpanded;
 374   if ( !this->GetList(varArgsExpanded, listName.c_str()) )
 375     {
 376     this->SetError("sub-command REVERSE requires list to be present.");
 377     return false;
 378     }
 379
 380   std::string value;
 381   std::vector<std::string>::reverse_iterator it;
 382   for ( it = varArgsExpanded.rbegin(); it != varArgsExpanded.rend(); ++ it )
 383     {
 384     if (value.size())
 385       {
 386       value += ";";
 387       }
 388     value += it->c_str();
 389     }
 390
 391   this->Makefile->AddDefinition(listName.c_str(), value.c_str());
 392   return true;
 393 }
 394
 395 //----------------------------------------------------------------------------
 396 bool cmListCommand
 397 ::HandleSortCommand(std::vector<std::string> const& args)
 398 {
 399   if(args.size() < 2)
 400     {
 401     this->SetError("sub-command SORT requires a list as an argument.");
 402     return false;
 403     }
 404
 405   const std::string& listName = args[1];
 406   // expand the variable
 407   std::vector<std::string> varArgsExpanded;
 408   if ( !this->GetList(varArgsExpanded, listName.c_str()) )
 409     {
 410     this->SetError("sub-command SORT requires list to be present.");
 411     return false;
 412     }
 413
 414   std::sort(varArgsExpanded.begin(), varArgsExpanded.end());
 415
 416   std::string value;
 417   std::vector<std::string>::iterator it;
 418   for ( it = varArgsExpanded.begin(); it != varArgsExpanded.end(); ++ it )
 419     {
 420     if (value.size())
 421       {
 422       value += ";";
 423       }
 424     value += it->c_str();
 425     }
 426
 427   this->Makefile->AddDefinition(listName.c_str(), value.c_str());
 428   return true;
 429 }
 430
 431 //----------------------------------------------------------------------------
 432 bool cmListCommand::HandleRemoveAtCommand(
 433   std::vector<std::string> const& args)
 434 {
 435   if(args.size() < 3)
 436     {
 437     this->SetError("sub-command REMOVE_AT requires at least "
 438                    "two arguments.");
 439     return false;
 440     }
 441
 442   const std::string& listName = args[1];
 443   // expand the variable
 444   std::vector<std::string> varArgsExpanded;
 445   if ( !this->GetList(varArgsExpanded, listName.c_str()) )
 446     {
 447     this->SetError("sub-command REMOVE_AT requires list to be present.");
 448     return false;
 449     }
 450
 451   size_t cc;
 452   std::vector<size_t> removed;
 453   for ( cc = 2; cc < args.size(); ++ cc )
 454     {
 455     int item = atoi(args[cc].c_str());
 456     size_t nitem = varArgsExpanded.size();
 457     if ( item < 0 )
 458       {
 459       item = (int)nitem + item;
 460       }
 461     if ( item < 0 || nitem <= (size_t)item )
 462       {
 463       cmOStringStream str;
 464       str << "index: " << item << " out of range (-"
 465           << varArgsExpanded.size() << ", "
 466           << varArgsExpanded.size()-1 << ")";
 467       this->SetError(str.str().c_str());
 468       return false;
 469       }
 470     removed.push_back(static_cast<size_t>(item));
 471     }
 472
 473   std::string value;
 474   for ( cc = 0; cc < varArgsExpanded.size(); ++ cc )
 475     {
 476     size_t kk;
 477     bool found = false;
 478     for ( kk = 0; kk < removed.size(); ++ kk )
 479       {
 480       if ( cc == removed[kk] )
 481         {
 482         found = true;
 483         }
 484       }
 485
 486     if ( !found )
 487       {
 488       if (value.size())
 489         {
 490         value += ";";
 491         }
 492       value += varArgsExpanded[cc];
 493       }
 494     }
 495
 496   this->Makefile->AddDefinition(listName.c_str(), value.c_str());
 497   return true;
 498 }
 499