Revise C++ coding style using clang-format

Run the `Utilities/Scripts/clang-format.bash` script to update
all our C++ code to a new style defined by `.clang-format`.
Use `clang-format` version 3.8.

* If you reached this commit for a line in `git blame`, re-run the blame
  operation starting at the parent of this commit to see older history
  for the content.

* See the parent commit for instructions to rebase a change across this
  style transition commit.

1 files changed, 76 insertions, 113 deletions

diff --git a/Source/CTest/cmParseCacheCoverage.cxx b/Source/CTest/cmParseCacheCoverage.cxx
index f838087..0916da2 100644
--- a/Source/CTest/cmParseCacheCoverage.cxx
+++ b/Source/CTest/cmParseCacheCoverage.cxx
@@ -7,44 +7,35 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-
 cmParseCacheCoverage::cmParseCacheCoverage(
-  cmCTestCoverageHandlerContainer& cont,
-  cmCTest* ctest)
-  :cmParseMumpsCoverage(cont, ctest)
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : cmParseMumpsCoverage(cont, ctest)
 {
 }
 
-
 bool cmParseCacheCoverage::LoadCoverageData(const char* d)
 {
   // load all the .mcov files in the specified directory
   cmsys::Directory dir;
-  if(!dir.Load(d))
-    {
+  if (!dir.Load(d)) {
     return false;
-    }
+  }
   size_t numf;
   unsigned int i;
   numf = dir.GetNumberOfFiles();
-  for (i = 0; i < numf; i++)
-    {
+  for (i = 0; i < numf; i++) {
     std::string file = dir.GetFile(i);
-    if(file != "." && file != ".."
-       && !cmSystemTools::FileIsDirectory(file))
-      {
+    if (file != "." && file != ".." && !cmSystemTools::FileIsDirectory(file)) {
       std::string path = d;
       path += "/";
       path += file;
-      if(cmSystemTools::GetFilenameLastExtension(path) == ".cmcov")
-        {
-        if(!this->ReadCMCovFile(path.c_str()))
-          {
+      if (cmSystemTools::GetFilenameLastExtension(path) == ".cmcov") {
+        if (!this->ReadCMCovFile(path.c_str())) {
           return false;
-          }
         }
       }
     }
+  }
   return true;
 }
 
@@ -55,32 +46,26 @@ void cmParseCacheCoverage::RemoveUnCoveredFiles()
   // that only have -1 or 0 for the lines.
   cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator ci =
     this->Coverage.TotalCoverage.begin();
-  while(ci != this->Coverage.TotalCoverage.end())
-    {
-    cmCTestCoverageHandlerContainer::SingleFileCoverageVector& v =
-      ci->second;
+  while (ci != this->Coverage.TotalCoverage.end()) {
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector& v = ci->second;
     bool nothing = true;
-    for(cmCTestCoverageHandlerContainer::SingleFileCoverageVector::iterator i=
-          v.begin(); i != v.end(); ++i)
-      {
-      if(*i > 0)
-        {
+    for (cmCTestCoverageHandlerContainer::SingleFileCoverageVector::iterator
+           i = v.begin();
+         i != v.end(); ++i) {
+      if (*i > 0) {
         nothing = false;
         break;
-        }
       }
-    if(nothing)
-      {
+    }
+    if (nothing) {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-                 "No coverage found in: " << ci->first
-                 << std::endl, this->Coverage.Quiet);
+                         "No coverage found in: " << ci->first << std::endl,
+                         this->Coverage.Quiet);
       this->Coverage.TotalCoverage.erase(ci++);
-      }
-    else
-      {
+    } else {
       ++ci;
-      }
     }
+  }
 }
 
 bool cmParseCacheCoverage::SplitString(std::vector<std::string>& args,
@@ -88,18 +73,16 @@ bool cmParseCacheCoverage::SplitString(std::vector<std::string>& args,
 {
   std::string::size_type pos1 = 0;
   std::string::size_type pos2 = line.find(',', 0);
-  if(pos2 == std::string::npos)
-    {
+  if (pos2 == std::string::npos) {
     return false;
-    }
+  }
   std::string arg;
-  while(pos2 != std::string::npos)
-    {
-    arg = line.substr(pos1, pos2-pos1);
+  while (pos2 != std::string::npos) {
+    arg = line.substr(pos1, pos2 - pos1);
     args.push_back(arg);
-    pos1 = pos2+1;
-    pos2 = line.find(',',pos1);
-    }
+    pos1 = pos2 + 1;
+    pos2 = line.find(',', pos1);
+  }
   arg = line.substr(pos1);
   args.push_back(arg);
   return true;
@@ -108,126 +91,106 @@ bool cmParseCacheCoverage::SplitString(std::vector<std::string>& args,
 bool cmParseCacheCoverage::ReadCMCovFile(const char* file)
 {
   cmsys::ifstream in(file);
-  if(!in)
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Can not open : "
-               << file << "\n");
+  if (!in) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Can not open : " << file << "\n");
     return false;
-    }
+  }
   std::string line;
   std::vector<std::string> separateLine;
-  if(!cmSystemTools::GetLineFromStream(in, line))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Empty file : "
-               << file << "  referenced in this line of cmcov data:\n"
-               "[" << line << "]\n");
+  if (!cmSystemTools::GetLineFromStream(in, line)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Empty file : "
+                 << file << "  referenced in this line of cmcov data:\n"
+                            "["
+                 << line << "]\n");
     return false;
-    }
+  }
   separateLine.clear();
   this->SplitString(separateLine, line);
-  if(separateLine.size() !=4 || separateLine[0] != "Routine"
-     || separateLine[1] != "Line" || separateLine[2] != "RtnLine"
-     || separateLine[3] != "Code")
-    {
+  if (separateLine.size() != 4 || separateLine[0] != "Routine" ||
+      separateLine[1] != "Line" || separateLine[2] != "RtnLine" ||
+      separateLine[3] != "Code") {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Bad first line of cmcov file : "
-               << file << "  line:\n"
-               "[" << line << "]\n");
-    }
+               "Bad first line of cmcov file : " << file << "  line:\n"
+                                                            "["
+                                                 << line << "]\n");
+  }
   std::string routine;
   std::string filepath;
-  while(cmSystemTools::GetLineFromStream(in, line))
-    {
+  while (cmSystemTools::GetLineFromStream(in, line)) {
     // clear out line argument vector
     separateLine.clear();
     // parse the comma separated line
     this->SplitString(separateLine, line);
     // might have more because code could have a quoted , in it
     // but we only care about the first 3 args anyway
-    if(separateLine.size() < 4)
-      {
+    if (separateLine.size() < 4) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
                  "Bad line of cmcov file expected at least 4 found: "
-                 << separateLine.size() << " "
-                 << file << "  line:\n"
-                 "[" << line << "]\n");
-      for(std::string::size_type i = 0; i < separateLine.size(); ++i)
-        {
-        cmCTestLog(this->CTest, ERROR_MESSAGE,""
-                   << separateLine[1] << " ");
-        }
+                   << separateLine.size() << " " << file << "  line:\n"
+                                                            "["
+                   << line << "]\n");
+      for (std::string::size_type i = 0; i < separateLine.size(); ++i) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "" << separateLine[1] << " ");
+      }
       cmCTestLog(this->CTest, ERROR_MESSAGE, "\n");
       return false;
-      }
+    }
     // if we do not have a routine yet, then it should be
     // the first argument in the vector
-    if(routine.empty())
-      {
+    if (routine.empty()) {
       routine = separateLine[0];
       // Find the full path to the file
-      if(!this->FindMumpsFile(routine, filepath))
-        {
+      if (!this->FindMumpsFile(routine, filepath)) {
         cmCTestLog(this->CTest, ERROR_MESSAGE,
-                   "Could not find mumps file for routine: "
-                   << routine << "\n");
+                   "Could not find mumps file for routine: " << routine
+                                                             << "\n");
         filepath = "";
         continue; // move to next line
-        }
       }
+    }
     // if we have a routine name, check for end of routine
-    else
-      {
+    else {
       // Totals in arg 0 marks the end of a routine
-      if(separateLine[0].substr(0, 6) == "Totals")
-        {
+      if (separateLine[0].substr(0, 6) == "Totals") {
         routine = ""; // at the end of this routine
         filepath = "";
         continue; // move to next line
-        }
       }
+    }
     // if the file path was not found for the routine
     // move to next line. We should have already warned
     // after the call to FindMumpsFile that we did not find
     // it, so don't report again to cut down on output
-    if(filepath.empty())
-      {
+    if (filepath.empty()) {
       continue;
-      }
+    }
     // now we are ready to set the coverage from the line of data
-    cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
-      coverageVector = this->Coverage.TotalCoverage[filepath];
-    std::string::size_type linenumber = atoi(separateLine[1].c_str()) -1;
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector& coverageVector =
+      this->Coverage.TotalCoverage[filepath];
+    std::string::size_type linenumber = atoi(separateLine[1].c_str()) - 1;
     int count = atoi(separateLine[2].c_str());
-    if(linenumber > coverageVector.size())
-      {
+    if (linenumber > coverageVector.size()) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
                  "Parse error line is greater than number of lines in file: "
-                 << linenumber << " " << filepath << "\n");
+                   << linenumber << " " << filepath << "\n");
       continue; // skip setting count to avoid crash
-      }
+    }
     // now add to count for linenumber
     // for some reason the cache coverage adds extra lines to the
     // end of the file in some cases. Since they do not exist, we will
     // mark them as non executable
-    while(linenumber >= coverageVector.size())
-      {
+    while (linenumber >= coverageVector.size()) {
       coverageVector.push_back(-1);
-      }
+    }
     // Accounts for lines that were previously marked
     // as non-executable code (-1). if the parser comes back with
     // a non-zero count, increase the count by 1 to push the line
     // into the executable code set in addition to the count found.
-    if(coverageVector[linenumber] == -1 &&
-        count > 0)
-      {
-        coverageVector[linenumber] += count+1;
-      }
-    else
-      {
-        coverageVector[linenumber] += count;
-      }
+    if (coverageVector[linenumber] == -1 && count > 0) {
+      coverageVector[linenumber] += count + 1;
+    } else {
+      coverageVector[linenumber] += count;
     }
+  }
   return true;
 }