mirror of
https://github.com/reactos/CMake.git
synced 2024-12-05 02:06:34 +00:00
440 lines
12 KiB
C++
440 lines
12 KiB
C++
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
#include "cmSetPropertyCommand.h"
|
|
|
|
#include <sstream>
|
|
|
|
#include "cmGlobalGenerator.h"
|
|
#include "cmInstalledFile.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmProperty.h"
|
|
#include "cmSourceFile.h"
|
|
#include "cmState.h"
|
|
#include "cmSystemTools.h"
|
|
#include "cmTarget.h"
|
|
#include "cmTest.h"
|
|
#include "cmake.h"
|
|
|
|
class cmExecutionStatus;
|
|
|
|
cmSetPropertyCommand::cmSetPropertyCommand()
|
|
{
|
|
this->AppendMode = false;
|
|
this->AppendAsString = false;
|
|
this->Remove = true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::InitialPass(std::vector<std::string> const& args,
|
|
cmExecutionStatus&)
|
|
{
|
|
if (args.size() < 2) {
|
|
this->SetError("called with incorrect number of arguments");
|
|
return false;
|
|
}
|
|
|
|
// Get the scope on which to set the property.
|
|
std::vector<std::string>::const_iterator arg = args.begin();
|
|
cmProperty::ScopeType scope;
|
|
if (*arg == "GLOBAL") {
|
|
scope = cmProperty::GLOBAL;
|
|
} else if (*arg == "DIRECTORY") {
|
|
scope = cmProperty::DIRECTORY;
|
|
} else if (*arg == "TARGET") {
|
|
scope = cmProperty::TARGET;
|
|
} else if (*arg == "SOURCE") {
|
|
scope = cmProperty::SOURCE_FILE;
|
|
} else if (*arg == "TEST") {
|
|
scope = cmProperty::TEST;
|
|
} else if (*arg == "CACHE") {
|
|
scope = cmProperty::CACHE;
|
|
} else if (*arg == "INSTALL") {
|
|
scope = cmProperty::INSTALL;
|
|
} else {
|
|
std::ostringstream e;
|
|
e << "given invalid scope " << *arg << ". "
|
|
<< "Valid scopes are GLOBAL, DIRECTORY, "
|
|
"TARGET, SOURCE, TEST, CACHE, INSTALL.";
|
|
this->SetError(e.str());
|
|
return false;
|
|
}
|
|
|
|
// Parse the rest of the arguments up to the values.
|
|
enum Doing
|
|
{
|
|
DoingNone,
|
|
DoingNames,
|
|
DoingProperty,
|
|
DoingValues
|
|
};
|
|
Doing doing = DoingNames;
|
|
const char* sep = "";
|
|
for (++arg; arg != args.end(); ++arg) {
|
|
if (*arg == "PROPERTY") {
|
|
doing = DoingProperty;
|
|
} else if (*arg == "APPEND") {
|
|
doing = DoingNone;
|
|
this->AppendMode = true;
|
|
this->Remove = false;
|
|
this->AppendAsString = false;
|
|
} else if (*arg == "APPEND_STRING") {
|
|
doing = DoingNone;
|
|
this->AppendMode = true;
|
|
this->Remove = false;
|
|
this->AppendAsString = true;
|
|
} else if (doing == DoingNames) {
|
|
this->Names.insert(*arg);
|
|
} else if (doing == DoingProperty) {
|
|
this->PropertyName = *arg;
|
|
doing = DoingValues;
|
|
} else if (doing == DoingValues) {
|
|
this->PropertyValue += sep;
|
|
sep = ";";
|
|
this->PropertyValue += *arg;
|
|
this->Remove = false;
|
|
} else {
|
|
std::ostringstream e;
|
|
e << "given invalid argument \"" << *arg << "\".";
|
|
this->SetError(e.str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Make sure a property name was found.
|
|
if (this->PropertyName.empty()) {
|
|
this->SetError("not given a PROPERTY <name> argument.");
|
|
return false;
|
|
}
|
|
|
|
// Dispatch property setting.
|
|
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::CACHE:
|
|
return this->HandleCacheMode();
|
|
case cmProperty::INSTALL:
|
|
return this->HandleInstallMode();
|
|
|
|
case cmProperty::VARIABLE:
|
|
case cmProperty::CACHED_VARIABLE:
|
|
break; // should never happen
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleGlobalMode()
|
|
{
|
|
if (!this->Names.empty()) {
|
|
this->SetError("given names for GLOBAL scope.");
|
|
return false;
|
|
}
|
|
|
|
// Set or append the property.
|
|
cmake* cm = this->Makefile->GetCMakeInstance();
|
|
const char* name = this->PropertyName.c_str();
|
|
const char* value = this->PropertyValue.c_str();
|
|
if (this->Remove) {
|
|
value = CM_NULLPTR;
|
|
}
|
|
if (this->AppendMode) {
|
|
cm->AppendProperty(name, value ? value : "", this->AppendAsString);
|
|
} else {
|
|
cm->SetProperty(name, value);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleDirectoryMode()
|
|
{
|
|
if (this->Names.size() > 1) {
|
|
this->SetError("allows at most one name for DIRECTORY scope.");
|
|
return false;
|
|
}
|
|
|
|
// Default to the current directory.
|
|
cmMakefile* mf = this->Makefile;
|
|
|
|
// Lookup the directory if given.
|
|
if (!this->Names.empty()) {
|
|
// Construct the directory name. Interpret relative paths with
|
|
// respect to the current directory.
|
|
std::string dir = *this->Names.begin();
|
|
if (!cmSystemTools::FileIsFullPath(dir.c_str())) {
|
|
dir = this->Makefile->GetCurrentSourceDirectory();
|
|
dir += "/";
|
|
dir += *this->Names.begin();
|
|
}
|
|
|
|
// The local generators are associated with collapsed paths.
|
|
dir = cmSystemTools::CollapseFullPath(dir);
|
|
|
|
mf = this->Makefile->GetGlobalGenerator()->FindMakefile(dir);
|
|
if (!mf) {
|
|
// 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;
|
|
}
|
|
}
|
|
|
|
// Set or append the property.
|
|
const char* name = this->PropertyName.c_str();
|
|
const char* value = this->PropertyValue.c_str();
|
|
if (this->Remove) {
|
|
value = CM_NULLPTR;
|
|
}
|
|
if (this->AppendMode) {
|
|
mf->AppendProperty(name, value ? value : "", this->AppendAsString);
|
|
} else {
|
|
mf->SetProperty(name, value);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleTargetMode()
|
|
{
|
|
for (std::set<std::string>::const_iterator ni = this->Names.begin();
|
|
ni != this->Names.end(); ++ni) {
|
|
if (this->Makefile->IsAlias(*ni)) {
|
|
this->SetError("can not be used on an ALIAS target.");
|
|
return false;
|
|
}
|
|
if (cmTarget* target = this->Makefile->FindTargetToUse(*ni)) {
|
|
// Handle the current target.
|
|
if (!this->HandleTarget(target)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
std::ostringstream e;
|
|
e << "could not find TARGET " << *ni
|
|
<< ". Perhaps it has not yet been created.";
|
|
this->SetError(e.str());
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleTarget(cmTarget* target)
|
|
{
|
|
// Set or append the property.
|
|
const char* name = this->PropertyName.c_str();
|
|
const char* value = this->PropertyValue.c_str();
|
|
if (this->Remove) {
|
|
value = CM_NULLPTR;
|
|
}
|
|
if (this->AppendMode) {
|
|
target->AppendProperty(name, value, this->AppendAsString);
|
|
} else {
|
|
target->SetProperty(name, value);
|
|
}
|
|
|
|
// Check the resulting value.
|
|
target->CheckProperty(name, this->Makefile);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleSourceMode()
|
|
{
|
|
for (std::set<std::string>::const_iterator ni = this->Names.begin();
|
|
ni != this->Names.end(); ++ni) {
|
|
// Get the source file.
|
|
if (cmSourceFile* sf = this->Makefile->GetOrCreateSource(*ni)) {
|
|
if (!this->HandleSource(sf)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
std::ostringstream e;
|
|
e << "given SOURCE name that could not be found or created: " << *ni;
|
|
this->SetError(e.str());
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleSource(cmSourceFile* sf)
|
|
{
|
|
// Set or append the property.
|
|
const char* name = this->PropertyName.c_str();
|
|
const char* value = this->PropertyValue.c_str();
|
|
if (this->Remove) {
|
|
value = CM_NULLPTR;
|
|
}
|
|
|
|
if (this->AppendMode) {
|
|
sf->AppendProperty(name, value, this->AppendAsString);
|
|
} else {
|
|
sf->SetProperty(name, value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleTestMode()
|
|
{
|
|
// Look for tests with all names given.
|
|
std::set<std::string>::iterator next;
|
|
for (std::set<std::string>::iterator ni = this->Names.begin();
|
|
ni != this->Names.end(); ni = next) {
|
|
next = ni;
|
|
++next;
|
|
if (cmTest* test = this->Makefile->GetTest(*ni)) {
|
|
if (this->HandleTest(test)) {
|
|
this->Names.erase(ni);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Names that are still left were not found.
|
|
if (!this->Names.empty()) {
|
|
std::ostringstream e;
|
|
e << "given TEST names that do not exist:\n";
|
|
for (std::set<std::string>::const_iterator ni = this->Names.begin();
|
|
ni != this->Names.end(); ++ni) {
|
|
e << " " << *ni << "\n";
|
|
}
|
|
this->SetError(e.str());
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleTest(cmTest* test)
|
|
{
|
|
// Set or append the property.
|
|
const char* name = this->PropertyName.c_str();
|
|
const char* value = this->PropertyValue.c_str();
|
|
if (this->Remove) {
|
|
value = CM_NULLPTR;
|
|
}
|
|
if (this->AppendMode) {
|
|
test->AppendProperty(name, value, this->AppendAsString);
|
|
} else {
|
|
test->SetProperty(name, value);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleCacheMode()
|
|
{
|
|
if (this->PropertyName == "ADVANCED") {
|
|
if (!this->Remove && !cmSystemTools::IsOn(this->PropertyValue.c_str()) &&
|
|
!cmSystemTools::IsOff(this->PropertyValue.c_str())) {
|
|
std::ostringstream e;
|
|
e << "given non-boolean value \"" << this->PropertyValue
|
|
<< "\" for CACHE property \"ADVANCED\". ";
|
|
this->SetError(e.str());
|
|
return false;
|
|
}
|
|
} else if (this->PropertyName == "TYPE") {
|
|
if (!cmState::IsCacheEntryType(this->PropertyValue)) {
|
|
std::ostringstream e;
|
|
e << "given invalid CACHE entry TYPE \"" << this->PropertyValue << "\"";
|
|
this->SetError(e.str());
|
|
return false;
|
|
}
|
|
} else if (this->PropertyName != "HELPSTRING" &&
|
|
this->PropertyName != "STRINGS" &&
|
|
this->PropertyName != "VALUE") {
|
|
std::ostringstream e;
|
|
e << "given invalid CACHE property " << this->PropertyName << ". "
|
|
<< "Settable CACHE properties are: "
|
|
<< "ADVANCED, HELPSTRING, STRINGS, TYPE, and VALUE.";
|
|
this->SetError(e.str());
|
|
return false;
|
|
}
|
|
|
|
for (std::set<std::string>::const_iterator ni = this->Names.begin();
|
|
ni != this->Names.end(); ++ni) {
|
|
// Get the source file.
|
|
cmMakefile* mf = this->GetMakefile();
|
|
cmake* cm = mf->GetCMakeInstance();
|
|
const char* existingValue = cm->GetState()->GetCacheEntryValue(*ni);
|
|
if (existingValue) {
|
|
if (!this->HandleCacheEntry(*ni)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
std::ostringstream e;
|
|
e << "could not find CACHE variable " << *ni
|
|
<< ". Perhaps it has not yet been created.";
|
|
this->SetError(e.str());
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleCacheEntry(std::string const& cacheKey)
|
|
{
|
|
// Set or append the property.
|
|
const char* name = this->PropertyName.c_str();
|
|
const char* value = this->PropertyValue.c_str();
|
|
cmState* state = this->Makefile->GetState();
|
|
if (this->Remove) {
|
|
state->RemoveCacheEntryProperty(cacheKey, name);
|
|
}
|
|
if (this->AppendMode) {
|
|
state->AppendCacheEntryProperty(cacheKey, name, value,
|
|
this->AppendAsString);
|
|
} else {
|
|
state->SetCacheEntryProperty(cacheKey, name, value);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleInstallMode()
|
|
{
|
|
cmake* cm = this->Makefile->GetCMakeInstance();
|
|
|
|
for (std::set<std::string>::const_iterator i = this->Names.begin();
|
|
i != this->Names.end(); ++i) {
|
|
if (cmInstalledFile* file =
|
|
cm->GetOrCreateInstalledFile(this->Makefile, *i)) {
|
|
if (!this->HandleInstall(file)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
std::ostringstream e;
|
|
e << "given INSTALL name that could not be found or created: " << *i;
|
|
this->SetError(e.str());
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool cmSetPropertyCommand::HandleInstall(cmInstalledFile* file)
|
|
{
|
|
// Set or append the property.
|
|
std::string const& name = this->PropertyName;
|
|
|
|
cmMakefile* mf = this->Makefile;
|
|
|
|
const char* value = this->PropertyValue.c_str();
|
|
if (this->Remove) {
|
|
file->RemoveProperty(name);
|
|
} else if (this->AppendMode) {
|
|
file->AppendProperty(mf, name, value, this->AppendAsString);
|
|
} else {
|
|
file->SetProperty(mf, name, value);
|
|
}
|
|
return true;
|
|
}
|