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, 80 insertions, 122 deletions

diff --git a/Source/cmAddExecutableCommand.cxx b/Source/cmAddExecutableCommand.cxx
index dccf9d9..fec5eb8 100644
--- a/Source/cmAddExecutableCommand.cxx
+++ b/Source/cmAddExecutableCommand.cxx
@@ -12,14 +12,13 @@
 #include "cmAddExecutableCommand.h"
 
 // cmExecutableCommand
-bool cmAddExecutableCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   std::vector<std::string>::const_iterator s = args.begin();
 
   std::string exename = *s;
@@ -31,58 +30,41 @@ bool cmAddExecutableCommand
   bool importTarget = false;
   bool importGlobal = false;
   bool isAlias = false;
-  while ( s != args.end() )
-    {
-    if (*s == "WIN32")
-      {
+  while (s != args.end()) {
+    if (*s == "WIN32") {
       ++s;
       use_win32 = true;
-      }
-    else if ( *s == "MACOSX_BUNDLE" )
-      {
+    } else if (*s == "MACOSX_BUNDLE") {
       ++s;
       use_macbundle = true;
-      }
-    else if(*s == "EXCLUDE_FROM_ALL")
-      {
+    } else if (*s == "EXCLUDE_FROM_ALL") {
       ++s;
       excludeFromAll = true;
-      }
-    else if(*s == "IMPORTED")
-     {
-     ++s;
-     importTarget = true;
-     }
-    else if(importTarget && *s == "GLOBAL")
-      {
+    } else if (*s == "IMPORTED") {
+      ++s;
+      importTarget = true;
+    } else if (importTarget && *s == "GLOBAL") {
       ++s;
       importGlobal = true;
-      }
-    else if(*s == "ALIAS")
-      {
+    } else if (*s == "ALIAS") {
       ++s;
       isAlias = true;
-      }
-    else
-      {
+    } else {
       break;
-      }
     }
+  }
 
   bool nameOk = cmGeneratorExpression::IsValidTargetName(exename) &&
     !cmGlobalGenerator::IsReservedTarget(exename);
 
-  if (nameOk && !importTarget && !isAlias)
-    {
+  if (nameOk && !importTarget && !isAlias) {
     nameOk = exename.find(":") == std::string::npos;
-    }
-  if (!nameOk)
-    {
+  }
+  if (!nameOk) {
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
     std::ostringstream e;
     bool issueMessage = false;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0037))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0037)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n";
         issueMessage = true;
@@ -93,9 +75,8 @@ bool cmAddExecutableCommand
       case cmPolicies::REQUIRED_ALWAYS:
         issueMessage = true;
         messageType = cmake::FATAL_ERROR;
-      }
-    if (issueMessage)
-      {
+    }
+    if (issueMessage) {
       /* clang-format off */
       e << "The target name \"" << exename <<
           "\" is reserved or not valid for certain "
@@ -104,147 +85,124 @@ bool cmAddExecutableCommand
       /* clang-format on */
       this->Makefile->IssueMessage(messageType, e.str());
 
-      if (messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
     }
+  }
 
   // Special modifiers are not allowed with IMPORTED signature.
-  if(importTarget
-      && (use_win32 || use_macbundle || excludeFromAll))
-    {
-    if(use_win32)
-      {
+  if (importTarget && (use_win32 || use_macbundle || excludeFromAll)) {
+    if (use_win32) {
       this->SetError("may not be given WIN32 for an IMPORTED target.");
-      }
-    else if(use_macbundle)
-      {
-      this->SetError(
-        "may not be given MACOSX_BUNDLE for an IMPORTED target.");
-      }
-    else // if(excludeFromAll)
-      {
+    } else if (use_macbundle) {
+      this->SetError("may not be given MACOSX_BUNDLE for an IMPORTED target.");
+    } else // if(excludeFromAll)
+    {
       this->SetError(
         "may not be given EXCLUDE_FROM_ALL for an IMPORTED target.");
-      }
-    return false;
     }
-  if (isAlias)
-    {
-    if(!cmGeneratorExpression::IsValidTargetName(exename))
-      {
+    return false;
+  }
+  if (isAlias) {
+    if (!cmGeneratorExpression::IsValidTargetName(exename)) {
       this->SetError("Invalid name for ALIAS: " + exename);
       return false;
-      }
-    if(excludeFromAll)
-      {
+    }
+    if (excludeFromAll) {
       this->SetError("EXCLUDE_FROM_ALL with ALIAS makes no sense.");
       return false;
-      }
-    if(importTarget || importGlobal)
-      {
+    }
+    if (importTarget || importGlobal) {
       this->SetError("IMPORTED with ALIAS is not allowed.");
       return false;
-      }
-    if(args.size() != 3)
-      {
+    }
+    if (args.size() != 3) {
       std::ostringstream e;
       e << "ALIAS requires exactly one target argument.";
       this->SetError(e.str());
       return false;
-      }
+    }
 
-    const char *aliasedName = s->c_str();
-    if(this->Makefile->IsAlias(aliasedName))
-      {
+    const char* aliasedName = s->c_str();
+    if (this->Makefile->IsAlias(aliasedName)) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << exename
-        << "\" because target \"" << aliasedName << "\" is itself an ALIAS.";
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" is itself an ALIAS.";
       this->SetError(e.str());
       return false;
-      }
-    cmTarget *aliasedTarget =
-                    this->Makefile->FindTargetToUse(aliasedName, true);
-    if(!aliasedTarget)
-      {
+    }
+    cmTarget* aliasedTarget =
+      this->Makefile->FindTargetToUse(aliasedName, true);
+    if (!aliasedTarget) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << exename
-        << "\" because target \"" << aliasedName << "\" does not already "
-        "exist.";
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" does not already "
+                          "exist.";
       this->SetError(e.str());
       return false;
-      }
+    }
     cmState::TargetType type = aliasedTarget->GetType();
-    if(type != cmState::EXECUTABLE)
-      {
+    if (type != cmState::EXECUTABLE) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << exename
-        << "\" because target \"" << aliasedName << "\" is not an "
-        "executable.";
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" is not an "
+                          "executable.";
       this->SetError(e.str());
       return false;
-      }
-    if(aliasedTarget->IsImported())
-      {
+    }
+    if (aliasedTarget->IsImported()) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << exename
-        << "\" because target \"" << aliasedName << "\" is IMPORTED.";
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" is IMPORTED.";
       this->SetError(e.str());
       return false;
-      }
+    }
     this->Makefile->AddAlias(exename, aliasedName);
     return true;
-    }
+  }
 
   // Handle imported target creation.
-  if(importTarget)
-    {
+  if (importTarget) {
     // Make sure the target does not already exist.
-    if(this->Makefile->FindTargetToUse(exename))
-      {
+    if (this->Makefile->FindTargetToUse(exename)) {
       std::ostringstream e;
       e << "cannot create imported target \"" << exename
         << "\" because another target with the same name already exists.";
       this->SetError(e.str());
       return false;
-      }
+    }
 
     // Create the imported target.
     this->Makefile->AddImportedTarget(exename, cmState::EXECUTABLE,
                                       importGlobal);
     return true;
-    }
+  }
 
   // Enforce name uniqueness.
   {
-  std::string msg;
-  if(!this->Makefile->EnforceUniqueName(exename, msg))
-    {
-    this->SetError(msg);
-    return false;
+    std::string msg;
+    if (!this->Makefile->EnforceUniqueName(exename, msg)) {
+      this->SetError(msg);
+      return false;
     }
   }
 
-  if (s == args.end())
-    {
-    this->SetError
-      ("called with incorrect number of arguments, no sources provided");
+  if (s == args.end()) {
+    this->SetError(
+      "called with incorrect number of arguments, no sources provided");
     return false;
-    }
+  }
 
   std::vector<std::string> srclists(s, args.end());
-  cmTarget* tgt = this->Makefile->AddExecutable(exename.c_str(), srclists,
-                                                excludeFromAll);
-  if ( use_win32 )
-    {
+  cmTarget* tgt =
+    this->Makefile->AddExecutable(exename.c_str(), srclists, excludeFromAll);
+  if (use_win32) {
     tgt->SetProperty("WIN32_EXECUTABLE", "ON");
-    }
-  if ( use_macbundle)
-    {
+  }
+  if (use_macbundle) {
     tgt->SetProperty("MACOSX_BUNDLE", "ON");
-    }
+  }
 
   return true;
 }