1 files changed, 439 insertions, 0 deletions
diff --git a/Source/cmSetPropertyCommand.cxx b/Source/cmSetPropertyCommand.cxx
new file mode 100644
index 0000000..60c198a
--- /dev/null
+++ b/Source/cmSetPropertyCommand.cxx
@@ -0,0 +1,439 @@
+/* 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;
+}