Meta: modernize old-fashioned loops to range-based `for`.

Changes done via `clang-tidy` with some manual fine-tuning
for the variable naming and `auto` type deduction
where appropriate.

1 files changed, 17 insertions, 21 deletions

diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx
index 0972664..1a01854 100644
--- a/Source/cmIfCommand.cxx
+++ b/Source/cmIfCommand.cxx
@@ -15,10 +15,9 @@ static std::string cmIfCommandError(
   std::vector<cmExpandedCommandArgument> const& args)
 {
   std::string err = "given arguments:\n ";
-  for (std::vector<cmExpandedCommandArgument>::const_iterator i = args.begin();
-       i != args.end(); ++i) {
+  for (cmExpandedCommandArgument const& i : args) {
     err += " ";
-    err += cmOutputConverter::EscapeForCMake(i->GetValue());
+    err += cmOutputConverter::EscapeForCMake(i.GetValue());
   }
   err += "\n";
   return err;
@@ -45,21 +44,20 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
       // execute the functions for the true parts of the if statement
       cmExecutionStatus status;
       int scopeDepth = 0;
-      for (unsigned int c = 0; c < this->Functions.size(); ++c) {
+      for (cmListFileFunction const& func : this->Functions) {
         // keep track of scope depth
-        if (!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(), "if")) {
+        if (!cmSystemTools::Strucmp(func.Name.c_str(), "if")) {
           scopeDepth++;
         }
-        if (!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),
-                                    "endif")) {
+        if (!cmSystemTools::Strucmp(func.Name.c_str(), "endif")) {
           scopeDepth--;
         }
         // watch for our state change
         if (scopeDepth == 0 &&
-            !cmSystemTools::Strucmp(this->Functions[c].Name.c_str(), "else")) {
+            !cmSystemTools::Strucmp(func.Name.c_str(), "else")) {
 
           if (this->ElseSeen) {
-            cmListFileBacktrace bt = mf.GetBacktrace(this->Functions[c]);
+            cmListFileBacktrace bt = mf.GetBacktrace(func);
             mf.GetCMakeInstance()->IssueMessage(
               cmake::FATAL_ERROR,
               "A duplicate ELSE command was found inside an IF block.", bt);
@@ -74,13 +72,12 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
           // if trace is enabled, print a (trivially) evaluated "else"
           // statement
           if (!this->IsBlocking && mf.GetCMakeInstance()->GetTrace()) {
-            mf.PrintCommandTrace(this->Functions[c]);
+            mf.PrintCommandTrace(func);
           }
         } else if (scopeDepth == 0 &&
-                   !cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),
-                                           "elseif")) {
+                   !cmSystemTools::Strucmp(func.Name.c_str(), "elseif")) {
           if (this->ElseSeen) {
-            cmListFileBacktrace bt = mf.GetBacktrace(this->Functions[c]);
+            cmListFileBacktrace bt = mf.GetBacktrace(func);
             mf.GetCMakeInstance()->IssueMessage(
               cmake::FATAL_ERROR,
               "An ELSEIF command was found after an ELSE command.", bt);
@@ -93,23 +90,22 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
           } else {
             // if trace is enabled, print the evaluated "elseif" statement
             if (mf.GetCMakeInstance()->GetTrace()) {
-              mf.PrintCommandTrace(this->Functions[c]);
+              mf.PrintCommandTrace(func);
             }
 
             std::string errorString;
 
             std::vector<cmExpandedCommandArgument> expandedArguments;
-            mf.ExpandArguments(this->Functions[c].Arguments,
-                               expandedArguments);
+            mf.ExpandArguments(func.Arguments, expandedArguments);
 
             cmake::MessageType messType;
 
             cmListFileContext conditionContext =
               cmListFileContext::FromCommandContext(
-                this->Functions[c], this->GetStartingContext().FilePath);
+                func, this->GetStartingContext().FilePath);
 
-            cmConditionEvaluator conditionEvaluator(
-              mf, conditionContext, mf.GetBacktrace(this->Functions[c]));
+            cmConditionEvaluator conditionEvaluator(mf, conditionContext,
+                                                    mf.GetBacktrace(func));
 
             bool isTrue = conditionEvaluator.IsTrue(expandedArguments,
                                                     errorString, messType);
@@ -117,7 +113,7 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
             if (!errorString.empty()) {
               std::string err = cmIfCommandError(expandedArguments);
               err += errorString;
-              cmListFileBacktrace bt = mf.GetBacktrace(this->Functions[c]);
+              cmListFileBacktrace bt = mf.GetBacktrace(func);
               mf.GetCMakeInstance()->IssueMessage(messType, err, bt);
               if (messType == cmake::FATAL_ERROR) {
                 cmSystemTools::SetFatalErrorOccured();
@@ -135,7 +131,7 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
         // should we execute?
         else if (!this->IsBlocking) {
           status.Clear();
-          mf.ExecuteCommand(this->Functions[c], status);
+          mf.ExecuteCommand(func, status);
           if (status.GetReturnInvoked()) {
             inStatus.SetReturnInvoked();
             return true;