CMakeLua/Source/cmSetPropertyCommand.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmSetPropertyCommand.cxx,v $
   5   Language:  C++
   6 <<<<<<< cmSetPropertyCommand.cxx
   7   Date:      $Date: 2008/02/15 16:22:23 $
   8   Version:   $Revision: 1.6 $
   9 =======
  10   Date:      $Date: 2008-04-01 18:22:06 $
  11   Version:   $Revision: 1.7 $
  12 >>>>>>> 1.7
  13
  14   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  15   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  16
  17      This software is distributed WITHOUT ANY WARRANTY; without even
  18      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  19      PURPOSE.  See the above copyright notices for more information.
  20
  21 =========================================================================*/
  22 #include "cmSetPropertyCommand.h"
  23 #include "cmSetTargetPropertiesCommand.h"
  24 #include "cmSetTestsPropertiesCommand.h"
  25 #include "cmSetSourceFilesPropertiesCommand.h"
  26
  27 //----------------------------------------------------------------------------
  28 cmSetPropertyCommand::cmSetPropertyCommand()
  29 {
  30   this->AppendMode = false;
  31   this->Remove = true;
  32 }
  33
  34 //----------------------------------------------------------------------------
  35 bool cmSetPropertyCommand
  36 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
  37 {
  38   if(args.size() < 2 )
  39     {
  40     this->SetError("called with incorrect number of arguments");
  41     return false;
  42     }
  43
  44   // Get the scope on which to set the property.
  45   std::vector<std::string>::const_iterator arg = args.begin();
  46   cmProperty::ScopeType scope;
  47   if(*arg == "GLOBAL")
  48     {
  49     scope = cmProperty::GLOBAL;
  50     }
  51   else if(*arg == "DIRECTORY")
  52     {
  53     scope = cmProperty::DIRECTORY;
  54     }
  55   else if(*arg == "TARGET")
  56     {
  57     scope = cmProperty::TARGET;
  58     }
  59   else if(*arg == "SOURCE")
  60     {
  61     scope = cmProperty::SOURCE_FILE;
  62     }
  63   else if(*arg == "TEST")
  64     {
  65     scope = cmProperty::TEST;
  66     }
  67   else
  68     {
  69     cmOStringStream e;
  70     e << "given invalid scope " << *arg << ".  "
  71       << "Valid scopes are GLOBAL, DIRECTORY, TARGET, SOURCE, TEST.";
  72     this->SetError(e.str().c_str());
  73     return false;
  74     }
  75
  76   // Parse the rest of the arguments up to the values.
  77   enum Doing { DoingNone, DoingNames, DoingProperty, DoingValues };
  78   Doing doing = DoingNames;
  79   const char* sep = "";
  80   for(++arg; arg != args.end(); ++arg)
  81     {
  82     if(*arg == "PROPERTY")
  83       {
  84       doing = DoingProperty;
  85       }
  86     else if(*arg == "APPEND")
  87       {
  88       doing = DoingNone;
  89       this->AppendMode = true;
  90       }
  91     else if(doing == DoingNames)
  92       {
  93       this->Names.insert(*arg);
  94       }
  95     else if(doing == DoingProperty)
  96       {
  97       this->PropertyName = *arg;
  98       doing = DoingValues;
  99       }
 100     else if(doing == DoingValues)
 101       {
 102       this->PropertyValue += sep;
 103       sep = ";";
 104       this->PropertyValue += *arg;
 105       this->Remove = false;
 106       }
 107     else
 108       {
 109       cmOStringStream e;
 110       e << "given invalid argument \"" << *arg << "\".";
 111       this->SetError(e.str().c_str());
 112       return false;
 113       }
 114     }
 115
 116   // Make sure a property name was found.
 117   if(this->PropertyName.empty())
 118     {
 119     this->SetError("not given a PROPERTY <name> argument.");
 120     return false;
 121     }
 122
 123   // Dispatch property setting.
 124   switch(scope)
 125     {
 126     case cmProperty::GLOBAL:      return this->HandleGlobalMode();
 127     case cmProperty::DIRECTORY:   return this->HandleDirectoryMode();
 128     case cmProperty::TARGET:      return this->HandleTargetMode();
 129     case cmProperty::SOURCE_FILE: return this->HandleSourceMode();
 130     case cmProperty::TEST:        return this->HandleTestMode();
 131
 132     case cmProperty::VARIABLE:
 133     case cmProperty::CACHED_VARIABLE:
 134       break; // should never happen
 135     }
 136   return true;
 137 }
 138
 139 //----------------------------------------------------------------------------
 140 bool cmSetPropertyCommand::HandleGlobalMode()
 141 {
 142   if(!this->Names.empty())
 143     {
 144     this->SetError("given names for GLOBAL scope.");
 145     return false;
 146     }
 147
 148   // Set or append the property.
 149   cmake* cm = this->Makefile->GetCMakeInstance();
 150   const char* name = this->PropertyName.c_str();
 151   const char *value = this->PropertyValue.c_str();
 152   if (this->Remove)
 153     {
 154     value = 0;
 155     }
 156   if(this->AppendMode)
 157     {
 158     cm->AppendProperty(name, value);
 159     }
 160   else
 161     {
 162     cm->SetProperty(name, value);
 163     }
 164
 165   return true;
 166 }
 167
 168 //----------------------------------------------------------------------------
 169 bool cmSetPropertyCommand::HandleDirectoryMode()
 170 {
 171   if(this->Names.size() > 1)
 172     {
 173     this->SetError("allows at most one name for DIRECTORY scope.");
 174     return false;
 175     }
 176
 177   // Default to the current directory.
 178   cmMakefile* mf = this->Makefile;
 179
 180   // Lookup the directory if given.
 181   if(!this->Names.empty())
 182     {
 183     // Construct the directory name.  Interpret relative paths with
 184     // respect to the current directory.
 185     std::string dir = *this->Names.begin();
 186     if(!cmSystemTools::FileIsFullPath(dir.c_str()))
 187       {
 188       dir = this->Makefile->GetCurrentDirectory();
 189       dir += "/";
 190       dir += *this->Names.begin();
 191       }
 192
 193     // The local generators are associated with collapsed paths.
 194     dir = cmSystemTools::CollapseFullPath(dir.c_str());
 195
 196     // Lookup the generator.
 197     if(cmLocalGenerator* lg =
 198        (this->Makefile->GetLocalGenerator()
 199         ->GetGlobalGenerator()->FindLocalGenerator(dir.c_str())))
 200       {
 201       // Use the makefile for the directory found.
 202       mf = lg->GetMakefile();
 203       }
 204     else
 205       {
 206       // Could not find the directory.
 207       this->SetError
 208         ("DIRECTORY scope provided but requested directory was not found. "
 209          "This could be because the directory argument was invalid or, "
 210          "it is valid but has not been processed yet.");
 211       return false;
 212       }
 213     }
 214
 215   // Set or append the property.
 216   const char* name = this->PropertyName.c_str();
 217   const char *value = this->PropertyValue.c_str();
 218   if (this->Remove)
 219     {
 220     value = 0;
 221     }
 222   if(this->AppendMode)
 223     {
 224     mf->AppendProperty(name, value);
 225     }
 226   else
 227     {
 228     mf->SetProperty(name, value);
 229     }
 230
 231   return true;
 232 }
 233
 234 //----------------------------------------------------------------------------
 235 bool cmSetPropertyCommand::HandleTargetMode()
 236 {
 237   for(std::set<cmStdString>::const_iterator ni = this->Names.begin();
 238       ni != this->Names.end(); ++ni)
 239     {
 240     if(cmTarget* target = this->Makefile->FindTargetToUse(ni->c_str()))
 241       {
 242       // Handle the current target.
 243       if(!this->HandleTarget(target))
 244         {
 245         return false;
 246         }
 247       }
 248     else
 249       {
 250       cmOStringStream e;
 251       e << "could not find TARGET " << *ni
 252         << ".  Perhaps it has not yet been created.";
 253       this->SetError(e.str().c_str());
 254       return false;
 255       }
 256     }
 257   return true;
 258 }
 259
 260 //----------------------------------------------------------------------------
 261 bool cmSetPropertyCommand::HandleTarget(cmTarget* target)
 262 {
 263   // Set or append the property.
 264   const char* name = this->PropertyName.c_str();
 265   const char *value = this->PropertyValue.c_str();
 266   if (this->Remove)
 267     {
 268     value = 0;
 269     }
 270   if(this->AppendMode)
 271     {
 272     target->AppendProperty(name, value);
 273     }
 274   else
 275     {
 276     target->SetProperty(name, value);
 277     }
 278
 279   return true;
 280 }
 281
 282 //----------------------------------------------------------------------------
 283 bool cmSetPropertyCommand::HandleSourceMode()
 284 {
 285   for(std::set<cmStdString>::const_iterator ni = this->Names.begin();
 286       ni != this->Names.end(); ++ni)
 287     {
 288     // Get the source file.
 289     if(cmSourceFile* sf = this->Makefile->GetOrCreateSource(ni->c_str()))
 290       {
 291       if(!this->HandleSource(sf))
 292         {
 293         return false;
 294         }
 295       }
 296     else
 297       {
 298       cmOStringStream e;
 299       e << "given SOURCE name that could not be found or created: " << *ni;
 300       this->SetError(e.str().c_str());
 301       return false;
 302       }
 303     }
 304   return true;
 305 }
 306
 307 //----------------------------------------------------------------------------
 308 bool cmSetPropertyCommand::HandleSource(cmSourceFile* sf)
 309 {
 310   // Set or append the property.
 311   const char* name = this->PropertyName.c_str();
 312   const char *value = this->PropertyValue.c_str();
 313   if (this->Remove)
 314     {
 315     value = 0;
 316     }
 317
 318   if(this->AppendMode)
 319     {
 320     sf->AppendProperty(name, value);
 321     }
 322   else
 323     {
 324     sf->SetProperty(name, value);
 325     }
 326   return true;
 327 }
 328
 329 //----------------------------------------------------------------------------
 330 bool cmSetPropertyCommand::HandleTestMode()
 331 {
 332   // Loop over all tests looking for matching names.
 333   std::vector<cmTest*> const& tests = *this->Makefile->GetTests();
 334   for(std::vector<cmTest*>::const_iterator ti = tests.begin();
 335       ti != tests.end(); ++ti)
 336     {
 337     cmTest* test = *ti;
 338     std::set<cmStdString>::iterator ni =
 339       this->Names.find(test->GetName());
 340     if(ni != this->Names.end())
 341       {
 342       if(this->HandleTest(test))
 343         {
 344         this->Names.erase(ni);
 345         }
 346       else
 347         {
 348         return false;
 349         }
 350       }
 351     }
 352
 353   // Names that are still left were not found.
 354   if(!this->Names.empty())
 355     {
 356     cmOStringStream e;
 357     e << "given TEST names that do not exist:\n";
 358     for(std::set<cmStdString>::const_iterator ni = this->Names.begin();
 359         ni != this->Names.end(); ++ni)
 360       {
 361       e << "  " << *ni << "\n";
 362       }
 363     this->SetError(e.str().c_str());
 364     return false;
 365     }
 366   return true;
 367 }
 368
 369 //----------------------------------------------------------------------------
 370 bool cmSetPropertyCommand::HandleTest(cmTest* test)
 371 {
 372   // Set or append the property.
 373   const char* name = this->PropertyName.c_str();
 374   const char *value = this->PropertyValue.c_str();
 375   if (this->Remove)
 376     {
 377     value = 0;
 378     }
 379   if(this->AppendMode)
 380     {
 381     test->AppendProperty(name, value);
 382     }
 383   else
 384     {
 385     test->SetProperty(name, value);
 386     }
 387
 388   return true;
 389 }