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

diff --git a/Source/cmSourceFileLocation.cxx b/Source/cmSourceFileLocation.cxx
index 6e474020f6..3219f3678b 100644
--- a/Source/cmSourceFileLocation.cxx
+++ b/Source/cmSourceFileLocation.cxx
@@ -19,9 +19,10 @@
 #include "assert.h"
 
 cmSourceFileLocation::cmSourceFileLocation()
-  : Makefile(0), AmbiguousDirectory(true), AmbiguousExtension(true)
+  : Makefile(0)
+  , AmbiguousDirectory(true)
+  , AmbiguousExtension(true)
 {
-
 }
 
 cmSourceFileLocation::cmSourceFileLocation(const cmSourceFileLocation& loc)
@@ -33,13 +34,12 @@ cmSourceFileLocation::cmSourceFileLocation(const cmSourceFileLocation& loc)
   this->Name = loc.Name;
 }
 
-cmSourceFileLocation&
-cmSourceFileLocation::operator=(const cmSourceFileLocation& loc)
+cmSourceFileLocation& cmSourceFileLocation::operator=(
+  const cmSourceFileLocation& loc)
 {
-  if(this == &loc)
-    {
+  if (this == &loc) {
     return *this;
-    }
+  }
   this->Makefile = loc.Makefile;
   this->AmbiguousDirectory = loc.AmbiguousDirectory;
   this->AmbiguousExtension = loc.AmbiguousExtension;
@@ -49,58 +49,50 @@ cmSourceFileLocation::operator=(const cmSourceFileLocation& loc)
   return *this;
 }
 
-cmSourceFileLocation
-::cmSourceFileLocation(cmMakefile const* mf, const std::string& name)
+cmSourceFileLocation::cmSourceFileLocation(cmMakefile const* mf,
+                                           const std::string& name)
   : Makefile(mf)
 {
   this->AmbiguousDirectory = !cmSystemTools::FileIsFullPath(name.c_str());
   this->AmbiguousExtension = true;
   this->Directory = cmSystemTools::GetFilenamePath(name);
-  if (cmSystemTools::FileIsFullPath(this->Directory.c_str()))
-    {
-    this->Directory
-                  = cmSystemTools::CollapseFullPath(this->Directory);
-    }
+  if (cmSystemTools::FileIsFullPath(this->Directory.c_str())) {
+    this->Directory = cmSystemTools::CollapseFullPath(this->Directory);
+  }
   this->Name = cmSystemTools::GetFilenameName(name);
   this->UpdateExtension(name);
 }
 
 void cmSourceFileLocation::Update(cmSourceFileLocation const& loc)
 {
-  if(this->AmbiguousDirectory && !loc.AmbiguousDirectory)
-    {
+  if (this->AmbiguousDirectory && !loc.AmbiguousDirectory) {
     this->Directory = loc.Directory;
     this->AmbiguousDirectory = false;
-    }
-  if(this->AmbiguousExtension && !loc.AmbiguousExtension)
-    {
+  }
+  if (this->AmbiguousExtension && !loc.AmbiguousExtension) {
     this->Name = loc.Name;
     this->AmbiguousExtension = false;
-    }
+  }
 }
 
 void cmSourceFileLocation::DirectoryUseSource()
 {
   assert(this->Makefile);
-  if(this->AmbiguousDirectory)
-    {
-    this->Directory =
-      cmSystemTools::CollapseFullPath(
-        this->Directory, this->Makefile->GetCurrentSourceDirectory());
+  if (this->AmbiguousDirectory) {
+    this->Directory = cmSystemTools::CollapseFullPath(
+      this->Directory, this->Makefile->GetCurrentSourceDirectory());
     this->AmbiguousDirectory = false;
-    }
+  }
 }
 
 void cmSourceFileLocation::DirectoryUseBinary()
 {
   assert(this->Makefile);
-  if(this->AmbiguousDirectory)
-    {
-    this->Directory =
-      cmSystemTools::CollapseFullPath(
-        this->Directory, this->Makefile->GetCurrentBinaryDirectory());
+  if (this->AmbiguousDirectory) {
+    this->Directory = cmSystemTools::CollapseFullPath(
+      this->Directory, this->Makefile->GetCurrentBinaryDirectory());
     this->AmbiguousDirectory = false;
-    }
+  }
 }
 
 void cmSourceFileLocation::UpdateExtension(const std::string& name)
@@ -108,155 +100,129 @@ void cmSourceFileLocation::UpdateExtension(const std::string& name)
   assert(this->Makefile);
   // Check the extension.
   std::string ext = cmSystemTools::GetFilenameLastExtension(name);
-  if(!ext.empty()) { ext = ext.substr(1); }
+  if (!ext.empty()) {
+    ext = ext.substr(1);
+  }
 
   // The global generator checks extensions of enabled languages.
   cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
   cmMakefile const* mf = this->Makefile;
   const std::vector<std::string>& srcExts =
-      mf->GetCMakeInstance()->GetSourceExtensions();
+    mf->GetCMakeInstance()->GetSourceExtensions();
   const std::vector<std::string>& hdrExts =
-      mf->GetCMakeInstance()->GetHeaderExtensions();
-  if(!gg->GetLanguageFromExtension(ext.c_str()).empty() ||
-     std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end() ||
-     std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end())
-    {
+    mf->GetCMakeInstance()->GetHeaderExtensions();
+  if (!gg->GetLanguageFromExtension(ext.c_str()).empty() ||
+      std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end() ||
+      std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end()) {
     // This is a known extension.  Use the given filename with extension.
     this->Name = cmSystemTools::GetFilenameName(name);
     this->AmbiguousExtension = false;
-    }
-  else
-    {
+  } else {
     // This is not a known extension.  See if the file exists on disk as
     // named.
     std::string tryPath;
-    if(this->AmbiguousDirectory)
-      {
+    if (this->AmbiguousDirectory) {
       // Check the source tree only because a file in the build tree should
       // be specified by full path at least once.  We do not want this
       // detection to depend on whether the project has already been built.
       tryPath = this->Makefile->GetCurrentSourceDirectory();
       tryPath += "/";
-      }
-    if(!this->Directory.empty())
-      {
+    }
+    if (!this->Directory.empty()) {
       tryPath += this->Directory;
       tryPath += "/";
-      }
+    }
     tryPath += this->Name;
-    if(cmSystemTools::FileExists(tryPath.c_str(), true))
-      {
+    if (cmSystemTools::FileExists(tryPath.c_str(), true)) {
       // We found a source file named by the user on disk.  Trust it's
       // extension.
       this->Name = cmSystemTools::GetFilenameName(name);
       this->AmbiguousExtension = false;
 
       // If the directory was ambiguous, it isn't anymore.
-      if(this->AmbiguousDirectory)
-        {
+      if (this->AmbiguousDirectory) {
         this->DirectoryUseSource();
-        }
       }
     }
+  }
 }
 
-bool
-cmSourceFileLocation
-::MatchesAmbiguousExtension(cmSourceFileLocation const& loc) const
+bool cmSourceFileLocation::MatchesAmbiguousExtension(
+  cmSourceFileLocation const& loc) const
 {
   assert(this->Makefile);
   // This location's extension is not ambiguous but loc's extension
   // is.  See if the names match as-is.
-  if(this->Name == loc.Name)
-    {
+  if (this->Name == loc.Name) {
     return true;
-    }
+  }
 
   // Check if loc's name could possibly be extended to our name by
   // adding an extension.
-  if(!(this->Name.size() > loc.Name.size() &&
-       this->Name[loc.Name.size()] == '.' &&
-       cmHasLiteralPrefixImpl(this->Name.c_str(),
-                              loc.Name.c_str(), loc.Name.size())))
-    {
+  if (!(this->Name.size() > loc.Name.size() &&
+        this->Name[loc.Name.size()] == '.' &&
+        cmHasLiteralPrefixImpl(this->Name.c_str(), loc.Name.c_str(),
+                               loc.Name.size()))) {
     return false;
-    }
+  }
 
   // Only a fixed set of extensions will be tried to match a file on
   // disk.  One of these must match if loc refers to this source file.
-  std::string const& ext = this->Name.substr(loc.Name.size()+1);
+  std::string const& ext = this->Name.substr(loc.Name.size() + 1);
   cmMakefile const* mf = this->Makefile;
   const std::vector<std::string>& srcExts =
-      mf->GetCMakeInstance()->GetSourceExtensions();
-  if(std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end())
-    {
+    mf->GetCMakeInstance()->GetSourceExtensions();
+  if (std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end()) {
     return true;
-    }
+  }
   std::vector<std::string> hdrExts =
-      mf->GetCMakeInstance()->GetHeaderExtensions();
-  if(std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end())
-    {
+    mf->GetCMakeInstance()->GetHeaderExtensions();
+  if (std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end()) {
     return true;
-    }
+  }
   return false;
 }
 
 bool cmSourceFileLocation::Matches(cmSourceFileLocation const& loc)
 {
   assert(this->Makefile);
-  if(this->AmbiguousExtension == loc.AmbiguousExtension)
-    {
+  if (this->AmbiguousExtension == loc.AmbiguousExtension) {
     // Both extensions are similarly ambiguous.  Since only the old fixed set
     // of extensions will be tried, the names must match at this point to be
     // the same file.
-    if(this->Name.size() != loc.Name.size() ||
-      !cmSystemTools::ComparePath(this->Name, loc.Name))
-      {
+    if (this->Name.size() != loc.Name.size() ||
+        !cmSystemTools::ComparePath(this->Name, loc.Name)) {
       return false;
-      }
     }
-  else
-    {
+  } else {
     const cmSourceFileLocation* loc1;
     const cmSourceFileLocation* loc2;
-    if(this->AmbiguousExtension)
-      {
+    if (this->AmbiguousExtension) {
       // Only "this" extension is ambiguous.
       loc1 = &loc;
       loc2 = this;
-      }
-    else
-      {
+    } else {
       // Only "loc" extension is ambiguous.
       loc1 = this;
       loc2 = &loc;
-      }
-    if(!loc1->MatchesAmbiguousExtension(*loc2))
-      {
+    }
+    if (!loc1->MatchesAmbiguousExtension(*loc2)) {
       return false;
-      }
     }
+  }
 
-  if(!this->AmbiguousDirectory && !loc.AmbiguousDirectory)
-    {
+  if (!this->AmbiguousDirectory && !loc.AmbiguousDirectory) {
     // Both sides have absolute directories.
-    if(this->Directory != loc.Directory)
-      {
+    if (this->Directory != loc.Directory) {
       return false;
-      }
     }
-  else if(this->AmbiguousDirectory && loc.AmbiguousDirectory)
-    {
-    if (this->Makefile == loc.Makefile)
-      {
+  } else if (this->AmbiguousDirectory && loc.AmbiguousDirectory) {
+    if (this->Makefile == loc.Makefile) {
       // Both sides have directories relative to the same location.
-      if(this->Directory != loc.Directory)
-        {
+      if (this->Directory != loc.Directory) {
         return false;
-        }
       }
-    else
-      {
+    } else {
       // Each side has a directory relative to a different location.
       // This can occur when referencing a source file from a different
       // directory.  This is not yet allowed.
@@ -264,41 +230,28 @@ bool cmSourceFileLocation::Matches(cmSourceFileLocation const& loc)
         cmake::INTERNAL_ERROR,
         "Matches error: Each side has a directory relative to a different "
         "location. This can occur when referencing a source file from a "
-        "different directory.  This is not yet allowed."
-        );
+        "different directory.  This is not yet allowed.");
       return false;
-      }
     }
-  else if(this->AmbiguousDirectory)
-    {
+  } else if (this->AmbiguousDirectory) {
     // Compare possible directory combinations.
-    std::string const& srcDir =
-      cmSystemTools::CollapseFullPath(
-        this->Directory, this->Makefile->GetCurrentSourceDirectory());
-    std::string const& binDir =
-      cmSystemTools::CollapseFullPath(
-        this->Directory, this->Makefile->GetCurrentBinaryDirectory());
-    if(srcDir != loc.Directory &&
-       binDir != loc.Directory)
-      {
+    std::string const& srcDir = cmSystemTools::CollapseFullPath(
+      this->Directory, this->Makefile->GetCurrentSourceDirectory());
+    std::string const& binDir = cmSystemTools::CollapseFullPath(
+      this->Directory, this->Makefile->GetCurrentBinaryDirectory());
+    if (srcDir != loc.Directory && binDir != loc.Directory) {
       return false;
-      }
     }
-  else if(loc.AmbiguousDirectory)
-    {
+  } else if (loc.AmbiguousDirectory) {
     // Compare possible directory combinations.
-    std::string const& srcDir =
-      cmSystemTools::CollapseFullPath(
-        loc.Directory, loc.Makefile->GetCurrentSourceDirectory());
-    std::string const& binDir =
-      cmSystemTools::CollapseFullPath(
-        loc.Directory, loc.Makefile->GetCurrentBinaryDirectory());
-    if(srcDir != this->Directory &&
-       binDir != this->Directory)
-      {
+    std::string const& srcDir = cmSystemTools::CollapseFullPath(
+      loc.Directory, loc.Makefile->GetCurrentSourceDirectory());
+    std::string const& binDir = cmSystemTools::CollapseFullPath(
+      loc.Directory, loc.Makefile->GetCurrentBinaryDirectory());
+    if (srcDir != this->Directory && binDir != this->Directory) {
       return false;
-      }
     }
+  }
 
   // File locations match.
   this->Update(loc);