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, 132 insertions, 207 deletions

diff --git a/Source/cmAddLibraryCommand.cxx b/Source/cmAddLibraryCommand.cxx
index e40ecf4..4516ed2 100644
--- a/Source/cmAddLibraryCommand.cxx
+++ b/Source/cmAddLibraryCommand.cxx
@@ -15,21 +15,20 @@
 #include "cmake.h"
 
 // cmLibraryCommand
-bool cmAddLibraryCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAddLibraryCommand::InitialPass(std::vector<std::string> const& args,
+                                      cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   // Library type defaults to value of BUILD_SHARED_LIBS, if it exists,
   // otherwise it defaults to static library.
   cmState::TargetType type = cmState::SHARED_LIBRARY;
-  if (cmSystemTools::IsOff(this->Makefile->GetDefinition("BUILD_SHARED_LIBS")))
-    {
+  if (cmSystemTools::IsOff(
+        this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) {
     type = cmState::STATIC_LIBRARY;
-    }
+  }
   bool excludeFromAll = false;
   bool importTarget = false;
   bool importGlobal = false;
@@ -45,186 +44,145 @@ bool cmAddLibraryCommand
   // source list name. There may be two keyword arguments, check for them
   bool haveSpecifiedType = false;
   bool isAlias = false;
-  while ( s != args.end() )
-    {
+  while (s != args.end()) {
     std::string libType = *s;
-    if(libType == "STATIC")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    if (libType == "STATIC") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting STATIC type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::STATIC_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(libType == "SHARED")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (libType == "SHARED") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting SHARED type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::SHARED_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(libType == "MODULE")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (libType == "MODULE") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting MODULE type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::MODULE_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(libType == "OBJECT")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (libType == "OBJECT") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting OBJECT type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::OBJECT_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(libType == "UNKNOWN")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (libType == "UNKNOWN") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting UNKNOWN type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::UNKNOWN_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(libType == "ALIAS")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (libType == "ALIAS") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting ALIAS type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       isAlias = true;
-      }
-    else if(libType == "INTERFACE")
-      {
-      if (haveSpecifiedType)
-        {
+    } else if (libType == "INTERFACE") {
+      if (haveSpecifiedType) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting/multiple types.";
         this->SetError(e.str());
         return false;
-        }
-      if (isAlias)
-        {
+      }
+      if (isAlias) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting ALIAS type.";
         this->SetError(e.str());
         return false;
-        }
-      if (excludeFromAll)
-        {
+      }
+      if (excludeFromAll) {
         std::ostringstream e;
         e << "INTERFACE library may not be used with EXCLUDE_FROM_ALL.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::INTERFACE_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(*s == "EXCLUDE_FROM_ALL")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (*s == "EXCLUDE_FROM_ALL") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library may not be used with EXCLUDE_FROM_ALL.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       excludeFromAll = true;
-      }
-    else if(*s == "IMPORTED")
-      {
+    } else if (*s == "IMPORTED") {
       ++s;
       importTarget = true;
-      }
-    else if(importTarget && *s == "GLOBAL")
-      {
+    } else if (importTarget && *s == "GLOBAL") {
       ++s;
       importGlobal = true;
-      }
-    else if(type == cmState::INTERFACE_LIBRARY && *s == "GLOBAL")
-      {
+    } else if (type == cmState::INTERFACE_LIBRARY && *s == "GLOBAL") {
       std::ostringstream e;
       e << "GLOBAL option may only be used with IMPORTED libraries.";
       this->SetError(e.str());
       return false;
-      }
-    else
-      {
+    } else {
       break;
-      }
     }
+  }
 
-  if (type == cmState::INTERFACE_LIBRARY)
-    {
-    if (s != args.end())
-      {
+  if (type == cmState::INTERFACE_LIBRARY) {
+    if (s != args.end()) {
       std::ostringstream e;
       e << "INTERFACE library requires no source arguments.";
       this->SetError(e.str());
       return false;
-      }
-    if (importGlobal && !importTarget)
-      {
+    }
+    if (importGlobal && !importTarget) {
       std::ostringstream e;
       e << "INTERFACE library specified as GLOBAL, but not as IMPORTED.";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   bool nameOk = cmGeneratorExpression::IsValidTargetName(libName) &&
     !cmGlobalGenerator::IsReservedTarget(libName);
 
-  if (nameOk && !importTarget && !isAlias)
-    {
+  if (nameOk && !importTarget && !isAlias) {
     nameOk = libName.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:
-        if(type != cmState::INTERFACE_LIBRARY)
-          {
+        if (type != cmState::INTERFACE_LIBRARY) {
           e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n";
           issueMessage = true;
-          }
+        }
       case cmPolicies::OLD:
         break;
       case cmPolicies::NEW:
@@ -232,208 +190,177 @@ bool cmAddLibraryCommand
       case cmPolicies::REQUIRED_ALWAYS:
         issueMessage = true;
         messageType = cmake::FATAL_ERROR;
-      }
-    if (issueMessage)
-      {
-      e << "The target name \"" << libName <<
-          "\" is reserved or not valid for certain "
-          "CMake features, such as generator expressions, and may result "
-          "in undefined behavior.";
+    }
+    if (issueMessage) {
+      e << "The target name \"" << libName
+        << "\" is reserved or not valid for certain "
+           "CMake features, such as generator expressions, and may result "
+           "in undefined behavior.";
       this->Makefile->IssueMessage(messageType, e.str());
 
-      if (messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
     }
+  }
 
-  if (isAlias)
-    {
-    if(!cmGeneratorExpression::IsValidTargetName(libName))
-      {
+  if (isAlias) {
+    if (!cmGeneratorExpression::IsValidTargetName(libName)) {
       this->SetError("Invalid name for ALIAS: " + libName);
       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 \"" << libName
-        << "\" because target \"" << aliasedName << "\" is itself an ALIAS.";
+      e << "cannot create ALIAS target \"" << libName << "\" 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 \"" << libName
-        << "\" because target \"" << aliasedName << "\" does not already "
-        "exist.";
+      e << "cannot create ALIAS target \"" << libName << "\" because target \""
+        << aliasedName << "\" does not already "
+                          "exist.";
       this->SetError(e.str());
       return false;
-      }
+    }
     cmState::TargetType aliasedType = aliasedTarget->GetType();
-    if(aliasedType != cmState::SHARED_LIBRARY
-        && aliasedType != cmState::STATIC_LIBRARY
-        && aliasedType != cmState::MODULE_LIBRARY
-        && aliasedType != cmState::OBJECT_LIBRARY
-        && aliasedType != cmState::INTERFACE_LIBRARY)
-      {
+    if (aliasedType != cmState::SHARED_LIBRARY &&
+        aliasedType != cmState::STATIC_LIBRARY &&
+        aliasedType != cmState::MODULE_LIBRARY &&
+        aliasedType != cmState::OBJECT_LIBRARY &&
+        aliasedType != cmState::INTERFACE_LIBRARY) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << libName
-        << "\" because target \"" << aliasedName << "\" is not a library.";
+      e << "cannot create ALIAS target \"" << libName << "\" because target \""
+        << aliasedName << "\" is not a library.";
       this->SetError(e.str());
       return false;
-      }
-    if(aliasedTarget->IsImported())
-      {
+    }
+    if (aliasedTarget->IsImported()) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << libName
-        << "\" because target \"" << aliasedName << "\" is IMPORTED.";
+      e << "cannot create ALIAS target \"" << libName << "\" because target \""
+        << aliasedName << "\" is IMPORTED.";
       this->SetError(e.str());
       return false;
-      }
+    }
     this->Makefile->AddAlias(libName, aliasedName);
     return true;
-    }
+  }
 
-  if(importTarget && excludeFromAll)
-    {
+  if (importTarget && excludeFromAll) {
     this->SetError("excludeFromAll with IMPORTED target makes no sense.");
     return false;
-    }
+  }
 
   /* ideally we should check whether for the linker language of the target
     CMAKE_${LANG}_CREATE_SHARED_LIBRARY is defined and if not default to
     STATIC. But at this point we know only the name of the target, but not
     yet its linker language. */
-  if ((type == cmState::SHARED_LIBRARY ||
-       type == cmState::MODULE_LIBRARY) &&
-       (this->Makefile->GetState()->GetGlobalPropertyAsBool(
-                                      "TARGET_SUPPORTS_SHARED_LIBS") == false))
-    {
+  if ((type == cmState::SHARED_LIBRARY || type == cmState::MODULE_LIBRARY) &&
+      (this->Makefile->GetState()->GetGlobalPropertyAsBool(
+         "TARGET_SUPPORTS_SHARED_LIBS") == false)) {
     std::ostringstream w;
-    w <<
-      "ADD_LIBRARY called with " <<
-      (type==cmState::SHARED_LIBRARY ? "SHARED" : "MODULE") <<
-      " option but the target platform does not support dynamic linking. "
-      "Building a STATIC library instead. This may lead to problems.";
+    w << "ADD_LIBRARY called with "
+      << (type == cmState::SHARED_LIBRARY ? "SHARED" : "MODULE")
+      << " option but the target platform does not support dynamic linking. "
+         "Building a STATIC library instead. This may lead to problems.";
     this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
     type = cmState::STATIC_LIBRARY;
-    }
+  }
 
   // Handle imported target creation.
-  if(importTarget)
-    {
+  if (importTarget) {
     // The IMPORTED signature requires a type to be specified explicitly.
-    if (!haveSpecifiedType)
-      {
+    if (!haveSpecifiedType) {
       this->SetError("called with IMPORTED argument but no library type.");
       return false;
-      }
-    if(type == cmState::OBJECT_LIBRARY)
-      {
+    }
+    if (type == cmState::OBJECT_LIBRARY) {
       this->Makefile->IssueMessage(
         cmake::FATAL_ERROR,
-        "The OBJECT library type may not be used for IMPORTED libraries."
-        );
+        "The OBJECT library type may not be used for IMPORTED libraries.");
       return true;
-      }
-    if(type == cmState::INTERFACE_LIBRARY)
-      {
-      if (!cmGeneratorExpression::IsValidTargetName(libName))
-        {
+    }
+    if (type == cmState::INTERFACE_LIBRARY) {
+      if (!cmGeneratorExpression::IsValidTargetName(libName)) {
         std::ostringstream e;
         e << "Invalid name for IMPORTED INTERFACE library target: " << libName;
         this->SetError(e.str());
         return false;
-        }
       }
+    }
 
     // Make sure the target does not already exist.
-    if(this->Makefile->FindTargetToUse(libName))
-      {
+    if (this->Makefile->FindTargetToUse(libName)) {
       std::ostringstream e;
       e << "cannot create imported target \"" << libName
         << "\" because another target with the same name already exists.";
       this->SetError(e.str());
       return false;
-      }
+    }
 
     // Create the imported target.
     this->Makefile->AddImportedTarget(libName, type, importGlobal);
     return true;
-    }
+  }
 
   // A non-imported target may not have UNKNOWN type.
-  if(type == cmState::UNKNOWN_LIBRARY)
-    {
+  if (type == cmState::UNKNOWN_LIBRARY) {
     this->Makefile->IssueMessage(
       cmake::FATAL_ERROR,
-      "The UNKNOWN library type may be used only for IMPORTED libraries."
-      );
+      "The UNKNOWN library type may be used only for IMPORTED libraries.");
     return true;
-    }
+  }
 
   // Enforce name uniqueness.
   {
-  std::string msg;
-  if(!this->Makefile->EnforceUniqueName(libName, msg))
-    {
-    this->SetError(msg);
-    return false;
+    std::string msg;
+    if (!this->Makefile->EnforceUniqueName(libName, msg)) {
+      this->SetError(msg);
+      return false;
     }
   }
 
   std::vector<std::string> srclists;
 
-  if(type == cmState::INTERFACE_LIBRARY)
-    {
-    if (!cmGeneratorExpression::IsValidTargetName(libName)
-        || libName.find("::") != std::string::npos)
-      {
+  if (type == cmState::INTERFACE_LIBRARY) {
+    if (!cmGeneratorExpression::IsValidTargetName(libName) ||
+        libName.find("::") != std::string::npos) {
       std::ostringstream e;
       e << "Invalid name for INTERFACE library target: " << libName;
       this->SetError(e.str());
       return false;
-      }
+    }
 
-    this->Makefile->AddLibrary(libName,
-                               type,
-                               srclists,
-                               excludeFromAll);
+    this->Makefile->AddLibrary(libName, type, srclists, excludeFromAll);
     return true;
-    }
+  }
 
-  if (s == args.end())
-    {
+  if (s == args.end()) {
     std::string msg = "You have called ADD_LIBRARY for library ";
     msg += args[0];
     msg += " without any source files. This typically indicates a problem ";
     msg += "with your CMakeLists.txt file";
-    cmSystemTools::Message(msg.c_str() ,"Warning");
-    }
+    cmSystemTools::Message(msg.c_str(), "Warning");
+  }
 
   srclists.insert(srclists.end(), s, args.end());
 
@@ -441,5 +368,3 @@ bool cmAddLibraryCommand
 
   return true;
 }
-
-