cmCommand refactor: cmUtilitySourceCommand

3 files changed, 25 insertions, 37 deletions

diff --git a/Source/cmCommands.cxx b/Source/cmCommands.cxx
index f71be0d..ad14c6b 100644
--- a/Source/cmCommands.cxx
+++ b/Source/cmCommands.cxx
@@ -323,8 +323,7 @@ void GetProjectCommands(cmState* state)
     "subdir_depends", cmSubdirDependsCommand, cmPolicies::CMP0029,
     "The subdir_depends command should not be called; see CMP0029.");
   state->AddDisallowedCommand(
-    "utility_source", cm::make_unique<cmUtilitySourceCommand>(),
-    cmPolicies::CMP0034,
+    "utility_source", cmUtilitySourceCommand, cmPolicies::CMP0034,
     "The utility_source command should not be called; see CMP0034.");
   state->AddDisallowedCommand(
     "variable_requires", cm::make_unique<cmVariableRequiresCommand>(),
diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx
index d255b67..25fe4ad 100644
--- a/Source/cmUtilitySourceCommand.cxx
+++ b/Source/cmUtilitySourceCommand.cxx
@@ -4,20 +4,19 @@
 
 #include <string.h>
 
+#include "cmExecutionStatus.h"
 #include "cmMakefile.h"
 #include "cmState.h"
 #include "cmStateTypes.h"
 #include "cmStringAlgorithms.h"
 #include "cmSystemTools.h"
 
-class cmExecutionStatus;
-
 // cmUtilitySourceCommand
-bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args,
-                                         cmExecutionStatus&)
+bool cmUtilitySourceCommand(std::vector<std::string> const& args,
+                            cmExecutionStatus& status)
 {
   if (args.size() < 3) {
-    this->SetError("called with incorrect number of arguments");
+    status.SetError("called with incorrect number of arguments");
     return false;
   }
 
@@ -25,15 +24,15 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args,
 
   // The first argument is the cache entry name.
   std::string const& cacheEntry = *arg++;
-  const char* cacheValue = this->Makefile->GetDefinition(cacheEntry);
+  const char* cacheValue = status.GetMakefile().GetDefinition(cacheEntry);
   // If it exists already and appears up to date then we are done.  If
   // the string contains "(IntDir)" but that is not the
   // CMAKE_CFG_INTDIR setting then the value is out of date.
   std::string const& intDir =
-    this->Makefile->GetRequiredDefinition("CMAKE_CFG_INTDIR");
+    status.GetMakefile().GetRequiredDefinition("CMAKE_CFG_INTDIR");
 
   bool haveCacheValue = false;
-  if (this->Makefile->IsOn("CMAKE_CROSSCOMPILING")) {
+  if (status.GetMakefile().IsOn("CMAKE_CROSSCOMPILING")) {
     haveCacheValue = (cacheValue != nullptr);
     if (!haveCacheValue) {
       std::string msg = cmStrCat(
@@ -44,7 +43,7 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args,
       cmSystemTools::Message(msg, "Warning");
     }
   } else {
-    cmState* state = this->Makefile->GetState();
+    cmState* state = status.GetMakefile().GetState();
     haveCacheValue = (cacheValue &&
                       (strstr(cacheValue, "(IntDir)") == nullptr ||
                        (intDir == "$(IntDir)")) &&
@@ -63,7 +62,7 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args,
   // The third argument specifies the relative directory of the source
   // of the utility.
   std::string const& relativeSource = *arg++;
-  std::string utilitySource = this->Makefile->GetCurrentSourceDirectory();
+  std::string utilitySource = status.GetMakefile().GetCurrentSourceDirectory();
   utilitySource = utilitySource + "/" + relativeSource;
 
   // If the directory doesn't exist, the source has not been included.
@@ -81,11 +80,12 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args,
 
   // The source exists.
   const std::string& cmakeCFGout =
-    this->Makefile->GetRequiredDefinition("CMAKE_CFG_INTDIR");
-  std::string utilityDirectory = this->Makefile->GetCurrentBinaryDirectory();
+    status.GetMakefile().GetRequiredDefinition("CMAKE_CFG_INTDIR");
+  std::string utilityDirectory =
+    status.GetMakefile().GetCurrentBinaryDirectory();
   std::string exePath;
-  if (this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH")) {
-    exePath = this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
+  if (status.GetMakefile().GetDefinition("EXECUTABLE_OUTPUT_PATH")) {
+    exePath = status.GetMakefile().GetDefinition("EXECUTABLE_OUTPUT_PATH");
   }
   if (!exePath.empty()) {
     utilityDirectory = exePath;
@@ -95,21 +95,22 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args,
 
   // Construct the cache entry for the executable's location.
   std::string utilityExecutable = utilityDirectory + "/" + cmakeCFGout + "/" +
-    utilityName + this->Makefile->GetDefinition("CMAKE_EXECUTABLE_SUFFIX");
+    utilityName +
+    status.GetMakefile().GetDefinition("CMAKE_EXECUTABLE_SUFFIX");
 
   // make sure we remove any /./ in the name
   cmSystemTools::ReplaceString(utilityExecutable, "/./", "/");
 
   // Enter the value into the cache.
-  this->Makefile->AddCacheDefinition(cacheEntry, utilityExecutable.c_str(),
-                                     "Path to an internal program.",
-                                     cmStateEnums::FILEPATH);
+  status.GetMakefile().AddCacheDefinition(
+    cacheEntry, utilityExecutable.c_str(), "Path to an internal program.",
+    cmStateEnums::FILEPATH);
   // add a value into the cache that maps from the
   // full path to the name of the project
   cmSystemTools::ConvertToUnixSlashes(utilityExecutable);
-  this->Makefile->AddCacheDefinition(utilityExecutable, utilityName.c_str(),
-                                     "Executable to project name.",
-                                     cmStateEnums::INTERNAL);
+  status.GetMakefile().AddCacheDefinition(
+    utilityExecutable, utilityName.c_str(), "Executable to project name.",
+    cmStateEnums::INTERNAL);
 
   return true;
 }
diff --git a/Source/cmUtilitySourceCommand.h b/Source/cmUtilitySourceCommand.h
index cef7fed..934d539 100644
--- a/Source/cmUtilitySourceCommand.h
+++ b/Source/cmUtilitySourceCommand.h
@@ -8,21 +8,9 @@
 #include <string>
 #include <vector>
 
-#include "cm_memory.hxx"
-
-#include "cmCommand.h"
-
 class cmExecutionStatus;
 
-class cmUtilitySourceCommand : public cmCommand
-{
-public:
-  std::unique_ptr<cmCommand> Clone() override
-  {
-    return cm::make_unique<cmUtilitySourceCommand>();
-  }
-  bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
-};
+bool cmUtilitySourceCommand(std::vector<std::string> const& args,
+                            cmExecutionStatus& status);
 
 #endif