1 files changed, 30 insertions, 21 deletions

diff --git a/Source/cmCMakeMinimumRequired.cxx b/Source/cmCMakeMinimumRequired.cxx
index 4b4bca2..f93c266 100644
--- a/Source/cmCMakeMinimumRequired.cxx
+++ b/Source/cmCMakeMinimumRequired.cxx
@@ -5,26 +5,32 @@
 #include <sstream>
 #include <stdio.h>
 
+#include "cmExecutionStatus.h"
 #include "cmMakefile.h"
 #include "cmMessageType.h"
 #include "cmSystemTools.h"
 #include "cmVersion.h"
 
-class cmExecutionStatus;
+namespace {
+bool EnforceUnknownArguments(std::string const& version_max,
+                             std::vector<std::string> const& unknown_arguments,
+                             cmExecutionStatus& status);
+}
 
 // cmCMakeMinimumRequired
-bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
-                                         cmExecutionStatus&)
+bool cmCMakeMinimumRequired(std::vector<std::string> const& args,
+                            cmExecutionStatus& status)
 {
   // Process arguments.
   std::string version_string;
   bool doing_version = false;
+  std::vector<std::string> unknown_arguments;
   for (std::string const& arg : args) {
     if (arg == "VERSION") {
       doing_version = true;
     } else if (arg == "FATAL_ERROR") {
       if (doing_version) {
-        this->SetError("called with no value for VERSION.");
+        status.SetError("called with no value for VERSION.");
         return false;
       }
       doing_version = false;
@@ -32,17 +38,17 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
       doing_version = false;
       version_string = arg;
     } else {
-      this->UnknownArguments.push_back(arg);
+      unknown_arguments.push_back(arg);
     }
   }
   if (doing_version) {
-    this->SetError("called with no value for VERSION.");
+    status.SetError("called with no value for VERSION.");
     return false;
   }
 
   // Make sure there was a version to check.
   if (version_string.empty()) {
-    return this->EnforceUnknownArguments(std::string());
+    return EnforceUnknownArguments(std::string(), unknown_arguments, status);
   }
 
   // Separate the <min> version and any trailing ...<max> component.
@@ -56,13 +62,13 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
     std::ostringstream e;
     e << "VERSION \"" << version_string
       << R"(" does not have a version on both sides of "...".)";
-    this->SetError(e.str());
+    status.SetError(e.str());
     return false;
   }
 
   // Save the required version string.
-  this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION",
-                                version_min.c_str());
+  status.GetMakefile().AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION",
+                                     version_min);
 
   // Get the current version number.
   unsigned int current_major = cmVersion::GetMajorVersion();
@@ -80,7 +86,7 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
              &required_minor, &required_patch, &required_tweak) < 2) {
     std::ostringstream e;
     e << "could not parse VERSION \"" << version_min << "\".";
-    this->SetError(e.str());
+    status.SetError(e.str());
     return false;
   }
 
@@ -96,32 +102,34 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
     e << "CMake " << version_min
       << " or higher is required.  You are running version "
       << cmVersion::GetCMakeVersion();
-    this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
+    status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR, e.str());
     cmSystemTools::SetFatalErrorOccured();
     return true;
   }
 
   // The version is not from the future, so enforce unknown arguments.
-  if (!this->EnforceUnknownArguments(version_max)) {
+  if (!EnforceUnknownArguments(version_max, unknown_arguments, status)) {
     return false;
   }
 
   if (required_major < 2 || (required_major == 2 && required_minor < 4)) {
-    this->Makefile->IssueMessage(
+    status.GetMakefile().IssueMessage(
       MessageType::AUTHOR_WARNING,
       "Compatibility with CMake < 2.4 is not supported by CMake >= 3.0.");
-    this->Makefile->SetPolicyVersion("2.4", version_max);
+    status.GetMakefile().SetPolicyVersion("2.4", version_max);
   } else {
-    this->Makefile->SetPolicyVersion(version_min, version_max);
+    status.GetMakefile().SetPolicyVersion(version_min, version_max);
   }
 
   return true;
 }
 
-bool cmCMakeMinimumRequired::EnforceUnknownArguments(
-  std::string const& version_max)
+namespace {
+bool EnforceUnknownArguments(std::string const& version_max,
+                             std::vector<std::string> const& unknown_arguments,
+                             cmExecutionStatus& status)
 {
-  if (this->UnknownArguments.empty()) {
+  if (unknown_arguments.empty()) {
     return true;
   }
 
@@ -150,7 +158,8 @@ bool cmCMakeMinimumRequired::EnforceUnknownArguments(
   }
 
   std::ostringstream e;
-  e << "called with unknown argument \"" << this->UnknownArguments[0] << "\".";
-  this->SetError(e.str());
+  e << "called with unknown argument \"" << unknown_arguments[0] << "\".";
+  status.SetError(e.str());
   return false;
 }
+}