1 files changed, 34 insertions, 65 deletions

diff --git a/Source/cmQTWrapUICommand.cxx b/Source/cmQTWrapUICommand.cxx
index 2223e2d82..66c0228fc 100644
--- a/Source/cmQTWrapUICommand.cxx
+++ b/Source/cmQTWrapUICommand.cxx
@@ -3,56 +3,47 @@
 #include "cmQTWrapUICommand.h"
 
 #include "cmCustomCommandLines.h"
+#include "cmExecutionStatus.h"
 #include "cmMakefile.h"
 #include "cmRange.h"
 #include "cmSourceFile.h"
+#include "cmStringAlgorithms.h"
 #include "cmSystemTools.h"
 
-#include <utility>
-
-class cmExecutionStatus;
-
-// cmQTWrapUICommand
-bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args,
-                                    cmExecutionStatus&)
+bool cmQTWrapUICommand(std::vector<std::string> const& args,
+                       cmExecutionStatus& status)
 {
   if (args.size() < 4) {
-    this->SetError("called with incorrect number of arguments");
+    status.SetError("called with incorrect number of arguments");
     return false;
   }
 
+  cmMakefile& mf = status.GetMakefile();
+
   // Get the uic and moc executables to run in the custom commands.
-  std::string const& uic_exe =
-    this->Makefile->GetRequiredDefinition("QT_UIC_EXECUTABLE");
-  std::string const& moc_exe =
-    this->Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
+  std::string const& uic_exe = mf.GetRequiredDefinition("QT_UIC_EXECUTABLE");
+  std::string const& moc_exe = mf.GetRequiredDefinition("QT_MOC_EXECUTABLE");
 
   // Get the variable holding the list of sources.
   std::string const& headerList = args[1];
   std::string const& sourceList = args[2];
-  std::string headerListValue = this->Makefile->GetSafeDefinition(headerList);
-  std::string sourceListValue = this->Makefile->GetSafeDefinition(sourceList);
+  std::string headerListValue = mf.GetSafeDefinition(headerList);
+  std::string sourceListValue = mf.GetSafeDefinition(sourceList);
 
   // Create rules for all sources listed.
   for (std::string const& arg : cmMakeRange(args).advance(3)) {
-    cmSourceFile* curr = this->Makefile->GetSource(arg);
+    cmSourceFile* curr = mf.GetSource(arg);
     // if we should wrap the class
     if (!(curr && curr->GetPropertyAsBool("WRAP_EXCLUDE"))) {
       // Compute the name of the files to generate.
       std::string srcName =
         cmSystemTools::GetFilenameWithoutLastExtension(arg);
-      std::string hName = this->Makefile->GetCurrentBinaryDirectory();
-      hName += "/";
-      hName += srcName;
-      hName += ".h";
-      std::string cxxName = this->Makefile->GetCurrentBinaryDirectory();
-      cxxName += "/";
-      cxxName += srcName;
-      cxxName += ".cxx";
-      std::string mocName = this->Makefile->GetCurrentBinaryDirectory();
-      mocName += "/moc_";
-      mocName += srcName;
-      mocName += ".cxx";
+      std::string hName =
+        cmStrCat(mf.GetCurrentBinaryDirectory(), '/', srcName, ".h");
+      std::string cxxName =
+        cmStrCat(mf.GetCurrentBinaryDirectory(), '/', srcName, ".cxx");
+      std::string mocName =
+        cmStrCat(mf.GetCurrentBinaryDirectory(), "/moc_", srcName, ".cxx");
 
       // Compute the name of the ui file from which to generate others.
       std::string uiName;
@@ -60,9 +51,9 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args,
         uiName = arg;
       } else {
         if (curr && curr->GetIsGenerated()) {
-          uiName = this->Makefile->GetCurrentBinaryDirectory();
+          uiName = mf.GetCurrentBinaryDirectory();
         } else {
-          uiName = this->Makefile->GetCurrentSourceDirectory();
+          uiName = mf.GetCurrentSourceDirectory();
         }
         uiName += "/";
         uiName += arg;
@@ -83,56 +74,34 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args,
       sourceListValue += mocName;
 
       // set up .ui to .h and .cxx command
-      cmCustomCommandLine hCommand;
-      hCommand.push_back(uic_exe);
-      hCommand.push_back("-o");
-      hCommand.push_back(hName);
-      hCommand.push_back(uiName);
-      cmCustomCommandLines hCommandLines;
-      hCommandLines.push_back(std::move(hCommand));
-
-      cmCustomCommandLine cxxCommand;
-      cxxCommand.push_back(uic_exe);
-      cxxCommand.push_back("-impl");
-      cxxCommand.push_back(hName);
-      cxxCommand.push_back("-o");
-      cxxCommand.push_back(cxxName);
-      cxxCommand.push_back(uiName);
-      cmCustomCommandLines cxxCommandLines;
-      cxxCommandLines.push_back(std::move(cxxCommand));
-
-      cmCustomCommandLine mocCommand;
-      mocCommand.push_back(moc_exe);
-      mocCommand.push_back("-o");
-      mocCommand.push_back(mocName);
-      mocCommand.push_back(hName);
-      cmCustomCommandLines mocCommandLines;
-      mocCommandLines.push_back(std::move(mocCommand));
+      cmCustomCommandLines hCommandLines =
+        cmMakeSingleCommandLine({ uic_exe, "-o", hName, uiName });
+      cmCustomCommandLines cxxCommandLines = cmMakeSingleCommandLine(
+        { uic_exe, "-impl", hName, "-o", cxxName, uiName });
+      cmCustomCommandLines mocCommandLines =
+        cmMakeSingleCommandLine({ moc_exe, "-o", mocName, hName });
 
       std::vector<std::string> depends;
       depends.push_back(uiName);
       std::string no_main_dependency;
       const char* no_comment = nullptr;
       const char* no_working_dir = nullptr;
-      this->Makefile->AddCustomCommandToOutput(
-        hName, depends, no_main_dependency, hCommandLines, no_comment,
-        no_working_dir);
+      mf.AddCustomCommandToOutput(hName, depends, no_main_dependency,
+                                  hCommandLines, no_comment, no_working_dir);
 
       depends.push_back(hName);
-      this->Makefile->AddCustomCommandToOutput(
-        cxxName, depends, no_main_dependency, cxxCommandLines, no_comment,
-        no_working_dir);
+      mf.AddCustomCommandToOutput(cxxName, depends, no_main_dependency,
+                                  cxxCommandLines, no_comment, no_working_dir);
 
       depends.clear();
       depends.push_back(hName);
-      this->Makefile->AddCustomCommandToOutput(
-        mocName, depends, no_main_dependency, mocCommandLines, no_comment,
-        no_working_dir);
+      mf.AddCustomCommandToOutput(mocName, depends, no_main_dependency,
+                                  mocCommandLines, no_comment, no_working_dir);
     }
   }
 
   // Store the final list of source files and headers.
-  this->Makefile->AddDefinition(sourceList, sourceListValue.c_str());
-  this->Makefile->AddDefinition(headerList, headerListValue.c_str());
+  mf.AddDefinition(sourceList, sourceListValue);
+  mf.AddDefinition(headerList, headerListValue);
   return true;
 }