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, 180 insertions, 220 deletions

diff --git a/Source/CTest/cmCTestBZR.cxx b/Source/CTest/cmCTestBZR.cxx
index 6dd17b0594..dd53be849c 100644
--- a/Source/CTest/cmCTestBZR.cxx
+++ b/Source/CTest/cmCTestBZR.cxx
@@ -19,63 +19,58 @@
 
 #include <cm_expat.h>
 
-extern "C"
-int cmBZRXMLParserUnknownEncodingHandler(void*,
-                                         const XML_Char *name,
-                                         XML_Encoding *info)
+extern "C" int cmBZRXMLParserUnknownEncodingHandler(void*,
+                                                    const XML_Char* name,
+                                                    XML_Encoding* info)
 {
-  static const int latin1[]=
-    {
-      0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
-      0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
-      0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
-      0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
-      0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
-      0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
-      0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
-      0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
-      0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
-      0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
-      0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
-      0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
-      0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
-      0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
-      0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
-      0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
-      0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
-      0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
-      0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-      0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178,
-      0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
-      0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
-      0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
-      0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
-      0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
-      0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
-      0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
-      0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
-      0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
-      0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
-      0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
-      0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
-    };
+  static const int latin1[] = {
+    0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
+    0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010, 0x0011,
+    0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A,
+    0x001B, 0x001C, 0x001D, 0x001E, 0x001F, 0x0020, 0x0021, 0x0022, 0x0023,
+    0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C,
+    0x002D, 0x002E, 0x002F, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035,
+    0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E,
+    0x003F, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+    0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050,
+    0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059,
+    0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, 0x0060, 0x0061, 0x0062,
+    0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B,
+    0x006C, 0x006D, 0x006E, 0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074,
+    0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D,
+    0x007E, 0x007F, 0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020,
+    0x2021, 0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
+    0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0x02DC,
+    0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178, 0x00A0, 0x00A1,
+    0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00AA,
+    0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, 0x00B0, 0x00B1, 0x00B2, 0x00B3,
+    0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC,
+    0x00BD, 0x00BE, 0x00BF, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5,
+    0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE,
+    0x00CF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+    0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x00E0,
+    0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9,
+    0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00F0, 0x00F1, 0x00F2,
+    0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, 0x00FB,
+    0x00FC, 0x00FD, 0x00FE, 0x00FF
+  };
 
   // The BZR xml output plugin can use some encodings that are not
   // recognized by expat.  This will lead to an error, e.g. "Error
   // parsing bzr log xml: unknown encoding", the following is a
   // workaround for these unknown encodings.
-  if(name == std::string("ascii") || name == std::string("cp1252") ||
-     name == std::string("ANSI_X3.4-1968"))
-    {
-    for(unsigned int i=0;i<256;++i) info->map[i] = latin1[i];
+  if (name == std::string("ascii") || name == std::string("cp1252") ||
+      name == std::string("ANSI_X3.4-1968")) {
+    for (unsigned int i = 0; i < 256; ++i)
+      info->map[i] = latin1[i];
     return 1;
-    }
+  }
 
   return 0;
 }
 
-cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log):
-  cmCTestGlobalVC(ct, log)
+cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
 {
   this->PriorRev = this->Unknown;
   // Even though it is specified in the documentation, with bzr 1.13
@@ -88,69 +83,68 @@ cmCTestBZR::~cmCTestBZR()
 {
 }
 
-class cmCTestBZR::InfoParser: public cmCTestVC::LineParser
+class cmCTestBZR::InfoParser : public cmCTestVC::LineParser
 {
 public:
-  InfoParser(cmCTestBZR* bzr, const char* prefix):
-    BZR(bzr), CheckOutFound(false)
-    {
+  InfoParser(cmCTestBZR* bzr, const char* prefix)
+    : BZR(bzr)
+    , CheckOutFound(false)
+  {
     this->SetLog(&bzr->Log, prefix);
     this->RegexCheckOut.compile("checkout of branch: *([^\t\r\n]+)$");
     this->RegexParent.compile("parent branch: *([^\t\r\n]+)$");
-    }
+  }
+
 private:
   cmCTestBZR* BZR;
   bool CheckOutFound;
   cmsys::RegularExpression RegexCheckOut;
   cmsys::RegularExpression RegexParent;
   virtual bool ProcessLine()
-    {
-    if(this->RegexCheckOut.find(this->Line))
-      {
+  {
+    if (this->RegexCheckOut.find(this->Line)) {
       this->BZR->URL = this->RegexCheckOut.match(1);
       CheckOutFound = true;
-      }
-    else if(!CheckOutFound && this->RegexParent.find(this->Line))
-      {
+    } else if (!CheckOutFound && this->RegexParent.find(this->Line)) {
       this->BZR->URL = this->RegexParent.match(1);
-      }
-    return true;
     }
+    return true;
+  }
 };
 
-class cmCTestBZR::RevnoParser: public cmCTestVC::LineParser
+class cmCTestBZR::RevnoParser : public cmCTestVC::LineParser
 {
 public:
-  RevnoParser(cmCTestBZR* bzr, const char* prefix, std::string& rev):
-    Rev(rev)
-    {
+  RevnoParser(cmCTestBZR* bzr, const char* prefix, std::string& rev)
+    : Rev(rev)
+  {
     this->SetLog(&bzr->Log, prefix);
     this->RegexRevno.compile("^([0-9]+)$");
-    }
+  }
+
 private:
   std::string& Rev;
   cmsys::RegularExpression RegexRevno;
   virtual bool ProcessLine()
-    {
-    if(this->RegexRevno.find(this->Line))
-      {
+  {
+    if (this->RegexRevno.find(this->Line)) {
       this->Rev = this->RegexRevno.match(1);
-      }
-    return true;
     }
+    return true;
+  }
 };
 
 std::string cmCTestBZR::LoadInfo()
 {
   // Run "bzr info" to get the repository info from the work tree.
   const char* bzr = this->CommandLineTool.c_str();
-  const char* bzr_info[] = {bzr, "info", 0};
+  const char* bzr_info[] = { bzr, "info", 0 };
   InfoParser iout(this, "info-out> ");
   OutputLogger ierr(this->Log, "info-err> ");
   this->RunChild(bzr_info, &iout, &ierr);
 
   // Run "bzr revno" to get the repository revision number from the work tree.
-  const char* bzr_revno[] = {bzr, "revno", 0};
+  const char* bzr_revno[] = { bzr, "revno", 0 };
   std::string rev;
   RevnoParser rout(this, "revno-out> ", rev);
   OutputLogger rerr(this->Log, "revno-err> ");
@@ -164,7 +158,7 @@ void cmCTestBZR::NoteOldRevision()
   this->OldRevision = this->LoadInfo();
   this->Log << "Revision before update: " << this->OldRevision << "\n";
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
-             << this->OldRevision << "\n");
+               << this->OldRevision << "\n");
   this->PriorRev.Rev = this->OldRevision;
 }
 
@@ -173,35 +167,38 @@ void cmCTestBZR::NoteNewRevision()
   this->NewRevision = this->LoadInfo();
   this->Log << "Revision after update: " << this->NewRevision << "\n";
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
-             << this->NewRevision << "\n");
+               << this->NewRevision << "\n");
   this->Log << "URL = " << this->URL << "\n";
 }
 
-class cmCTestBZR::LogParser: public cmCTestVC::OutputLogger,
-                             private cmXMLParser
+class cmCTestBZR::LogParser : public cmCTestVC::OutputLogger,
+                              private cmXMLParser
 {
 public:
-  LogParser(cmCTestBZR* bzr, const char* prefix):
-    OutputLogger(bzr->Log, prefix), BZR(bzr),
-    EmailRegex("(.*) <([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+)>")
-    { this->InitializeParser(); }
+  LogParser(cmCTestBZR* bzr, const char* prefix)
+    : OutputLogger(bzr->Log, prefix)
+    , BZR(bzr)
+    , EmailRegex("(.*) <([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+)>")
+  {
+    this->InitializeParser();
+  }
   ~LogParser() { this->CleanupParser(); }
 
   virtual int InitializeParser()
-     {
-     int res = cmXMLParser::InitializeParser();
-     if (res)
-       {
-       XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
-                                     cmBZRXMLParserUnknownEncodingHandler, 0);
-       }
-     return res;
-     }
+  {
+    int res = cmXMLParser::InitializeParser();
+    if (res) {
+      XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
+                                    cmBZRXMLParserUnknownEncodingHandler, 0);
+    }
+    return res;
+  }
+
 private:
   cmCTestBZR* BZR;
 
   typedef cmCTestBZR::Revision Revision;
-  typedef cmCTestBZR::Change   Change;
+  typedef cmCTestBZR::Change Change;
   Revision Rev;
   std::vector<Change> Changes;
   Change CurChange;
@@ -210,194 +207,161 @@ private:
   cmsys::RegularExpression EmailRegex;
 
   virtual bool ProcessChunk(const char* data, int length)
-    {
+  {
     this->OutputLogger::ProcessChunk(data, length);
     this->ParseChunk(data, length);
     return true;
-    }
+  }
 
   virtual void StartElement(const std::string& name, const char**)
-    {
+  {
     this->CData.clear();
-    if(name == "log")
-      {
+    if (name == "log") {
       this->Rev = Revision();
       this->Changes.clear();
-      }
+    }
     // affected-files can contain blocks of
     // modified, unknown, renamed, kind-changed, removed, conflicts, added
-    else if(name == "modified"
-            || name == "renamed"
-            || name == "kind-changed")
-      {
+    else if (name == "modified" || name == "renamed" ||
+             name == "kind-changed") {
       this->CurChange = Change();
       this->CurChange.Action = 'M';
-      }
-    else if(name == "added")
-      {
+    } else if (name == "added") {
       this->CurChange = Change();
       this->CurChange = 'A';
-      }
-    else if(name == "removed")
-      {
+    } else if (name == "removed") {
       this->CurChange = Change();
       this->CurChange = 'D';
-      }
-    else if(name == "unknown"
-            || name == "conflicts")
-      {
+    } else if (name == "unknown" || name == "conflicts") {
       // Should not happen here
       this->CurChange = Change();
-      }
     }
+  }
 
   virtual void CharacterDataHandler(const char* data, int length)
-    {
-    this->CData.insert(this->CData.end(), data, data+length);
-    }
+  {
+    this->CData.insert(this->CData.end(), data, data + length);
+  }
 
   virtual void EndElement(const std::string& name)
-    {
-    if(name == "log")
-      {
+  {
+    if (name == "log") {
       this->BZR->DoRevision(this->Rev, this->Changes);
-      }
-    else if(!this->CData.empty() &&
-            (name == "file" || name == "directory"))
-      {
+    } else if (!this->CData.empty() &&
+               (name == "file" || name == "directory")) {
       this->CurChange.Path.assign(&this->CData[0], this->CData.size());
       cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
       this->Changes.push_back(this->CurChange);
-      }
-    else if(!this->CData.empty() && name == "symlink")
-      {
+    } else if (!this->CData.empty() && name == "symlink") {
       // symlinks have an arobase at the end in the log
-      this->CurChange.Path.assign(&this->CData[0], this->CData.size()-1);
+      this->CurChange.Path.assign(&this->CData[0], this->CData.size() - 1);
       cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
       this->Changes.push_back(this->CurChange);
-      }
-    else if(!this->CData.empty() && name == "committer")
-      {
+    } else if (!this->CData.empty() && name == "committer") {
       this->Rev.Author.assign(&this->CData[0], this->CData.size());
-      if(this->EmailRegex.find(this->Rev.Author))
-        {
+      if (this->EmailRegex.find(this->Rev.Author)) {
         this->Rev.Author = this->EmailRegex.match(1);
         this->Rev.EMail = this->EmailRegex.match(2);
-        }
       }
-    else if(!this->CData.empty() && name == "timestamp")
-      {
+    } else if (!this->CData.empty() && name == "timestamp") {
       this->Rev.Date.assign(&this->CData[0], this->CData.size());
-      }
-    else if(!this->CData.empty() && name == "message")
-      {
+    } else if (!this->CData.empty() && name == "message") {
       this->Rev.Log.assign(&this->CData[0], this->CData.size());
-      }
-    else if(!this->CData.empty() && name == "revno")
-      {
+    } else if (!this->CData.empty() && name == "revno") {
       this->Rev.Rev.assign(&this->CData[0], this->CData.size());
-      }
-    this->CData.clear();
     }
+    this->CData.clear();
+  }
 
   virtual void ReportError(int, int, const char* msg)
-    {
+  {
     this->BZR->Log << "Error parsing bzr log xml: " << msg << "\n";
-    }
+  }
 };
 
-class cmCTestBZR::UpdateParser: public cmCTestVC::LineParser
+class cmCTestBZR::UpdateParser : public cmCTestVC::LineParser
 {
 public:
-  UpdateParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
-    {
+  UpdateParser(cmCTestBZR* bzr, const char* prefix)
+    : BZR(bzr)
+  {
     this->SetLog(&bzr->Log, prefix);
     this->RegexUpdate.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
-    }
+  }
+
 private:
   cmCTestBZR* BZR;
   cmsys::RegularExpression RegexUpdate;
 
   virtual bool ProcessChunk(const char* first, int length)
-    {
+  {
     bool last_is_new_line = (*first == '\r' || *first == '\n');
 
     const char* const last = first + length;
-    for(const char* c = first; c != last; ++c)
-      {
-      if(*c == '\r' || *c == '\n')
-        {
-        if(!last_is_new_line)
-          {
+    for (const char* c = first; c != last; ++c) {
+      if (*c == '\r' || *c == '\n') {
+        if (!last_is_new_line) {
           // Log this line.
-          if(this->Log && this->Prefix)
-            {
+          if (this->Log && this->Prefix) {
             *this->Log << this->Prefix << this->Line << "\n";
-            }
+          }
 
           // Hand this line to the subclass implementation.
-          if(!this->ProcessLine())
-            {
+          if (!this->ProcessLine()) {
             this->Line = "";
             return false;
-            }
+          }
 
           this->Line = "";
           last_is_new_line = true;
-          }
         }
-      else
-        {
+      } else {
         // Append this character to the line under construction.
         this->Line.append(1, *c);
         last_is_new_line = false;
-        }
       }
-    return true;
     }
+    return true;
+  }
 
   bool ProcessLine()
-    {
-    if(this->RegexUpdate.find(this->Line))
-      {
+  {
+    if (this->RegexUpdate.find(this->Line)) {
       this->DoPath(this->RegexUpdate.match(1)[0],
                    this->RegexUpdate.match(2)[0],
-                   this->RegexUpdate.match(3)[0],
-                   this->RegexUpdate.match(4));
-      }
-    return true;
+                   this->RegexUpdate.match(3)[0], this->RegexUpdate.match(4));
     }
+    return true;
+  }
 
   void DoPath(char c0, char c1, char c2, std::string path)
-    {
-    if(path.empty()) return;
+  {
+    if (path.empty())
+      return;
     cmSystemTools::ConvertToUnixSlashes(path);
 
     const std::string dir = cmSystemTools::GetFilenamePath(path);
     const std::string name = cmSystemTools::GetFilenameName(path);
 
-    if ( c0=='C' )
-      {
+    if (c0 == 'C') {
       this->BZR->Dirs[dir][name].Status = PathConflicting;
       return;
-      }
+    }
 
-    if ( c1=='M' || c1=='K' || c1=='N' || c1=='D' || c2 =='*' )
-      {
+    if (c1 == 'M' || c1 == 'K' || c1 == 'N' || c1 == 'D' || c2 == '*') {
       this->BZR->Dirs[dir][name].Status = PathUpdated;
       return;
-      }
     }
+  }
 };
 
 bool cmCTestBZR::UpdateImpl()
 {
   // Get user-specified update options.
   std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
-  if(opts.empty())
-    {
+  if (opts.empty()) {
     opts = this->CTest->GetCTestConfiguration("BZRUpdateOptions");
-    }
+  }
   std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
 
   // TODO: if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
@@ -407,11 +371,10 @@ bool cmCTestBZR::UpdateImpl()
   bzr_update.push_back(this->CommandLineTool.c_str());
   bzr_update.push_back("pull");
 
-  for(std::vector<std::string>::const_iterator ai = args.begin();
-      ai != args.end(); ++ai)
-    {
+  for (std::vector<std::string>::const_iterator ai = args.begin();
+       ai != args.end(); ++ai) {
     bzr_update.push_back(ai->c_str());
-    }
+  }
 
   bzr_update.push_back(this->URL.c_str());
 
@@ -427,82 +390,79 @@ void cmCTestBZR::LoadRevisions()
 {
   cmCTestLog(this->CTest, HANDLER_OUTPUT,
              "   Gathering version information (one . per revision):\n"
-             "    " << std::flush);
+             "    "
+               << std::flush);
 
   // We are interested in every revision included in the update.
   this->Revisions.clear();
   std::string revs;
-  if(atoi(this->OldRevision.c_str()) <= atoi(this->NewRevision.c_str()))
-    {
+  if (atoi(this->OldRevision.c_str()) <= atoi(this->NewRevision.c_str())) {
     // DoRevision takes care of discarding the information about OldRevision
     revs = this->OldRevision + ".." + this->NewRevision;
-    }
-  else
-    {
+  } else {
     return;
-    }
+  }
 
   // Run "bzr log" to get all global revisions of interest.
   const char* bzr = this->CommandLineTool.c_str();
-  const char* bzr_log[] = {bzr, "log", "-v", "-r", revs.c_str(), "--xml",
-                           this->URL.c_str(), 0};
+  const char* bzr_log[] = {
+    bzr, "log", "-v", "-r", revs.c_str(), "--xml", this->URL.c_str(), 0
+  };
   {
-  LogParser out(this, "log-out> ");
-  OutputLogger err(this->Log, "log-err> ");
-  this->RunChild(bzr_log, &out, &err);
+    LogParser out(this, "log-out> ");
+    OutputLogger err(this->Log, "log-err> ");
+    this->RunChild(bzr_log, &out, &err);
   }
   cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
 }
 
-class cmCTestBZR::StatusParser: public cmCTestVC::LineParser
+class cmCTestBZR::StatusParser : public cmCTestVC::LineParser
 {
 public:
-  StatusParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
-    {
+  StatusParser(cmCTestBZR* bzr, const char* prefix)
+    : BZR(bzr)
+  {
     this->SetLog(&bzr->Log, prefix);
     this->RegexStatus.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
-    }
+  }
+
 private:
   cmCTestBZR* BZR;
   cmsys::RegularExpression RegexStatus;
   bool ProcessLine()
-    {
-    if(this->RegexStatus.find(this->Line))
-      {
+  {
+    if (this->RegexStatus.find(this->Line)) {
       this->DoPath(this->RegexStatus.match(1)[0],
                    this->RegexStatus.match(2)[0],
-                   this->RegexStatus.match(3)[0],
-                   this->RegexStatus.match(4));
-      }
-    return true;
+                   this->RegexStatus.match(3)[0], this->RegexStatus.match(4));
     }
+    return true;
+  }
 
   void DoPath(char c0, char c1, char c2, std::string path)
-    {
-    if(path.empty()) return;
+  {
+    if (path.empty())
+      return;
     cmSystemTools::ConvertToUnixSlashes(path);
 
-    if ( c0=='C' )
-      {
+    if (c0 == 'C') {
       this->BZR->DoModification(PathConflicting, path);
       return;
-      }
+    }
 
-    if ( c0 == '+' || c0 == 'R' || c0 == 'P'
-         || c1=='M' || c1=='K' || c1=='N' || c1=='D'
-         || c2 =='*' )
-      {
+    if (c0 == '+' || c0 == 'R' || c0 == 'P' || c1 == 'M' || c1 == 'K' ||
+        c1 == 'N' || c1 == 'D' || c2 == '*') {
       this->BZR->DoModification(PathModified, path);
       return;
-      }
     }
+  }
 };
 
 void cmCTestBZR::LoadModifications()
 {
   // Run "bzr status" which reports local modifications.
   const char* bzr = this->CommandLineTool.c_str();
-  const char* bzr_status[] = {bzr, "status", "-SV", 0};
+  const char* bzr_status[] = { bzr, "status", "-SV", 0 };
   StatusParser out(this, "status-out> ");
   OutputLogger err(this->Log, "status-err> ");
   this->RunChild(bzr_status, &out, &err);