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, 162 insertions, 230 deletions

diff --git a/Source/cmListCommand.cxx b/Source/cmListCommand.cxx
index feecb1e..32e965d 100644
--- a/Source/cmListCommand.cxx
+++ b/Source/cmListCommand.cxx
@@ -19,62 +19,50 @@
 #include <assert.h>
 #include <ctype.h>
 #include <stdlib.h> // required for atoi
-bool cmListCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmListCommand::InitialPass(std::vector<std::string> const& args,
+                                cmExecutionStatus&)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("must be called with at least two arguments.");
     return false;
-    }
+  }
 
-  const std::string &subCommand = args[0];
-  if(subCommand == "LENGTH")
-    {
+  const std::string& subCommand = args[0];
+  if (subCommand == "LENGTH") {
     return this->HandleLengthCommand(args);
-    }
-  if(subCommand == "GET")
-    {
+  }
+  if (subCommand == "GET") {
     return this->HandleGetCommand(args);
-    }
-  if(subCommand == "APPEND")
-    {
+  }
+  if (subCommand == "APPEND") {
     return this->HandleAppendCommand(args);
-    }
-  if(subCommand == "FIND")
-    {
+  }
+  if (subCommand == "FIND") {
     return this->HandleFindCommand(args);
-    }
-  if(subCommand == "INSERT")
-    {
+  }
+  if (subCommand == "INSERT") {
     return this->HandleInsertCommand(args);
-    }
-  if(subCommand == "REMOVE_AT")
-    {
+  }
+  if (subCommand == "REMOVE_AT") {
     return this->HandleRemoveAtCommand(args);
-    }
-  if(subCommand == "REMOVE_ITEM")
-    {
+  }
+  if (subCommand == "REMOVE_ITEM") {
     return this->HandleRemoveItemCommand(args);
-    }
-  if(subCommand == "REMOVE_DUPLICATES")
-    {
+  }
+  if (subCommand == "REMOVE_DUPLICATES") {
     return this->HandleRemoveDuplicatesCommand(args);
-    }
-  if(subCommand == "SORT")
-    {
+  }
+  if (subCommand == "SORT") {
     return this->HandleSortCommand(args);
-    }
-  if(subCommand == "REVERSE")
-    {
+  }
+  if (subCommand == "REVERSE") {
     return this->HandleReverseCommand(args);
-    }
-  if(subCommand == "FILTER")
-    {
+  }
+  if (subCommand == "FILTER") {
     return this->HandleFilterCommand(args);
-    }
+  }
 
-  std::string e = "does not recognize sub-command "+subCommand;
+  std::string e = "does not recognize sub-command " + subCommand;
   this->SetError(e);
   return false;
 }
@@ -83,12 +71,10 @@ bool cmListCommand::GetListString(std::string& listString,
                                   const std::string& var)
 {
   // get the old value
-  const char* cacheValue
-    = this->Makefile->GetDefinition(var);
-  if(!cacheValue)
-    {
+  const char* cacheValue = this->Makefile->GetDefinition(var);
+  if (!cacheValue) {
     return false;
-    }
+  }
   listString = cacheValue;
   return true;
 }
@@ -97,27 +83,22 @@ bool cmListCommand::GetList(std::vector<std::string>& list,
                             const std::string& var)
 {
   std::string listString;
-  if ( !this->GetListString(listString, var) )
-    {
+  if (!this->GetListString(listString, var)) {
     return false;
-    }
+  }
   // if the size of the list
-  if(listString.empty())
-    {
+  if (listString.empty()) {
     return true;
-    }
+  }
   // expand the variable into a list
   cmSystemTools::ExpandListArgument(listString, list, true);
   // if no empty elements then just return
-  if (std::find(list.begin(), list.end(), std::string()) == list.end())
-    {
+  if (std::find(list.begin(), list.end(), std::string()) == list.end()) {
     return true;
-    }
+  }
   // if we have empty elements we need to check policy CMP0007
-  switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0007))
-    {
-    case cmPolicies::WARN:
-      {
+  switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0007)) {
+    case cmPolicies::WARN: {
       // Default is to warn and use old behavior
       // OLD behavior is to allow compatibility, so recall
       // ExpandListArgument without the true which will remove
@@ -128,10 +109,9 @@ bool cmListCommand::GetList(std::vector<std::string>& list,
       warn += " List has value = [";
       warn += listString;
       warn += "].";
-      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
-                                   warn);
+      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, warn);
       return true;
-      }
+    }
     case cmPolicies::OLD:
       // OLD behavior is to allow compatibility, so recall
       // ExpandListArgument without the true which will remove
@@ -145,20 +125,18 @@ bool cmListCommand::GetList(std::vector<std::string>& list,
     case cmPolicies::REQUIRED_ALWAYS:
       this->Makefile->IssueMessage(
         cmake::FATAL_ERROR,
-        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0007)
-        );
+        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0007));
       return false;
-    }
+  }
   return true;
 }
 
 bool cmListCommand::HandleLengthCommand(std::vector<std::string> const& args)
 {
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("sub-command LENGTH requires two arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   const std::string& variableName = args[args.size() - 1];
@@ -177,52 +155,45 @@ bool cmListCommand::HandleLengthCommand(std::vector<std::string> const& args)
 
 bool cmListCommand::HandleGetCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 4)
-    {
+  if (args.size() < 4) {
     this->SetError("sub-command GET requires at least three arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   const std::string& variableName = args[args.size() - 1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->Makefile->AddDefinition(variableName, "NOTFOUND");
     return true;
-    }
+  }
   // FIXME: Add policy to make non-existing lists an error like empty lists.
-  if(varArgsExpanded.empty())
-    {
+  if (varArgsExpanded.empty()) {
     this->SetError("GET given empty list");
     return false;
-    }
+  }
 
   std::string value;
   size_t cc;
   const char* sep = "";
   size_t nitem = varArgsExpanded.size();
-  for ( cc = 2; cc < args.size()-1; cc ++ )
-    {
+  for (cc = 2; cc < args.size() - 1; cc++) {
     int item = atoi(args[cc].c_str());
     value += sep;
     sep = ";";
-    if ( item < 0 )
-      {
+    if (item < 0) {
       item = (int)nitem + item;
-      }
-    if ( item < 0 || nitem <= (size_t)item )
-      {
+    }
+    if (item < 0 || nitem <= (size_t)item) {
       std::ostringstream str;
-      str << "index: " << item << " out of range (-"
-          << nitem << ", "
+      str << "index: " << item << " out of range (-" << nitem << ", "
           << nitem - 1 << ")";
       this->SetError(str.str());
       return false;
-      }
-    value += varArgsExpanded[item];
     }
+    value += varArgsExpanded[item];
+  }
 
   this->Makefile->AddDefinition(variableName, value.c_str());
   return true;
@@ -233,20 +204,18 @@ bool cmListCommand::HandleAppendCommand(std::vector<std::string> const& args)
   assert(args.size() >= 2);
 
   // Skip if nothing to append.
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     return true;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::string listString;
   this->GetListString(listString, listName);
 
-  if(!listString.empty() && !args.empty())
-    {
+  if (!listString.empty() && !args.empty()) {
     listString += ";";
-    }
+  }
   listString += cmJoin(cmMakeRange(args).advance(2), ";");
 
   this->Makefile->AddDefinition(listName, listString.c_str());
@@ -255,31 +224,28 @@ bool cmListCommand::HandleAppendCommand(std::vector<std::string> const& args)
 
 bool cmListCommand::HandleFindCommand(std::vector<std::string> const& args)
 {
-  if(args.size() != 4)
-    {
+  if (args.size() != 4) {
     this->SetError("sub-command FIND requires three arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   const std::string& variableName = args[args.size() - 1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->Makefile->AddDefinition(variableName, "-1");
     return true;
-    }
+  }
 
   std::vector<std::string>::iterator it =
-      std::find(varArgsExpanded.begin(), varArgsExpanded.end(), args[2]);
-  if (it != varArgsExpanded.end())
-    {
+    std::find(varArgsExpanded.begin(), varArgsExpanded.end(), args[2]);
+  if (it != varArgsExpanded.end()) {
     std::ostringstream indexStream;
     indexStream << std::distance(varArgsExpanded.begin(), it);
     this->Makefile->AddDefinition(variableName, indexStream.str().c_str());
     return true;
-    }
+  }
 
   this->Makefile->AddDefinition(variableName, "-1");
   return true;
@@ -287,103 +253,93 @@ bool cmListCommand::HandleFindCommand(std::vector<std::string> const& args)
 
 bool cmListCommand::HandleInsertCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 4)
-    {
+  if (args.size() < 4) {
     this->SetError("sub-command INSERT requires at least three arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
 
   // expand the variable
   int item = atoi(args[2].c_str());
   std::vector<std::string> varArgsExpanded;
-  if((!this->GetList(varArgsExpanded, listName)
-      || varArgsExpanded.empty()) && item != 0)
-    {
+  if ((!this->GetList(varArgsExpanded, listName) || varArgsExpanded.empty()) &&
+      item != 0) {
     std::ostringstream str;
     str << "index: " << item << " out of range (0, 0)";
     this->SetError(str.str());
     return false;
-    }
+  }
 
-  if (!varArgsExpanded.empty())
-    {
+  if (!varArgsExpanded.empty()) {
     size_t nitem = varArgsExpanded.size();
-    if ( item < 0 )
-      {
+    if (item < 0) {
       item = (int)nitem + item;
-      }
-    if ( item < 0 || nitem <= (size_t)item )
-      {
+    }
+    if (item < 0 || nitem <= (size_t)item) {
       std::ostringstream str;
-      str << "index: " << item << " out of range (-"
-        << varArgsExpanded.size() << ", "
-        << (varArgsExpanded.empty() ? 0 : (varArgsExpanded.size() - 1)) << ")";
+      str << "index: " << item << " out of range (-" << varArgsExpanded.size()
+          << ", "
+          << (varArgsExpanded.empty() ? 0 : (varArgsExpanded.size() - 1))
+          << ")";
       this->SetError(str.str());
       return false;
-      }
     }
+  }
 
-  varArgsExpanded.insert(varArgsExpanded.begin()+item,
-                         args.begin() + 3, args.end());
+  varArgsExpanded.insert(varArgsExpanded.begin() + item, args.begin() + 3,
+                         args.end());
 
   std::string value = cmJoin(varArgsExpanded, ";");
   this->Makefile->AddDefinition(listName, value.c_str());
   return true;
 }
 
-bool cmListCommand
-::HandleRemoveItemCommand(std::vector<std::string> const& args)
+bool cmListCommand::HandleRemoveItemCommand(
+  std::vector<std::string> const& args)
 {
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("sub-command REMOVE_ITEM requires two or more arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError("sub-command REMOVE_ITEM requires list to be present.");
     return false;
-    }
+  }
 
   std::vector<std::string> remove(args.begin() + 2, args.end());
   std::sort(remove.begin(), remove.end());
   std::vector<std::string>::const_iterator remEnd =
-      std::unique(remove.begin(), remove.end());
+    std::unique(remove.begin(), remove.end());
   std::vector<std::string>::const_iterator remBegin = remove.begin();
 
   std::vector<std::string>::const_iterator argsEnd =
-      cmRemoveMatching(varArgsExpanded, cmMakeRange(remBegin, remEnd));
+    cmRemoveMatching(varArgsExpanded, cmMakeRange(remBegin, remEnd));
   std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
   std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
   this->Makefile->AddDefinition(listName, value.c_str());
   return true;
 }
 
-bool cmListCommand
-::HandleReverseCommand(std::vector<std::string> const& args)
+bool cmListCommand::HandleReverseCommand(std::vector<std::string> const& args)
 {
   assert(args.size() >= 2);
-  if(args.size() > 2)
-    {
-    this->SetError(
-      "sub-command REVERSE only takes one argument.");
+  if (args.size() > 2) {
+    this->SetError("sub-command REVERSE only takes one argument.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError("sub-command REVERSE requires list to be present.");
     return false;
-    }
+  }
 
   std::string value = cmJoin(cmReverseRange(varArgsExpanded), ";");
 
@@ -391,56 +347,48 @@ bool cmListCommand
   return true;
 }
 
-bool cmListCommand
-::HandleRemoveDuplicatesCommand(std::vector<std::string> const& args)
+bool cmListCommand::HandleRemoveDuplicatesCommand(
+  std::vector<std::string> const& args)
 {
   assert(args.size() >= 2);
-  if(args.size() > 2)
-    {
-    this->SetError(
-      "sub-command REMOVE_DUPLICATES only takes one argument.");
+  if (args.size() > 2) {
+    this->SetError("sub-command REMOVE_DUPLICATES only takes one argument.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError(
       "sub-command REMOVE_DUPLICATES requires list to be present.");
     return false;
-    }
+  }
 
   std::vector<std::string>::const_iterator argsEnd =
-      cmRemoveDuplicates(varArgsExpanded);
-  std::vector<std::string>::const_iterator argsBegin =
-      varArgsExpanded.begin();
+    cmRemoveDuplicates(varArgsExpanded);
+  std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
   std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
 
   this->Makefile->AddDefinition(listName, value.c_str());
   return true;
 }
 
-bool cmListCommand
-::HandleSortCommand(std::vector<std::string> const& args)
+bool cmListCommand::HandleSortCommand(std::vector<std::string> const& args)
 {
   assert(args.size() >= 2);
-  if(args.size() > 2)
-    {
-    this->SetError(
-      "sub-command SORT only takes one argument.");
+  if (args.size() > 2) {
+    this->SetError("sub-command SORT only takes one argument.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError("sub-command SORT requires list to be present.");
     return false;
-    }
+  }
 
   std::sort(varArgsExpanded.begin(), varArgsExpanded.end());
 
@@ -449,60 +397,52 @@ bool cmListCommand
   return true;
 }
 
-bool cmListCommand::HandleRemoveAtCommand(
-  std::vector<std::string> const& args)
+bool cmListCommand::HandleRemoveAtCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("sub-command REMOVE_AT requires at least "
                    "two arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError("sub-command REMOVE_AT requires list to be present.");
     return false;
-    }
+  }
   // FIXME: Add policy to make non-existing lists an error like empty lists.
-  if(varArgsExpanded.empty())
-    {
+  if (varArgsExpanded.empty()) {
     this->SetError("REMOVE_AT given empty list");
     return false;
-    }
+  }
 
   size_t cc;
   std::vector<size_t> removed;
   size_t nitem = varArgsExpanded.size();
-  for ( cc = 2; cc < args.size(); ++ cc )
-    {
+  for (cc = 2; cc < args.size(); ++cc) {
     int item = atoi(args[cc].c_str());
-    if ( item < 0 )
-      {
+    if (item < 0) {
       item = (int)nitem + item;
-      }
-    if ( item < 0 || nitem <= (size_t)item )
-      {
+    }
+    if (item < 0 || nitem <= (size_t)item) {
       std::ostringstream str;
-      str << "index: " << item << " out of range (-"
-          << nitem << ", "
+      str << "index: " << item << " out of range (-" << nitem << ", "
           << nitem - 1 << ")";
       this->SetError(str.str());
       return false;
-      }
-    removed.push_back(static_cast<size_t>(item));
     }
+    removed.push_back(static_cast<size_t>(item));
+  }
 
   std::sort(removed.begin(), removed.end());
   std::vector<size_t>::const_iterator remEnd =
-      std::unique(removed.begin(), removed.end());
+    std::unique(removed.begin(), removed.end());
   std::vector<size_t>::const_iterator remBegin = removed.begin();
 
   std::vector<std::string>::const_iterator argsEnd =
-      cmRemoveIndices(varArgsExpanded, cmMakeRange(remBegin, remEnd));
+    cmRemoveIndices(varArgsExpanded, cmMakeRange(remBegin, remEnd));
   std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
   std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
 
@@ -510,74 +450,67 @@ bool cmListCommand::HandleRemoveAtCommand(
   return true;
 }
 
-bool cmListCommand::HandleFilterCommand(
-  std::vector<std::string> const& args)
+bool cmListCommand::HandleFilterCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("sub-command FILTER requires a list to be specified.");
     return false;
-    }
+  }
 
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("sub-command FILTER requires an operator to be specified.");
     return false;
-    }
+  }
 
-  if(args.size() < 4)
-    {
+  if (args.size() < 4) {
     this->SetError("sub-command FILTER requires a mode to be specified.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError("sub-command FILTER requires list to be present.");
     return false;
-    }
+  }
 
   const std::string& op = args[2];
   bool includeMatches;
-  if(op == "INCLUDE")
-    {
+  if (op == "INCLUDE") {
     includeMatches = true;
-    }
-  else if(op == "EXCLUDE")
-    {
+  } else if (op == "EXCLUDE") {
     includeMatches = false;
-    }
-  else
-    {
+  } else {
     this->SetError("sub-command FILTER does not recognize operator " + op);
     return false;
-    }
+  }
 
   const std::string& mode = args[3];
-  if(mode == "REGEX")
-    {
-    if(args.size() != 5)
-      {
+  if (mode == "REGEX") {
+    if (args.size() != 5) {
       this->SetError("sub-command FILTER, mode REGEX "
-          "requires five arguments.");
+                     "requires five arguments.");
       return false;
-      }
-    return this->FilterRegex(args, includeMatches, listName, varArgsExpanded);
     }
+    return this->FilterRegex(args, includeMatches, listName, varArgsExpanded);
+  }
 
   this->SetError("sub-command FILTER does not recognize mode " + mode);
   return false;
 }
 
-class MatchesRegex {
+class MatchesRegex
+{
 public:
   MatchesRegex(cmsys::RegularExpression& in_regex, bool in_includeMatches)
-    : regex(in_regex), includeMatches(in_includeMatches) {}
+    : regex(in_regex)
+    , includeMatches(in_includeMatches)
+  {
+  }
 
-  bool operator()(const std::string& target) {
+  bool operator()(const std::string& target)
+  {
     return regex.find(target) ^ includeMatches;
   }
 
@@ -587,26 +520,25 @@ private:
 };
 
 bool cmListCommand::FilterRegex(std::vector<std::string> const& args,
-    bool includeMatches,
-    std::string const& listName,
-    std::vector<std::string>& varArgsExpanded)
+                                bool includeMatches,
+                                std::string const& listName,
+                                std::vector<std::string>& varArgsExpanded)
 {
   const std::string& pattern = args[4];
   cmsys::RegularExpression regex(pattern);
-  if(!regex.is_valid())
-    {
+  if (!regex.is_valid()) {
     std::string error = "sub-command FILTER, mode REGEX ";
     error += "failed to compile regex \"";
     error += pattern;
     error += "\".";
     this->SetError(error);
     return false;
-    }
+  }
 
   std::vector<std::string>::iterator argsBegin = varArgsExpanded.begin();
   std::vector<std::string>::iterator argsEnd = varArgsExpanded.end();
   std::vector<std::string>::iterator newArgsEnd =
-      std::remove_if(argsBegin, argsEnd, MatchesRegex(regex, includeMatches));
+    std::remove_if(argsBegin, argsEnd, MatchesRegex(regex, includeMatches));
 
   std::string value = cmJoin(cmMakeRange(argsBegin, newArgsEnd), ";");
   this->Makefile->AddDefinition(listName, value.c_str());