Source/cmGetPropertyCommand.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmGetPropertyCommand.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-03-10 15:10:59 $
   7   Version:   $Revision: 1.12 $
   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 "cmGetPropertyCommand.h"
  18
  19 #include "cmake.h"
  20 #include "cmTest.h"
  21 #include "cmPropertyDefinition.h"
  22
  23 //----------------------------------------------------------------------------
  24 cmGetPropertyCommand::cmGetPropertyCommand()
  25 {
  26   this->InfoType = OutValue;
  27 }
  28
  29 //----------------------------------------------------------------------------
  30 bool cmGetPropertyCommand
  31 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
  32 {
  33   if(args.size() < 3 )
  34     {
  35     this->SetError("called with incorrect number of arguments");
  36     return false;
  37     }
  38
  39   // The cmake variable in which to store the result.
  40   this->Variable = args[0];
  41
  42   // Get the scope from which to get the property.
  43   cmProperty::ScopeType scope;
  44   if(args[1] == "GLOBAL")
  45     {
  46     scope = cmProperty::GLOBAL;
  47     }
  48   else if(args[1] == "DIRECTORY")
  49     {
  50     scope = cmProperty::DIRECTORY;
  51     }
  52   else if(args[1] == "TARGET")
  53     {
  54     scope = cmProperty::TARGET;
  55     }
  56   else if(args[1] == "SOURCE")
  57     {
  58     scope = cmProperty::SOURCE_FILE;
  59     }
  60   else if(args[1] == "TEST")
  61     {
  62     scope = cmProperty::TEST;
  63     }
  64   else if(args[1] == "VARIABLE")
  65     {
  66     scope = cmProperty::VARIABLE;
  67     }
  68   else if(args[1] == "CACHE")
  69     {
  70     scope = cmProperty::CACHE;
  71     }
  72   else
  73     {
  74     cmOStringStream e;
  75     e << "given invalid scope " << args[1] << ".  "
  76       << "Valid scopes are "
  77       << "GLOBAL, DIRECTORY, TARGET, SOURCE, TEST, VARIABLE, CACHE.";
  78     this->SetError(e.str().c_str());
  79     return false;
  80     }
  81
  82   // Parse remaining arguments.
  83   enum Doing { DoingNone, DoingName, DoingProperty, DoingType };
  84   Doing doing = DoingName;
  85   for(unsigned int i=2; i < args.size(); ++i)
  86     {
  87     if(args[i] == "PROPERTY")
  88       {
  89       doing = DoingProperty;
  90       }
  91     else if(args[i] == "BRIEF_DOCS")
  92       {
  93       doing = DoingNone;
  94       this->InfoType = OutBriefDoc;
  95       }
  96     else if(args[i] == "FULL_DOCS")
  97       {
  98       doing = DoingNone;
  99       this->InfoType = OutFullDoc;
 100       }
 101     else if(args[i] == "SET")
 102       {
 103       doing = DoingNone;
 104       this->InfoType = OutSet;
 105       }
 106     else if(args[i] == "DEFINED")
 107       {
 108       doing = DoingNone;
 109       this->InfoType = OutDefined;
 110       }
 111     else if(doing == DoingName)
 112       {
 113       doing = DoingNone;
 114       this->Name = args[i];
 115       }
 116     else if(doing == DoingProperty)
 117       {
 118       doing = DoingNone;
 119       this->PropertyName = args[i];
 120       }
 121     else
 122       {
 123       cmOStringStream e;
 124       e << "given invalid argument \"" << args[i] << "\".";
 125       this->SetError(e.str().c_str());
 126       return false;
 127       }
 128     }
 129
 130   // Make sure a property name was found.
 131   if(this->PropertyName.empty())
 132     {
 133     this->SetError("not given a PROPERTY <name> argument.");
 134     return false;
 135     }
 136
 137   // Compute requested output.
 138   if(this->InfoType == OutBriefDoc)
 139     {
 140     // Lookup brief documentation.
 141     std::string output;
 142     if(cmPropertyDefinition* def =
 143        this->Makefile->GetCMakeInstance()->
 144        GetPropertyDefinition(this->PropertyName.c_str(), scope))
 145       {
 146       output = def->GetShortDescription();
 147       }
 148     else
 149       {
 150       output = "NOTFOUND";
 151       }
 152     this->Makefile->AddDefinition(this->Variable.c_str(), output.c_str());
 153     }
 154   else if(this->InfoType == OutFullDoc)
 155     {
 156     // Lookup full documentation.
 157     std::string output;
 158     if(cmPropertyDefinition* def =
 159        this->Makefile->GetCMakeInstance()->
 160        GetPropertyDefinition(this->PropertyName.c_str(), scope))
 161       {
 162       output = def->GetFullDescription();
 163       }
 164     else
 165       {
 166       output = "NOTFOUND";
 167       }
 168     this->Makefile->AddDefinition(this->Variable.c_str(), output.c_str());
 169     }
 170   else if(this->InfoType == OutDefined)
 171     {
 172     // Lookup if the property is defined
 173     if(this->Makefile->GetCMakeInstance()->
 174        GetPropertyDefinition(this->PropertyName.c_str(), scope))
 175       {
 176       this->Makefile->AddDefinition(this->Variable.c_str(), "1");
 177       }
 178     else
 179       {
 180       this->Makefile->AddDefinition(this->Variable.c_str(), "0");
 181       }
 182     }
 183   else
 184     {
 185     // Dispatch property getting.
 186     switch(scope)
 187       {
 188       case cmProperty::GLOBAL:      return this->HandleGlobalMode();
 189       case cmProperty::DIRECTORY:   return this->HandleDirectoryMode();
 190       case cmProperty::TARGET:      return this->HandleTargetMode();
 191       case cmProperty::SOURCE_FILE: return this->HandleSourceMode();
 192       case cmProperty::TEST:        return this->HandleTestMode();
 193       case cmProperty::VARIABLE:    return this->HandleVariableMode();
 194       case cmProperty::CACHE:       return this->HandleCacheMode();
 195
 196       case cmProperty::CACHED_VARIABLE:
 197         break; // should never happen
 198       }
 199     }
 200
 201   return true;
 202 }
 203
 204 //----------------------------------------------------------------------------
 205 bool cmGetPropertyCommand::StoreResult(const char* value)
 206 {
 207   if(this->InfoType == OutSet)
 208     {
 209     this->Makefile->AddDefinition(this->Variable.c_str(), value? "1":"0");
 210     }
 211   else // if(this->InfoType == OutValue)
 212     {
 213     if(value)
 214       {
 215       this->Makefile->AddDefinition(this->Variable.c_str(), value);
 216       }
 217     else
 218       {
 219       this->Makefile->RemoveDefinition(this->Variable.c_str());
 220       }
 221     }
 222   return true;
 223 }
 224
 225 //----------------------------------------------------------------------------
 226 bool cmGetPropertyCommand::HandleGlobalMode()
 227 {
 228   if(!this->Name.empty())
 229     {
 230     this->SetError("given name for GLOBAL scope.");
 231     return false;
 232     }
 233
 234   // Get the property.
 235   cmake* cm = this->Makefile->GetCMakeInstance();
 236   return this->StoreResult(cm->GetProperty(this->PropertyName.c_str()));
 237 }
 238
 239 //----------------------------------------------------------------------------
 240 bool cmGetPropertyCommand::HandleDirectoryMode()
 241 {
 242   // Default to the current directory.
 243   cmMakefile* mf = this->Makefile;
 244
 245   // Lookup the directory if given.
 246   if(!this->Name.empty())
 247     {
 248     // Construct the directory name.  Interpret relative paths with
 249     // respect to the current directory.
 250     std::string dir = this->Name;
 251     if(!cmSystemTools::FileIsFullPath(dir.c_str()))
 252       {
 253       dir = this->Makefile->GetCurrentDirectory();
 254       dir += "/";
 255       dir += this->Name;
 256       }
 257
 258     // The local generators are associated with collapsed paths.
 259     dir = cmSystemTools::CollapseFullPath(dir.c_str());
 260
 261     // Lookup the generator.
 262     if(cmLocalGenerator* lg =
 263        (this->Makefile->GetLocalGenerator()
 264         ->GetGlobalGenerator()->FindLocalGenerator(dir.c_str())))
 265       {
 266       // Use the makefile for the directory found.
 267       mf = lg->GetMakefile();
 268       }
 269     else
 270       {
 271       // Could not find the directory.
 272       this->SetError
 273         ("DIRECTORY scope provided but requested directory was not found. "
 274          "This could be because the directory argument was invalid or, "
 275          "it is valid but has not been processed yet.");
 276       return false;
 277       }
 278     }
 279
 280   // Get the property.
 281   return this->StoreResult(mf->GetProperty(this->PropertyName.c_str()));
 282 }
 283
 284 //----------------------------------------------------------------------------
 285 bool cmGetPropertyCommand::HandleTargetMode()
 286 {
 287   if(this->Name.empty())
 288     {
 289     this->SetError("not given name for TARGET scope.");
 290     return false;
 291     }
 292
 293   if(cmTarget* target = this->Makefile->FindTargetToUse(this->Name.c_str()))
 294     {
 295     return this->StoreResult(target->GetProperty(this->PropertyName.c_str()));
 296     }
 297   else
 298     {
 299     cmOStringStream e;
 300     e << "could not find TARGET " << this->Name
 301       << ".  Perhaps it has not yet been created.";
 302     this->SetError(e.str().c_str());
 303     return false;
 304     }
 305 }
 306
 307 //----------------------------------------------------------------------------
 308 bool cmGetPropertyCommand::HandleSourceMode()
 309 {
 310   if(this->Name.empty())
 311     {
 312     this->SetError("not given name for SOURCE scope.");
 313     return false;
 314     }
 315
 316   // Get the source file.
 317   if(cmSourceFile* sf =
 318      this->Makefile->GetOrCreateSource(this->Name.c_str()))
 319     {
 320     return
 321       this->StoreResult(sf->GetPropertyForUser(this->PropertyName.c_str()));
 322     }
 323   else
 324     {
 325     cmOStringStream e;
 326     e << "given SOURCE name that could not be found or created: "
 327       << this->Name;
 328     this->SetError(e.str().c_str());
 329     return false;
 330     }
 331 }
 332
 333 //----------------------------------------------------------------------------
 334 bool cmGetPropertyCommand::HandleTestMode()
 335 {
 336   if(this->Name.empty())
 337     {
 338     this->SetError("not given name for TEST scope.");
 339     return false;
 340     }
 341
 342   // Loop over all tests looking for matching names.
 343   if(cmTest* test = this->Makefile->GetTest(this->Name.c_str()))
 344     {
 345     return this->StoreResult(test->GetProperty(this->PropertyName.c_str()));
 346     }
 347
 348   // If not found it is an error.
 349   cmOStringStream e;
 350   e << "given TEST name that does not exist: " << this->Name;
 351   this->SetError(e.str().c_str());
 352   return false;
 353 }
 354
 355 //----------------------------------------------------------------------------
 356 bool cmGetPropertyCommand::HandleVariableMode()
 357 {
 358   if(!this->Name.empty())
 359     {
 360     this->SetError("given name for VARIABLE scope.");
 361     return false;
 362     }
 363
 364   return this->StoreResult
 365     (this->Makefile->GetDefinition(this->PropertyName.c_str()));
 366 }
 367
 368 //----------------------------------------------------------------------------
 369 bool cmGetPropertyCommand::HandleCacheMode()
 370 {
 371   if(this->Name.empty())
 372     {
 373     this->SetError("not given name for CACHE scope.");
 374     return false;
 375     }
 376
 377   const char* value = 0;
 378   cmCacheManager::CacheIterator it =
 379     this->Makefile->GetCacheManager()->GetCacheIterator(this->Name.c_str());
 380   if(!it.IsAtEnd())
 381     {
 382     value = it.GetProperty(this->PropertyName.c_str());
 383     }
 384   this->StoreResult(value);
 385   return true;
 386 }