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, 712 insertions, 1028 deletions

diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index 82220be..88c6d61 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -26,8 +26,8 @@
 // C/C++ scanner is needed for bootstrapping CMake.
 #include "cmDependsC.h"
 #ifdef CMAKE_BUILD_WITH_CMAKE
-# include "cmDependsFortran.h"
-# include "cmDependsJava.h"
+#include "cmDependsFortran.h"
+#include "cmDependsJava.h"
 #endif
 
 #include <cmsys/Terminal.h>
@@ -40,23 +40,31 @@
 class cmMakeSafe
 {
 public:
-  cmMakeSafe(const char* s): Data(s) {}
-  cmMakeSafe(std::string const& s): Data(s.c_str()) {}
+  cmMakeSafe(const char* s)
+    : Data(s)
+  {
+  }
+  cmMakeSafe(std::string const& s)
+    : Data(s.c_str())
+  {
+  }
+
 private:
   const char* Data;
-  friend std::ostream& operator<<(std::ostream& os,
-                                  cmMakeSafe const& self)
-    {
-    for(const char* c = self.Data; *c; ++c)
-      {
-      switch (*c)
-        {
-        case '=': os << "$(EQUALS)"; break;
-        default: os << *c; break;
-        }
+  friend std::ostream& operator<<(std::ostream& os, cmMakeSafe const& self)
+  {
+    for (const char* c = self.Data; *c; ++c) {
+      switch (*c) {
+        case '=':
+          os << "$(EQUALS)";
+          break;
+        default:
+          os << *c;
+          break;
       }
-    return os;
     }
+    return os;
+  }
 };
 
 // Helper function used below.
@@ -64,21 +72,18 @@ static std::string cmSplitExtension(std::string const& in, std::string& base)
 {
   std::string ext;
   std::string::size_type dot_pos = in.rfind(".");
-  if(dot_pos != std::string::npos)
-    {
+  if (dot_pos != std::string::npos) {
     // Remove the extension first in case &base == &in.
     ext = in.substr(dot_pos, std::string::npos);
     base = in.substr(0, dot_pos);
-    }
-  else
-    {
+  } else {
     base = in;
-    }
+  }
   return ext;
 }
 
-cmLocalUnixMakefileGenerator3::
-cmLocalUnixMakefileGenerator3(cmGlobalGenerator* gg, cmMakefile* mf)
+cmLocalUnixMakefileGenerator3::cmLocalUnixMakefileGenerator3(
+  cmGlobalGenerator* gg, cmMakefile* mf)
   : cmLocalCommonGenerator(gg, mf)
 {
   this->MakefileVariableSize = 0;
@@ -99,10 +104,9 @@ void cmLocalUnixMakefileGenerator3::Generate()
 
   // Record whether some options are enabled to avoid checking many
   // times later.
-  if(!this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile())
-    {
+  if (!this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile()) {
     this->ColorMakefile = this->Makefile->IsOn("CMAKE_COLOR_MAKEFILE");
-    }
+  }
   this->SkipPreprocessedSourceRules =
     this->Makefile->IsOn("CMAKE_SKIP_PREPROCESSED_SOURCE_RULES");
   this->SkipAssemblySourceRules =
@@ -112,21 +116,18 @@ void cmLocalUnixMakefileGenerator3::Generate()
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-  for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-      t != targets.end(); ++t)
-    {
-    if ((*t)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+       t != targets.end(); ++t) {
+    if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     cmsys::auto_ptr<cmMakefileTargetGenerator> tg(
       cmMakefileTargetGenerator::New(*t));
-    if (tg.get())
-      {
+    if (tg.get()) {
       tg->WriteRuleFiles();
       gg->RecordTargetProgress(tg.get());
-      }
     }
+  }
 
   // write the local Makefile
   this->WriteLocalMakefile();
@@ -141,44 +142,40 @@ void cmLocalUnixMakefileGenerator3::ComputeHomeRelativeOutputPath()
   // directory from the top output directory.
   this->HomeRelativeOutputPath =
     this->Convert(this->GetCurrentBinaryDirectory(), HOME_OUTPUT);
-  if(this->HomeRelativeOutputPath == ".")
-    {
+  if (this->HomeRelativeOutputPath == ".") {
     this->HomeRelativeOutputPath = "";
-    }
-  if(!this->HomeRelativeOutputPath.empty())
-    {
+  }
+  if (!this->HomeRelativeOutputPath.empty()) {
     this->HomeRelativeOutputPath += "/";
-    }
+  }
 }
 
 void cmLocalUnixMakefileGenerator3::ComputeObjectFilenames(
-                        std::map<cmSourceFile const*, std::string>& mapping,
-                        cmGeneratorTarget const* gt)
+  std::map<cmSourceFile const*, std::string>& mapping,
+  cmGeneratorTarget const* gt)
 {
-  for(std::map<cmSourceFile const*, std::string>::iterator
-      si = mapping.begin(); si != mapping.end(); ++si)
-    {
+  for (std::map<cmSourceFile const*, std::string>::iterator si =
+         mapping.begin();
+       si != mapping.end(); ++si) {
     cmSourceFile const* sf = si->first;
-    si->second = this->GetObjectFileNameWithoutTarget(*sf,
-                                                      gt->ObjectDirectory);
-    }
+    si->second =
+      this->GetObjectFileNameWithoutTarget(*sf, gt->ObjectDirectory);
+  }
 }
 
-void cmLocalUnixMakefileGenerator3::
-GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles)
+void cmLocalUnixMakefileGenerator3::GetLocalObjectFiles(
+  std::map<std::string, LocalObjectInfo>& localObjectFiles)
 {
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
-      ti != targets.end(); ++ti)
-    {
+  for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
+       ti != targets.end(); ++ti) {
     cmGeneratorTarget* gt = *ti;
-    if (gt->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (gt->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     std::vector<cmSourceFile const*> objectSources;
-    gt->GetObjectSources(objectSources, this->Makefile
-                                    ->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+    gt->GetObjectSources(
+      objectSources, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
     // Compute full path to object file directory for this target.
     std::string dir;
     dir += gt->LocalGenerator->GetCurrentBinaryDirectory();
@@ -186,49 +183,42 @@ GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles)
     dir += this->GetTargetDirectory(gt);
     dir += "/";
     // Compute the name of each object file.
-    for(std::vector<cmSourceFile const*>::iterator
-          si = objectSources.begin();
-        si != objectSources.end(); ++si)
-      {
+    for (std::vector<cmSourceFile const*>::iterator si = objectSources.begin();
+         si != objectSources.end(); ++si) {
       cmSourceFile const* sf = *si;
       bool hasSourceExtension = true;
-      std::string objectName = this->GetObjectFileNameWithoutTarget(*sf,
-                                                                    dir,
-                                                        &hasSourceExtension);
-      if(cmSystemTools::FileIsFullPath(objectName.c_str()))
-        {
+      std::string objectName =
+        this->GetObjectFileNameWithoutTarget(*sf, dir, &hasSourceExtension);
+      if (cmSystemTools::FileIsFullPath(objectName.c_str())) {
         objectName = cmSystemTools::GetFilenameName(objectName);
-        }
+      }
       LocalObjectInfo& info = localObjectFiles[objectName];
       info.HasSourceExtension = hasSourceExtension;
       info.push_back(LocalObjectEntry(gt, sf->GetLanguage()));
-      }
     }
+  }
 }
 
-void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets
-                                            (std::vector<std::string>& targets)
+void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets(
+  std::vector<std::string>& targets)
 {
   std::map<std::string, LocalObjectInfo> localObjectFiles;
   this->GetLocalObjectFiles(localObjectFiles);
   for (std::map<std::string, LocalObjectInfo>::iterator lo =
          localObjectFiles.begin();
-       lo != localObjectFiles.end(); ++lo)
-    {
+       lo != localObjectFiles.end(); ++lo) {
     targets.push_back(lo->first);
 
     std::string::size_type dot_pos = lo->first.rfind(".");
     std::string base = lo->first.substr(0, dot_pos);
-    if(lo->second.HasPreprocessRule)
-      {
+    if (lo->second.HasPreprocessRule) {
       targets.push_back(base + ".i");
-      }
+    }
 
-    if(lo->second.HasAssembleRule)
-      {
+    if (lo->second.HasAssembleRule) {
       targets.push_back(base + ".s");
-      }
     }
+  }
 }
 
 void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
@@ -240,15 +230,13 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
   // rules may depend on this file itself.
   std::string ruleFileNameFull = this->ConvertToFullPath(ruleFileName);
   cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str());
-  if(!ruleFileStream)
-    {
+  if (!ruleFileStream) {
     return;
-    }
+  }
   // always write the top makefile
-  if (!this->IsRootMakefile())
-    {
+  if (!this->IsRootMakefile()) {
     ruleFileStream.SetCopyIfDifferent(true);
-    }
+  }
 
   // write the all rules
   this->WriteLocalAllRules(ruleFileStream);
@@ -256,23 +244,18 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
   // only write local targets unless at the top Keep track of targets already
   // listed.
   std::set<std::string> emittedTargets;
-  if (!this->IsRootMakefile())
-    {
+  if (!this->IsRootMakefile()) {
     // write our targets, and while doing it collect up the object
     // file rules
-    this->WriteLocalMakefileTargets(ruleFileStream,emittedTargets);
-    }
-  else
-    {
-    cmGlobalUnixMakefileGenerator3 *gg =
+    this->WriteLocalMakefileTargets(ruleFileStream, emittedTargets);
+  } else {
+    cmGlobalUnixMakefileGenerator3* gg =
       static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-    gg->WriteConvenienceRules(ruleFileStream,emittedTargets);
-    }
+    gg->WriteConvenienceRules(ruleFileStream, emittedTargets);
+  }
 
-  bool do_preprocess_rules =
-    this->GetCreatePreprocessedSourceRules();
-  bool do_assembly_rules =
-    this->GetCreateAssemblySourceRules();
+  bool do_preprocess_rules = this->GetCreatePreprocessedSourceRules();
+  bool do_assembly_rules = this->GetCreateAssemblySourceRules();
 
   std::map<std::string, LocalObjectInfo> localObjectFiles;
   this->GetLocalObjectFiles(localObjectFiles);
@@ -281,8 +264,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
   // for each object file name
   for (std::map<std::string, LocalObjectInfo>::iterator lo =
          localObjectFiles.begin();
-       lo != localObjectFiles.end(); ++lo)
-    {
+       lo != localObjectFiles.end(); ++lo) {
     // Add a convenience rule for building the object file.
     this->WriteObjectConvenienceRule(ruleFileStream,
                                      "target to build an object file",
@@ -293,66 +275,57 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
     bool lang_has_preprocessor = false;
     bool lang_has_assembly = false;
 
-    for(std::vector<LocalObjectEntry>::const_iterator ei =
-          lo->second.begin(); ei != lo->second.end(); ++ei)
-      {
-      if(ei->Language == "C" ||
-         ei->Language == "CXX" ||
-         ei->Language == "Fortran")
-        {
+    for (std::vector<LocalObjectEntry>::const_iterator ei = lo->second.begin();
+         ei != lo->second.end(); ++ei) {
+      if (ei->Language == "C" || ei->Language == "CXX" ||
+          ei->Language == "Fortran") {
         // Right now, C, C++ and Fortran have both a preprocessor and the
         // ability to generate assembly code
         lang_has_preprocessor = true;
         lang_has_assembly = true;
         break;
-        }
       }
+    }
 
     // Add convenience rules for preprocessed and assembly files.
-    if(lang_has_preprocessor && do_preprocess_rules)
-      {
+    if (lang_has_preprocessor && do_preprocess_rules) {
       std::string::size_type dot_pos = lo->first.rfind(".");
       std::string base = lo->first.substr(0, dot_pos);
-      this->WriteObjectConvenienceRule(
-        ruleFileStream, "target to preprocess a source file",
-       (base + ".i").c_str(), lo->second);
+      this->WriteObjectConvenienceRule(ruleFileStream,
+                                       "target to preprocess a source file",
+                                       (base + ".i").c_str(), lo->second);
       lo->second.HasPreprocessRule = true;
-      }
+    }
 
-    if(lang_has_assembly && do_assembly_rules)
-      {
+    if (lang_has_assembly && do_assembly_rules) {
       std::string::size_type dot_pos = lo->first.rfind(".");
       std::string base = lo->first.substr(0, dot_pos);
       this->WriteObjectConvenienceRule(
-       ruleFileStream, "target to generate assembly for a file",
-       (base + ".s").c_str(), lo->second);
+        ruleFileStream, "target to generate assembly for a file",
+        (base + ".s").c_str(), lo->second);
       lo->second.HasAssembleRule = true;
-      }
     }
+  }
 
   // add a help target as long as there isn;t a real target named help
-  if(emittedTargets.insert("help").second)
-    {
-    cmGlobalUnixMakefileGenerator3 *gg =
+  if (emittedTargets.insert("help").second) {
+    cmGlobalUnixMakefileGenerator3* gg =
       static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-    gg->WriteHelpRule(ruleFileStream,this);
-    }
+    gg->WriteHelpRule(ruleFileStream, this);
+  }
 
   this->WriteSpecialTargetsBottom(ruleFileStream);
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::WriteObjectConvenienceRule(std::ostream& ruleFileStream,
-                             const char* comment, const char* output,
-                             LocalObjectInfo const& info)
+void cmLocalUnixMakefileGenerator3::WriteObjectConvenienceRule(
+  std::ostream& ruleFileStream, const char* comment, const char* output,
+  LocalObjectInfo const& info)
 {
   // If the rule includes the source file extension then create a
   // version that has the extension removed.  The help should include
   // only the version without source extension.
   bool inHelp = true;
-  if(info.HasSourceExtension)
-    {
+  if (info.HasSourceExtension) {
     // Remove the last extension.  This should be kept.
     std::string outBase1 = output;
     std::string outExt1 = cmSplitExtension(outBase1, outBase1);
@@ -367,39 +340,34 @@ cmLocalUnixMakefileGenerator3
     std::vector<std::string> depends;
     depends.push_back(output);
     std::vector<std::string> no_commands;
-    this->WriteMakeRule(ruleFileStream, 0,
-                        outNoExt, depends, no_commands, true, true);
+    this->WriteMakeRule(ruleFileStream, 0, outNoExt, depends, no_commands,
+                        true, true);
     inHelp = false;
-    }
+  }
 
   // Recursively make the rule for each target using the object file.
   std::vector<std::string> commands;
-  for(std::vector<LocalObjectEntry>::const_iterator t = info.begin();
-      t != info.end(); ++t)
-    {
-    std::string tgtMakefileName =
-      this->GetRelativeTargetDirectory(t->Target);
+  for (std::vector<LocalObjectEntry>::const_iterator t = info.begin();
+       t != info.end(); ++t) {
+    std::string tgtMakefileName = this->GetRelativeTargetDirectory(t->Target);
     std::string targetName = tgtMakefileName;
     tgtMakefileName += "/build.make";
     targetName += "/";
     targetName += output;
     commands.push_back(
-      this->GetRecursiveMakeCall(tgtMakefileName.c_str(), targetName)
-      );
-    }
-  this->CreateCDCommand(commands,
-                        this->GetBinaryDirectory(),
+      this->GetRecursiveMakeCall(tgtMakefileName.c_str(), targetName));
+  }
+  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                         cmLocalGenerator::START_OUTPUT);
 
   // Write the rule to the makefile.
   std::vector<std::string> no_depends;
-  this->WriteMakeRule(ruleFileStream, comment,
-                      output, no_depends, commands, true, inHelp);
+  this->WriteMakeRule(ruleFileStream, comment, output, no_depends, commands,
+                      true, inHelp);
 }
 
-void cmLocalUnixMakefileGenerator3
-::WriteLocalMakefileTargets(std::ostream& ruleFileStream,
-                            std::set<std::string> &emitted)
+void cmLocalUnixMakefileGenerator3::WriteLocalMakefileTargets(
+  std::ostream& ruleFileStream, std::set<std::string>& emitted)
 {
   std::vector<std::string> depends;
   std::vector<std::string> commands;
@@ -408,16 +376,14 @@ void cmLocalUnixMakefileGenerator3
   // on the target
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
   std::string localName;
-  for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-      t != targets.end(); ++t)
-    {
-    if(((*t)->GetType() == cmState::EXECUTABLE) ||
-       ((*t)->GetType() == cmState::STATIC_LIBRARY) ||
-       ((*t)->GetType() == cmState::SHARED_LIBRARY) ||
-       ((*t)->GetType() == cmState::MODULE_LIBRARY) ||
-       ((*t)->GetType() == cmState::OBJECT_LIBRARY) ||
-       ((*t)->GetType() == cmState::UTILITY))
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+       t != targets.end(); ++t) {
+    if (((*t)->GetType() == cmState::EXECUTABLE) ||
+        ((*t)->GetType() == cmState::STATIC_LIBRARY) ||
+        ((*t)->GetType() == cmState::SHARED_LIBRARY) ||
+        ((*t)->GetType() == cmState::MODULE_LIBRARY) ||
+        ((*t)->GetType() == cmState::OBJECT_LIBRARY) ||
+        ((*t)->GetType() == cmState::UTILITY)) {
       emitted.insert((*t)->GetName());
 
       // for subdirs add a rule to build this specific target by name.
@@ -429,64 +395,57 @@ void cmLocalUnixMakefileGenerator3
       // Build the target for this pass.
       std::string makefile2 = cmake::GetCMakeFilesDirectoryPostSlash();
       makefile2 += "Makefile2";
-      commands.push_back(this->GetRecursiveMakeCall
-                         (makefile2.c_str(),localName));
-      this->CreateCDCommand(commands,
-                            this->GetBinaryDirectory(),
+      commands.push_back(
+        this->GetRecursiveMakeCall(makefile2.c_str(), localName));
+      this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                             cmLocalGenerator::START_OUTPUT);
       this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
                           localName, depends, commands, true);
 
       // Add a target with the canonical name (no prefix, suffix or path).
-      if(localName != (*t)->GetName())
-        {
+      if (localName != (*t)->GetName()) {
         commands.clear();
         depends.push_back(localName);
         this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
                             (*t)->GetName(), depends, commands, true);
-        }
+      }
 
       // Add a fast rule to build the target
-      std::string makefileName =
-                         this->GetRelativeTargetDirectory(*t);
+      std::string makefileName = this->GetRelativeTargetDirectory(*t);
       makefileName += "/build.make";
       // make sure the makefile name is suitable for a makefile
-      std::string makeTargetName =
-        this->GetRelativeTargetDirectory(*t);
+      std::string makeTargetName = this->GetRelativeTargetDirectory(*t);
       makeTargetName += "/build";
       localName = (*t)->GetName();
       localName += "/fast";
       depends.clear();
       commands.clear();
-      commands.push_back(this->GetRecursiveMakeCall
-                         (makefileName.c_str(), makeTargetName));
-      this->CreateCDCommand(commands,
-                            this->GetBinaryDirectory(),
+      commands.push_back(
+        this->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));
+      this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                             cmLocalGenerator::START_OUTPUT);
       this->WriteMakeRule(ruleFileStream, "fast build rule for target.",
                           localName, depends, commands, true);
 
       // Add a local name for the rule to relink the target before
       // installation.
-      if((*t)->NeedRelinkBeforeInstall(this->ConfigName))
-        {
+      if ((*t)->NeedRelinkBeforeInstall(this->ConfigName)) {
         makeTargetName = this->GetRelativeTargetDirectory(*t);
         makeTargetName += "/preinstall";
         localName = (*t)->GetName();
         localName += "/preinstall";
         depends.clear();
         commands.clear();
-        commands.push_back(this->GetRecursiveMakeCall
-                           (makefile2.c_str(), makeTargetName));
-        this->CreateCDCommand(commands,
-                              this->GetBinaryDirectory(),
+        commands.push_back(
+          this->GetRecursiveMakeCall(makefile2.c_str(), makeTargetName));
+        this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                               cmLocalGenerator::START_OUTPUT);
         this->WriteMakeRule(ruleFileStream,
                             "Manual pre-install relink rule for target.",
                             localName, depends, commands, true);
-        }
       }
     }
+  }
 }
 
 void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
@@ -497,10 +456,9 @@ void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
 
   // Open the output file.
   cmGeneratedFileStream infoFileStream(infoFileName.c_str());
-  if(!infoFileStream)
-    {
+  if (!infoFileStream) {
     return;
-    }
+  }
 
   infoFileStream.SetCopyIfDifferent(true);
   // Write the do not edit header.
@@ -520,43 +478,35 @@ void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
   /* clang-format on */
 
   // Tell the dependency scanner to use unix paths if necessary.
-  if(cmSystemTools::GetForceUnixPaths())
-    {
+  if (cmSystemTools::GetForceUnixPaths()) {
     /* clang-format off */
     infoFileStream
       << "# Force unix paths in dependencies.\n"
       << "set(CMAKE_FORCE_UNIX_PATHS 1)\n"
       << "\n";
     /* clang-format on */
-    }
+  }
 
   // Store the include regular expressions for this directory.
-  infoFileStream
-    << "\n"
-    << "# The C and CXX include file regular expressions for "
-    << "this directory.\n";
-  infoFileStream
-    << "set(CMAKE_C_INCLUDE_REGEX_SCAN ";
+  infoFileStream << "\n"
+                 << "# The C and CXX include file regular expressions for "
+                 << "this directory.\n";
+  infoFileStream << "set(CMAKE_C_INCLUDE_REGEX_SCAN ";
   this->WriteCMakeArgument(infoFileStream,
                            this->Makefile->GetIncludeRegularExpression());
-  infoFileStream
-    << ")\n";
-  infoFileStream
-    << "set(CMAKE_C_INCLUDE_REGEX_COMPLAIN ";
+  infoFileStream << ")\n";
+  infoFileStream << "set(CMAKE_C_INCLUDE_REGEX_COMPLAIN ";
   this->WriteCMakeArgument(infoFileStream,
                            this->Makefile->GetComplainRegularExpression());
-  infoFileStream
-    << ")\n";
+  infoFileStream << ")\n";
   infoFileStream
     << "set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})\n";
-  infoFileStream
-    << "set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN "
-    "${CMAKE_C_INCLUDE_REGEX_COMPLAIN})\n";
+  infoFileStream << "set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN "
+                    "${CMAKE_C_INCLUDE_REGEX_COMPLAIN})\n";
 }
 
-std::string
-cmLocalUnixMakefileGenerator3
-::ConvertToFullPath(const std::string& localPath)
+std::string cmLocalUnixMakefileGenerator3::ConvertToFullPath(
+  const std::string& localPath)
 {
   std::string dir = this->GetCurrentBinaryDirectory();
   dir += "/";
@@ -564,156 +514,126 @@ cmLocalUnixMakefileGenerator3
   return dir;
 }
 
-
-const std::string &cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath()
+const std::string& cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath()
 {
   return this->HomeRelativeOutputPath;
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::WriteMakeRule(std::ostream& os,
-                const char* comment,
-                const std::string& target,
-                const std::vector<std::string>& depends,
-                const std::vector<std::string>& commands,
-                bool symbolic,
-                bool in_help)
+void cmLocalUnixMakefileGenerator3::WriteMakeRule(
+  std::ostream& os, const char* comment, const std::string& target,
+  const std::vector<std::string>& depends,
+  const std::vector<std::string>& commands, bool symbolic, bool in_help)
 {
   // Make sure there is a target.
-  if(target.empty())
-    {
+  if (target.empty()) {
     cmSystemTools::Error("No target for WriteMakeRule! called with comment: ",
                          comment);
     return;
-    }
+  }
 
   std::string replace;
 
   // Write the comment describing the rule in the makefile.
-  if(comment)
-    {
+  if (comment) {
     replace = comment;
     std::string::size_type lpos = 0;
     std::string::size_type rpos;
-    while((rpos = replace.find('\n', lpos)) != std::string::npos)
-      {
-      os << "# " << replace.substr(lpos, rpos-lpos) << "\n";
-      lpos = rpos+1;
-      }
-    os << "# " << replace.substr(lpos) << "\n";
+    while ((rpos = replace.find('\n', lpos)) != std::string::npos) {
+      os << "# " << replace.substr(lpos, rpos - lpos) << "\n";
+      lpos = rpos + 1;
     }
+    os << "# " << replace.substr(lpos) << "\n";
+  }
 
   // Construct the left hand side of the rule.
   std::string tgt = this->Convert(target, HOME_OUTPUT, MAKERULE);
 
   const char* space = "";
-  if(tgt.size() == 1)
-    {
+  if (tgt.size() == 1) {
     // Add a space before the ":" to avoid drive letter confusion on
     // Windows.
     space = " ";
-    }
+  }
 
   // Mark the rule as symbolic if requested.
-  if(symbolic)
-    {
-    if(const char* sym =
-       this->Makefile->GetDefinition("CMAKE_MAKE_SYMBOLIC_RULE"))
-      {
+  if (symbolic) {
+    if (const char* sym =
+          this->Makefile->GetDefinition("CMAKE_MAKE_SYMBOLIC_RULE")) {
       os << cmMakeSafe(tgt) << space << ": " << sym << "\n";
-      }
     }
+  }
 
   // Write the rule.
-  if(depends.empty())
-    {
+  if (depends.empty()) {
     // No dependencies.  The commands will always run.
     os << cmMakeSafe(tgt) << space << ":\n";
-    }
-  else
-    {
+  } else {
     // Split dependencies into multiple rule lines.  This allows for
     // very long dependency lists even on older make implementations.
-    for(std::vector<std::string>::const_iterator dep = depends.begin();
-        dep != depends.end(); ++dep)
-      {
+    for (std::vector<std::string>::const_iterator dep = depends.begin();
+         dep != depends.end(); ++dep) {
       replace = *dep;
-      replace = this->Convert(replace,HOME_OUTPUT,MAKERULE);
+      replace = this->Convert(replace, HOME_OUTPUT, MAKERULE);
       os << cmMakeSafe(tgt) << space << ": " << cmMakeSafe(replace) << "\n";
-      }
     }
+  }
 
   // Write the list of commands.
   os << cmWrap("\t", commands, "", "\n") << "\n";
-  if(symbolic && !this->IsWatcomWMake())
-    {
+  if (symbolic && !this->IsWatcomWMake()) {
     os << ".PHONY : " << cmMakeSafe(tgt) << "\n";
-    }
+  }
   os << "\n";
   // Add the output to the local help if requested.
-  if(in_help)
-    {
+  if (in_help) {
     this->LocalHelp.push_back(target);
-    }
+  }
 }
 
-std::string
-cmLocalUnixMakefileGenerator3
-::ConvertShellCommand(std::string const& cmd, RelativeRoot root)
+std::string cmLocalUnixMakefileGenerator3::ConvertShellCommand(
+  std::string const& cmd, RelativeRoot root)
 {
-  if(this->IsWatcomWMake() &&
-     cmSystemTools::FileIsFullPath(cmd.c_str()) &&
-     cmd.find_first_of("( )") != cmd.npos)
-    {
+  if (this->IsWatcomWMake() && cmSystemTools::FileIsFullPath(cmd.c_str()) &&
+      cmd.find_first_of("( )") != cmd.npos) {
     // On Watcom WMake use the windows short path for the command
     // name.  This is needed to avoid funny quoting problems on
     // lines with shell redirection operators.
     std::string scmd;
-    if(cmSystemTools::GetShortPath(cmd, scmd))
-      {
+    if (cmSystemTools::GetShortPath(cmd, scmd)) {
       return this->Convert(scmd, NONE, SHELL);
-      }
     }
+  }
   return this->Convert(cmd, root, SHELL);
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::WriteMakeVariables(std::ostream& makefileStream)
+void cmLocalUnixMakefileGenerator3::WriteMakeVariables(
+  std::ostream& makefileStream)
 {
   this->WriteDivider(makefileStream);
-  makefileStream
-    << "# Set environment variables for the build.\n"
-    << "\n";
+  makefileStream << "# Set environment variables for the build.\n"
+                 << "\n";
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-  if(gg->DefineWindowsNULL)
-    {
-    makefileStream
-      << "!IF \"$(OS)\" == \"Windows_NT\"\n"
-      << "NULL=\n"
-      << "!ELSE\n"
-      << "NULL=nul\n"
-      << "!ENDIF\n";
-    }
-  if(this->IsWindowsShell())
-    {
-     makefileStream
-       << "SHELL = cmd.exe\n"
-       << "\n";
-    }
-  else
-    {
+  if (gg->DefineWindowsNULL) {
+    makefileStream << "!IF \"$(OS)\" == \"Windows_NT\"\n"
+                   << "NULL=\n"
+                   << "!ELSE\n"
+                   << "NULL=nul\n"
+                   << "!ENDIF\n";
+  }
+  if (this->IsWindowsShell()) {
+    makefileStream << "SHELL = cmd.exe\n"
+                   << "\n";
+  } else {
 #if !defined(__VMS)
     /* clang-format off */
       makefileStream
         << "# The shell in which to execute make rules.\n"
         << "SHELL = /bin/sh\n"
         << "\n";
-    /* clang-format on */
+/* clang-format on */
 #endif
-    }
+  }
 
   /* clang-format off */
   makefileStream
@@ -747,14 +667,12 @@ cmLocalUnixMakefileGenerator3
   /* clang-format on */
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::WriteSpecialTargetsTop(std::ostream& makefileStream)
+void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsTop(
+  std::ostream& makefileStream)
 {
   this->WriteDivider(makefileStream);
-  makefileStream
-    << "# Special targets provided by cmake.\n"
-    << "\n";
+  makefileStream << "# Special targets provided by cmake.\n"
+                 << "\n";
 
   std::vector<std::string> no_commands;
   std::vector<std::string> no_depends;
@@ -762,25 +680,23 @@ cmLocalUnixMakefileGenerator3
   // Special target to cleanup operation of make tool.
   // This should be the first target except for the default_target in
   // the interface Makefile.
-  this->WriteMakeRule(
-    makefileStream, "Disable implicit rules so canonical targets will work.",
-    ".SUFFIXES", no_depends, no_commands, false);
+  this->WriteMakeRule(makefileStream,
+                      "Disable implicit rules so canonical targets will work.",
+                      ".SUFFIXES", no_depends, no_commands, false);
 
-  if(!this->IsNMake()
-      && !this->IsWatcomWMake() && !this->BorlandMakeCurlyHack)
-    {
+  if (!this->IsNMake() && !this->IsWatcomWMake() &&
+      !this->BorlandMakeCurlyHack) {
     // turn off RCS and SCCS automatic stuff from gmake
     makefileStream
       << "# Remove some rules from gmake that .SUFFIXES does not remove.\n"
       << "SUFFIXES =\n\n";
-    }
+  }
   // Add a fake suffix to keep HP happy.  Must be max 32 chars for SGI make.
   std::vector<std::string> depends;
   depends.push_back(".hpux_make_needs_suffix_list");
-  this->WriteMakeRule(makefileStream, 0,
-                      ".SUFFIXES", depends, no_commands, false);
-  if(this->IsWatcomWMake())
-    {
+  this->WriteMakeRule(makefileStream, 0, ".SUFFIXES", depends, no_commands,
+                      false);
+  if (this->IsWatcomWMake()) {
     // Switch on WMake feature, if an error or interrupt occurs during
     // makefile processing, the current target being made may be deleted
     // without prompting (the same as command line -e option).
@@ -791,18 +707,16 @@ cmLocalUnixMakefileGenerator3
       "\n"
       ;
     /* clang-format on */
-    }
-  if(this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
-    {
+  }
+  if (this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE")) {
     /* clang-format off */
     makefileStream
       << "# Produce verbose output by default.\n"
       << "VERBOSE = 1\n"
       << "\n";
     /* clang-format on */
-    }
-  if(this->IsWatcomWMake())
-    {
+  }
+  if (this->IsWatcomWMake()) {
     /* clang-format off */
     makefileStream <<
       "!ifndef VERBOSE\n"
@@ -811,9 +725,7 @@ cmLocalUnixMakefileGenerator3
       "\n"
       ;
     /* clang-format on */
-    }
-  else
-    {
+  } else {
     // Write special target to silence make output.  This must be after
     // the default target in case VERBOSE is set (which changes the
     // name).  The setting of CMAKE_VERBOSE_MAKEFILE to ON will cause a
@@ -822,89 +734,73 @@ cmLocalUnixMakefileGenerator3
     // the user.
     this->WriteMakeRule(makefileStream,
                         "Suppress display of executed commands.",
-                        "$(VERBOSE).SILENT",
-                        no_depends,
-                        no_commands, false);
-    }
+                        "$(VERBOSE).SILENT", no_depends, no_commands, false);
+  }
 
   // Work-around for makes that drop rules that have no dependencies
   // or commands.
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
   std::string hack = gg->GetEmptyRuleHackDepends();
-  if(!hack.empty())
-    {
+  if (!hack.empty()) {
     no_depends.push_back(hack);
-    }
+  }
   std::string hack_cmd = gg->GetEmptyRuleHackCommand();
-  if(!hack_cmd.empty())
-    {
+  if (!hack_cmd.empty()) {
     no_commands.push_back(hack_cmd);
-    }
+  }
 
   // Special symbolic target that never exists to force dependers to
   // run their rules.
-  this->WriteMakeRule
-    (makefileStream,
-     "A target that is always out of date.",
-     "cmake_force", no_depends, no_commands, true);
+  this->WriteMakeRule(makefileStream, "A target that is always out of date.",
+                      "cmake_force", no_depends, no_commands, true);
 
   // Variables for reference by other rules.
   this->WriteMakeVariables(makefileStream);
 }
 
-void cmLocalUnixMakefileGenerator3
-::WriteSpecialTargetsBottom(std::ostream& makefileStream)
+void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsBottom(
+  std::ostream& makefileStream)
 {
   this->WriteDivider(makefileStream);
-  makefileStream
-    << "# Special targets to cleanup operation of make.\n"
-    << "\n";
+  makefileStream << "# Special targets to cleanup operation of make.\n"
+                 << "\n";
 
   // Write special "cmake_check_build_system" target to run cmake with
   // the --check-build-system flag.
   {
-  // Build command to run CMake to check if anything needs regenerating.
-  std::string cmakefileName = cmake::GetCMakeFilesDirectoryPostSlash();
-  cmakefileName += "Makefile.cmake";
-  std::string runRule =
-    "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
-  runRule += " --check-build-system ";
-  runRule += this->Convert(cmakefileName,NONE,SHELL);
-  runRule += " 0";
+    // Build command to run CMake to check if anything needs regenerating.
+    std::string cmakefileName = cmake::GetCMakeFilesDirectoryPostSlash();
+    cmakefileName += "Makefile.cmake";
+    std::string runRule =
+      "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
+    runRule += " --check-build-system ";
+    runRule += this->Convert(cmakefileName, NONE, SHELL);
+    runRule += " 0";
 
-  std::vector<std::string> no_depends;
-  std::vector<std::string> commands;
-  commands.push_back(runRule);
-  if(!this->IsRootMakefile())
-    {
-    this->CreateCDCommand(commands,
-                          this->GetBinaryDirectory(),
-                          cmLocalGenerator::START_OUTPUT);
+    std::vector<std::string> no_depends;
+    std::vector<std::string> commands;
+    commands.push_back(runRule);
+    if (!this->IsRootMakefile()) {
+      this->CreateCDCommand(commands, this->GetBinaryDirectory(),
+                            cmLocalGenerator::START_OUTPUT);
     }
-  this->WriteMakeRule(makefileStream,
-                      "Special rule to run CMake to check the build system "
+    this->WriteMakeRule(
+      makefileStream, "Special rule to run CMake to check the build system "
                       "integrity.\n"
                       "No rule that depends on this can have "
                       "commands that come from listfiles\n"
                       "because they might be regenerated.",
-                      "cmake_check_build_system",
-                      no_depends,
-                      commands, true);
+      "cmake_check_build_system", no_depends, commands, true);
   }
 }
 
-
-
-void
-cmLocalUnixMakefileGenerator3
-::WriteConvenienceRule(std::ostream& ruleFileStream,
-                       const std::string& realTarget,
-                       const std::string& helpTarget)
+void cmLocalUnixMakefileGenerator3::WriteConvenienceRule(
+  std::ostream& ruleFileStream, const std::string& realTarget,
+  const std::string& helpTarget)
 {
   // A rule is only needed if the names are different.
-  if(realTarget != helpTarget)
-    {
+  if (realTarget != helpTarget) {
     // The helper target depends on the real target.
     std::vector<std::string> depends;
     depends.push_back(realTarget);
@@ -915,34 +811,28 @@ cmLocalUnixMakefileGenerator3
     // Write the rule.
     this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
                         helpTarget, depends, no_commands, true);
-    }
+  }
 }
 
-
-std::string
-cmLocalUnixMakefileGenerator3
-::GetRelativeTargetDirectory(cmGeneratorTarget* target)
+std::string cmLocalUnixMakefileGenerator3::GetRelativeTargetDirectory(
+  cmGeneratorTarget* target)
 {
   std::string dir = this->HomeRelativeOutputPath;
   dir += this->GetTargetDirectory(target);
-  return this->Convert(dir,NONE,UNCHANGED);
+  return this->Convert(dir, NONE, UNCHANGED);
 }
 
-
-
 void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags,
                                                 const std::string& newFlags)
 {
-  if(this->IsWatcomWMake() && !newFlags.empty())
-    {
+  if (this->IsWatcomWMake() && !newFlags.empty()) {
     std::string newf = newFlags;
-    if(newf.find("\\\"") != newf.npos)
-      {
+    if (newf.find("\\\"") != newf.npos) {
       cmSystemTools::ReplaceString(newf, "\\\"", "\"");
       this->cmLocalGenerator::AppendFlags(flags, newf);
       return;
-      }
     }
+  }
   this->cmLocalGenerator::AppendFlags(flags, newFlags);
 }
 
@@ -952,203 +842,161 @@ void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags,
   this->cmLocalGenerator::AppendFlags(flags, newFlags);
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendRuleDepend(std::vector<std::string>& depends,
-                   const char* ruleFileName)
+void cmLocalUnixMakefileGenerator3::AppendRuleDepend(
+  std::vector<std::string>& depends, const char* ruleFileName)
 {
   // Add a dependency on the rule file itself unless an option to skip
   // it is specifically enabled by the user or project.
   const char* nodep =
     this->Makefile->GetDefinition("CMAKE_SKIP_RULE_DEPENDENCY");
-  if(!nodep || cmSystemTools::IsOff(nodep))
-    {
+  if (!nodep || cmSystemTools::IsOff(nodep)) {
     depends.push_back(ruleFileName);
-    }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendRuleDepends(std::vector<std::string>& depends,
-                    std::vector<std::string> const& ruleFiles)
+void cmLocalUnixMakefileGenerator3::AppendRuleDepends(
+  std::vector<std::string>& depends, std::vector<std::string> const& ruleFiles)
 {
   // Add a dependency on the rule file itself unless an option to skip
   // it is specifically enabled by the user or project.
-  if(!this->Makefile->IsOn("CMAKE_SKIP_RULE_DEPENDENCY"))
-    {
+  if (!this->Makefile->IsOn("CMAKE_SKIP_RULE_DEPENDENCY")) {
     depends.insert(depends.end(), ruleFiles.begin(), ruleFiles.end());
-    }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendCustomDepends(std::vector<std::string>& depends,
-                      const std::vector<cmCustomCommand>& ccs)
+void cmLocalUnixMakefileGenerator3::AppendCustomDepends(
+  std::vector<std::string>& depends, const std::vector<cmCustomCommand>& ccs)
 {
-  for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
-      i != ccs.end(); ++i)
-    {
+  for (std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
+       i != ccs.end(); ++i) {
     cmCustomCommandGenerator ccg(*i, this->ConfigName, this);
     this->AppendCustomDepend(depends, ccg);
-    }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendCustomDepend(std::vector<std::string>& depends,
-                     cmCustomCommandGenerator const& ccg)
+void cmLocalUnixMakefileGenerator3::AppendCustomDepend(
+  std::vector<std::string>& depends, cmCustomCommandGenerator const& ccg)
 {
-  for(std::vector<std::string>::const_iterator d = ccg.GetDepends().begin();
-      d != ccg.GetDepends().end(); ++d)
-    {
+  for (std::vector<std::string>::const_iterator d = ccg.GetDepends().begin();
+       d != ccg.GetDepends().end(); ++d) {
     // Lookup the real name of the dependency in case it is a CMake target.
     std::string dep;
-    if(this->GetRealDependency(*d, this->ConfigName,
-                               dep))
-      {
+    if (this->GetRealDependency(*d, this->ConfigName, dep)) {
       depends.push_back(dep);
-      }
     }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendCustomCommands(std::vector<std::string>& commands,
-                       const std::vector<cmCustomCommand>& ccs,
-                       cmGeneratorTarget* target,
-                       cmLocalGenerator::RelativeRoot relative)
+void cmLocalUnixMakefileGenerator3::AppendCustomCommands(
+  std::vector<std::string>& commands, const std::vector<cmCustomCommand>& ccs,
+  cmGeneratorTarget* target, cmLocalGenerator::RelativeRoot relative)
 {
-  for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
-      i != ccs.end(); ++i)
-    {
+  for (std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
+       i != ccs.end(); ++i) {
     cmCustomCommandGenerator ccg(*i, this->ConfigName, this);
     this->AppendCustomCommand(commands, ccg, target, true, relative);
-    }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendCustomCommand(std::vector<std::string>& commands,
-                      cmCustomCommandGenerator const& ccg,
-                      cmGeneratorTarget* target,
-                      bool echo_comment,
-                      cmLocalGenerator::RelativeRoot relative,
-                      std::ostream* content)
+void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
+  std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg,
+  cmGeneratorTarget* target, bool echo_comment,
+  cmLocalGenerator::RelativeRoot relative, std::ostream* content)
 {
   // Optionally create a command to display the custom command's
   // comment text.  This is used for pre-build, pre-link, and
   // post-build command comments.  Custom build step commands have
   // their comments generated elsewhere.
-  if(echo_comment)
-    {
+  if (echo_comment) {
     const char* comment = ccg.GetComment();
-    if(comment && *comment)
-      {
+    if (comment && *comment) {
       this->AppendEcho(commands, comment,
                        cmLocalUnixMakefileGenerator3::EchoGenerate);
-      }
     }
+  }
 
   // if the command specified a working directory use it.
-  std::string dir  = this->GetCurrentBinaryDirectory();
+  std::string dir = this->GetCurrentBinaryDirectory();
   std::string workingDir = ccg.GetWorkingDirectory();
-  if(!workingDir.empty())
-    {
+  if (!workingDir.empty()) {
     dir = workingDir;
-    }
-  if(content)
-    {
+  }
+  if (content) {
     *content << dir;
-    }
+  }
 
   // Add each command line to the set of commands.
   std::vector<std::string> commands1;
-  for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c)
-    {
+  for (unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c) {
     // Build the command line in a single string.
     std::string cmd = ccg.GetCommand(c);
-    if (!cmd.empty())
-      {
+    if (!cmd.empty()) {
       // Use "call " before any invocations of .bat or .cmd files
       // invoked as custom commands in the WindowsShell.
       //
       bool useCall = false;
 
-      if (this->IsWindowsShell())
-        {
+      if (this->IsWindowsShell()) {
         std::string suffix;
-        if (cmd.size() > 4)
-          {
-          suffix = cmSystemTools::LowerCase(cmd.substr(cmd.size()-4));
-          if (suffix == ".bat" || suffix == ".cmd")
-            {
+        if (cmd.size() > 4) {
+          suffix = cmSystemTools::LowerCase(cmd.substr(cmd.size() - 4));
+          if (suffix == ".bat" || suffix == ".cmd") {
             useCall = true;
-            }
           }
         }
+      }
 
       cmSystemTools::ReplaceString(cmd, "/./", "/");
       // Convert the command to a relative path only if the current
       // working directory will be the start-output directory.
       bool had_slash = cmd.find("/") != cmd.npos;
-      if(workingDir.empty())
-        {
-        cmd = this->Convert(cmd,START_OUTPUT);
-        }
+      if (workingDir.empty()) {
+        cmd = this->Convert(cmd, START_OUTPUT);
+      }
       bool has_slash = cmd.find("/") != cmd.npos;
-      if(had_slash && !has_slash)
-        {
+      if (had_slash && !has_slash) {
         // This command was specified as a path to a file in the
         // current directory.  Add a leading "./" so it can run
         // without the current directory being in the search path.
         cmd = "./" + cmd;
-        }
-      std::string launcher =
-        this->MakeLauncher(ccg, target,
-                           workingDir.empty()? START_OUTPUT : NONE);
+      }
+      std::string launcher = this->MakeLauncher(
+        ccg, target, workingDir.empty() ? START_OUTPUT : NONE);
       cmd = launcher + this->ConvertShellCommand(cmd, NONE);
 
       ccg.AppendArguments(c, cmd);
-      if(content)
-        {
+      if (content) {
         // Rule content does not include the launcher.
-        *content << (cmd.c_str()+launcher.size());
-        }
-      if(this->BorlandMakeCurlyHack)
-        {
+        *content << (cmd.c_str() + launcher.size());
+      }
+      if (this->BorlandMakeCurlyHack) {
         // Borland Make has a very strange bug.  If the first curly
         // brace anywhere in the command string is a left curly, it
         // must be written {{} instead of just {.  Otherwise some
         // curly braces are removed.  The hack can be skipped if the
         // first curly brace is the last character.
         std::string::size_type lcurly = cmd.find("{");
-        if(lcurly != cmd.npos && lcurly < (cmd.size()-1))
-          {
+        if (lcurly != cmd.npos && lcurly < (cmd.size() - 1)) {
           std::string::size_type rcurly = cmd.find("}");
-          if(rcurly == cmd.npos || rcurly > lcurly)
-            {
+          if (rcurly == cmd.npos || rcurly > lcurly) {
             // The first curly is a left curly.  Use the hack.
             std::string hack_cmd = cmd.substr(0, lcurly);
             hack_cmd += "{{}";
-            hack_cmd += cmd.substr(lcurly+1);
+            hack_cmd += cmd.substr(lcurly + 1);
             cmd = hack_cmd;
-            }
           }
         }
-      if (launcher.empty())
-        {
-        if (useCall)
-          {
+      }
+      if (launcher.empty()) {
+        if (useCall) {
           cmd = "call " + cmd;
-          }
-        else if (this->IsNMake() && cmd[0]=='"')
-          {
+        } else if (this->IsNMake() && cmd[0] == '"') {
           cmd = "echo >nul && " + cmd;
-          }
         }
-      commands1.push_back(cmd);
       }
+      commands1.push_back(cmd);
     }
+  }
 
   // Setup the proper working directory for the commands.
   this->CreateCDCommand(commands1, dir.c_str(), relative);
@@ -1157,18 +1005,16 @@ cmLocalUnixMakefileGenerator3
   commands.insert(commands.end(), commands1.begin(), commands1.end());
 }
 
-std::string
-cmLocalUnixMakefileGenerator3::MakeLauncher(
-  cmCustomCommandGenerator const& ccg,
-  cmGeneratorTarget* target, RelativeRoot relative)
+std::string cmLocalUnixMakefileGenerator3::MakeLauncher(
+  cmCustomCommandGenerator const& ccg, cmGeneratorTarget* target,
+  RelativeRoot relative)
 {
   // Short-circuit if there is no launcher.
   const char* prop = "RULE_LAUNCH_CUSTOM";
   const char* val = this->GetRuleLauncher(target, prop);
-  if(!(val && *val))
-    {
+  if (!(val && *val)) {
     return "";
-    }
+  }
 
   // Expand rules in the empty string.  It may insert the launcher and
   // perform replacements.
@@ -1177,65 +1023,56 @@ cmLocalUnixMakefileGenerator3::MakeLauncher(
   vars.CMTarget = target;
   std::string output;
   const std::vector<std::string>& outputs = ccg.GetOutputs();
-  if(!outputs.empty())
-    {
+  if (!outputs.empty()) {
     output = this->Convert(outputs[0], relative, SHELL);
-    }
+  }
   vars.Output = output.c_str();
 
   std::string launcher;
   this->ExpandRuleVariables(launcher, vars);
-  if(!launcher.empty())
-    {
+  if (!launcher.empty()) {
     launcher += " ";
-    }
+  }
   return launcher;
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendCleanCommand(std::vector<std::string>& commands,
-                     const std::vector<std::string>& files,
-                     cmGeneratorTarget* target, const char* filename)
+void cmLocalUnixMakefileGenerator3::AppendCleanCommand(
+  std::vector<std::string>& commands, const std::vector<std::string>& files,
+  cmGeneratorTarget* target, const char* filename)
 {
   std::string cleanfile = this->GetCurrentBinaryDirectory();
   cleanfile += "/";
   cleanfile += this->GetTargetDirectory(target);
   cleanfile += "/cmake_clean";
-  if(filename)
-    {
+  if (filename) {
     cleanfile += "_";
     cleanfile += filename;
-    }
+  }
   cleanfile += ".cmake";
   std::string cleanfilePath = this->Convert(cleanfile, FULL);
   cmsys::ofstream fout(cleanfilePath.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     cmSystemTools::Error("Could not create ", cleanfilePath.c_str());
-    }
-  if(!files.empty())
-    {
+  }
+  if (!files.empty()) {
     fout << "file(REMOVE_RECURSE\n";
-    for(std::vector<std::string>::const_iterator f = files.begin();
-        f != files.end(); ++f)
-      {
-      std::string fc = this->Convert(*f,START_OUTPUT,UNCHANGED);
+    for (std::vector<std::string>::const_iterator f = files.begin();
+         f != files.end(); ++f) {
+      std::string fc = this->Convert(*f, START_OUTPUT, UNCHANGED);
       fout << "  " << cmOutputConverter::EscapeForCMake(fc) << "\n";
-      }
-    fout << ")\n";
     }
+    fout << ")\n";
+  }
   std::string remove = "$(CMAKE_COMMAND) -P ";
   remove += this->Convert(cleanfile, START_OUTPUT, SHELL);
   commands.push_back(remove);
 
   // For the main clean rule add per-language cleaning.
-  if(!filename)
-    {
+  if (!filename) {
     // Get the set of source languages in the target.
     std::set<std::string> languages;
-    target->GetLanguages(languages,
-                      this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+    target->GetLanguages(
+      languages, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
     /* clang-format off */
     fout << "\n"
          << "# Per-language clean rules from dependency scanning.\n"
@@ -1244,23 +1081,19 @@ cmLocalUnixMakefileGenerator3
          << "/cmake_clean_${lang}.cmake OPTIONAL)\n"
          << "endforeach()\n";
     /* clang-format on */
-    }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands,
-                                          std::string const& text,
-                                          EchoColor color,
-                                          EchoProgress const* progress)
+void cmLocalUnixMakefileGenerator3::AppendEcho(
+  std::vector<std::string>& commands, std::string const& text, EchoColor color,
+  EchoProgress const* progress)
 {
   // Choose the color for the text.
   std::string color_name;
-  if(this->GlobalGenerator->GetToolSupportsColor() && this->ColorMakefile)
-    {
+  if (this->GlobalGenerator->GetToolSupportsColor() && this->ColorMakefile) {
     // See cmake::ExecuteEchoColor in cmake.cxx for these options.
     // This color set is readable on both black and white backgrounds.
-    switch(color)
-      {
+    switch (color) {
       case EchoNormal:
         break;
       case EchoDepend:
@@ -1278,47 +1111,39 @@ cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands,
       case EchoGlobal:
         color_name = "--cyan ";
         break;
-      }
     }
+  }
 
   // Echo one line at a time.
   std::string line;
   line.reserve(200);
-  for(const char* c = text.c_str();; ++c)
-    {
-    if(*c == '\n' || *c == '\0')
-      {
+  for (const char* c = text.c_str();; ++c) {
+    if (*c == '\n' || *c == '\0') {
       // Avoid writing a blank last line on end-of-string.
-      if(*c != '\0' || !line.empty())
-        {
+      if (*c != '\0' || !line.empty()) {
         // Add a command to echo this line.
         std::string cmd;
-        if(color_name.empty() && !progress)
-          {
+        if (color_name.empty() && !progress) {
           // Use the native echo command.
           cmd = "@echo ";
           cmd += this->EscapeForShell(line, false, true);
-          }
-        else
-          {
+        } else {
           // Use cmake to echo the text in color.
           cmd = "@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) ";
           cmd += color_name;
-          if (progress)
-            {
+          if (progress) {
             cmd += "--progress-dir=";
-            cmd += this->Convert(progress->Dir,
-                                 cmLocalGenerator::FULL,
+            cmd += this->Convert(progress->Dir, cmLocalGenerator::FULL,
                                  cmLocalGenerator::SHELL);
             cmd += " ";
             cmd += "--progress-num=";
             cmd += progress->Arg;
             cmd += " ";
-            }
-          cmd += this->EscapeForShell(line);
           }
-        commands.push_back(cmd);
+          cmd += this->EscapeForShell(line);
         }
+        commands.push_back(cmd);
+      }
 
       // Reset the line to emtpy.
       line = "";
@@ -1327,22 +1152,18 @@ cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands,
       progress = 0;
 
       // Terminate on end-of-string.
-      if(*c == '\0')
-        {
+      if (*c == '\0') {
         return;
-        }
       }
-    else if(*c != '\r')
-      {
+    } else if (*c != '\r') {
       // Append this character to the current line.
       line += *c;
-      }
     }
+  }
 }
 
-std::string
-cmLocalUnixMakefileGenerator3
-::CreateMakeVariable(const std::string& sin, const std::string& s2in)
+std::string cmLocalUnixMakefileGenerator3::CreateMakeVariable(
+  const std::string& sin, const std::string& s2in)
 {
   std::string s = sin;
   std::string s2 = s2in;
@@ -1351,27 +1172,24 @@ cmLocalUnixMakefileGenerator3
   // if there is no restriction on the length of make variables
   // and there are no "." characters in the string, then return the
   // unmodified combination.
-  if((!this->MakefileVariableSize && unmodified.find('.') == s.npos)
-     && (!this->MakefileVariableSize && unmodified.find('+') == s.npos)
-     && (!this->MakefileVariableSize && unmodified.find('-') == s.npos))
-    {
+  if ((!this->MakefileVariableSize && unmodified.find('.') == s.npos) &&
+      (!this->MakefileVariableSize && unmodified.find('+') == s.npos) &&
+      (!this->MakefileVariableSize && unmodified.find('-') == s.npos)) {
     return unmodified;
-    }
+  }
 
   // see if the variable has been defined before and return
   // the modified version of the variable
   std::map<std::string, std::string>::iterator i =
     this->MakeVariableMap.find(unmodified);
-  if(i != this->MakeVariableMap.end())
-    {
+  if (i != this->MakeVariableMap.end()) {
     return i->second;
-    }
+  }
   // start with the unmodified variable
   std::string ret = unmodified;
   // if this there is no value for this->MakefileVariableSize then
   // the string must have bad characters in it
-  if(!this->MakefileVariableSize)
-    {
+  if (!this->MakefileVariableSize) {
     cmSystemTools::ReplaceString(ret, ".", "_");
     cmSystemTools::ReplaceString(ret, "-", "__");
     cmSystemTools::ReplaceString(ret, "+", "___");
@@ -1379,53 +1197,47 @@ cmLocalUnixMakefileGenerator3
     char buffer[5];
     // make sure the _ version is not already used, if
     // it is used then add number to the end of the variable
-    while(this->ShortMakeVariableMap.count(ret) && ni < 1000)
-      {
+    while (this->ShortMakeVariableMap.count(ret) && ni < 1000) {
       ++ni;
       sprintf(buffer, "%04d", ni);
       ret = unmodified + buffer;
-      }
+    }
     this->ShortMakeVariableMap[ret] = "1";
     this->MakeVariableMap[unmodified] = ret;
     return ret;
-    }
+  }
 
   // if the string is greater than 32 chars it is an invalid variable name
   // for borland make
-  if(static_cast<int>(ret.size()) > this->MakefileVariableSize)
-    {
+  if (static_cast<int>(ret.size()) > this->MakefileVariableSize) {
     int keep = this->MakefileVariableSize - 8;
     int size = keep + 3;
     std::string str1 = s;
     std::string str2 = s2;
     // we must shorten the combined string by 4 characters
     // keep no more than 24 characters from the second string
-    if(static_cast<int>(str2.size()) > keep)
-      {
+    if (static_cast<int>(str2.size()) > keep) {
       str2 = str2.substr(0, keep);
-      }
-    if(static_cast<int>(str1.size()) + static_cast<int>(str2.size()) > size)
-      {
+    }
+    if (static_cast<int>(str1.size()) + static_cast<int>(str2.size()) > size) {
       str1 = str1.substr(0, size - str2.size());
-      }
+    }
     char buffer[5];
     int ni = 0;
     sprintf(buffer, "%04d", ni);
     ret = str1 + str2 + buffer;
-    while(this->ShortMakeVariableMap.count(ret) && ni < 1000)
-      {
+    while (this->ShortMakeVariableMap.count(ret) && ni < 1000) {
       ++ni;
       sprintf(buffer, "%04d", ni);
       ret = str1 + str2 + buffer;
-      }
-    if(ni == 1000)
-      {
+    }
+    if (ni == 1000) {
       cmSystemTools::Error("Borland makefile variable length too long");
       return unmodified;
-      }
+    }
     // once an unused variable is found
     this->ShortMakeVariableMap[ret] = "1";
-    }
+  }
   // always make an entry into the unmodified to variable map
   this->MakeVariableMap[unmodified] = ret;
   return ret;
@@ -1436,11 +1248,10 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
                                                        bool color)
 {
   // read in the target info file
-  if(!this->Makefile->ReadListFile(tgtInfo) ||
-     cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (!this->Makefile->ReadListFile(tgtInfo) ||
+      cmSystemTools::GetErrorOccuredFlag()) {
     cmSystemTools::Error("Target DependInfo.cmake file not found");
-    }
+  }
 
   // Check if any multiple output pairs have a missing file.
   this->CheckMultipleOutputs(verbose);
@@ -1457,19 +1268,16 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
   cmFileTimeComparison* ftc =
     this->GlobalGenerator->GetCMakeInstance()->GetFileComparison();
   {
-  int result;
-  if(!ftc->FileTimeCompare(internalDependFile.c_str(), tgtInfo, &result) ||
-     result < 0)
-    {
-    if(verbose)
-      {
-      std::ostringstream msg;
-      msg << "Dependee \"" << tgtInfo
-          << "\" is newer than depender \""
-          << internalDependFile << "\"." << std::endl;
-      cmSystemTools::Stdout(msg.str().c_str());
+    int result;
+    if (!ftc->FileTimeCompare(internalDependFile.c_str(), tgtInfo, &result) ||
+        result < 0) {
+      if (verbose) {
+        std::ostringstream msg;
+        msg << "Dependee \"" << tgtInfo << "\" is newer than depender \""
+            << internalDependFile << "\"." << std::endl;
+        cmSystemTools::Stdout(msg.str().c_str());
       }
-    needRescanDependInfo = true;
+      needRescanDependInfo = true;
     }
   }
 
@@ -1480,19 +1288,17 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
   dirInfoFile += cmake::GetCMakeFilesDirectory();
   dirInfoFile += "/CMakeDirectoryInformation.cmake";
   {
-  int result;
-  if(!ftc->FileTimeCompare(internalDependFile.c_str(),
-                           dirInfoFile.c_str(), &result) || result < 0)
-    {
-    if(verbose)
-      {
-      std::ostringstream msg;
-      msg << "Dependee \"" << dirInfoFile
-          << "\" is newer than depender \""
-          << internalDependFile << "\"." << std::endl;
-      cmSystemTools::Stdout(msg.str().c_str());
+    int result;
+    if (!ftc->FileTimeCompare(internalDependFile.c_str(), dirInfoFile.c_str(),
+                              &result) ||
+        result < 0) {
+      if (verbose) {
+        std::ostringstream msg;
+        msg << "Dependee \"" << dirInfoFile << "\" is newer than depender \""
+            << internalDependFile << "\"." << std::endl;
+        cmSystemTools::Stdout(msg.str().c_str());
       }
-    needRescanDirInfo = true;
+      needRescanDirInfo = true;
     }
   }
 
@@ -1502,8 +1308,7 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
   // not be considered.
   std::map<std::string, cmDepends::DependencyVector> validDependencies;
   bool needRescanDependencies = false;
-  if (needRescanDirInfo == false)
-    {
+  if (needRescanDirInfo == false) {
     cmDependsC checker;
     checker.SetVerbose(verbose);
     checker.SetFileComparison(ftc);
@@ -1517,34 +1322,30 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
     // dependency vector. This means that in the normal case, when only
     // few or one file have been edited, then also only this one file is
     // actually scanned again, instead of all files for this target.
-    needRescanDependencies = !checker.Check(dependFile.c_str(),
-                                            internalDependFile.c_str(),
-                                            validDependencies);
-    }
+    needRescanDependencies = !checker.Check(
+      dependFile.c_str(), internalDependFile.c_str(), validDependencies);
+  }
 
-  if(needRescanDependInfo || needRescanDirInfo || needRescanDependencies)
-    {
+  if (needRescanDependInfo || needRescanDirInfo || needRescanDependencies) {
     // The dependencies must be regenerated.
     std::string targetName = cmSystemTools::GetFilenameName(dir);
-    targetName = targetName.substr(0, targetName.length()-4);
+    targetName = targetName.substr(0, targetName.length() - 4);
     std::string message = "Scanning dependencies of target ";
     message += targetName;
-    cmSystemTools::MakefileColorEcho(
-      cmsysTerminal_Color_ForegroundMagenta |
-      cmsysTerminal_Color_ForegroundBold,
-      message.c_str(), true, color);
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundMagenta |
+                                       cmsysTerminal_Color_ForegroundBold,
+                                     message.c_str(), true, color);
 
     return this->ScanDependencies(dir.c_str(), validDependencies);
-    }
+  }
 
   // The dependencies are already up-to-date.
   return true;
 }
 
-bool
-cmLocalUnixMakefileGenerator3
-::ScanDependencies(const char* targetDir,
-                 std::map<std::string, cmDepends::DependencyVector>& validDeps)
+bool cmLocalUnixMakefileGenerator3::ScanDependencies(
+  const char* targetDir,
+  std::map<std::string, cmDepends::DependencyVector>& validDeps)
 {
   // Read the directory information file.
   cmMakefile* mf = this->Makefile;
@@ -1552,42 +1353,34 @@ cmLocalUnixMakefileGenerator3
   std::string dirInfoFile = this->GetCurrentBinaryDirectory();
   dirInfoFile += cmake::GetCMakeFilesDirectory();
   dirInfoFile += "/CMakeDirectoryInformation.cmake";
-  if(mf->ReadListFile(dirInfoFile.c_str()) &&
-     !cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (mf->ReadListFile(dirInfoFile.c_str()) &&
+      !cmSystemTools::GetErrorOccuredFlag()) {
     haveDirectoryInfo = true;
-    }
+  }
 
   // Lookup useful directory information.
-  if(haveDirectoryInfo)
-    {
+  if (haveDirectoryInfo) {
     // Test whether we need to force Unix paths.
-    if(const char* force = mf->GetDefinition("CMAKE_FORCE_UNIX_PATHS"))
-      {
-      if(!cmSystemTools::IsOff(force))
-        {
+    if (const char* force = mf->GetDefinition("CMAKE_FORCE_UNIX_PATHS")) {
+      if (!cmSystemTools::IsOff(force)) {
         cmSystemTools::SetForceUnixPaths(true);
-        }
       }
+    }
 
     // Setup relative path top directories.
-    if(const char* relativePathTopSource =
-       mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_SOURCE"))
-      {
-      this->StateSnapshot.GetDirectory()
-            .SetRelativePathTopSource(relativePathTopSource);
-      }
-    if(const char* relativePathTopBinary =
-       mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_BINARY"))
-      {
-      this->StateSnapshot.GetDirectory()
-            .SetRelativePathTopBinary(relativePathTopBinary);
-      }
+    if (const char* relativePathTopSource =
+          mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_SOURCE")) {
+      this->StateSnapshot.GetDirectory().SetRelativePathTopSource(
+        relativePathTopSource);
     }
-  else
-    {
-    cmSystemTools::Error("Directory Information file not found");
+    if (const char* relativePathTopBinary =
+          mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_BINARY")) {
+      this->StateSnapshot.GetDirectory().SetRelativePathTopBinary(
+        relativePathTopBinary);
     }
+  } else {
+    cmSystemTools::Error("Directory Information file not found");
+  }
 
   // create the file stream for the depends file
   std::string dir = targetDir;
@@ -1598,67 +1391,59 @@ cmLocalUnixMakefileGenerator3
   ruleFileNameFull += "/depend.make";
   cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str());
   ruleFileStream.SetCopyIfDifferent(true);
-  if(!ruleFileStream)
-    {
+  if (!ruleFileStream) {
     return false;
-    }
+  }
 
   // Open the cmake dependency tracking file.  This should not be
   // copy-if-different because dependencies are re-scanned when it is
   // older than the DependInfo.cmake.
   std::string internalRuleFileNameFull = dir;
   internalRuleFileNameFull += "/depend.internal";
-  cmGeneratedFileStream
-    internalRuleFileStream(internalRuleFileNameFull.c_str());
-  if(!internalRuleFileStream)
-    {
+  cmGeneratedFileStream internalRuleFileStream(
+    internalRuleFileNameFull.c_str());
+  if (!internalRuleFileStream) {
     return false;
-    }
+  }
 
   this->WriteDisclaimer(ruleFileStream);
   this->WriteDisclaimer(internalRuleFileStream);
 
   // for each language we need to scan, scan it
-  const char *langStr = mf->GetSafeDefinition("CMAKE_DEPENDS_LANGUAGES");
+  const char* langStr = mf->GetSafeDefinition("CMAKE_DEPENDS_LANGUAGES");
   std::vector<std::string> langs;
   cmSystemTools::ExpandListArgument(langStr, langs);
-  for (std::vector<std::string>::iterator li =
-         langs.begin(); li != langs.end(); ++li)
-    {
+  for (std::vector<std::string>::iterator li = langs.begin();
+       li != langs.end(); ++li) {
     // construct the checker
     std::string lang = *li;
 
     // Create the scanner for this language
-    cmDepends *scanner = 0;
-    if(lang == "C" || lang == "CXX" || lang == "RC" || lang == "ASM")
-      {
+    cmDepends* scanner = 0;
+    if (lang == "C" || lang == "CXX" || lang == "RC" || lang == "ASM") {
       // TODO: Handle RC (resource files) dependencies correctly.
       scanner = new cmDependsC(this, targetDir, lang, &validDeps);
-      }
+    }
 #ifdef CMAKE_BUILD_WITH_CMAKE
-    else if(lang == "Fortran")
-      {
+    else if (lang == "Fortran") {
       scanner = new cmDependsFortran(this);
-      }
-    else if(lang == "Java")
-      {
+    } else if (lang == "Java") {
       scanner = new cmDependsJava();
-      }
+    }
 #endif
 
-    if (scanner)
-      {
+    if (scanner) {
       scanner->SetLocalGenerator(this);
-      scanner->SetFileComparison
-        (this->GlobalGenerator->GetCMakeInstance()->GetFileComparison());
+      scanner->SetFileComparison(
+        this->GlobalGenerator->GetCMakeInstance()->GetFileComparison());
       scanner->SetLanguage(lang);
       scanner->SetTargetDirectory(dir.c_str());
       scanner->Write(ruleFileStream, internalRuleFileStream);
 
       // free the scanner for this language
       delete scanner;
-      }
     }
+  }
 
   return true;
 }
@@ -1669,68 +1454,62 @@ void cmLocalUnixMakefileGenerator3::CheckMultipleOutputs(bool verbose)
 
   // Get the string listing the multiple output pairs.
   const char* pairs_string = mf->GetDefinition("CMAKE_MULTIPLE_OUTPUT_PAIRS");
-  if(!pairs_string)
-    {
+  if (!pairs_string) {
     return;
-    }
+  }
 
   // Convert the string to a list and preserve empty entries.
   std::vector<std::string> pairs;
   cmSystemTools::ExpandListArgument(pairs_string, pairs, true);
-  for(std::vector<std::string>::const_iterator i = pairs.begin();
-      i != pairs.end() && (i+1) != pairs.end();)
-    {
+  for (std::vector<std::string>::const_iterator i = pairs.begin();
+       i != pairs.end() && (i + 1) != pairs.end();) {
     const std::string& depender = *i++;
     const std::string& dependee = *i++;
 
     // If the depender is missing then delete the dependee to make
     // sure both will be regenerated.
-    if(cmSystemTools::FileExists(dependee.c_str()) &&
-       !cmSystemTools::FileExists(depender.c_str()))
-      {
-      if(verbose)
-        {
+    if (cmSystemTools::FileExists(dependee.c_str()) &&
+        !cmSystemTools::FileExists(depender.c_str())) {
+      if (verbose) {
         std::ostringstream msg;
         msg << "Deleting primary custom command output \"" << dependee
-            << "\" because another output \""
-            << depender << "\" does not exist." << std::endl;
+            << "\" because another output \"" << depender
+            << "\" does not exist." << std::endl;
         cmSystemTools::Stdout(msg.str().c_str());
-        }
-      cmSystemTools::RemoveFile(dependee);
       }
+      cmSystemTools::RemoveFile(dependee);
     }
+  }
 }
 
-void cmLocalUnixMakefileGenerator3
-::WriteLocalAllRules(std::ostream& ruleFileStream)
+void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
+  std::ostream& ruleFileStream)
 {
   this->WriteDisclaimer(ruleFileStream);
 
   // Write the main entry point target.  This must be the VERY first
   // target so that make with no arguments will run it.
   {
-  // Just depend on the all target to drive the build.
-  std::vector<std::string> depends;
-  std::vector<std::string> no_commands;
-  depends.push_back("all");
+    // Just depend on the all target to drive the build.
+    std::vector<std::string> depends;
+    std::vector<std::string> no_commands;
+    depends.push_back("all");
 
-  // Write the rule.
-  this->WriteMakeRule(ruleFileStream,
-                      "Default target executed when no arguments are "
-                      "given to make.",
-                      "default_target",
-                      depends,
-                      no_commands, true);
-
-  // Help out users that try "gmake target1 target2 -j".
-  cmGlobalUnixMakefileGenerator3* gg =
-    static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-  if(gg->AllowNotParallel())
-    {
-    std::vector<std::string> no_depends;
+    // Write the rule.
     this->WriteMakeRule(ruleFileStream,
-      "Allow only one \"make -f Makefile2\" at a time, but pass parallelism.",
-      ".NOTPARALLEL", no_depends, no_commands, false);
+                        "Default target executed when no arguments are "
+                        "given to make.",
+                        "default_target", depends, no_commands, true);
+
+    // Help out users that try "gmake target1 target2 -j".
+    cmGlobalUnixMakefileGenerator3* gg =
+      static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
+    if (gg->AllowNotParallel()) {
+      std::vector<std::string> no_depends;
+      this->WriteMakeRule(ruleFileStream, "Allow only one \"make -f "
+                                          "Makefile2\" at a time, but pass "
+                                          "parallelism.",
+                          ".NOTPARALLEL", no_depends, no_commands, false);
     }
   }
 
@@ -1739,25 +1518,21 @@ void cmLocalUnixMakefileGenerator3
   // Include the progress variables for the target.
   // Write all global targets
   this->WriteDivider(ruleFileStream);
-  ruleFileStream
-    << "# Targets provided globally by CMake.\n"
-    << "\n";
+  ruleFileStream << "# Targets provided globally by CMake.\n"
+                 << "\n";
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
   std::vector<cmGeneratorTarget*>::iterator glIt;
-  for ( glIt = targets.begin(); glIt != targets.end(); ++ glIt )
-    {
-    if ( (*glIt)->GetType() == cmState::GLOBAL_TARGET )
-      {
-      std::string targetString = "Special rule for the target " +
-          (*glIt)->GetName();
+  for (glIt = targets.begin(); glIt != targets.end(); ++glIt) {
+    if ((*glIt)->GetType() == cmState::GLOBAL_TARGET) {
+      std::string targetString =
+        "Special rule for the target " + (*glIt)->GetName();
       std::vector<std::string> commands;
       std::vector<std::string> depends;
 
       const char* text = (*glIt)->GetProperty("EchoString");
-      if ( !text )
-        {
+      if (!text) {
         text = "Running external command ...";
-        }
+      }
       depends.insert(depends.end(), (*glIt)->GetUtilities().begin(),
                      (*glIt)->GetUtilities().end());
       this->AppendEcho(commands, text,
@@ -1766,43 +1541,33 @@ void cmLocalUnixMakefileGenerator3
       cmGeneratorTarget* gt = *glIt;
 
       // Global targets store their rules in pre- and post-build commands.
-      this->AppendCustomDepends(depends,
-                                gt->GetPreBuildCommands());
-      this->AppendCustomDepends(depends,
-                                gt->GetPostBuildCommands());
-      this->AppendCustomCommands(commands,
-                                 gt->GetPreBuildCommands(),
-                                 gt,
+      this->AppendCustomDepends(depends, gt->GetPreBuildCommands());
+      this->AppendCustomDepends(depends, gt->GetPostBuildCommands());
+      this->AppendCustomCommands(commands, gt->GetPreBuildCommands(), gt,
                                  cmLocalGenerator::START_OUTPUT);
-      this->AppendCustomCommands(commands,
-                                 gt->GetPostBuildCommands(),
-                                 gt,
+      this->AppendCustomCommands(commands, gt->GetPostBuildCommands(), gt,
                                  cmLocalGenerator::START_OUTPUT);
       std::string targetName = gt->GetName();
-      this->WriteMakeRule(ruleFileStream, targetString.c_str(),
-                          targetName, depends, commands, true);
+      this->WriteMakeRule(ruleFileStream, targetString.c_str(), targetName,
+                          depends, commands, true);
 
       // Provide a "/fast" version of the target.
       depends.clear();
-      if((targetName == "install")
-          || (targetName == "install_local")
-          || (targetName == "install_strip"))
-        {
+      if ((targetName == "install") || (targetName == "install_local") ||
+          (targetName == "install_strip")) {
         // Provide a fast install target that does not depend on all
         // but has the same command.
         depends.push_back("preinstall/fast");
-        }
-      else
-        {
+      } else {
         // Just forward to the real target so at least it will work.
         depends.push_back(targetName);
         commands.clear();
-        }
-      targetName += "/fast";
-      this->WriteMakeRule(ruleFileStream, targetString.c_str(),
-                          targetName, depends, commands, true);
       }
+      targetName += "/fast";
+      this->WriteMakeRule(ruleFileStream, targetString.c_str(), targetName,
+                          depends, commands, true);
     }
+  }
 
   std::vector<std::string> depends;
   std::vector<std::string> commands;
@@ -1815,52 +1580,46 @@ void cmLocalUnixMakefileGenerator3
 
   std::string progressDir = this->GetBinaryDirectory();
   progressDir += cmake::GetCMakeFilesDirectory();
-    {
+  {
     std::ostringstream progCmd;
-    progCmd <<
-      "$(CMAKE_COMMAND) -E cmake_progress_start ";
-    progCmd << this->Convert(progressDir,
-                             cmLocalGenerator::FULL,
+    progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
+    progCmd << this->Convert(progressDir, cmLocalGenerator::FULL,
                              cmLocalGenerator::SHELL);
 
     std::string progressFile = cmake::GetCMakeFilesDirectory();
     progressFile += "/progress.marks";
-    std::string progressFileNameFull =
-      this->ConvertToFullPath(progressFile);
-    progCmd << " " << this->Convert(progressFileNameFull,
-                                    cmLocalGenerator::FULL,
-                                    cmLocalGenerator::SHELL);
+    std::string progressFileNameFull = this->ConvertToFullPath(progressFile);
+    progCmd << " "
+            << this->Convert(progressFileNameFull, cmLocalGenerator::FULL,
+                             cmLocalGenerator::SHELL);
     commands.push_back(progCmd.str());
-    }
+  }
   std::string mf2Dir = cmake::GetCMakeFilesDirectoryPostSlash();
   mf2Dir += "Makefile2";
-  commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(),
-                                                recursiveTarget));
-  this->CreateCDCommand(commands,
-                        this->GetBinaryDirectory(),
+  commands.push_back(
+    this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
+  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                         cmLocalGenerator::START_OUTPUT);
-    {
+  {
     std::ostringstream progCmd;
     progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
-    progCmd << this->Convert(progressDir,
-                             cmLocalGenerator::FULL,
+    progCmd << this->Convert(progressDir, cmLocalGenerator::FULL,
                              cmLocalGenerator::SHELL);
     progCmd << " 0";
     commands.push_back(progCmd.str());
-    }
-  this->WriteMakeRule(ruleFileStream, "The main all target", "all",
-                      depends, commands, true);
+  }
+  this->WriteMakeRule(ruleFileStream, "The main all target", "all", depends,
+                      commands, true);
 
   // Write the clean rule.
   recursiveTarget = this->GetCurrentBinaryDirectory();
   recursiveTarget += "/clean";
   commands.clear();
   depends.clear();
-  commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(),
-                                                recursiveTarget));
-  this->CreateCDCommand(commands,
-                                this->GetBinaryDirectory(),
-                                cmLocalGenerator::START_OUTPUT);
+  commands.push_back(
+    this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
+  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
+                        cmLocalGenerator::START_OUTPUT);
   this->WriteMakeRule(ruleFileStream, "The main clean target", "clean",
                       depends, commands, true);
   commands.clear();
@@ -1876,20 +1635,16 @@ void cmLocalUnixMakefileGenerator3
   depends.clear();
   const char* noall =
     this->Makefile->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
-  if(!noall || cmSystemTools::IsOff(noall))
-    {
+  if (!noall || cmSystemTools::IsOff(noall)) {
     // Drive the build before installing.
     depends.push_back("all");
-    }
-  else
-    {
+  } else {
     // At least make sure the build system is up to date.
     depends.push_back("cmake_check_build_system");
-    }
-  commands.push_back
-    (this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
-  this->CreateCDCommand(commands,
-                        this->GetBinaryDirectory(),
+  }
+  commands.push_back(
+    this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
+  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                         cmLocalGenerator::START_OUTPUT);
   this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.",
                       "preinstall", depends, commands, true);
@@ -1905,28 +1660,24 @@ void cmLocalUnixMakefileGenerator3
   std::string runRule =
     "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
   runRule += " --check-build-system ";
-  runRule += this->Convert(cmakefileName,cmLocalGenerator::NONE,
+  runRule += this->Convert(cmakefileName, cmLocalGenerator::NONE,
                            cmLocalGenerator::SHELL);
   runRule += " 1";
   commands.push_back(runRule);
-  this->CreateCDCommand(commands,
-                        this->GetBinaryDirectory(),
+  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                         cmLocalGenerator::START_OUTPUT);
-  this->WriteMakeRule(ruleFileStream, "clear depends",
-                      "depend",
-                      depends, commands, true);
+  this->WriteMakeRule(ruleFileStream, "clear depends", "depend", depends,
+                      commands, true);
 }
 
-
 void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
                                                       bool verbose)
 {
   // Get the list of target files to check
   const char* infoDef = mf->GetDefinition("CMAKE_DEPEND_INFO_FILES");
-  if(!infoDef)
-    {
+  if (!infoDef) {
     return;
-    }
+  }
   std::vector<std::string> files;
   cmSystemTools::ExpandListArgument(infoDef, files);
 
@@ -1934,9 +1685,8 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
   // dependencies for that target.
   cmDepends clearer;
   clearer.SetVerbose(verbose);
-  for(std::vector<std::string>::iterator l = files.begin();
-      l != files.end(); ++l)
-    {
+  for (std::vector<std::string>::iterator l = files.begin(); l != files.end();
+       ++l) {
     std::string dir = cmSystemTools::GetFilenamePath(*l);
 
     // Clear the implicit dependency makefile.
@@ -1947,64 +1697,60 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
     // regeneration.
     std::string internalDependFile = dir + "/depend.internal";
     cmSystemTools::RemoveFile(internalDependFile);
-    }
+  }
 }
 
-
-namespace
+namespace {
+// Helper predicate for removing absolute paths that don't point to the
+// source or binary directory. It is used when CMAKE_DEPENDS_IN_PROJECT_ONLY
+// is set ON, to only consider in-project dependencies during the build.
+class NotInProjectDir
 {
-  // Helper predicate for removing absolute paths that don't point to the
-  // source or binary directory. It is used when CMAKE_DEPENDS_IN_PROJECT_ONLY
-  // is set ON, to only consider in-project dependencies during the build.
-  class NotInProjectDir
+public:
+  // Constructor with the source and binary directory's path
+  NotInProjectDir(const std::string& sourceDir, const std::string& binaryDir)
+    : SourceDir(sourceDir)
+    , BinaryDir(binaryDir)
   {
-  public:
-    // Constructor with the source and binary directory's path
-    NotInProjectDir(const std::string& sourceDir,
-                    const std::string& binaryDir)
-      : SourceDir(sourceDir), BinaryDir(binaryDir) {}
-
-    // Operator evaluating the predicate
-    bool operator()(const std::string& path) const
-      {
-      // Keep all relative paths:
-      if(!cmSystemTools::FileIsFullPath(path))
-        {
-        return false;
-        }
-      // If it's an absolute path, check if it starts with the source
-      // direcotory:
-      return (!(IsInDirectory(SourceDir, path)||
-                IsInDirectory(BinaryDir, path)));
-      }
+  }
 
-  private:
-    // Helper function used by the predicate
-    static bool IsInDirectory(const std::string& baseDir,
-                              const std::string& testDir)
-      {
-      // First check if the test directory "starts with" the base directory:
-      if (testDir.find(baseDir) != 0)
-        {
-        return false;
-        }
-      // If it does, then check that it's either the same string, or that the
-      // next character is a slash:
-      return ((testDir.size() == baseDir.size())||
-              (testDir[baseDir.size()] == '/'));
-      }
+  // Operator evaluating the predicate
+  bool operator()(const std::string& path) const
+  {
+    // Keep all relative paths:
+    if (!cmSystemTools::FileIsFullPath(path)) {
+      return false;
+    }
+    // If it's an absolute path, check if it starts with the source
+    // direcotory:
+    return (
+      !(IsInDirectory(SourceDir, path) || IsInDirectory(BinaryDir, path)));
+  }
 
-    // The path to the source directory
-    std::string SourceDir;
-    // The path to the binary directory
-    std::string BinaryDir;
-  };
-}
+private:
+  // Helper function used by the predicate
+  static bool IsInDirectory(const std::string& baseDir,
+                            const std::string& testDir)
+  {
+    // First check if the test directory "starts with" the base directory:
+    if (testDir.find(baseDir) != 0) {
+      return false;
+    }
+    // If it does, then check that it's either the same string, or that the
+    // next character is a slash:
+    return ((testDir.size() == baseDir.size()) ||
+            (testDir[baseDir.size()] == '/'));
+  }
 
+  // The path to the source directory
+  std::string SourceDir;
+  // The path to the binary directory
+  std::string BinaryDir;
+};
+}
 
-void cmLocalUnixMakefileGenerator3
-::WriteDependLanguageInfo(std::ostream& cmakefileStream,
-                          cmGeneratorTarget* target)
+void cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo(
+  std::ostream& cmakefileStream, cmGeneratorTarget* target)
 {
   ImplicitDependLanguageMap const& implicitLangs =
     this->GetImplicitDepends(target);
@@ -2012,36 +1758,30 @@ void cmLocalUnixMakefileGenerator3
   // list the languages
   cmakefileStream
     << "# The set of languages for which implicit dependencies are needed:\n";
-  cmakefileStream
-    << "set(CMAKE_DEPENDS_LANGUAGES\n";
-  for(ImplicitDependLanguageMap::const_iterator
-        l = implicitLangs.begin(); l != implicitLangs.end(); ++l)
-    {
+  cmakefileStream << "set(CMAKE_DEPENDS_LANGUAGES\n";
+  for (ImplicitDependLanguageMap::const_iterator l = implicitLangs.begin();
+       l != implicitLangs.end(); ++l) {
     cmakefileStream << "  \"" << l->first << "\"\n";
-    }
+  }
   cmakefileStream << "  )\n";
 
   // now list the files for each language
   cmakefileStream
     << "# The set of files for implicit dependencies of each language:\n";
-  for(ImplicitDependLanguageMap::const_iterator
-        l = implicitLangs.begin(); l != implicitLangs.end(); ++l)
-    {
-    cmakefileStream
-      << "set(CMAKE_DEPENDS_CHECK_" << l->first << "\n";
+  for (ImplicitDependLanguageMap::const_iterator l = implicitLangs.begin();
+       l != implicitLangs.end(); ++l) {
+    cmakefileStream << "set(CMAKE_DEPENDS_CHECK_" << l->first << "\n";
     ImplicitDependFileMap const& implicitPairs = l->second;
 
     // for each file pair
-    for(ImplicitDependFileMap::const_iterator pi = implicitPairs.begin();
-        pi != implicitPairs.end(); ++pi)
-      {
-      for(cmDepends::DependencyVector::const_iterator di = pi->second.begin();
-          di != pi->second.end(); ++ di)
-        {
+    for (ImplicitDependFileMap::const_iterator pi = implicitPairs.begin();
+         pi != implicitPairs.end(); ++pi) {
+      for (cmDepends::DependencyVector::const_iterator di = pi->second.begin();
+           di != pi->second.end(); ++di) {
         cmakefileStream << "  \"" << *di << "\" ";
         cmakefileStream << "\"" << pi->first << "\"\n";
-        }
       }
+    }
     cmakefileStream << "  )\n";
 
     // Tell the dependency scanner what compiler is used.
@@ -2049,138 +1789,112 @@ void cmLocalUnixMakefileGenerator3
     cidVar += l->first;
     cidVar += "_COMPILER_ID";
     const char* cid = this->Makefile->GetDefinition(cidVar);
-    if(cid && *cid)
-      {
-      cmakefileStream
-        << "set(CMAKE_" << l->first << "_COMPILER_ID \""
-        << cid << "\")\n";
-      }
+    if (cid && *cid) {
+      cmakefileStream << "set(CMAKE_" << l->first << "_COMPILER_ID \"" << cid
+                      << "\")\n";
+    }
 
     // Build a list of preprocessor definitions for the target.
     std::set<std::string> defines;
-    this->AddCompileDefinitions(defines, target,
-                                this->ConfigName, l->first);
-    if(!defines.empty())
-      {
+    this->AddCompileDefinitions(defines, target, this->ConfigName, l->first);
+    if (!defines.empty()) {
       /* clang-format off */
       cmakefileStream
         << "\n"
         << "# Preprocessor definitions for this target.\n"
         << "set(CMAKE_TARGET_DEFINITIONS_" << l->first << "\n";
       /* clang-format on */
-      for(std::set<std::string>::const_iterator di = defines.begin();
-          di != defines.end(); ++di)
-        {
-        cmakefileStream
-          << "  " << cmOutputConverter::EscapeForCMake(*di) << "\n";
-        }
-      cmakefileStream
-        << "  )\n";
+      for (std::set<std::string>::const_iterator di = defines.begin();
+           di != defines.end(); ++di) {
+        cmakefileStream << "  " << cmOutputConverter::EscapeForCMake(*di)
+                        << "\n";
       }
+      cmakefileStream << "  )\n";
+    }
 
     // Target-specific include directories:
-    cmakefileStream
-      << "\n"
-      << "# The include file search paths:\n";
-    cmakefileStream
-      << "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n";
+    cmakefileStream << "\n"
+                    << "# The include file search paths:\n";
+    cmakefileStream << "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n";
     std::vector<std::string> includes;
 
-
     const std::string& config =
       this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
-    this->GetIncludeDirectories(includes, target,
-                                l->first, config);
-    if(this->Makefile->IsOn("CMAKE_DEPENDS_IN_PROJECT_ONLY"))
-      {
+    this->GetIncludeDirectories(includes, target, l->first, config);
+    if (this->Makefile->IsOn("CMAKE_DEPENDS_IN_PROJECT_ONLY")) {
       const char* sourceDir = this->GetState()->GetSourceDirectory();
       const char* binaryDir = this->GetState()->GetBinaryDirectory();
       std::vector<std::string>::iterator itr =
         std::remove_if(includes.begin(), includes.end(),
                        ::NotInProjectDir(sourceDir, binaryDir));
       includes.erase(itr, includes.end());
-      }
-    for(std::vector<std::string>::iterator i = includes.begin();
-        i != includes.end(); ++i)
-      {
-      cmakefileStream
-        << "  \""
-        << this->Convert(*i, cmLocalGenerator::HOME_OUTPUT)
-        << "\"\n";
-      }
-    cmakefileStream
-      << "  )\n";
     }
+    for (std::vector<std::string>::iterator i = includes.begin();
+         i != includes.end(); ++i) {
+      cmakefileStream << "  \""
+                      << this->Convert(*i, cmLocalGenerator::HOME_OUTPUT)
+                      << "\"\n";
+    }
+    cmakefileStream << "  )\n";
+  }
 
   // Store include transform rule properties.  Write the directory
   // rules first because they may be overridden by later target rules.
   std::vector<std::string> transformRules;
-  if(const char* xform =
-     this->Makefile->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM"))
-    {
+  if (const char* xform =
+        this->Makefile->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) {
     cmSystemTools::ExpandListArgument(xform, transformRules);
-    }
-  if(const char* xform =
-     target->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM"))
-    {
+  }
+  if (const char* xform =
+        target->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) {
     cmSystemTools::ExpandListArgument(xform, transformRules);
+  }
+  if (!transformRules.empty()) {
+    cmakefileStream << "set(CMAKE_INCLUDE_TRANSFORMS\n";
+    for (std::vector<std::string>::const_iterator tri = transformRules.begin();
+         tri != transformRules.end(); ++tri) {
+      cmakefileStream << "  " << cmOutputConverter::EscapeForCMake(*tri)
+                      << "\n";
     }
-  if(!transformRules.empty())
-    {
-    cmakefileStream
-      << "set(CMAKE_INCLUDE_TRANSFORMS\n";
-    for(std::vector<std::string>::const_iterator tri = transformRules.begin();
-        tri != transformRules.end(); ++tri)
-      {
-      cmakefileStream << "  "
-          << cmOutputConverter::EscapeForCMake(*tri) << "\n";
-      }
-    cmakefileStream
-      << "  )\n";
-    }
+    cmakefileStream << "  )\n";
+  }
 }
 
 void cmLocalUnixMakefileGenerator3::WriteDisclaimer(std::ostream& os)
 {
-  os
-    << "# CMAKE generated file: DO NOT EDIT!\n"
-    << "# Generated by \"" << this->GlobalGenerator->GetName() << "\""
-    << " Generator, CMake Version "
-    << cmVersion::GetMajorVersion() << "."
-    << cmVersion::GetMinorVersion() << "\n\n";
+  os << "# CMAKE generated file: DO NOT EDIT!\n"
+     << "# Generated by \"" << this->GlobalGenerator->GetName() << "\""
+     << " Generator, CMake Version " << cmVersion::GetMajorVersion() << "."
+     << cmVersion::GetMinorVersion() << "\n\n";
 }
 
-std::string
-cmLocalUnixMakefileGenerator3
-::GetRecursiveMakeCall(const char *makefile, const std::string& tgt)
+std::string cmLocalUnixMakefileGenerator3::GetRecursiveMakeCall(
+  const char* makefile, const std::string& tgt)
 {
   // Call make on the given file.
   std::string cmd;
   cmd += "$(MAKE) -f ";
-  cmd += this->Convert(makefile,NONE,SHELL);
+  cmd += this->Convert(makefile, NONE, SHELL);
   cmd += " ";
 
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
   // Pass down verbosity level.
-  if(!gg->MakeSilentFlag.empty())
-    {
+  if (!gg->MakeSilentFlag.empty()) {
     cmd += gg->MakeSilentFlag;
     cmd += " ";
-    }
+  }
 
   // Most unix makes will pass the command line flags to make down to
   // sub-invoked makes via an environment variable.  However, some
   // makes do not support that, so you have to pass the flags
   // explicitly.
-  if(gg->PassMakeflags)
-    {
+  if (gg->PassMakeflags) {
     cmd += "-$(MAKEFLAGS) ";
-    }
+  }
 
   // Add the target.
-  if (!tgt.empty())
-    {
+  if (!tgt.empty()) {
     // The make target is always relative to the top of the build tree.
     std::string tgt2 = this->Convert(tgt, HOME_OUTPUT);
 
@@ -2188,53 +1902,43 @@ cmLocalUnixMakefileGenerator3
     cmSystemTools::ConvertToOutputSlashes(tgt2);
 
     // Escape one extra time if the make tool requires it.
-    if(this->MakeCommandEscapeTargetTwice)
-      {
+    if (this->MakeCommandEscapeTargetTwice) {
       tgt2 = this->EscapeForShell(tgt2, true, false);
-      }
+    }
 
     // The target name is now a string that should be passed verbatim
     // on the command line.
     cmd += this->EscapeForShell(tgt2, true, false);
-    }
+  }
   return cmd;
 }
 
 void cmLocalUnixMakefileGenerator3::WriteDivider(std::ostream& os)
 {
-  os
-    << "#======================================"
-    << "=======================================\n";
+  os << "#======================================"
+     << "=======================================\n";
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::WriteCMakeArgument(std::ostream& os, const char* s)
+void cmLocalUnixMakefileGenerator3::WriteCMakeArgument(std::ostream& os,
+                                                       const char* s)
 {
   // Write the given string to the stream with escaping to get it back
   // into CMake through the lexical scanner.
   os << "\"";
-  for(const char* c = s; *c; ++c)
-    {
-    if(*c == '\\')
-      {
+  for (const char* c = s; *c; ++c) {
+    if (*c == '\\') {
       os << "\\\\";
-      }
-    else if(*c == '"')
-      {
+    } else if (*c == '"') {
       os << "\\\"";
-      }
-    else
-      {
+    } else {
       os << *c;
-      }
     }
+  }
   os << "\"";
 }
 
-std::string
-cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p,
-                                                         bool useWatcomQuote)
+std::string cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(
+  const char* p, bool useWatcomQuote)
 {
   // Split the path into its components.
   std::vector<std::string> components;
@@ -2242,78 +1946,65 @@ cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p,
 
   // Open the quoted result.
   std::string result;
-  if(useWatcomQuote)
-    {
+  if (useWatcomQuote) {
 #if defined(_WIN32) && !defined(__CYGWIN__)
     result = "'";
 #else
     result = "\"'";
 #endif
-    }
-  else
-    {
+  } else {
     result = "\"";
-    }
+  }
 
   // Return an empty path if there are no components.
-  if(!components.empty())
-    {
+  if (!components.empty()) {
     // Choose a slash direction and fix root component.
     const char* slash = "/";
 #if defined(_WIN32) && !defined(__CYGWIN__)
-    if(!cmSystemTools::GetForceUnixPaths())
-      {
+    if (!cmSystemTools::GetForceUnixPaths()) {
       slash = "\\";
-      for(std::string::iterator i = components[0].begin();
-          i != components[0].end(); ++i)
-        {
-        if(*i == '/')
-          {
+      for (std::string::iterator i = components[0].begin();
+           i != components[0].end(); ++i) {
+        if (*i == '/') {
           *i = '\\';
-          }
         }
       }
+    }
 #endif
 
     // Begin the quoted result with the root component.
     result += components[0];
 
-    if (components.size() > 1)
-      {
+    if (components.size() > 1) {
       // Now add the rest of the components separated by the proper slash
       // direction for this platform.
-      std::vector<std::string>::const_iterator compEnd
-          = std::remove(components.begin() + 1, components.end() - 1,
-                          std::string());
-      std::vector<std::string>::const_iterator compStart
-          = components.begin() + 1;
+      std::vector<std::string>::const_iterator compEnd = std::remove(
+        components.begin() + 1, components.end() - 1, std::string());
+      std::vector<std::string>::const_iterator compStart =
+        components.begin() + 1;
       result += cmJoin(cmMakeRange(compStart, compEnd), slash);
       // Only the last component can be empty to avoid double slashes.
       result += slash;
       result += components.back();
-      }
     }
+  }
 
   // Close the quoted result.
-  if(useWatcomQuote)
-    {
+  if (useWatcomQuote) {
 #if defined(_WIN32) && !defined(__CYGWIN__)
     result += "'";
 #else
     result += "'\"";
 #endif
-    }
-  else
-    {
+  } else {
     result += "\"";
-    }
+  }
 
   return result;
 }
 
-std::string
-cmLocalUnixMakefileGenerator3
-::GetTargetDirectory(cmGeneratorTarget const* target) const
+std::string cmLocalUnixMakefileGenerator3::GetTargetDirectory(
+  cmGeneratorTarget const* target) const
 {
   std::string dir = cmake::GetCMakeFilesDirectoryPostSlash();
   dir += target->GetName();
@@ -2326,32 +2017,28 @@ cmLocalUnixMakefileGenerator3
 }
 
 cmLocalUnixMakefileGenerator3::ImplicitDependLanguageMap const&
-cmLocalUnixMakefileGenerator3::GetImplicitDepends(
-    const cmGeneratorTarget* tgt)
+cmLocalUnixMakefileGenerator3::GetImplicitDepends(const cmGeneratorTarget* tgt)
 {
   return this->ImplicitDepends[tgt->GetName()];
 }
 
-void
-cmLocalUnixMakefileGenerator3::AddImplicitDepends(const cmGeneratorTarget* tgt,
-                                                  const std::string& lang,
-                                                  const char* obj,
-                                                  const char* src)
+void cmLocalUnixMakefileGenerator3::AddImplicitDepends(
+  const cmGeneratorTarget* tgt, const std::string& lang, const char* obj,
+  const char* src)
 {
   this->ImplicitDepends[tgt->GetName()][lang][obj].push_back(src);
 }
 
-void cmLocalUnixMakefileGenerator3
-::CreateCDCommand(std::vector<std::string>& commands, const char *tgtDir,
-                  cmLocalGenerator::RelativeRoot relRetDir)
+void cmLocalUnixMakefileGenerator3::CreateCDCommand(
+  std::vector<std::string>& commands, const char* tgtDir,
+  cmLocalGenerator::RelativeRoot relRetDir)
 {
   const char* retDir = this->GetRelativeRootPath(relRetDir);
 
   // do we need to cd?
-  if (!strcmp(tgtDir,retDir))
-    {
+  if (!strcmp(tgtDir, retDir)) {
     return;
-    }
+  }
 
   // In a Windows shell we must change drive letter too.  The shell
   // used by NMake and Borland make does not support "cd /d" so this
@@ -2361,29 +2048,26 @@ void cmLocalUnixMakefileGenerator3
 
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-  if(!gg->UnixCD)
-    {
+  if (!gg->UnixCD) {
     // On Windows we must perform each step separately and then change
     // back because the shell keeps the working directory between
     // commands.
     std::string cmd = cd_cmd;
     cmd += this->ConvertToOutputForExisting(tgtDir, relRetDir);
-    commands.insert(commands.begin(),cmd);
+    commands.insert(commands.begin(), cmd);
 
     // Change back to the starting directory.
     cmd = cd_cmd;
     cmd += this->ConvertToOutputForExisting(relRetDir, tgtDir);
     commands.push_back(cmd);
-    }
-  else
-    {
+  } else {
     // On UNIX we must construct a single shell command to change
     // directory and build because make resets the directory between
     // each command.
     std::string outputForExisting =
-                          this->ConvertToOutputForExisting(tgtDir, relRetDir);
+      this->ConvertToOutputForExisting(tgtDir, relRetDir);
     std::string prefix = cd_cmd + outputForExisting + " && ";
     std::transform(commands.begin(), commands.end(), commands.begin(),
                    std::bind1st(std::plus<std::string>(), prefix));
-    }
+  }
 }