CMakeLua/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/01/30 16:21:54 $
   7   Version:   $Revision: 1.7 $
   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] == "DEFINED")
  98       {
  99       doing = DoingNone;
 100       this->InfoType = OutDefined;
 101       }
 102     else if(doing == DoingName)
 103       {
 104       doing = DoingNone;
 105       this->Name = args[i];
 106       }
 107     else if(doing == DoingProperty)
 108       {
 109       doing = DoingNone;
 110       this->PropertyName = args[i];
 111       }
 112     else
 113       {
 114       cmOStringStream e;
 115       e << "given invalid argument \"" << args[i] << "\".";
 116       this->SetError(e.str().c_str());
 117       return false;
 118       }
 119     }
 120
 121   // Make sure a property name was found.
 122   if(this->PropertyName.empty())
 123     {
 124     this->SetError("not given a PROPERTY <name> argument.");
 125     return false;
 126     }
 127
 128   // Compute requested output.
 129   if(this->InfoType == OutBriefDoc)
 130     {
 131     // Lookup brief documentation.
 132     std::string output;
 133     if(cmPropertyDefinition* def =
 134        this->Makefile->GetCMakeInstance()->
 135        GetPropertyDefinition(this->PropertyName.c_str(), scope))
 136       {
 137       output = def->GetShortDescription();
 138       }
 139     else
 140       {
 141       output = "NOTFOUND";
 142       }
 143     this->Makefile->AddDefinition(this->Variable.c_str(), output.c_str());
 144     }
 145   else if(this->InfoType == OutFullDoc)
 146     {
 147     // Lookup full documentation.
 148     std::string output;
 149     if(cmPropertyDefinition* def =
 150        this->Makefile->GetCMakeInstance()->
 151        GetPropertyDefinition(this->PropertyName.c_str(), scope))
 152       {
 153       output = def->GetFullDescription();
 154       }
 155     else
 156       {
 157       output = "NOTFOUND";
 158       }
 159     this->Makefile->AddDefinition(this->Variable.c_str(), output.c_str());
 160     }
 161   else
 162     {
 163     // Dispatch property getting.
 164     switch(scope)
 165       {
 166       case cmProperty::GLOBAL:      return this->HandleGlobalMode();
 167       case cmProperty::DIRECTORY:   return this->HandleDirectoryMode();
 168       case cmProperty::TARGET:      return this->HandleTargetMode();
 169       case cmProperty::SOURCE_FILE: return this->HandleSourceMode();
 170       case cmProperty::TEST:        return this->HandleTestMode();
 171       case cmProperty::VARIABLE:    return this->HandleVariableMode();
 172
 173       case cmProperty::CACHED_VARIABLE:
 174         break; // should never happen
 175       }
 176     }
 177
 178   return true;
 179 }
 180
 181 //----------------------------------------------------------------------------
 182 bool cmGetPropertyCommand::StoreResult(const char* value)
 183 {
 184   if(this->InfoType == OutDefined)
 185     {
 186     this->Makefile->AddDefinition(this->Variable.c_str(), value? "1":"0");
 187     }
 188   else // if(this->InfoType == OutValue)
 189     {
 190     this->Makefile->AddDefinition(this->Variable.c_str(), value);
 191     }
 192   return true;
 193 }
 194
 195 //----------------------------------------------------------------------------
 196 bool cmGetPropertyCommand::HandleGlobalMode()
 197 {
 198   if(!this->Name.empty())
 199     {
 200     this->SetError("given name for GLOBAL scope.");
 201     return false;
 202     }
 203
 204   // Get the property.
 205   cmake* cm = this->Makefile->GetCMakeInstance();
 206   return this->StoreResult(cm->GetProperty(this->PropertyName.c_str()));
 207 }
 208
 209 //----------------------------------------------------------------------------
 210 bool cmGetPropertyCommand::HandleDirectoryMode()
 211 {
 212   // Default to the current directory.
 213   cmMakefile* mf = this->Makefile;
 214
 215   // Lookup the directory if given.
 216   if(!this->Name.empty())
 217     {
 218     // Construct the directory name.  Interpret relative paths with
 219     // respect to the current directory.
 220     std::string dir = this->Name;
 221     if(!cmSystemTools::FileIsFullPath(dir.c_str()))
 222       {
 223       dir = this->Makefile->GetCurrentDirectory();
 224       dir += "/";
 225       dir += this->Name;
 226       }
 227
 228     // The local generators are associated with collapsed paths.
 229     dir = cmSystemTools::CollapseFullPath(dir.c_str());
 230
 231     // Lookup the generator.
 232     if(cmLocalGenerator* lg =
 233        (this->Makefile->GetLocalGenerator()
 234         ->GetGlobalGenerator()->FindLocalGenerator(dir.c_str())))
 235       {
 236       // Use the makefile for the directory found.
 237       mf = lg->GetMakefile();
 238       }
 239     else
 240       {
 241       // Could not find the directory.
 242       this->SetError
 243         ("DIRECTORY scope provided but requested directory was not found. "
 244          "This could be because the directory argument was invalid or, "
 245          "it is valid but has not been processed yet.");
 246       return false;
 247       }
 248     }
 249
 250   // Get the property.
 251   return this->StoreResult(mf->GetProperty(this->PropertyName.c_str()));
 252 }
 253
 254 //----------------------------------------------------------------------------
 255 bool cmGetPropertyCommand::HandleTargetMode()
 256 {
 257   if(this->Name.empty())
 258     {
 259     this->SetError("not given name for TARGET scope.");
 260     return false;
 261     }
 262
 263   if(cmTarget* target = this->Makefile->FindTargetToUse(this->Name.c_str()))
 264     {
 265     return this->StoreResult(target->GetProperty(this->PropertyName.c_str()));
 266     }
 267   else
 268     {
 269     cmOStringStream e;
 270     e << "could not find TARGET " << this->Name
 271       << ".  Perhaps it has not yet been created.";
 272     this->SetError(e.str().c_str());
 273     return false;
 274     }
 275 }
 276
 277 //----------------------------------------------------------------------------
 278 bool cmGetPropertyCommand::HandleSourceMode()
 279 {
 280   if(this->Name.empty())
 281     {
 282     this->SetError("not given name for SOURCE scope.");
 283     return false;
 284     }
 285
 286   // Get the source file.
 287   if(cmSourceFile* sf =
 288      this->Makefile->GetOrCreateSource(this->Name.c_str()))
 289     {
 290     return
 291       this->StoreResult(sf->GetPropertyForUser(this->PropertyName.c_str()));
 292     }
 293   else
 294     {
 295     cmOStringStream e;
 296     e << "given SOURCE name that could not be found or created: "
 297       << this->Name;
 298     this->SetError(e.str().c_str());
 299     return false;
 300     }
 301 }
 302
 303 //----------------------------------------------------------------------------
 304 bool cmGetPropertyCommand::HandleTestMode()
 305 {
 306   if(this->Name.empty())
 307     {
 308     this->SetError("not given name for TEST scope.");
 309     return false;
 310     }
 311
 312   // Loop over all tests looking for matching names.
 313   std::vector<cmTest*> const& tests = *this->Makefile->GetTests();
 314   for(std::vector<cmTest*>::const_iterator ti = tests.begin();
 315       ti != tests.end(); ++ti)
 316     {
 317     cmTest* test = *ti;
 318     if(test->GetName() == this->Name)
 319       {
 320       return this->StoreResult(test->GetProperty(this->PropertyName.c_str()));
 321       }
 322     }
 323
 324   // If not found it is an error.
 325   cmOStringStream e;
 326   e << "given TEST name that does not exist: " << this->Name;
 327   this->SetError(e.str().c_str());
 328   return false;
 329 }
 330
 331 //----------------------------------------------------------------------------
 332 bool cmGetPropertyCommand::HandleVariableMode()
 333 {
 334   if(!this->Name.empty())
 335     {
 336     this->SetError("given name for VARIABLE scope.");
 337     return false;
 338     }
 339
 340   return this->StoreResult
 341     (this->Makefile->GetDefinition(this->PropertyName.c_str()));
 342 }