cmCommand refactor: cmExecProgramCommand

Source/cmCommands.cxx

@@ -122,8 +122,7 @@ void GetScriptingCommands(cmState* state)
                            cm::make_unique<cmCMakePolicyCommand>());
   state->AddBuiltinCommand("configure_file", cmConfigureFileCommand);
   state->AddBuiltinCommand("continue", cmContinueCommand);
-  state->AddBuiltinCommand("exec_program",
+  state->AddBuiltinCommand("exec_program", cmExecProgramCommand);
-                           cm::make_unique<cmExecProgramCommand>());
   state->AddBuiltinCommand("execute_process",
                            cm::make_unique<cmExecuteProcessCommand>());
   state->AddBuiltinCommand("file", cmFileCommand);

Source/cmExecProgramCommand.cxx

@@ -5,18 +5,25 @@
 #include "cmsys/Process.h"
 #include <stdio.h>
 
+#include "cmExecutionStatus.h"
 #include "cmMakefile.h"
 #include "cmProcessOutput.h"
 #include "cmSystemTools.h"
 
-class cmExecutionStatus;
+typedef cmProcessOutput::Encoding Encoding;
+
+namespace {
+bool RunCommand(std::string command, std::string& output, int& retVal,
+                const char* directory = nullptr, bool verbose = true,
+                Encoding encoding = cmProcessOutput::Auto);
+}
 
 // cmExecProgramCommand
-bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
+bool cmExecProgramCommand(std::vector<std::string> const& args,
-                                       cmExecutionStatus&)
+                          cmExecutionStatus& status)
 {
   if (args.empty()) {
-    this->SetError("called with incorrect number of arguments");
+    status.SetError("called with incorrect number of arguments");
     return false;
   }
   std::string arguments;
@@ -34,7 +41,7 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
       haveoutput_variable = true;
     } else if (haveoutput_variable) {
       if (!output_variable.empty()) {
-        this->SetError("called with incorrect number of arguments");
+        status.SetError("called with incorrect number of arguments");
         return false;
       }
       output_variable = arg;
@@ -47,7 +54,7 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
       havereturn_variable = true;
     } else if (havereturn_variable) {
       if (!return_variable.empty()) {
-        this->SetError("called with incorrect number of arguments");
+        status.SetError("called with incorrect number of arguments");
         return false;
       }
       return_variable = arg;
@@ -82,11 +89,9 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
   bool result = true;
   if (args.size() - count == 2) {
     cmSystemTools::MakeDirectory(args[1]);
-    result = cmExecProgramCommand::RunCommand(command, output, retVal,
+    result = RunCommand(command, output, retVal, args[1].c_str(), verbose);
-                                              args[1].c_str(), verbose);
   } else {
-    result = cmExecProgramCommand::RunCommand(command, output, retVal, nullptr,
+    result = RunCommand(command, output, retVal, nullptr, verbose);
-                                              verbose);
   }
   if (!result) {
     retVal = -1;
@@ -103,21 +108,21 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
     }
 
     std::string coutput = std::string(output, first, last - first + 1);
-    this->Makefile->AddDefinition(output_variable, coutput);
+    status.GetMakefile().AddDefinition(output_variable, coutput);
   }
 
   if (!return_variable.empty()) {
     char buffer[100];
     sprintf(buffer, "%d", retVal);
-    this->Makefile->AddDefinition(return_variable, buffer);
+    status.GetMakefile().AddDefinition(return_variable, buffer);
   }
 
   return true;
 }
 
-bool cmExecProgramCommand::RunCommand(std::string command, std::string& output,
+namespace {
-                                      int& retVal, const char* dir,
+bool RunCommand(std::string command, std::string& output, int& retVal,
-                                      bool verbose, Encoding encoding)
+                const char* dir, bool verbose, Encoding encoding)
 {
   if (cmSystemTools::GetRunCommandOutput()) {
     verbose = false;
@@ -284,3 +289,4 @@ bool cmExecProgramCommand::RunCommand(std::string command, std::string& output,
 
   return true;
 }
+}

Source/cmExecProgramCommand.h

@@ -8,43 +8,16 @@
 #include <string>
 #include <vector>
 
-#include "cm_memory.hxx"
-
-#include "cmCommand.h"
-#include "cmProcessOutput.h"
-
 class cmExecutionStatus;
 
-/** \class cmExecProgramCommand
+/**
  * \brief Command that adds a target to the build system.
  *
  * cmExecProgramCommand adds an extra target to the build system.
  * This is useful when you would like to add special
  * targets like "install,", "clean," and so on.
  */
-class cmExecProgramCommand : public cmCommand
+bool cmExecProgramCommand(std::vector<std::string> const& args,
-{
+                          cmExecutionStatus& status);
-public:
-  typedef cmProcessOutput::Encoding Encoding;
-  /**
-   * This is a virtual constructor for the command.
-   */
-  std::unique_ptr<cmCommand> Clone() override
-  {
-    return cm::make_unique<cmExecProgramCommand>();
-  }
-
-  /**
-   * This is called when the command is first encountered in
-   * the CMakeLists.txt file.
-   */
-  bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
-
-private:
-  static bool RunCommand(std::string command, std::string& output, int& retVal,
-                         const char* directory = nullptr, bool verbose = true,
-                         Encoding encoding = cmProcessOutput::Auto);
-};
 
 #endif