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