2009-09-28 19:43:28 +04:00
|
|
|
/*============================================================================
|
|
|
|
CMake - Cross Platform Makefile Generator
|
|
|
|
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
|
2007-06-25 18:33:25 +04:00
|
|
|
|
2009-09-28 19:43:28 +04:00
|
|
|
Distributed under the OSI-approved BSD License (the "License");
|
|
|
|
see accompanying file Copyright.txt for details.
|
2007-06-25 18:33:25 +04:00
|
|
|
|
2009-09-28 19:43:28 +04:00
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even the
|
|
|
|
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the License for more information.
|
|
|
|
============================================================================*/
|
2007-06-25 18:33:25 +04:00
|
|
|
#include "cmGetPropertyCommand.h"
|
|
|
|
|
|
|
|
#include "cmake.h"
|
2015-04-06 11:52:45 +03:00
|
|
|
#include "cmState.h"
|
2007-06-25 18:33:25 +04:00
|
|
|
#include "cmTest.h"
|
2013-06-14 16:35:52 +04:00
|
|
|
#include "cmGlobalGenerator.h"
|
|
|
|
#include "cmLocalGenerator.h"
|
|
|
|
#include "cmSourceFile.h"
|
2007-10-24 22:43:10 +04:00
|
|
|
#include "cmPropertyDefinition.h"
|
2007-06-25 18:33:25 +04:00
|
|
|
|
2008-01-18 01:19:13 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
cmGetPropertyCommand::cmGetPropertyCommand()
|
|
|
|
{
|
|
|
|
this->InfoType = OutValue;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
2008-01-23 18:28:26 +03:00
|
|
|
bool cmGetPropertyCommand
|
|
|
|
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
|
2007-06-25 18:33:25 +04:00
|
|
|
{
|
|
|
|
if(args.size() < 3 )
|
|
|
|
{
|
|
|
|
this->SetError("called with incorrect number of arguments");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-01-18 01:19:13 +03:00
|
|
|
// The cmake variable in which to store the result.
|
|
|
|
this->Variable = args[0];
|
2007-06-25 18:33:25 +04:00
|
|
|
|
2008-01-18 01:19:13 +03:00
|
|
|
// Get the scope from which to get the property.
|
2007-06-25 18:33:25 +04:00
|
|
|
cmProperty::ScopeType scope;
|
2008-01-18 01:19:13 +03:00
|
|
|
if(args[1] == "GLOBAL")
|
2007-06-25 18:33:25 +04:00
|
|
|
{
|
|
|
|
scope = cmProperty::GLOBAL;
|
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
else if(args[1] == "DIRECTORY")
|
2007-06-25 18:33:25 +04:00
|
|
|
{
|
|
|
|
scope = cmProperty::DIRECTORY;
|
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
else if(args[1] == "TARGET")
|
2007-06-25 18:33:25 +04:00
|
|
|
{
|
|
|
|
scope = cmProperty::TARGET;
|
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
else if(args[1] == "SOURCE")
|
|
|
|
{
|
|
|
|
scope = cmProperty::SOURCE_FILE;
|
|
|
|
}
|
|
|
|
else if(args[1] == "TEST")
|
2007-06-25 18:33:25 +04:00
|
|
|
{
|
|
|
|
scope = cmProperty::TEST;
|
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
else if(args[1] == "VARIABLE")
|
2007-06-25 18:33:25 +04:00
|
|
|
{
|
2008-01-18 01:19:13 +03:00
|
|
|
scope = cmProperty::VARIABLE;
|
2007-06-25 18:33:25 +04:00
|
|
|
}
|
2009-03-10 18:10:59 +03:00
|
|
|
else if(args[1] == "CACHE")
|
|
|
|
{
|
|
|
|
scope = cmProperty::CACHE;
|
|
|
|
}
|
2014-05-15 21:12:40 +04:00
|
|
|
else if(args[1] == "INSTALL")
|
|
|
|
{
|
|
|
|
scope = cmProperty::INSTALL;
|
|
|
|
}
|
2007-06-25 18:33:25 +04:00
|
|
|
else
|
|
|
|
{
|
2015-01-05 22:31:31 +03:00
|
|
|
std::ostringstream e;
|
2008-01-18 01:19:13 +03:00
|
|
|
e << "given invalid scope " << args[1] << ". "
|
|
|
|
<< "Valid scopes are "
|
2014-05-15 21:12:40 +04:00
|
|
|
<< "GLOBAL, DIRECTORY, TARGET, SOURCE, TEST, VARIABLE, CACHE, INSTALL.";
|
2014-03-11 03:04:11 +04:00
|
|
|
this->SetError(e.str());
|
2007-06-25 18:33:25 +04:00
|
|
|
return false;
|
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
|
|
|
|
// Parse remaining arguments.
|
|
|
|
enum Doing { DoingNone, DoingName, DoingProperty, DoingType };
|
|
|
|
Doing doing = DoingName;
|
|
|
|
for(unsigned int i=2; i < args.size(); ++i)
|
2007-10-24 22:43:10 +04:00
|
|
|
{
|
2008-01-18 01:19:13 +03:00
|
|
|
if(args[i] == "PROPERTY")
|
|
|
|
{
|
|
|
|
doing = DoingProperty;
|
|
|
|
}
|
|
|
|
else if(args[i] == "BRIEF_DOCS")
|
|
|
|
{
|
|
|
|
doing = DoingNone;
|
|
|
|
this->InfoType = OutBriefDoc;
|
|
|
|
}
|
|
|
|
else if(args[i] == "FULL_DOCS")
|
|
|
|
{
|
|
|
|
doing = DoingNone;
|
|
|
|
this->InfoType = OutFullDoc;
|
|
|
|
}
|
2008-04-01 22:22:09 +04:00
|
|
|
else if(args[i] == "SET")
|
|
|
|
{
|
|
|
|
doing = DoingNone;
|
|
|
|
this->InfoType = OutSet;
|
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
else if(args[i] == "DEFINED")
|
|
|
|
{
|
|
|
|
doing = DoingNone;
|
|
|
|
this->InfoType = OutDefined;
|
|
|
|
}
|
|
|
|
else if(doing == DoingName)
|
|
|
|
{
|
|
|
|
doing = DoingNone;
|
|
|
|
this->Name = args[i];
|
|
|
|
}
|
|
|
|
else if(doing == DoingProperty)
|
|
|
|
{
|
|
|
|
doing = DoingNone;
|
|
|
|
this->PropertyName = args[i];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-01-05 22:31:31 +03:00
|
|
|
std::ostringstream e;
|
2008-01-18 01:19:13 +03:00
|
|
|
e << "given invalid argument \"" << args[i] << "\".";
|
2014-03-11 03:04:11 +04:00
|
|
|
this->SetError(e.str());
|
2008-01-18 01:19:13 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure a property name was found.
|
|
|
|
if(this->PropertyName.empty())
|
|
|
|
{
|
|
|
|
this->SetError("not given a PROPERTY <name> argument.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Compute requested output.
|
|
|
|
if(this->InfoType == OutBriefDoc)
|
|
|
|
{
|
|
|
|
// Lookup brief documentation.
|
|
|
|
std::string output;
|
2015-06-06 10:46:38 +03:00
|
|
|
if(cmPropertyDefinition const* def = this->Makefile->GetState()->
|
2014-03-11 03:04:11 +04:00
|
|
|
GetPropertyDefinition(this->PropertyName, scope))
|
2007-10-24 22:43:10 +04:00
|
|
|
{
|
|
|
|
output = def->GetShortDescription();
|
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
else
|
|
|
|
{
|
|
|
|
output = "NOTFOUND";
|
|
|
|
}
|
2014-03-11 03:04:11 +04:00
|
|
|
this->Makefile->AddDefinition(this->Variable, output.c_str());
|
2007-10-24 22:43:10 +04:00
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
else if(this->InfoType == OutFullDoc)
|
2007-06-25 18:33:25 +04:00
|
|
|
{
|
2008-01-18 01:19:13 +03:00
|
|
|
// Lookup full documentation.
|
|
|
|
std::string output;
|
2015-06-06 10:46:38 +03:00
|
|
|
if(cmPropertyDefinition const* def = this->Makefile->GetState()->
|
2014-03-11 03:04:11 +04:00
|
|
|
GetPropertyDefinition(this->PropertyName, scope))
|
2007-10-24 22:43:10 +04:00
|
|
|
{
|
|
|
|
output = def->GetFullDescription();
|
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
else
|
|
|
|
{
|
|
|
|
output = "NOTFOUND";
|
|
|
|
}
|
2014-03-11 03:04:11 +04:00
|
|
|
this->Makefile->AddDefinition(this->Variable, output.c_str());
|
2007-10-24 22:43:10 +04:00
|
|
|
}
|
2008-04-01 22:22:09 +04:00
|
|
|
else if(this->InfoType == OutDefined)
|
|
|
|
{
|
|
|
|
// Lookup if the property is defined
|
2015-04-05 00:33:26 +03:00
|
|
|
if(this->Makefile->GetState()->
|
2014-03-11 03:04:11 +04:00
|
|
|
GetPropertyDefinition(this->PropertyName, scope))
|
2008-04-01 22:22:09 +04:00
|
|
|
{
|
2014-03-11 03:04:11 +04:00
|
|
|
this->Makefile->AddDefinition(this->Variable, "1");
|
2008-04-01 22:22:09 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-03-11 03:04:11 +04:00
|
|
|
this->Makefile->AddDefinition(this->Variable, "0");
|
2008-04-01 22:22:09 +04:00
|
|
|
}
|
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// Dispatch property getting.
|
|
|
|
switch(scope)
|
|
|
|
{
|
|
|
|
case cmProperty::GLOBAL: return this->HandleGlobalMode();
|
|
|
|
case cmProperty::DIRECTORY: return this->HandleDirectoryMode();
|
|
|
|
case cmProperty::TARGET: return this->HandleTargetMode();
|
|
|
|
case cmProperty::SOURCE_FILE: return this->HandleSourceMode();
|
|
|
|
case cmProperty::TEST: return this->HandleTestMode();
|
|
|
|
case cmProperty::VARIABLE: return this->HandleVariableMode();
|
2009-03-10 18:10:59 +03:00
|
|
|
case cmProperty::CACHE: return this->HandleCacheMode();
|
2014-05-15 21:12:40 +04:00
|
|
|
case cmProperty::INSTALL: return this->HandleInstallMode();
|
2008-01-18 01:19:13 +03:00
|
|
|
|
|
|
|
case cmProperty::CACHED_VARIABLE:
|
|
|
|
break; // should never happen
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-25 18:33:25 +04:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-01-18 01:19:13 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool cmGetPropertyCommand::StoreResult(const char* value)
|
|
|
|
{
|
2008-04-01 22:22:09 +04:00
|
|
|
if(this->InfoType == OutSet)
|
2008-01-18 01:19:13 +03:00
|
|
|
{
|
2014-03-11 03:04:11 +04:00
|
|
|
this->Makefile->AddDefinition(this->Variable, value? "1":"0");
|
2008-01-18 01:19:13 +03:00
|
|
|
}
|
|
|
|
else // if(this->InfoType == OutValue)
|
|
|
|
{
|
2009-03-10 00:57:12 +03:00
|
|
|
if(value)
|
|
|
|
{
|
2014-03-11 03:04:11 +04:00
|
|
|
this->Makefile->AddDefinition(this->Variable, value);
|
2009-03-10 00:57:12 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-03-11 03:04:11 +04:00
|
|
|
this->Makefile->RemoveDefinition(this->Variable);
|
2009-03-10 00:57:12 +03:00
|
|
|
}
|
2008-01-18 01:19:13 +03:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool cmGetPropertyCommand::HandleGlobalMode()
|
|
|
|
{
|
|
|
|
if(!this->Name.empty())
|
|
|
|
{
|
|
|
|
this->SetError("given name for GLOBAL scope.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get the property.
|
|
|
|
cmake* cm = this->Makefile->GetCMakeInstance();
|
2015-04-11 15:15:55 +03:00
|
|
|
return this->StoreResult(cm->GetState()
|
|
|
|
->GetGlobalProperty(this->PropertyName));
|
2008-01-18 01:19:13 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool cmGetPropertyCommand::HandleDirectoryMode()
|
|
|
|
{
|
|
|
|
// Default to the current directory.
|
|
|
|
cmMakefile* mf = this->Makefile;
|
|
|
|
|
|
|
|
// Lookup the directory if given.
|
|
|
|
if(!this->Name.empty())
|
|
|
|
{
|
|
|
|
// Construct the directory name. Interpret relative paths with
|
|
|
|
// respect to the current directory.
|
|
|
|
std::string dir = this->Name;
|
|
|
|
if(!cmSystemTools::FileIsFullPath(dir.c_str()))
|
|
|
|
{
|
2015-04-16 22:17:41 +03:00
|
|
|
dir = this->Makefile->GetCurrentSourceDirectory();
|
2008-01-18 01:19:13 +03:00
|
|
|
dir += "/";
|
|
|
|
dir += this->Name;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The local generators are associated with collapsed paths.
|
2014-10-15 16:54:05 +04:00
|
|
|
dir = cmSystemTools::CollapseFullPath(dir);
|
2008-01-18 01:19:13 +03:00
|
|
|
|
|
|
|
// Lookup the generator.
|
2015-08-02 13:39:51 +03:00
|
|
|
mf = this->Makefile->GetGlobalGenerator()->FindMakefile(dir);
|
|
|
|
if (!mf)
|
2008-01-18 01:19:13 +03:00
|
|
|
{
|
|
|
|
// Could not find the directory.
|
|
|
|
this->SetError
|
|
|
|
("DIRECTORY scope provided but requested directory was not found. "
|
|
|
|
"This could be because the directory argument was invalid or, "
|
|
|
|
"it is valid but has not been processed yet.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-07 15:50:54 +03:00
|
|
|
if (this->PropertyName == "DEFINITIONS")
|
|
|
|
{
|
|
|
|
switch(mf->GetPolicyStatus(cmPolicies::CMP0059))
|
|
|
|
{
|
|
|
|
case cmPolicies::WARN:
|
|
|
|
mf->IssueMessage(cmake::AUTHOR_WARNING,
|
|
|
|
cmPolicies::GetPolicyWarning(cmPolicies::CMP0059));
|
|
|
|
case cmPolicies::OLD:
|
|
|
|
return this->StoreResult(mf->GetDefineFlagsCMP0059());
|
|
|
|
case cmPolicies::NEW:
|
|
|
|
case cmPolicies::REQUIRED_ALWAYS:
|
|
|
|
case cmPolicies::REQUIRED_IF_USED:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-18 01:19:13 +03:00
|
|
|
// Get the property.
|
2014-03-11 03:04:11 +04:00
|
|
|
return this->StoreResult(mf->GetProperty(this->PropertyName));
|
2008-01-18 01:19:13 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool cmGetPropertyCommand::HandleTargetMode()
|
|
|
|
{
|
|
|
|
if(this->Name.empty())
|
|
|
|
{
|
|
|
|
this->SetError("not given name for TARGET scope.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-07-12 11:14:31 +04:00
|
|
|
if(this->PropertyName == "ALIASED_TARGET")
|
|
|
|
{
|
2014-01-16 02:56:38 +04:00
|
|
|
if(this->Makefile->IsAlias(this->Name))
|
2013-07-12 11:14:31 +04:00
|
|
|
{
|
|
|
|
if(cmTarget* target =
|
2014-01-16 02:56:38 +04:00
|
|
|
this->Makefile->FindTargetToUse(this->Name))
|
2013-07-12 11:14:31 +04:00
|
|
|
{
|
2014-02-07 02:31:47 +04:00
|
|
|
return this->StoreResult(target->GetName().c_str());
|
2013-07-12 11:14:31 +04:00
|
|
|
}
|
|
|
|
}
|
2013-12-26 15:45:44 +04:00
|
|
|
return this->StoreResult((this->Variable + "-NOTFOUND").c_str());
|
2013-07-12 11:14:31 +04:00
|
|
|
}
|
2014-01-16 02:56:38 +04:00
|
|
|
if(cmTarget* target = this->Makefile->FindTargetToUse(this->Name))
|
2008-01-18 01:19:13 +03:00
|
|
|
{
|
2014-05-09 18:50:29 +04:00
|
|
|
return this->StoreResult(target->GetProperty(this->PropertyName,
|
|
|
|
this->Makefile));
|
2008-01-18 01:19:13 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-01-05 22:31:31 +03:00
|
|
|
std::ostringstream e;
|
2008-01-18 01:19:13 +03:00
|
|
|
e << "could not find TARGET " << this->Name
|
|
|
|
<< ". Perhaps it has not yet been created.";
|
2014-03-11 03:04:11 +04:00
|
|
|
this->SetError(e.str());
|
2008-01-18 01:19:13 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool cmGetPropertyCommand::HandleSourceMode()
|
|
|
|
{
|
|
|
|
if(this->Name.empty())
|
|
|
|
{
|
|
|
|
this->SetError("not given name for SOURCE scope.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get the source file.
|
|
|
|
if(cmSourceFile* sf =
|
2014-03-11 03:04:11 +04:00
|
|
|
this->Makefile->GetOrCreateSource(this->Name))
|
2008-01-18 01:19:13 +03:00
|
|
|
{
|
2008-01-30 19:21:54 +03:00
|
|
|
return
|
2014-03-11 03:04:11 +04:00
|
|
|
this->StoreResult(sf->GetPropertyForUser(this->PropertyName));
|
2008-01-18 01:19:13 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-01-05 22:31:31 +03:00
|
|
|
std::ostringstream e;
|
2008-01-18 01:19:13 +03:00
|
|
|
e << "given SOURCE name that could not be found or created: "
|
|
|
|
<< this->Name;
|
2014-03-11 03:04:11 +04:00
|
|
|
this->SetError(e.str());
|
2008-01-18 01:19:13 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool cmGetPropertyCommand::HandleTestMode()
|
|
|
|
{
|
|
|
|
if(this->Name.empty())
|
|
|
|
{
|
|
|
|
this->SetError("not given name for TEST scope.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Loop over all tests looking for matching names.
|
2014-03-11 03:04:11 +04:00
|
|
|
if(cmTest* test = this->Makefile->GetTest(this->Name))
|
2008-01-18 01:19:13 +03:00
|
|
|
{
|
2014-03-11 03:04:11 +04:00
|
|
|
return this->StoreResult(test->GetProperty(this->PropertyName));
|
2008-01-18 01:19:13 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// If not found it is an error.
|
2015-01-05 22:31:31 +03:00
|
|
|
std::ostringstream e;
|
2008-01-18 01:19:13 +03:00
|
|
|
e << "given TEST name that does not exist: " << this->Name;
|
2014-03-11 03:04:11 +04:00
|
|
|
this->SetError(e.str());
|
2008-01-18 01:19:13 +03:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool cmGetPropertyCommand::HandleVariableMode()
|
|
|
|
{
|
|
|
|
if(!this->Name.empty())
|
|
|
|
{
|
|
|
|
this->SetError("given name for VARIABLE scope.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return this->StoreResult
|
2014-03-11 03:04:11 +04:00
|
|
|
(this->Makefile->GetDefinition(this->PropertyName));
|
2008-01-18 01:19:13 +03:00
|
|
|
}
|
2009-03-10 18:10:59 +03:00
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool cmGetPropertyCommand::HandleCacheMode()
|
|
|
|
{
|
|
|
|
if(this->Name.empty())
|
|
|
|
{
|
|
|
|
this->SetError("not given name for CACHE scope.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* value = 0;
|
2015-04-06 11:52:45 +03:00
|
|
|
if(this->Makefile->GetState()->GetCacheEntryValue(this->Name))
|
2009-03-10 18:10:59 +03:00
|
|
|
{
|
2015-04-06 11:52:45 +03:00
|
|
|
value = this->Makefile->GetState()
|
2015-04-05 11:48:04 +03:00
|
|
|
->GetCacheEntryProperty(this->Name, this->PropertyName);
|
2009-03-10 18:10:59 +03:00
|
|
|
}
|
|
|
|
this->StoreResult(value);
|
|
|
|
return true;
|
|
|
|
}
|
2014-05-15 21:12:40 +04:00
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool cmGetPropertyCommand::HandleInstallMode()
|
|
|
|
{
|
|
|
|
if(this->Name.empty())
|
|
|
|
{
|
|
|
|
this->SetError("not given name for INSTALL scope.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get the installed file.
|
|
|
|
cmake* cm = this->Makefile->GetCMakeInstance();
|
|
|
|
|
|
|
|
if(cmInstalledFile* file = cm->GetOrCreateInstalledFile(
|
|
|
|
this->Makefile, this->Name))
|
|
|
|
{
|
|
|
|
std::string value;
|
|
|
|
bool isSet = file->GetProperty(this->PropertyName, value);
|
|
|
|
|
|
|
|
return this->StoreResult(isSet ? value.c_str() : 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-01-05 22:31:31 +03:00
|
|
|
std::ostringstream e;
|
2014-05-15 21:12:40 +04:00
|
|
|
e << "given INSTALL name that could not be found or created: "
|
|
|
|
<< this->Name;
|
|
|
|
this->SetError(e.str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|