CMakeLua/Source/cmSetPropertyCommand.cxx

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