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, 77 insertions, 114 deletions

diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx
index 423bf62..8d142c9 100644
--- a/Source/cmFindProgramCommand.cxx
+++ b/Source/cmFindProgramCommand.cxx
@@ -20,15 +20,15 @@
 struct cmFindProgramHelper
 {
   cmFindProgramHelper()
-    {
-#if defined (_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
+  {
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
     // Consider platform-specific extensions.
     this->Extensions.push_back(".com");
     this->Extensions.push_back(".exe");
 #endif
     // Consider original name with no extensions.
     this->Extensions.push_back("");
-    }
+  }
 
   // List of valid extensions.
   std::vector<std::string> Extensions;
@@ -42,47 +42,39 @@ struct cmFindProgramHelper
   // Current full path under consideration.
   std::string TestPath;
 
-  void AddName(std::string const& name)
-    {
-    this->Names.push_back(name);
-    }
+  void AddName(std::string const& name) { this->Names.push_back(name); }
   void SetName(std::string const& name)
-    {
+  {
     this->Names.clear();
     this->AddName(name);
-    }
+  }
   bool CheckDirectory(std::string const& path)
-    {
+  {
     for (std::vector<std::string>::iterator i = this->Names.begin();
-         i != this->Names.end(); ++i)
-      {
-      if (this->CheckDirectoryForName(path, *i))
-        {
+         i != this->Names.end(); ++i) {
+      if (this->CheckDirectoryForName(path, *i)) {
         return true;
-        }
       }
-    return false;
     }
+    return false;
+  }
   bool CheckDirectoryForName(std::string const& path, std::string const& name)
-    {
+  {
     for (std::vector<std::string>::iterator ext = this->Extensions.begin();
-         ext != this->Extensions.end(); ++ext)
-      {
+         ext != this->Extensions.end(); ++ext) {
       this->TestPath = path;
       this->TestPath += name;
-      if (!ext->empty() && cmSystemTools::StringEndsWith(name, ext->c_str()))
-        {
+      if (!ext->empty() && cmSystemTools::StringEndsWith(name, ext->c_str())) {
         continue;
-        }
+      }
       this->TestPath += *ext;
-      if (cmSystemTools::FileExists(this->TestPath, true))
-        {
+      if (cmSystemTools::FileExists(this->TestPath, true)) {
         this->BestPath = cmSystemTools::CollapseFullPath(this->TestPath);
         return true;
-        }
       }
-    return false;
     }
+    return false;
+  }
 };
 
 cmFindProgramCommand::cmFindProgramCommand()
@@ -91,45 +83,39 @@ cmFindProgramCommand::cmFindProgramCommand()
 }
 
 // cmFindProgramCommand
-bool cmFindProgramCommand
-::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
+bool cmFindProgramCommand::InitialPass(std::vector<std::string> const& argsIn,
+                                       cmExecutionStatus&)
 {
   this->VariableDocumentation = "Path to a program.";
   this->CMakePathName = "PROGRAM";
   // call cmFindBase::ParseArguments
-  if(!this->ParseArguments(argsIn))
-    {
+  if (!this->ParseArguments(argsIn)) {
     return false;
-    }
-  if(this->AlreadyInCache)
-    {
+  }
+  if (this->AlreadyInCache) {
     // If the user specifies the entry on the command line without a
     // type we should add the type and docstring but keep the original
     // value.
-    if(this->AlreadyInCacheWithoutMetaInfo)
-      {
+    if (this->AlreadyInCacheWithoutMetaInfo) {
       this->Makefile->AddCacheDefinition(this->VariableName, "",
                                          this->VariableDocumentation.c_str(),
                                          cmState::FILEPATH);
-      }
-    return true;
     }
+    return true;
+  }
 
   std::string result = FindProgram();
-  if(result != "")
-    {
+  if (result != "") {
     // Save the value in the cache
-    this->Makefile->AddCacheDefinition(this->VariableName,
-                                       result.c_str(),
+    this->Makefile->AddCacheDefinition(this->VariableName, result.c_str(),
                                        this->VariableDocumentation.c_str(),
                                        cmState::FILEPATH);
 
     return true;
-    }
-  this->Makefile->AddCacheDefinition(this->VariableName,
-                                 (this->VariableName + "-NOTFOUND").c_str(),
-                                 this->VariableDocumentation.c_str(),
-                                 cmState::FILEPATH);
+  }
+  this->Makefile->AddCacheDefinition(
+    this->VariableName, (this->VariableName + "-NOTFOUND").c_str(),
+    this->VariableDocumentation.c_str(), cmState::FILEPATH);
   return true;
 }
 
@@ -137,32 +123,26 @@ std::string cmFindProgramCommand::FindProgram()
 {
   std::string program = "";
 
-  if(this->SearchAppBundleFirst || this->SearchAppBundleOnly)
-    {
+  if (this->SearchAppBundleFirst || this->SearchAppBundleOnly) {
     program = FindAppBundle();
-    }
-  if(program.empty() && !this->SearchAppBundleOnly)
-    {
+  }
+  if (program.empty() && !this->SearchAppBundleOnly) {
     program = this->FindNormalProgram();
-    }
+  }
 
-  if(program.empty() && this->SearchAppBundleLast)
-    {
+  if (program.empty() && this->SearchAppBundleLast) {
     program = this->FindAppBundle();
-    }
+  }
   return program;
 }
 
 std::string cmFindProgramCommand::FindNormalProgram()
 {
-  if(this->NamesPerDir)
-    {
+  if (this->NamesPerDir) {
     return this->FindNormalProgramNamesPerDir();
-    }
-  else
-    {
+  } else {
     return this->FindNormalProgramDirsPerName();
-    }
+  }
 }
 
 std::string cmFindProgramCommand::FindNormalProgramNamesPerDir()
@@ -170,26 +150,22 @@ std::string cmFindProgramCommand::FindNormalProgramNamesPerDir()
   // Search for all names in each directory.
   cmFindProgramHelper helper;
   for (std::vector<std::string>::const_iterator ni = this->Names.begin();
-       ni != this->Names.end() ; ++ni)
-    {
+       ni != this->Names.end(); ++ni) {
     helper.AddName(*ni);
-    }
+  }
 
   // Check for the names themselves (e.g. absolute paths).
-  if (helper.CheckDirectory(std::string()))
-    {
+  if (helper.CheckDirectory(std::string())) {
     return helper.BestPath;
-    }
+  }
 
   // Search every directory.
-  for (std::vector<std::string>::const_iterator
-         p = this->SearchPaths.begin(); p != this->SearchPaths.end(); ++p)
-    {
-    if(helper.CheckDirectory(*p))
-      {
+  for (std::vector<std::string>::const_iterator p = this->SearchPaths.begin();
+       p != this->SearchPaths.end(); ++p) {
+    if (helper.CheckDirectory(*p)) {
       return helper.BestPath;
-      }
     }
+  }
   // Couldn't find the program.
   return "";
 }
@@ -199,52 +175,44 @@ std::string cmFindProgramCommand::FindNormalProgramDirsPerName()
   // Search the entire path for each name.
   cmFindProgramHelper helper;
   for (std::vector<std::string>::const_iterator ni = this->Names.begin();
-       ni != this->Names.end() ; ++ni)
-    {
+       ni != this->Names.end(); ++ni) {
     // Switch to searching for this name.
     helper.SetName(*ni);
 
     // Check for the name by itself (e.g. an absolute path).
-    if (helper.CheckDirectory(std::string()))
-      {
+    if (helper.CheckDirectory(std::string())) {
       return helper.BestPath;
-      }
+    }
 
     // Search every directory.
-    for (std::vector<std::string>::const_iterator
-           p = this->SearchPaths.begin();
-         p != this->SearchPaths.end(); ++p)
-      {
-      if (helper.CheckDirectory(*p))
-        {
+    for (std::vector<std::string>::const_iterator p =
+           this->SearchPaths.begin();
+         p != this->SearchPaths.end(); ++p) {
+      if (helper.CheckDirectory(*p)) {
         return helper.BestPath;
-        }
       }
     }
+  }
   // Couldn't find the program.
   return "";
 }
 
 std::string cmFindProgramCommand::FindAppBundle()
 {
-  for(std::vector<std::string>::const_iterator name = this->Names.begin();
-      name != this->Names.end() ; ++name)
-    {
+  for (std::vector<std::string>::const_iterator name = this->Names.begin();
+       name != this->Names.end(); ++name) {
 
     std::string appName = *name + std::string(".app");
-    std::string appPath = cmSystemTools::FindDirectory(appName,
-                                                       this->SearchPaths,
-                                                       true);
+    std::string appPath =
+      cmSystemTools::FindDirectory(appName, this->SearchPaths, true);
 
-    if ( !appPath.empty() )
-      {
+    if (!appPath.empty()) {
       std::string executable = GetBundleExecutable(appPath);
-      if (!executable.empty())
-        {
+      if (!executable.empty()) {
         return cmSystemTools::CollapseFullPath(executable);
-        }
       }
     }
+  }
 
   // Couldn't find app bundle
   return "";
@@ -260,45 +228,40 @@ std::string cmFindProgramCommand::GetBundleExecutable(std::string bundlePath)
 
   // Get a CFString of the app bundle path
   // XXX - Is it safe to assume everything is in UTF8?
-  CFStringRef bundlePathCFS =
-    CFStringCreateWithCString(kCFAllocatorDefault ,
-                              bundlePath.c_str(), kCFStringEncodingUTF8 );
+  CFStringRef bundlePathCFS = CFStringCreateWithCString(
+    kCFAllocatorDefault, bundlePath.c_str(), kCFStringEncodingUTF8);
 
   // Make a CFURLRef from the CFString representation of the
   // bundle’s path.
-  CFURLRef bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
-                                                     bundlePathCFS,
-                                                     kCFURLPOSIXPathStyle,
-                                                     true );
+  CFURLRef bundleURL = CFURLCreateWithFileSystemPath(
+    kCFAllocatorDefault, bundlePathCFS, kCFURLPOSIXPathStyle, true);
 
   // Make a bundle instance using the URLRef.
-  CFBundleRef appBundle = CFBundleCreate( kCFAllocatorDefault, bundleURL );
+  CFBundleRef appBundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
 
   // returned executableURL is relative to <appbundle>/Contents/MacOS/
   CFURLRef executableURL = CFBundleCopyExecutableURL(appBundle);
 
-  if (executableURL != NULL)
-    {
+  if (executableURL != NULL) {
     const int MAX_OSX_PATH_SIZE = 1024;
     char buffer[MAX_OSX_PATH_SIZE];
 
     // Convert the CFString to a C string
-    CFStringGetCString( CFURLGetString(executableURL), buffer,
-                        MAX_OSX_PATH_SIZE, kCFStringEncodingUTF8 );
+    CFStringGetCString(CFURLGetString(executableURL), buffer,
+                       MAX_OSX_PATH_SIZE, kCFStringEncodingUTF8);
 
     // And finally to a c++ string
     executable = bundlePath + "/Contents/MacOS/" + std::string(buffer);
     // Only release CFURLRef if it's not null
-    CFRelease( executableURL );
-    }
+    CFRelease(executableURL);
+  }
 
   // Any CF objects returned from functions with "create" or
   // "copy" in their names must be released by us!
-  CFRelease( bundlePathCFS );
-  CFRelease( bundleURL );
-  CFRelease( appBundle );
+  CFRelease(bundlePathCFS);
+  CFRelease(bundleURL);
+  CFRelease(appBundle);
 #endif
 
   return executable;
 }
-