Source/cmGetPropertyCommand.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmGetPropertyCommand.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2008-04-01 19:22:30 $
   7   Version:   $Revision: 1.9 $
   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
  69     {
  70     cmOStringStream e;
  71     e << "given invalid scope " << args[1] << ".  "
  72       << "Valid scopes are "
  73       << "GLOBAL, DIRECTORY, TARGET, SOURCE, TEST, VARIABLE.";
  74     this->SetError(e.str().c_str());
  75     return false;
  76     }
  77
  78   // Parse remaining arguments.
  79   enum Doing { DoingNone, DoingName, DoingProperty, DoingType };
  80   Doing doing = DoingName;
  81   for(unsigned int i=2; i < args.size(); ++i)
  82     {
  83     if(args[i] == "PROPERTY")
  84       {
  85       doing = DoingProperty;
  86       }
  87     else if(args[i] == "BRIEF_DOCS")
  88       {
  89       doing = DoingNone;
  90       this->InfoType = OutBriefDoc;
  91       }
  92     else if(args[i] == "FULL_DOCS")
  93       {
  94       doing = DoingNone;
  95       this->InfoType = OutFullDoc;
  96       }
  97     else if(args[i] == "SET")
  98       {
  99       doing = DoingNone;
 100       this->InfoType = OutSet;
 101       }
 102     else if(args[i] == "DEFINED")
 103       {
 104       doing = DoingNone;
 105       this->InfoType = OutDefined;
 106       }
 107     else if(doing == DoingName)
 108       {
 109       doing = DoingNone;
 110       this->Name = args[i];
 111       }
 112     else if(doing == DoingProperty)
 113       {
 114       doing = DoingNone;
 115       this->PropertyName = args[i];
 116       }
 117     else
 118       {
 119       cmOStringStream e;
 120       e << "given invalid argument \"" << args[i] << "\".";
 121       this->SetError(e.str().c_str());
 122       return false;
 123       }
 124     }
 125
 126   // Make sure a property name was found.
 127   if(this->PropertyName.empty())
 128     {
 129     this->SetError("not given a PROPERTY <name> argument.");
 130     return false;
 131     }
 132
 133   // Compute requested output.
 134   if(this->InfoType == OutBriefDoc)
 135     {
 136     // Lookup brief documentation.
 137     std::string output;
 138     if(cmPropertyDefinition* def =
 139        this->Makefile->GetCMakeInstance()->
 140        GetPropertyDefinition(this->PropertyName.c_str(), scope))
 141       {
 142       output = def->GetShortDescription();
 143       }
 144     else
 145       {
 146       output = "NOTFOUND";
 147       }
 148     this->Makefile->AddDefinition(this->Variable.c_str(), output.c_str());
 149     }
 150   else if(this->InfoType == OutFullDoc)
 151     {
 152     // Lookup full documentation.
 153     std::string output;
 154     if(cmPropertyDefinition* def =
 155        this->Makefile->GetCMakeInstance()->
 156        GetPropertyDefinition(this->PropertyName.c_str(), scope))
 157       {
 158       output = def->GetFullDescription();
 159       }
 160     else
 161       {
 162       output = "NOTFOUND";
 163       }
 164     this->Makefile->AddDefinition(this->Variable.c_str(), output.c_str());
 165     }
 166   else if(this->InfoType == OutDefined)
 167     {
 168     // Lookup if the property is defined
 169     if(this->Makefile->GetCMakeInstance()->
 170        GetPropertyDefinition(this->PropertyName.c_str(), scope))
 171       {
 172       this->Makefile->AddDefinition(this->Variable.c_str(), "1");
 173       }
 174     else
 175       {
 176       this->Makefile->AddDefinition(this->Variable.c_str(), "0");
 177       }
 178     }
 179   else
 180     {
 181     // Dispatch property getting.
 182     switch(scope)
 183       {
 184       case cmProperty::GLOBAL:      return this->HandleGlobalMode();
 185       case cmProperty::DIRECTORY:   return this->HandleDirectoryMode();
 186       case cmProperty::TARGET:      return this->HandleTargetMode();
 187       case cmProperty::SOURCE_FILE: return this->HandleSourceMode();
 188       case cmProperty::TEST:        return this->HandleTestMode();
 189       case cmProperty::VARIABLE:    return this->HandleVariableMode();
 190
 191       case cmProperty::CACHED_VARIABLE:
 192         break; // should never happen
 193       }
 194     }
 195
 196   return true;
 197 }
 198
 199 //----------------------------------------------------------------------------
 200 bool cmGetPropertyCommand::StoreResult(const char* value)
 201 {
 202   if(this->InfoType == OutSet)
 203     {
 204     this->Makefile->AddDefinition(this->Variable.c_str(), value? "1":"0");
 205     }
 206   else // if(this->InfoType == OutValue)
 207     {
 208     this->Makefile->AddDefinition(this->Variable.c_str(), value);
 209     }
 210   return true;
 211 }
 212
 213 //----------------------------------------------------------------------------
 214 bool cmGetPropertyCommand::HandleGlobalMode()
 215 {
 216   if(!this->Name.empty())
 217     {
 218     this->SetError("given name for GLOBAL scope.");
 219     return false;
 220     }
 221
 222   // Get the property.
 223   cmake* cm = this->Makefile->GetCMakeInstance();
 224   return this->StoreResult(cm->GetProperty(this->PropertyName.c_str()));
 225 }
 226
 227 //----------------------------------------------------------------------------
 228 bool cmGetPropertyCommand::HandleDirectoryMode()
 229 {
 230   // Default to the current directory.
 231   cmMakefile* mf = this->Makefile;
 232
 233   // Lookup the directory if given.
 234   if(!this->Name.empty())
 235     {
 236     // Construct the directory name.  Interpret relative paths with
 237     // respect to the current directory.
 238     std::string dir = this->Name;
 239     if(!cmSystemTools::FileIsFullPath(dir.c_str()))
 240       {
 241       dir = this->Makefile->GetCurrentDirectory();
 242       dir += "/";
 243       dir += this->Name;
 244       }
 245
 246     // The local generators are associated with collapsed paths.
 247     dir = cmSystemTools::CollapseFullPath(dir.c_str());
 248
 249     // Lookup the generator.
 250     if(cmLocalGenerator* lg =
 251        (this->Makefile->GetLocalGenerator()
 252         ->GetGlobalGenerator()->FindLocalGenerator(dir.c_str())))
 253       {
 254       // Use the makefile for the directory found.
 255       mf = lg->GetMakefile();
 256       }
 257     else
 258       {
 259       // Could not find the directory.
 260       this->SetError
 261         ("DIRECTORY scope provided but requested directory was not found. "
 262          "This could be because the directory argument was invalid or, "
 263          "it is valid but has not been processed yet.");
 264       return false;
 265       }
 266     }
 267
 268   // Get the property.
 269   return this->StoreResult(mf->GetProperty(this->PropertyName.c_str()));
 270 }
 271
 272 //----------------------------------------------------------------------------
 273 bool cmGetPropertyCommand::HandleTargetMode()
 274 {
 275   if(this->Name.empty())
 276     {
 277     this->SetError("not given name for TARGET scope.");
 278     return false;
 279     }
 280
 281   if(cmTarget* target = this->Makefile->FindTargetToUse(this->Name.c_str()))
 282     {
 283     return this->StoreResult(target->GetProperty(this->PropertyName.c_str()));
 284     }
 285   else
 286     {
 287     cmOStringStream e;
 288     e << "could not find TARGET " << this->Name
 289       << ".  Perhaps it has not yet been created.";
 290     this->SetError(e.str().c_str());
 291     return false;
 292     }
 293 }
 294
 295 //----------------------------------------------------------------------------
 296 bool cmGetPropertyCommand::HandleSourceMode()
 297 {
 298   if(this->Name.empty())
 299     {
 300     this->SetError("not given name for SOURCE scope.");
 301     return false;
 302     }
 303
 304   // Get the source file.
 305   if(cmSourceFile* sf =
 306      this->Makefile->GetOrCreateSource(this->Name.c_str()))
 307     {
 308     return
 309       this->StoreResult(sf->GetPropertyForUser(this->PropertyName.c_str()));
 310     }
 311   else
 312     {
 313     cmOStringStream e;
 314     e << "given SOURCE name that could not be found or created: "
 315       << this->Name;
 316     this->SetError(e.str().c_str());
 317     return false;
 318     }
 319 }
 320
 321 //----------------------------------------------------------------------------
 322 bool cmGetPropertyCommand::HandleTestMode()
 323 {
 324   if(this->Name.empty())
 325     {
 326     this->SetError("not given name for TEST scope.");
 327     return false;
 328     }
 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     if(test->GetName() == this->Name)
 337       {
 338       return this->StoreResult(test->GetProperty(this->PropertyName.c_str()));
 339       }
 340     }
 341
 342   // If not found it is an error.
 343   cmOStringStream e;
 344   e << "given TEST name that does not exist: " << this->Name;
 345   this->SetError(e.str().c_str());
 346   return false;
 347 }
 348
 349 //----------------------------------------------------------------------------
 350 bool cmGetPropertyCommand::HandleVariableMode()
 351 {
 352   if(!this->Name.empty())
 353     {
 354     this->SetError("given name for VARIABLE scope.");
 355     return false;
 356     }
 357
 358   return this->StoreResult
 359     (this->Makefile->GetDefinition(this->PropertyName.c_str()));
 360 }