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, 825 insertions, 1193 deletions

diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 2b06d7d..3f4c22f 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -12,7 +12,7 @@
 #if defined(_WIN32) && !defined(__CYGWIN__)
 #include "windows.h" // this must be first to define GetCurrentDirectory
 #if defined(_MSC_VER) && _MSC_VER >= 1800
-# define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
 #endif
 #endif
 
@@ -40,9 +40,9 @@
 #include <cmsys/FStream.hxx>
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# include "cm_jsoncpp_value.h"
-# include "cm_jsoncpp_writer.h"
-# include <cmsys/MD5.h>
+#include "cm_jsoncpp_value.h"
+#include "cm_jsoncpp_writer.h"
+#include <cmsys/MD5.h>
 #endif
 
 #include <stdlib.h> // required for atof
@@ -53,11 +53,10 @@ bool cmTarget::StrictTargetComparison::operator()(cmTarget const* t1,
                                                   cmTarget const* t2) const
 {
   int nameResult = strcmp(t1->GetName().c_str(), t2->GetName().c_str());
-  if (nameResult == 0)
-    {
+  if (nameResult == 0) {
     return strcmp(t1->GetMakefile()->GetCurrentBinaryDirectory(),
                   t2->GetMakefile()->GetCurrentBinaryDirectory()) < 0;
-    }
+  }
   return nameResult < 0;
 }
 
@@ -105,10 +104,9 @@ cmGlobalGenerator::~cmGlobalGenerator()
 bool cmGlobalGenerator::SetGeneratorPlatform(std::string const& p,
                                              cmMakefile* mf)
 {
-  if(p.empty())
-    {
+  if (p.empty()) {
     return true;
-    }
+  }
 
   std::ostringstream e;
   /* clang-format off */
@@ -126,10 +124,9 @@ bool cmGlobalGenerator::SetGeneratorPlatform(std::string const& p,
 bool cmGlobalGenerator::SetGeneratorToolset(std::string const& ts,
                                             cmMakefile* mf)
 {
-  if(ts.empty())
-    {
+  if (ts.empty()) {
     return true;
-    }
+  }
   std::ostringstream e;
   /* clang-format off */
   e <<
@@ -144,99 +141,78 @@ bool cmGlobalGenerator::SetGeneratorToolset(std::string const& ts,
 }
 
 std::string cmGlobalGenerator::SelectMakeProgram(
-                                          const std::string& inMakeProgram,
-                                          const std::string& makeDefault) const
+  const std::string& inMakeProgram, const std::string& makeDefault) const
 {
   std::string makeProgram = inMakeProgram;
-  if(cmSystemTools::IsOff(makeProgram.c_str()))
-    {
+  if (cmSystemTools::IsOff(makeProgram.c_str())) {
     const char* makeProgramCSTR =
       this->CMakeInstance->GetCacheDefinition("CMAKE_MAKE_PROGRAM");
-    if(cmSystemTools::IsOff(makeProgramCSTR))
-      {
+    if (cmSystemTools::IsOff(makeProgramCSTR)) {
       makeProgram = makeDefault;
-      }
-    else
-      {
+    } else {
       makeProgram = makeProgramCSTR;
-      }
-    if(cmSystemTools::IsOff(makeProgram.c_str()) &&
-       !makeProgram.empty())
-      {
+    }
+    if (cmSystemTools::IsOff(makeProgram.c_str()) && !makeProgram.empty()) {
       makeProgram = "CMAKE_MAKE_PROGRAM-NOTFOUND";
-      }
     }
+  }
   return makeProgram;
 }
 
-void cmGlobalGenerator::ResolveLanguageCompiler(const std::string &lang,
-                                                cmMakefile *mf,
+void cmGlobalGenerator::ResolveLanguageCompiler(const std::string& lang,
+                                                cmMakefile* mf,
                                                 bool optional) const
 {
   std::string langComp = "CMAKE_";
   langComp += lang;
   langComp += "_COMPILER";
 
-  if(!mf->GetDefinition(langComp))
-    {
-    if(!optional)
-      {
-      cmSystemTools::Error(langComp.c_str(),
-                           " not set, after EnableLanguage");
-      }
-    return;
+  if (!mf->GetDefinition(langComp)) {
+    if (!optional) {
+      cmSystemTools::Error(langComp.c_str(), " not set, after EnableLanguage");
     }
+    return;
+  }
   const char* name = mf->GetRequiredDefinition(langComp);
   std::string path;
-  if(!cmSystemTools::FileIsFullPath(name))
-    {
+  if (!cmSystemTools::FileIsFullPath(name)) {
     path = cmSystemTools::FindProgram(name);
-    }
-  else
-    {
+  } else {
     path = name;
-    }
-  if((path.empty() || !cmSystemTools::FileExists(path.c_str()))
-      && (optional==false))
-    {
+  }
+  if ((path.empty() || !cmSystemTools::FileExists(path.c_str())) &&
+      (optional == false)) {
     return;
-    }
-  const char* cname = this->GetCMakeInstance()->
-    GetState()->GetInitializedCacheValue(langComp);
+  }
+  const char* cname =
+    this->GetCMakeInstance()->GetState()->GetInitializedCacheValue(langComp);
   std::string changeVars;
-  if(cname && !optional)
-    {
+  if (cname && !optional) {
     std::string cnameString;
-    if(!cmSystemTools::FileIsFullPath(cname))
-      {
+    if (!cmSystemTools::FileIsFullPath(cname)) {
       cnameString = cmSystemTools::FindProgram(cname);
-      }
-    else
-      {
+    } else {
       cnameString = cname;
-      }
+    }
     std::string pathString = path;
     // get rid of potentially multiple slashes:
     cmSystemTools::ConvertToUnixSlashes(cnameString);
     cmSystemTools::ConvertToUnixSlashes(pathString);
-    if (cnameString != pathString)
-      {
+    if (cnameString != pathString) {
       const char* cvars =
         this->GetCMakeInstance()->GetState()->GetGlobalProperty(
           "__CMAKE_DELETE_CACHE_CHANGE_VARS_");
-      if(cvars)
-        {
+      if (cvars) {
         changeVars += cvars;
         changeVars += ";";
-        }
+      }
       changeVars += langComp;
       changeVars += ";";
       changeVars += cname;
       this->GetCMakeInstance()->GetState()->SetGlobalProperty(
-        "__CMAKE_DELETE_CACHE_CHANGE_VARS_",
-        changeVars.c_str());
-      }
+        "__CMAKE_DELETE_CACHE_CHANGE_VARS_", changeVars.c_str());
     }
+  }
 }
 
 void cmGlobalGenerator::AddBuildExportSet(cmExportBuildFileGenerator* gen)
@@ -244,78 +220,70 @@ void cmGlobalGenerator::AddBuildExportSet(cmExportBuildFileGenerator* gen)
   this->BuildExportSets[gen->GetMainExportFileName()] = gen;
 }
 
-void
-cmGlobalGenerator::AddBuildExportExportSet(cmExportBuildFileGenerator* gen)
+void cmGlobalGenerator::AddBuildExportExportSet(
+  cmExportBuildFileGenerator* gen)
 {
   this->BuildExportSets[gen->GetMainExportFileName()] = gen;
   this->BuildExportExportSets[gen->GetMainExportFileName()] = gen;
 }
 
-bool cmGlobalGenerator::GenerateImportFile(const std::string &file)
+bool cmGlobalGenerator::GenerateImportFile(const std::string& file)
 {
-  std::map<std::string, cmExportBuildFileGenerator*>::iterator it
-                                          = this->BuildExportSets.find(file);
-  if (it != this->BuildExportSets.end())
-    {
+  std::map<std::string, cmExportBuildFileGenerator*>::iterator it =
+    this->BuildExportSets.find(file);
+  if (it != this->BuildExportSets.end()) {
     bool result = it->second->GenerateImportFile();
 
-    if (!this->ConfigureDoneCMP0026AndCMP0024)
-      {
+    if (!this->ConfigureDoneCMP0026AndCMP0024) {
       for (std::vector<cmMakefile*>::const_iterator mit =
-           this->Makefiles.begin(); mit != this->Makefiles.end(); ++mit)
-        {
+             this->Makefiles.begin();
+           mit != this->Makefiles.end(); ++mit) {
         (*mit)->RemoveExportBuildFileGeneratorCMP0024(it->second);
-        }
       }
+    }
 
     delete it->second;
     it->second = 0;
     this->BuildExportSets.erase(it);
     return result;
-    }
+  }
   return false;
 }
 
 void cmGlobalGenerator::ForceLinkerLanguages()
 {
-
 }
 
-bool
-cmGlobalGenerator::IsExportedTargetsFile(const std::string &filename) const
+bool cmGlobalGenerator::IsExportedTargetsFile(
+  const std::string& filename) const
 {
-  const std::map<std::string, cmExportBuildFileGenerator*>::const_iterator it
-                                      = this->BuildExportSets.find(filename);
-  if (it == this->BuildExportSets.end())
-    {
+  const std::map<std::string, cmExportBuildFileGenerator*>::const_iterator it =
+    this->BuildExportSets.find(filename);
+  if (it == this->BuildExportSets.end()) {
     return false;
-    }
-  return this->BuildExportExportSets.find(filename)
-                                        == this->BuildExportExportSets.end();
+  }
+  return this->BuildExportExportSets.find(filename) ==
+    this->BuildExportExportSets.end();
 }
 
 // Find the make program for the generator, required for try compiles
 void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
 {
-  if(this->FindMakeProgramFile.empty())
-    {
+  if (this->FindMakeProgramFile.empty()) {
     cmSystemTools::Error(
       "Generator implementation error, "
       "all generators must specify this->FindMakeProgramFile");
-    }
-  if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM")
-     || cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
-    {
+  }
+  if (!mf->GetDefinition("CMAKE_MAKE_PROGRAM") ||
+      cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
     std::string setMakeProgram =
       mf->GetModulesFile(this->FindMakeProgramFile.c_str());
-    if(!setMakeProgram.empty())
-      {
+    if (!setMakeProgram.empty()) {
       mf->ReadListFile(setMakeProgram.c_str());
-      }
     }
-  if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM")
-     || cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
-    {
+  }
+  if (!mf->GetDefinition("CMAKE_MAKE_PROGRAM") ||
+      cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
     std::ostringstream err;
     err << "CMake was unable to find a build program corresponding to \""
         << this->GetName() << "\".  CMAKE_MAKE_PROGRAM is not set.  You "
@@ -323,28 +291,24 @@ void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
     cmSystemTools::Error(err.str().c_str());
     cmSystemTools::SetFatalErrorOccured();
     return;
-    }
+  }
   std::string makeProgram = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
   // if there are spaces in the make program use short path
   // but do not short path the actual program name, as
   // this can cause trouble with VSExpress
-  if(makeProgram.find(' ') != makeProgram.npos)
-    {
+  if (makeProgram.find(' ') != makeProgram.npos) {
     std::string dir;
     std::string file;
-    cmSystemTools::SplitProgramPath(makeProgram,
-                                    dir, file);
+    cmSystemTools::SplitProgramPath(makeProgram, dir, file);
     std::string saveFile = file;
     cmSystemTools::GetShortPath(makeProgram, makeProgram);
-    cmSystemTools::SplitProgramPath(makeProgram,
-                                    dir, file);
+    cmSystemTools::SplitProgramPath(makeProgram, dir, file);
     makeProgram = dir;
     makeProgram += "/";
     makeProgram += saveFile;
     mf->AddCacheDefinition("CMAKE_MAKE_PROGRAM", makeProgram.c_str(),
-                           "make program",
-                           cmState::FILEPATH);
-    }
+                           "make program", cmState::FILEPATH);
+  }
 }
 
 // enable the given language
@@ -392,58 +356,48 @@ void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
 //
 //
 
-void
-cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
-                                  cmMakefile *mf, bool optional)
+void cmGlobalGenerator::EnableLanguage(
+  std::vector<std::string> const& languages, cmMakefile* mf, bool optional)
 {
-  if(languages.empty())
-    {
+  if (languages.empty()) {
     cmSystemTools::Error("EnableLanguage must have a lang specified!");
     cmSystemTools::SetFatalErrorOccured();
     return;
-    }
+  }
 
   std::set<std::string> cur_languages(languages.begin(), languages.end());
   for (std::set<std::string>::iterator li = cur_languages.begin();
-       li != cur_languages.end(); ++li)
-    {
-    if (!this->LanguagesInProgress.insert(*li).second)
-      {
+       li != cur_languages.end(); ++li) {
+    if (!this->LanguagesInProgress.insert(*li).second) {
       std::ostringstream e;
       e << "Language '" << *li << "' is currently being enabled.  "
-        "Recursive call not allowed.";
+                                  "Recursive call not allowed.";
       mf->IssueMessage(cmake::FATAL_ERROR, e.str());
       cmSystemTools::SetFatalErrorOccured();
       return;
-      }
     }
+  }
 
-  if(this->TryCompileOuterMakefile)
-    {
+  if (this->TryCompileOuterMakefile) {
     // In a try-compile we can only enable languages provided by caller.
-    for(std::vector<std::string>::const_iterator li = languages.begin();
-        li != languages.end(); ++li)
-      {
-      if(*li == "NONE")
-        {
+    for (std::vector<std::string>::const_iterator li = languages.begin();
+         li != languages.end(); ++li) {
+      if (*li == "NONE") {
         this->SetLanguageEnabled("NONE", mf);
-        }
-      else
-        {
+      } else {
         const char* lang = li->c_str();
-        if(this->LanguagesReady.find(lang) == this->LanguagesReady.end())
-          {
+        if (this->LanguagesReady.find(lang) == this->LanguagesReady.end()) {
           std::ostringstream e;
-          e << "The test project needs language "
-            << lang << " which is not enabled.";
-          this->TryCompileOuterMakefile
-            ->IssueMessage(cmake::FATAL_ERROR, e.str());
+          e << "The test project needs language " << lang
+            << " which is not enabled.";
+          this->TryCompileOuterMakefile->IssueMessage(cmake::FATAL_ERROR,
+                                                      e.str());
           cmSystemTools::SetFatalErrorOccured();
           return;
-          }
         }
       }
     }
+  }
 
   bool fatalError = false;
 
@@ -454,15 +408,14 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
   // If the configuration files path has been set,
   // then we are in a try compile and need to copy the enable language
   // files from the parent cmake bin dir, into the try compile bin dir
-  if(!this->ConfiguredFilesPath.empty())
-    {
+  if (!this->ConfiguredFilesPath.empty()) {
     rootBin = this->ConfiguredFilesPath;
-    }
+  }
   rootBin += "/";
   rootBin += cmVersion::GetCMakeVersion();
 
   // set the dir for parent files so they can be used by modules
-  mf->AddDefinition("CMAKE_PLATFORM_INFO_DIR",rootBin.c_str());
+  mf->AddDefinition("CMAKE_PLATFORM_INFO_DIR", rootBin.c_str());
 
   // find and make sure CMAKE_MAKE_PROGRAM is defined
   this->FindMakeProgram(mf);
@@ -470,18 +423,15 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
   // try and load the CMakeSystem.cmake if it is there
   std::string fpath = rootBin;
   bool const readCMakeSystem = !mf->GetDefinition("CMAKE_SYSTEM_LOADED");
-  if(readCMakeSystem)
-    {
+  if (readCMakeSystem) {
     fpath += "/CMakeSystem.cmake";
-    if(cmSystemTools::FileExists(fpath.c_str()))
-      {
+    if (cmSystemTools::FileExists(fpath.c_str())) {
       mf->ReadListFile(fpath.c_str());
-      }
     }
+  }
   //  Load the CMakeDetermineSystem.cmake file and find out
   // what platform we are running on
-  if (!mf->GetDefinition("CMAKE_SYSTEM"))
-    {
+  if (!mf->GetDefinition("CMAKE_SYSTEM")) {
 #if defined(_WIN32) && !defined(__CYGWIN__)
     /* Windows version number data.  */
     OSVERSIONINFOEXW osviex;
@@ -489,12 +439,12 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
     osviex.dwOSVersionInfoSize = sizeof(osviex);
 
 #ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-# pragma warning (push)
-# pragma warning (disable:4996)
+#pragma warning(push)
+#pragma warning(disable : 4996)
 #endif
     GetVersionExW((OSVERSIONINFOW*)&osviex);
 #ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-# pragma warning (pop)
+#pragma warning(pop)
 #endif
     std::ostringstream windowsVersionString;
     windowsVersionString << osviex.dwMajorVersion << "."
@@ -512,45 +462,39 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
     fpath = rootBin;
     fpath += "/CMakeSystem.cmake";
     mf->ReadListFile(fpath.c_str());
-    }
+  }
 
-  if(readCMakeSystem)
-    {
+  if (readCMakeSystem) {
     // Tell the generator about the target system.
     std::string system = mf->GetSafeDefinition("CMAKE_SYSTEM_NAME");
-    if(!this->SetSystemName(system, mf))
-      {
+    if (!this->SetSystemName(system, mf)) {
       cmSystemTools::SetFatalErrorOccured();
       return;
-      }
+    }
 
     // Tell the generator about the platform, if any.
     std::string platform = mf->GetSafeDefinition("CMAKE_GENERATOR_PLATFORM");
-    if(!this->SetGeneratorPlatform(platform, mf))
-      {
+    if (!this->SetGeneratorPlatform(platform, mf)) {
       cmSystemTools::SetFatalErrorOccured();
       return;
-      }
+    }
 
     // Tell the generator about the toolset, if any.
     std::string toolset = mf->GetSafeDefinition("CMAKE_GENERATOR_TOOLSET");
-    if(!this->SetGeneratorToolset(toolset, mf))
-      {
+    if (!this->SetGeneratorToolset(toolset, mf)) {
       cmSystemTools::SetFatalErrorOccured();
       return;
-      }
     }
+  }
 
   // **** Load the system specific initialization if not yet loaded
-  if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INITIALIZE_LOADED"))
-    {
+  if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INITIALIZE_LOADED")) {
     fpath = mf->GetModulesFile("CMakeSystemSpecificInitialize.cmake");
-    if(!mf->ReadListFile(fpath.c_str()))
-      {
+    if (!mf->ReadListFile(fpath.c_str())) {
       cmSystemTools::Error("Could not find cmake module file: "
                            "CMakeSystemSpecificInitialize.cmake");
-      }
     }
+  }
 
   std::map<std::string, bool> needTestLanguage;
   std::map<std::string, bool> needSetLanguageEnabledMaps;
@@ -558,21 +502,18 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
   // load the CMakeDetermine(LANG)Compiler.cmake file to find
   // the compiler
 
-  for(std::vector<std::string>::const_iterator l = languages.begin();
-      l != languages.end(); ++l)
-    {
+  for (std::vector<std::string>::const_iterator l = languages.begin();
+       l != languages.end(); ++l) {
     const char* lang = l->c_str();
     needSetLanguageEnabledMaps[lang] = false;
-    if(*l == "NONE")
-      {
+    if (*l == "NONE") {
       this->SetLanguageEnabled("NONE", mf);
       continue;
-      }
+    }
     std::string loadedLang = "CMAKE_";
-    loadedLang +=  lang;
+    loadedLang += lang;
     loadedLang += "_COMPILER_LOADED";
-    if(!mf->GetDefinition(loadedLang))
-      {
+    if (!mf->GetDefinition(loadedLang)) {
       fpath = rootBin;
       fpath += "/CMake";
       fpath += lang;
@@ -581,31 +522,27 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
       // If the existing build tree was already configured with this
       // version of CMake then try to load the configured file first
       // to avoid duplicate compiler tests.
-      if(cmSystemTools::FileExists(fpath.c_str()))
-        {
-        if(!mf->ReadListFile(fpath.c_str()))
-          {
+      if (cmSystemTools::FileExists(fpath.c_str())) {
+        if (!mf->ReadListFile(fpath.c_str())) {
           cmSystemTools::Error("Could not find cmake module file: ",
                                fpath.c_str());
-          }
+        }
         // if this file was found then the language was already determined
         // to be working
         needTestLanguage[lang] = false;
         this->SetLanguageEnabledFlag(lang, mf);
         needSetLanguageEnabledMaps[lang] = true;
         // this can only be called after loading CMake(LANG)Compiler.cmake
-        }
       }
+    }
 
-    if(!this->GetLanguageEnabled(lang) )
-      {
-      if (this->CMakeInstance->GetIsInTryCompile())
-        {
+    if (!this->GetLanguageEnabled(lang)) {
+      if (this->CMakeInstance->GetIsInTryCompile()) {
         cmSystemTools::Error("This should not have happened. "
                              "If you see this message, you are probably "
                              "using a broken CMakeLists.txt file or a "
                              "problematic release of CMake");
-        }
+      }
       // if the CMake(LANG)Compiler.cmake file was not found then
       // load CMakeDetermine(LANG)Compiler.cmake
       std::string determineCompiler = "CMakeDetermine";
@@ -613,20 +550,17 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
       determineCompiler += "Compiler.cmake";
       std::string determineFile =
         mf->GetModulesFile(determineCompiler.c_str());
-      if(!mf->ReadListFile(determineFile.c_str()))
-        {
+      if (!mf->ReadListFile(determineFile.c_str())) {
         cmSystemTools::Error("Could not find cmake module file: ",
                              determineCompiler.c_str());
-        }
-      if (cmSystemTools::GetFatalErrorOccured())
-        {
+      }
+      if (cmSystemTools::GetFatalErrorOccured()) {
         return;
-        }
+      }
       needTestLanguage[lang] = true;
       // Some generators like visual studio should not use the env variables
       // So the global generator can specify that in this variable
-      if(!mf->GetDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV"))
-        {
+      if (!mf->GetDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV")) {
         // put ${CMake_(LANG)_COMPILER_ENV_VAR}=${CMAKE_(LANG)_COMPILER
         // into the environment, in case user scripts want to run
         // configure, or sub cmakes
@@ -637,13 +571,12 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
         compilerEnv += lang;
         compilerEnv += "_COMPILER_ENV_VAR";
         std::string envVar = mf->GetRequiredDefinition(compilerEnv);
-        std::string envVarValue =
-          mf->GetRequiredDefinition(compilerName);
+        std::string envVarValue = mf->GetRequiredDefinition(compilerName);
         std::string env = envVar;
         env += "=";
         env += envVarValue;
         cmSystemTools::PutEnv(env);
-        }
+      }
 
       // if determineLanguage was called then load the file it
       // configures CMake(LANG)Compiler.cmake
@@ -651,11 +584,10 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
       fpath += "/CMake";
       fpath += lang;
       fpath += "Compiler.cmake";
-      if(!mf->ReadListFile(fpath.c_str()))
-        {
+      if (!mf->ReadListFile(fpath.c_str())) {
         cmSystemTools::Error("Could not find cmake module file: ",
                              fpath.c_str());
-        }
+      }
       this->SetLanguageEnabledFlag(lang, mf);
       needSetLanguageEnabledMaps[lang] = true;
       // this can only be called after loading CMake(LANG)Compiler.cmake
@@ -663,30 +595,26 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
       // not know if it is a working compiler yet so set the test language
       // flag
       needTestLanguage[lang] = true;
-      } // end if(!this->GetLanguageEnabled(lang) )
-    }  // end loop over languages
+    } // end if(!this->GetLanguageEnabled(lang) )
+  }   // end loop over languages
 
   // **** Load the system specific information if not yet loaded
-  if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INFORMATION_LOADED"))
-    {
+  if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INFORMATION_LOADED")) {
     fpath = mf->GetModulesFile("CMakeSystemSpecificInformation.cmake");
-    if(!mf->ReadListFile(fpath.c_str()))
-      {
+    if (!mf->ReadListFile(fpath.c_str())) {
       cmSystemTools::Error("Could not find cmake module file: "
                            "CMakeSystemSpecificInformation.cmake");
-      }
     }
+  }
   // loop over languages again loading CMake(LANG)Information.cmake
   //
-  for(std::vector<std::string>::const_iterator l = languages.begin();
-      l != languages.end(); ++l)
-    {
+  for (std::vector<std::string>::const_iterator l = languages.begin();
+       l != languages.end(); ++l) {
     const char* lang = l->c_str();
-    if(*l == "NONE")
-      {
+    if (*l == "NONE") {
       this->SetLanguageEnabled("NONE", mf);
       continue;
-      }
+    }
 
     // Check that the compiler was found.
     std::string compilerName = "CMAKE_";
@@ -697,20 +625,15 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
     compilerEnv += "_COMPILER_ENV_VAR";
     std::ostringstream noCompiler;
     const char* compilerFile = mf->GetDefinition(compilerName);
-    if(!compilerFile || !*compilerFile ||
-       cmSystemTools::IsNOTFOUND(compilerFile))
-      {
+    if (!compilerFile || !*compilerFile ||
+        cmSystemTools::IsNOTFOUND(compilerFile)) {
       /* clang-format off */
       noCompiler <<
         "No " << compilerName << " could be found.\n"
         ;
       /* clang-format on */
-      }
-    else if(strcmp(lang, "RC") != 0 &&
-            strcmp(lang, "ASM_MASM") != 0)
-      {
-      if(!cmSystemTools::FileIsFullPath(compilerFile))
-        {
+    } else if (strcmp(lang, "RC") != 0 && strcmp(lang, "ASM_MASM") != 0) {
+      if (!cmSystemTools::FileIsFullPath(compilerFile)) {
         /* clang-format off */
         noCompiler <<
           "The " << compilerName << ":\n"
@@ -718,9 +641,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
           "is not a full path and was not found in the PATH.\n"
           ;
         /* clang-format on */
-        }
-      else if(!cmSystemTools::FileExists(compilerFile))
-        {
+      } else if (!cmSystemTools::FileExists(compilerFile)) {
         /* clang-format off */
         noCompiler <<
           "The " << compilerName << ":\n"
@@ -728,14 +649,12 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
           "is not a full path to an existing compiler tool.\n"
           ;
         /* clang-format on */
-        }
       }
-    if(!noCompiler.str().empty())
-      {
+    }
+    if (!noCompiler.str().empty()) {
       // Skip testing this language since the compiler is not found.
       needTestLanguage[lang] = false;
-      if(!optional)
-        {
+      if (!optional) {
         // The compiler was not found and it is not optional.  Remove
         // CMake(LANG)Compiler.cmake so we try again next time CMake runs.
         std::string compilerLangFile = rootBin;
@@ -743,40 +662,34 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
         compilerLangFile += lang;
         compilerLangFile += "Compiler.cmake";
         cmSystemTools::RemoveFile(compilerLangFile);
-        if(!this->CMakeInstance->GetIsInTryCompile())
-          {
+        if (!this->CMakeInstance->GetIsInTryCompile()) {
           this->PrintCompilerAdvice(noCompiler, lang,
                                     mf->GetDefinition(compilerEnv));
           mf->IssueMessage(cmake::FATAL_ERROR, noCompiler.str());
           fatalError = true;
-          }
         }
       }
+    }
 
     std::string langLoadedVar = "CMAKE_";
     langLoadedVar += lang;
     langLoadedVar += "_INFORMATION_LOADED";
-    if (!mf->GetDefinition(langLoadedVar))
-      {
+    if (!mf->GetDefinition(langLoadedVar)) {
       fpath = "CMake";
-      fpath +=  lang;
+      fpath += lang;
       fpath += "Information.cmake";
       std::string informationFile = mf->GetModulesFile(fpath.c_str());
-      if (informationFile.empty())
-        {
+      if (informationFile.empty()) {
         cmSystemTools::Error("Could not find cmake module file: ",
                              fpath.c_str());
-        }
-      else if(!mf->ReadListFile(informationFile.c_str()))
-        {
+      } else if (!mf->ReadListFile(informationFile.c_str())) {
         cmSystemTools::Error("Could not process cmake module file: ",
                              informationFile.c_str());
-        }
       }
-    if (needSetLanguageEnabledMaps[lang])
-      {
+    }
+    if (needSetLanguageEnabledMaps[lang]) {
       this->SetLanguageEnabledMaps(lang, mf);
-      }
+    }
     this->LanguagesReady.insert(lang);
 
     // Test the compiler for the language just setup
@@ -784,49 +697,43 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
     // At this point we should have enough info for a try compile
     // which is used in the backward stuff
     // If the language is untested then test it now with a try compile.
-    if(needTestLanguage[lang])
-      {
-      if (!this->CMakeInstance->GetIsInTryCompile())
-        {
+    if (needTestLanguage[lang]) {
+      if (!this->CMakeInstance->GetIsInTryCompile()) {
         std::string testLang = "CMakeTest";
         testLang += lang;
         testLang += "Compiler.cmake";
         std::string ifpath = mf->GetModulesFile(testLang.c_str());
-        if(!mf->ReadListFile(ifpath.c_str()))
-          {
+        if (!mf->ReadListFile(ifpath.c_str())) {
           cmSystemTools::Error("Could not find cmake module file: ",
                                testLang.c_str());
-          }
+        }
         std::string compilerWorks = "CMAKE_";
         compilerWorks += lang;
         compilerWorks += "_COMPILER_WORKS";
         // if the compiler did not work, then remove the
         // CMake(LANG)Compiler.cmake file so that it will get tested the
         // next time cmake is run
-        if(!mf->IsOn(compilerWorks))
-          {
+        if (!mf->IsOn(compilerWorks)) {
           std::string compilerLangFile = rootBin;
           compilerLangFile += "/CMake";
           compilerLangFile += lang;
           compilerLangFile += "Compiler.cmake";
           cmSystemTools::RemoveFile(compilerLangFile);
-          }
-        } // end if in try compile
-      } // end need test language
+        }
+      } // end if in try compile
+    }   // end need test language
     // Store the shared library flags so that we can satisfy CMP0018
     std::string sharedLibFlagsVar = "CMAKE_SHARED_LIBRARY_";
     sharedLibFlagsVar += lang;
     sharedLibFlagsVar += "_FLAGS";
-    const char* sharedLibFlags =
-      mf->GetSafeDefinition(sharedLibFlagsVar);
-    if (sharedLibFlags)
-      {
+    const char* sharedLibFlags = mf->GetSafeDefinition(sharedLibFlagsVar);
+    if (sharedLibFlags) {
       this->LanguageToOriginalSharedLibFlags[lang] = sharedLibFlags;
-      }
+    }
 
     // Translate compiler ids for compatibility.
     this->CheckCompilerIdCompatibility(mf, lang);
-    } // end for each language
+  } // end for each language
 
   // Now load files that can override any settings on the platform or for
   // the project First load the project compatibility file if it is in
@@ -835,26 +742,22 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
   projectCompatibility += "/Modules/";
   projectCompatibility += mf->GetSafeDefinition("PROJECT_NAME");
   projectCompatibility += "Compatibility.cmake";
-  if(cmSystemTools::FileExists(projectCompatibility.c_str()))
-    {
+  if (cmSystemTools::FileExists(projectCompatibility.c_str())) {
     mf->ReadListFile(projectCompatibility.c_str());
-    }
+  }
   // Inform any extra generator of the new language.
-  if (this->ExtraGenerator)
-    {
+  if (this->ExtraGenerator) {
     this->ExtraGenerator->EnableLanguage(languages, mf, false);
-    }
+  }
 
-  if(fatalError)
-    {
+  if (fatalError) {
     cmSystemTools::SetFatalErrorOccured();
-    }
+  }
 
   for (std::set<std::string>::iterator li = cur_languages.begin();
-       li != cur_languages.end(); ++li)
-    {
+       li != cur_languages.end(); ++li) {
     this->LanguagesInProgress.erase(*li);
-    }
+  }
 }
 
 void cmGlobalGenerator::PrintCompilerAdvice(std::ostream& os,
@@ -862,40 +765,30 @@ void cmGlobalGenerator::PrintCompilerAdvice(std::ostream& os,
                                             const char* envVar) const
 {
   // Subclasses override this method if they do not support this advice.
-  os <<
-    "Tell CMake where to find the compiler by setting "
-    ;
-  if(envVar)
-    {
-    os <<
-      "either the environment variable \"" << envVar << "\" or "
-      ;
-    }
-  os <<
-    "the CMake cache entry CMAKE_" << lang << "_COMPILER "
-    "to the full path to the compiler, or to the compiler name "
-    "if it is in the PATH."
-    ;
+  os << "Tell CMake where to find the compiler by setting ";
+  if (envVar) {
+    os << "either the environment variable \"" << envVar << "\" or ";
+  }
+  os << "the CMake cache entry CMAKE_" << lang
+     << "_COMPILER "
+        "to the full path to the compiler, or to the compiler name "
+        "if it is in the PATH.";
 }
 
-void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
-                                                std::string const& lang) const
+void cmGlobalGenerator::CheckCompilerIdCompatibility(
+  cmMakefile* mf, std::string const& lang) const
 {
   std::string compilerIdVar = "CMAKE_" + lang + "_COMPILER_ID";
   const char* compilerId = mf->GetDefinition(compilerIdVar);
-  if(!compilerId)
-    {
+  if (!compilerId) {
     return;
-    }
+  }
 
-  if(strcmp(compilerId, "AppleClang") == 0)
-    {
-    switch(mf->GetPolicyStatus(cmPolicies::CMP0025))
-      {
+  if (strcmp(compilerId, "AppleClang") == 0) {
+    switch (mf->GetPolicyStatus(cmPolicies::CMP0025)) {
       case cmPolicies::WARN:
-        if(!this->CMakeInstance->GetIsInTryCompile() &&
-           mf->PolicyOptionalWarningEnabled("CMAKE_POLICY_WARNING_CMP0025"))
-          {
+        if (!this->CMakeInstance->GetIsInTryCompile() &&
+            mf->PolicyOptionalWarningEnabled("CMAKE_POLICY_WARNING_CMP0025")) {
           std::ostringstream w;
           /* clang-format off */
           w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0025) << "\n"
@@ -904,7 +797,7 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
             ;
           /* clang-format on */
           mf->IssueMessage(cmake::AUTHOR_WARNING, w.str());
-          }
+        }
       case cmPolicies::OLD:
         // OLD behavior is to convert AppleClang to Clang.
         mf->AddDefinition(compilerIdVar, "Clang");
@@ -913,22 +806,18 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
       case cmPolicies::REQUIRED_ALWAYS:
         mf->IssueMessage(
           cmake::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0025)
-          );
+          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0025));
       case cmPolicies::NEW:
         // NEW behavior is to keep AppleClang.
         break;
-      }
     }
+  }
 
-  if(strcmp(compilerId, "QCC") == 0)
-    {
-    switch(mf->GetPolicyStatus(cmPolicies::CMP0047))
-      {
+  if (strcmp(compilerId, "QCC") == 0) {
+    switch (mf->GetPolicyStatus(cmPolicies::CMP0047)) {
       case cmPolicies::WARN:
-        if(!this->CMakeInstance->GetIsInTryCompile() &&
-           mf->PolicyOptionalWarningEnabled("CMAKE_POLICY_WARNING_CMP0047"))
-          {
+        if (!this->CMakeInstance->GetIsInTryCompile() &&
+            mf->PolicyOptionalWarningEnabled("CMAKE_POLICY_WARNING_CMP0047")) {
           std::ostringstream w;
           /* clang-format off */
           w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0047) << "\n"
@@ -937,78 +826,65 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
             ;
           /* clang-format on */
           mf->IssueMessage(cmake::AUTHOR_WARNING, w.str());
-          }
+        }
       case cmPolicies::OLD:
         // OLD behavior is to convert QCC to GNU.
         mf->AddDefinition(compilerIdVar, "GNU");
-        if(lang == "C")
-          {
+        if (lang == "C") {
           mf->AddDefinition("CMAKE_COMPILER_IS_GNUCC", "1");
-          }
-        else if(lang == "CXX")
-          {
+        } else if (lang == "CXX") {
           mf->AddDefinition("CMAKE_COMPILER_IS_GNUCXX", "1");
-          }
+        }
         break;
       case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::REQUIRED_ALWAYS:
         mf->IssueMessage(
           cmake::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0047)
-          );
+          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0047));
       case cmPolicies::NEW:
         // NEW behavior is to keep QCC.
         break;
-      }
     }
+  }
 }
 
-std::string
-cmGlobalGenerator::GetLanguageOutputExtension(cmSourceFile const& source) const
+std::string cmGlobalGenerator::GetLanguageOutputExtension(
+  cmSourceFile const& source) const
 {
   const std::string& lang = source.GetLanguage();
-  if(!lang.empty())
-    {
+  if (!lang.empty()) {
     std::map<std::string, std::string>::const_iterator it =
-                                  this->LanguageToOutputExtension.find(lang);
+      this->LanguageToOutputExtension.find(lang);
 
-    if(it != this->LanguageToOutputExtension.end())
-      {
+    if (it != this->LanguageToOutputExtension.end()) {
       return it->second;
-      }
     }
-  else
-    {
+  } else {
     // if no language is found then check to see if it is already an
     // ouput extension for some language.  In that case it should be ignored
     // and in this map, so it will not be compiled but will just be used.
     std::string const& ext = source.GetExtension();
-    if(!ext.empty())
-      {
-      if(this->OutputExtensions.count(ext))
-        {
+    if (!ext.empty()) {
+      if (this->OutputExtensions.count(ext)) {
         return ext;
-        }
       }
     }
+  }
   return "";
 }
 
-
 std::string cmGlobalGenerator::GetLanguageFromExtension(const char* ext) const
 {
   // if there is an extension and it starts with . then move past the
   // . because the extensions are not stored with a .  in the map
-  if(ext && *ext == '.')
-    {
+  if (ext && *ext == '.') {
     ++ext;
-    }
-  std::map<std::string, std::string>::const_iterator it
-                                        = this->ExtensionToLanguage.find(ext);
-  if(it != this->ExtensionToLanguage.end())
-    {
+  }
+  std::map<std::string, std::string>::const_iterator it =
+    this->ExtensionToLanguage.find(ext);
+  if (it != this->ExtensionToLanguage.end()) {
     return it->second;
-    }
+  }
   return "";
 }
 
@@ -1050,96 +926,83 @@ void cmGlobalGenerator::SetLanguageEnabledMaps(const std::string& l,
   // use LanguageToLinkerPreference to detect whether this functions has
   // run before
   if (this->LanguageToLinkerPreference.find(l) !=
-                                        this->LanguageToLinkerPreference.end())
-    {
+      this->LanguageToLinkerPreference.end()) {
     return;
-    }
+  }
 
-  std::string linkerPrefVar = std::string("CMAKE_") +
-    std::string(l) + std::string("_LINKER_PREFERENCE");
+  std::string linkerPrefVar =
+    std::string("CMAKE_") + std::string(l) + std::string("_LINKER_PREFERENCE");
   const char* linkerPref = mf->GetDefinition(linkerPrefVar);
   int preference = 0;
-  if(linkerPref)
-    {
-    if (sscanf(linkerPref, "%d", &preference)!=1)
-      {
+  if (linkerPref) {
+    if (sscanf(linkerPref, "%d", &preference) != 1) {
       // backward compatibility: before 2.6 LINKER_PREFERENCE
       // was either "None" or "Preferred", and only the first character was
       // tested. So if there is a custom language out there and it is
       // "Preferred", set its preference high
-      if (linkerPref[0]=='P')
-        {
+      if (linkerPref[0] == 'P') {
         preference = 100;
-        }
-      else
-        {
+      } else {
         preference = 0;
-        }
       }
     }
+  }
 
-  if (preference < 0)
-    {
+  if (preference < 0) {
     std::string msg = linkerPrefVar;
     msg += " is negative, adjusting it to 0";
     cmSystemTools::Message(msg.c_str(), "Warning");
     preference = 0;
-    }
+  }
 
   this->LanguageToLinkerPreference[l] = preference;
 
-  std::string outputExtensionVar = std::string("CMAKE_") +
-    std::string(l) + std::string("_OUTPUT_EXTENSION");
+  std::string outputExtensionVar =
+    std::string("CMAKE_") + std::string(l) + std::string("_OUTPUT_EXTENSION");
   const char* outputExtension = mf->GetDefinition(outputExtensionVar);
-  if(outputExtension)
-    {
+  if (outputExtension) {
     this->LanguageToOutputExtension[l] = outputExtension;
     this->OutputExtensions[outputExtension] = outputExtension;
-    if(outputExtension[0] == '.')
-      {
-      this->OutputExtensions[outputExtension+1] = outputExtension+1;
-      }
+    if (outputExtension[0] == '.') {
+      this->OutputExtensions[outputExtension + 1] = outputExtension + 1;
     }
+  }
 
   // The map was originally filled by SetLanguageEnabledFlag, but
   // since then the compiler- and platform-specific files have been
   // loaded which might have added more entries.
   this->FillExtensionToLanguageMap(l, mf);
 
-  std::string ignoreExtensionsVar = std::string("CMAKE_") +
-    std::string(l) + std::string("_IGNORE_EXTENSIONS");
+  std::string ignoreExtensionsVar =
+    std::string("CMAKE_") + std::string(l) + std::string("_IGNORE_EXTENSIONS");
   std::string ignoreExts = mf->GetSafeDefinition(ignoreExtensionsVar);
   std::vector<std::string> extensionList;
   cmSystemTools::ExpandListArgument(ignoreExts, extensionList);
-  for(std::vector<std::string>::iterator i = extensionList.begin();
-      i != extensionList.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = extensionList.begin();
+       i != extensionList.end(); ++i) {
     this->IgnoreExtensions[*i] = true;
-    }
-
+  }
 }
 
 void cmGlobalGenerator::FillExtensionToLanguageMap(const std::string& l,
                                                    cmMakefile* mf)
 {
-  std::string extensionsVar = std::string("CMAKE_") +
-    std::string(l) + std::string("_SOURCE_FILE_EXTENSIONS");
+  std::string extensionsVar = std::string("CMAKE_") + std::string(l) +
+    std::string("_SOURCE_FILE_EXTENSIONS");
   std::string exts = mf->GetSafeDefinition(extensionsVar);
   std::vector<std::string> extensionList;
   cmSystemTools::ExpandListArgument(exts, extensionList);
-  for(std::vector<std::string>::iterator i = extensionList.begin();
-      i != extensionList.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = extensionList.begin();
+       i != extensionList.end(); ++i) {
     this->ExtensionToLanguage[*i] = l;
-    }
+  }
 }
 
 bool cmGlobalGenerator::IgnoreFile(const char* ext) const
 {
-  if(!this->GetLanguageFromExtension(ext).empty())
-    {
+  if (!this->GetLanguageFromExtension(ext).empty()) {
     return false;
-    }
+  }
   return (this->IgnoreExtensions.count(ext) > 0);
 }
 
@@ -1159,10 +1022,9 @@ void cmGlobalGenerator::CreateLocalGenerators()
   this->LocalGenerators.clear();
   this->LocalGenerators.reserve(this->Makefiles.size());
   for (std::vector<cmMakefile*>::const_iterator it = this->Makefiles.begin();
-       it != this->Makefiles.end(); ++it)
-    {
+       it != this->Makefiles.end(); ++it) {
     this->LocalGenerators.push_back(this->CreateLocalGenerator(*it));
-    }
+  }
 }
 
 void cmGlobalGenerator::Configure()
@@ -1172,16 +1034,16 @@ void cmGlobalGenerator::Configure()
 
   cmState::Snapshot snapshot = this->CMakeInstance->GetCurrentSnapshot();
 
-  snapshot.GetDirectory().SetCurrentSource
-    (this->CMakeInstance->GetHomeDirectory());
-  snapshot.GetDirectory().SetCurrentBinary
-    (this->CMakeInstance->GetHomeOutputDirectory());
+  snapshot.GetDirectory().SetCurrentSource(
+    this->CMakeInstance->GetHomeDirectory());
+  snapshot.GetDirectory().SetCurrentBinary(
+    this->CMakeInstance->GetHomeOutputDirectory());
 
   cmMakefile* dirMf = new cmMakefile(this, snapshot);
   this->Makefiles.push_back(dirMf);
 
   this->BinaryDirectories.insert(
-      this->CMakeInstance->GetHomeOutputDirectory());
+    this->CMakeInstance->GetHomeOutputDirectory());
 
   // now do it
   this->ConfigureDoneCMP0026AndCMP0024 = false;
@@ -1194,55 +1056,47 @@ void cmGlobalGenerator::Configure()
   cmTargets globalTargets;
   this->CreateDefaultGlobalTargets(&globalTargets);
 
-  for (unsigned int i = 0; i < this->Makefiles.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->Makefiles.size(); ++i) {
     cmMakefile* mf = this->Makefiles[i];
     cmTargets* targets = &(mf->GetTargets());
     cmTargets::iterator tit;
-    for ( tit = globalTargets.begin(); tit != globalTargets.end(); ++ tit )
-      {
+    for (tit = globalTargets.begin(); tit != globalTargets.end(); ++tit) {
       (*targets)[tit->first] = tit->second;
       (*targets)[tit->first].SetMakefile(mf);
-      }
     }
+  }
 
   // update the cache entry for the number of local generators, this is used
   // for progress
   char num[100];
-  sprintf(num,"%d",static_cast<int>(this->Makefiles.size()));
-  this->GetCMakeInstance()->AddCacheEntry
-    ("CMAKE_NUMBER_OF_MAKEFILES", num,
-     "number of local generators", cmState::INTERNAL);
+  sprintf(num, "%d", static_cast<int>(this->Makefiles.size()));
+  this->GetCMakeInstance()->AddCacheEntry("CMAKE_NUMBER_OF_MAKEFILES", num,
+                                          "number of local generators",
+                                          cmState::INTERNAL);
 
   // check for link libraries and include directories containing "NOTFOUND"
   // and for infinite loops
   this->CheckTargetProperties();
 
-  if ( this->CMakeInstance->GetWorkingMode() == cmake::NORMAL_MODE)
-    {
+  if (this->CMakeInstance->GetWorkingMode() == cmake::NORMAL_MODE) {
     std::ostringstream msg;
-    if(cmSystemTools::GetErrorOccuredFlag())
-      {
+    if (cmSystemTools::GetErrorOccuredFlag()) {
       msg << "Configuring incomplete, errors occurred!";
-      const char* logs[] = {"CMakeOutput.log", "CMakeError.log", 0};
-      for(const char** log = logs; *log; ++log)
-        {
+      const char* logs[] = { "CMakeOutput.log", "CMakeError.log", 0 };
+      for (const char** log = logs; *log; ++log) {
         std::string f = this->CMakeInstance->GetHomeOutputDirectory();
         f += this->CMakeInstance->GetCMakeFilesDirectory();
         f += "/";
         f += *log;
-        if(cmSystemTools::FileExists(f.c_str()))
-          {
+        if (cmSystemTools::FileExists(f.c_str())) {
           msg << "\nSee also \"" << f << "\".";
-          }
         }
       }
-    else
-      {
+    } else {
       msg << "Configuring done";
-      }
-    this->CMakeInstance->UpdateProgress(msg.str().c_str(), -1);
     }
+    this->CMakeInstance->UpdateProgress(msg.str().c_str(), -1);
+  }
 }
 
 void cmGlobalGenerator::CreateGenerationObjects(TargetTypes targetTypes)
@@ -1252,31 +1106,29 @@ void cmGlobalGenerator::CreateGenerationObjects(TargetTypes targetTypes)
   this->ComputeBuildFileGenerators();
 }
 
-void cmGlobalGenerator::CreateImportedGenerationObjects(cmMakefile* mf,
-    const std::vector<std::string>& targets,
-    std::vector<const cmGeneratorTarget*>& exports)
+void cmGlobalGenerator::CreateImportedGenerationObjects(
+  cmMakefile* mf, const std::vector<std::string>& targets,
+  std::vector<const cmGeneratorTarget*>& exports)
 {
   this->CreateGenerationObjects(ImportedOnly);
   std::vector<cmMakefile*>::iterator mfit =
-      std::find(this->Makefiles.begin(), this->Makefiles.end(), mf);
+    std::find(this->Makefiles.begin(), this->Makefiles.end(), mf);
   cmLocalGenerator* lg =
-      this->LocalGenerators[std::distance(this->Makefiles.begin(), mfit)];
+    this->LocalGenerators[std::distance(this->Makefiles.begin(), mfit)];
   for (std::vector<std::string>::const_iterator it = targets.begin();
-       it != targets.end(); ++it)
-    {
+       it != targets.end(); ++it) {
     cmGeneratorTarget* gt = lg->FindGeneratorTargetToUse(*it);
-    if (gt)
-      {
+    if (gt) {
       exports.push_back(gt);
-      }
     }
+  }
 }
 
-cmExportBuildFileGenerator*
-cmGlobalGenerator::GetExportedTargetsFile(const std::string &filename) const
+cmExportBuildFileGenerator* cmGlobalGenerator::GetExportedTargetsFile(
+  const std::string& filename) const
 {
-  std::map<std::string, cmExportBuildFileGenerator*>::const_iterator it
-    = this->BuildExportSets.find(filename);
+  std::map<std::string, cmExportBuildFileGenerator*>::const_iterator it =
+    this->BuildExportSets.find(filename);
   return it == this->BuildExportSets.end() ? 0 : it->second;
 }
 
@@ -1288,11 +1140,10 @@ void cmGlobalGenerator::AddCMP0042WarnTarget(const std::string& target)
 bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const
 {
   // If the property is not enabled then okay.
-  if(!this->CMakeInstance->GetState()
-     ->GetGlobalPropertyAsBool("ALLOW_DUPLICATE_CUSTOM_TARGETS"))
-    {
+  if (!this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(
+        "ALLOW_DUPLICATE_CUSTOM_TARGETS")) {
     return true;
-    }
+  }
 
   // This generator does not support duplicate custom targets.
   std::ostringstream e;
@@ -1308,16 +1159,15 @@ bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const
 
 void cmGlobalGenerator::ComputeBuildFileGenerators()
 {
-  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
     std::vector<cmExportBuildFileGenerator*> gens =
-        this->Makefiles[i]->GetExportBuildFileGenerators();
+      this->Makefiles[i]->GetExportBuildFileGenerators();
     for (std::vector<cmExportBuildFileGenerator*>::const_iterator it =
-         gens.begin(); it != gens.end(); ++it)
-      {
+           gens.begin();
+         it != gens.end(); ++it) {
       (*it)->Compute(this->LocalGenerators[i]);
-      }
     }
+  }
 }
 
 bool cmGlobalGenerator::Compute()
@@ -1330,10 +1180,9 @@ bool cmGlobalGenerator::Compute()
   this->CMP0042WarnTargets.clear();
 
   // Check whether this generator is allowed to run.
-  if(!this->CheckALLOW_DUPLICATE_CUSTOM_TARGETS())
-    {
+  if (!this->CheckALLOW_DUPLICATE_CUSTOM_TARGETS()) {
     return false;
-    }
+  }
   this->FinalizeTargetCompileInfo();
 
   this->CreateGenerationObjects();
@@ -1346,63 +1195,56 @@ bool cmGlobalGenerator::Compute()
   // Iterate through all targets and set up automoc for those which have
   // the AUTOMOC, AUTOUIC or AUTORCC property set
   std::vector<cmGeneratorTarget const*> autogenTargets =
-      this->CreateQtAutoGeneratorsTargets();
+    this->CreateQtAutoGeneratorsTargets();
 #endif
 
   unsigned int i;
 
   // Add generator specific helper commands
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
     this->LocalGenerators[i]->AddHelperCommands();
-    }
+  }
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
   for (std::vector<cmGeneratorTarget const*>::iterator it =
-       autogenTargets.begin(); it != autogenTargets.end(); ++it)
-    {
+         autogenTargets.begin();
+       it != autogenTargets.end(); ++it) {
     cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(*it);
-    }
+  }
 #endif
 
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
     cmMakefile* mf = this->LocalGenerators[i]->GetMakefile();
     std::vector<cmInstallGenerator*>& gens = mf->GetInstallGenerators();
     for (std::vector<cmInstallGenerator*>::const_iterator git = gens.begin();
-         git != gens.end(); ++git)
-      {
+         git != gens.end(); ++git) {
       (*git)->Compute(this->LocalGenerators[i]);
-      }
     }
+  }
 
   this->AddExtraIDETargets();
 
   // Trace the dependencies, after that no custom commands should be added
   // because their dependencies might not be handled correctly
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
     this->LocalGenerators[i]->TraceDependencies();
-    }
+  }
 
   this->ForceLinkerLanguages();
 
   // Compute the manifest of main targets generated.
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
     this->LocalGenerators[i]->ComputeTargetManifest();
-    }
+  }
 
   // Compute the inter-target dependencies.
-  if(!this->ComputeTargetDepends())
-    {
+  if (!this->ComputeTargetDepends()) {
     return false;
-    }
+  }
 
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
     this->LocalGenerators[i]->ComputeHomeRelativeOutputPath();
-    }
+  }
 
   return true;
 }
@@ -1416,65 +1258,56 @@ void cmGlobalGenerator::Generate()
   this->ProcessEvaluationFiles();
 
   // Generate project files
-  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
     this->SetCurrentMakefile(this->LocalGenerators[i]->GetMakefile());
     this->LocalGenerators[i]->Generate();
-    if(!this->LocalGenerators[i]->GetMakefile()->IsOn(
-      "CMAKE_SKIP_INSTALL_RULES"))
-      {
+    if (!this->LocalGenerators[i]->GetMakefile()->IsOn(
+          "CMAKE_SKIP_INSTALL_RULES")) {
       this->LocalGenerators[i]->GenerateInstallRules();
-      }
-    this->LocalGenerators[i]->GenerateTestFiles();
-    this->CMakeInstance->UpdateProgress("Generating",
-      (static_cast<float>(i)+1.0f)/
-       static_cast<float>(this->LocalGenerators.size()));
     }
+    this->LocalGenerators[i]->GenerateTestFiles();
+    this->CMakeInstance->UpdateProgress(
+      "Generating", (static_cast<float>(i) + 1.0f) /
+        static_cast<float>(this->LocalGenerators.size()));
+  }
   this->SetCurrentMakefile(0);
 
-  if(!this->GenerateCPackPropertiesFile())
-    {
+  if (!this->GenerateCPackPropertiesFile()) {
     this->GetCMakeInstance()->IssueMessage(
       cmake::FATAL_ERROR, "Could not write CPack properties file.");
-    }
+  }
 
-  for (std::map<std::string, cmExportBuildFileGenerator*>::iterator
-      it = this->BuildExportSets.begin(); it != this->BuildExportSets.end();
-      ++it)
-    {
-    if (!it->second->GenerateImportFile()
-        && !cmSystemTools::GetErrorOccuredFlag())
-      {
-      this->GetCMakeInstance()
-          ->IssueMessage(cmake::FATAL_ERROR, "Could not write export file.");
+  for (std::map<std::string, cmExportBuildFileGenerator*>::iterator it =
+         this->BuildExportSets.begin();
+       it != this->BuildExportSets.end(); ++it) {
+    if (!it->second->GenerateImportFile() &&
+        !cmSystemTools::GetErrorOccuredFlag()) {
+      this->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR,
+                                             "Could not write export file.");
       return;
-      }
     }
+  }
   // Update rule hashes.
   this->CheckRuleHashes();
 
   this->WriteSummary();
 
-  if (this->ExtraGenerator != 0)
-    {
+  if (this->ExtraGenerator != 0) {
     this->ExtraGenerator->Generate();
-    }
+  }
 
-  if(!this->CMP0042WarnTargets.empty())
-    {
+  if (!this->CMP0042WarnTargets.empty()) {
     std::ostringstream w;
     w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0042) << "\n";
     w << "MACOSX_RPATH is not specified for"
          " the following targets:\n";
-    for(std::set<std::string>::iterator
-      iter = this->CMP0042WarnTargets.begin();
-      iter != this->CMP0042WarnTargets.end();
-      ++iter)
-      {
+    for (std::set<std::string>::iterator iter =
+           this->CMP0042WarnTargets.begin();
+         iter != this->CMP0042WarnTargets.end(); ++iter) {
       w << " " << *iter << "\n";
-      }
-    this->GetCMakeInstance()->IssueMessage(cmake::AUTHOR_WARNING, w.str());
     }
+    this->GetCMakeInstance()->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+  }
 
   this->CMakeInstance->UpdateProgress("Generating done", -1);
 }
@@ -1482,16 +1315,15 @@ void cmGlobalGenerator::Generate()
 bool cmGlobalGenerator::ComputeTargetDepends()
 {
   cmComputeTargetDepends ctd(this);
-  if(!ctd.Compute())
-    {
+  if (!ctd.Compute()) {
     return false;
-    }
+  }
   std::vector<cmGeneratorTarget const*> const& targets = ctd.GetTargets();
-  for(std::vector<cmGeneratorTarget const*>::const_iterator ti
-      = targets.begin(); ti != targets.end(); ++ti)
-    {
+  for (std::vector<cmGeneratorTarget const*>::const_iterator ti =
+         targets.begin();
+       ti != targets.end(); ++ti) {
     ctd.GetTargetDirectDepends(*ti, this->TargetDependencies[*ti]);
-    }
+  }
   return true;
 }
 
@@ -1501,59 +1333,52 @@ cmGlobalGenerator::CreateQtAutoGeneratorsTargets()
   std::vector<const cmGeneratorTarget*> autogenTargets;
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
-  for(unsigned int i=0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
     std::vector<cmGeneratorTarget*> targets =
       this->LocalGenerators[i]->GetGeneratorTargets();
     std::vector<cmGeneratorTarget*> filteredTargets;
     filteredTargets.reserve(targets.size());
-    for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
-        ti != targets.end(); ++ti)
-      {
-      if ((*ti)->GetType() == cmState::GLOBAL_TARGET)
-        {
+    for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
+         ti != targets.end(); ++ti) {
+      if ((*ti)->GetType() == cmState::GLOBAL_TARGET) {
         continue;
-        }
-      if((*ti)->GetType() != cmState::EXECUTABLE &&
-         (*ti)->GetType() != cmState::STATIC_LIBRARY &&
-         (*ti)->GetType() != cmState::SHARED_LIBRARY &&
-         (*ti)->GetType() != cmState::MODULE_LIBRARY &&
-         (*ti)->GetType() != cmState::OBJECT_LIBRARY)
-        {
+      }
+      if ((*ti)->GetType() != cmState::EXECUTABLE &&
+          (*ti)->GetType() != cmState::STATIC_LIBRARY &&
+          (*ti)->GetType() != cmState::SHARED_LIBRARY &&
+          (*ti)->GetType() != cmState::MODULE_LIBRARY &&
+          (*ti)->GetType() != cmState::OBJECT_LIBRARY) {
         continue;
-        }
-      if((!(*ti)->GetPropertyAsBool("AUTOMOC")
-            && !(*ti)->GetPropertyAsBool("AUTOUIC")
-            && !(*ti)->GetPropertyAsBool("AUTORCC"))
-          || (*ti)->IsImported())
-        {
+      }
+      if ((!(*ti)->GetPropertyAsBool("AUTOMOC") &&
+           !(*ti)->GetPropertyAsBool("AUTOUIC") &&
+           !(*ti)->GetPropertyAsBool("AUTORCC")) ||
+          (*ti)->IsImported()) {
         continue;
-        }
+      }
       // don't do anything if there is no Qt4 or Qt5Core (which contains moc):
       cmMakefile* mf = (*ti)->Target->GetMakefile();
       std::string qtMajorVersion = mf->GetSafeDefinition("QT_VERSION_MAJOR");
-      if (qtMajorVersion == "")
-        {
+      if (qtMajorVersion == "") {
         qtMajorVersion = mf->GetSafeDefinition("Qt5Core_VERSION_MAJOR");
-        }
-      if (qtMajorVersion != "4" && qtMajorVersion != "5")
-        {
+      }
+      if (qtMajorVersion != "4" && qtMajorVersion != "5") {
         continue;
-        }
+      }
 
       cmGeneratorTarget* gt = *ti;
 
       cmQtAutoGeneratorInitializer::InitializeAutogenSources(gt);
       filteredTargets.push_back(gt);
-      }
-    for(std::vector<cmGeneratorTarget*>::iterator ti = filteredTargets.begin();
-        ti != filteredTargets.end(); ++ti)
-      {
+    }
+    for (std::vector<cmGeneratorTarget*>::iterator ti =
+           filteredTargets.begin();
+         ti != filteredTargets.end(); ++ti) {
       cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
-           this->LocalGenerators[i], *ti);
+        this->LocalGenerators[i], *ti);
       autogenTargets.push_back(*ti);
-      }
     }
+  }
 #endif
   return autogenTargets;
 }
@@ -1561,114 +1386,95 @@ cmGlobalGenerator::CreateQtAutoGeneratorsTargets()
 void cmGlobalGenerator::FinalizeTargetCompileInfo()
 {
   // Construct per-target generator information.
-  for(unsigned int i=0; i < this->Makefiles.size(); ++i)
-    {
-    cmMakefile *mf = this->Makefiles[i];
+  for (unsigned int i = 0; i < this->Makefiles.size(); ++i) {
+    cmMakefile* mf = this->Makefiles[i];
 
     const cmStringRange noconfig_compile_definitions =
-                                mf->GetCompileDefinitionsEntries();
+      mf->GetCompileDefinitionsEntries();
     const cmBacktraceRange noconfig_compile_definitions_bts =
-                                mf->GetCompileDefinitionsBacktraces();
+      mf->GetCompileDefinitionsBacktraces();
 
     cmTargets& targets = mf->GetTargets();
-    for(cmTargets::iterator ti = targets.begin();
-        ti != targets.end(); ++ti)
-      {
+    for (cmTargets::iterator ti = targets.begin(); ti != targets.end(); ++ti) {
       cmTarget* t = &ti->second;
-      if (t->GetType() == cmState::GLOBAL_TARGET)
-        {
+      if (t->GetType() == cmState::GLOBAL_TARGET) {
         continue;
-        }
+      }
 
       t->AppendBuildInterfaceIncludes();
 
-      if (t->GetType() == cmState::INTERFACE_LIBRARY)
-        {
+      if (t->GetType() == cmState::INTERFACE_LIBRARY) {
         continue;
-        }
+      }
 
-      cmBacktraceRange::const_iterator btIt
-          = noconfig_compile_definitions_bts.begin();
-      for (cmStringRange::const_iterator it
-                                      = noconfig_compile_definitions.begin();
-          it != noconfig_compile_definitions.end(); ++it, ++btIt)
-        {
+      cmBacktraceRange::const_iterator btIt =
+        noconfig_compile_definitions_bts.begin();
+      for (cmStringRange::const_iterator
+             it = noconfig_compile_definitions.begin();
+           it != noconfig_compile_definitions.end(); ++it, ++btIt) {
         t->InsertCompileDefinition(*it, *btIt);
-        }
+      }
 
-      cmPolicies::PolicyStatus polSt
-                                  = mf->GetPolicyStatus(cmPolicies::CMP0043);
-      if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD)
-        {
+      cmPolicies::PolicyStatus polSt =
+        mf->GetPolicyStatus(cmPolicies::CMP0043);
+      if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD) {
         std::vector<std::string> configs;
         mf->GetConfigurations(configs);
 
-        for(std::vector<std::string>::const_iterator ci = configs.begin();
-            ci != configs.end(); ++ci)
-          {
+        for (std::vector<std::string>::const_iterator ci = configs.begin();
+             ci != configs.end(); ++ci) {
           std::string defPropName = "COMPILE_DEFINITIONS_";
           defPropName += cmSystemTools::UpperCase(*ci);
-          t->AppendProperty(defPropName,
-                            mf->GetProperty(defPropName));
-          }
+          t->AppendProperty(defPropName, mf->GetProperty(defPropName));
         }
       }
     }
+  }
 }
 
 void cmGlobalGenerator::CreateGeneratorTargets(
-    TargetTypes targetTypes,
-    cmMakefile *mf,
-    cmLocalGenerator *lg,
-    std::map<cmTarget*, cmGeneratorTarget*> const& importedMap)
+  TargetTypes targetTypes, cmMakefile* mf, cmLocalGenerator* lg,
+  std::map<cmTarget*, cmGeneratorTarget*> const& importedMap)
 {
-  if (targetTypes == AllTargets)
-    {
+  if (targetTypes == AllTargets) {
     cmTargets& targets = mf->GetTargets();
-    for(cmTargets::iterator ti = targets.begin();
-        ti != targets.end(); ++ti)
-      {
+    for (cmTargets::iterator ti = targets.begin(); ti != targets.end(); ++ti) {
       cmTarget* t = &ti->second;
       cmGeneratorTarget* gt = new cmGeneratorTarget(t, lg);
       lg->AddGeneratorTarget(gt);
-      }
     }
+  }
 
   std::vector<cmTarget*> itgts = mf->GetImportedTargets();
 
-  for(std::vector<cmTarget*>::const_iterator
-        j = itgts.begin(); j != itgts.end(); ++j)
-    {
+  for (std::vector<cmTarget*>::const_iterator j = itgts.begin();
+       j != itgts.end(); ++j) {
     lg->AddImportedGeneratorTarget(importedMap.find(*j)->second);
-    }
+  }
 }
 
 void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes)
 {
   std::map<cmTarget*, cmGeneratorTarget*> importedMap;
-  for(unsigned int i=0; i < this->Makefiles.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->Makefiles.size(); ++i) {
     cmMakefile* mf = this->Makefiles[i];
-    for(std::vector<cmTarget*>::const_iterator
-          j = mf->GetOwnedImportedTargets().begin();
-        j != mf->GetOwnedImportedTargets().end(); ++j)
-      {
+    for (std::vector<cmTarget*>::const_iterator j =
+           mf->GetOwnedImportedTargets().begin();
+         j != mf->GetOwnedImportedTargets().end(); ++j) {
       cmLocalGenerator* lg = this->LocalGenerators[i];
       cmGeneratorTarget* gt = new cmGeneratorTarget(*j, lg);
       lg->AddOwnedImportedGeneratorTarget(gt);
       importedMap[*j] = gt;
-      }
     }
+  }
 
   // Construct per-target generator information.
-  for(unsigned int i=0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
     this->CreateGeneratorTargets(targetTypes, this->Makefiles[i],
                                  this->LocalGenerators[i], importedMap);
-    }
+  }
 }
 
-
 void cmGlobalGenerator::ClearGeneratorMembers()
 {
   cmDeleteAll(this->BuildExportSets);
@@ -1697,126 +1503,108 @@ void cmGlobalGenerator::ComputeTargetObjectDirectory(cmGeneratorTarget*) const
 void cmGlobalGenerator::CheckTargetProperties()
 {
   std::map<std::string, std::string> notFoundMap;
-//  std::set<std::string> notFoundMap;
+  //  std::set<std::string> notFoundMap;
   // after it is all done do a ConfigureFinalPass
   cmState* state = this->GetCMakeInstance()->GetState();
-  for (unsigned int i = 0; i < this->Makefiles.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->Makefiles.size(); ++i) {
     this->Makefiles[i]->ConfigureFinalPass();
-    cmTargets &targets =
-      this->Makefiles[i]->GetTargets();
-    for (cmTargets::iterator l = targets.begin();
-         l != targets.end(); l++)
-      {
-      if (l->second.GetType() == cmState::INTERFACE_LIBRARY)
-        {
+    cmTargets& targets = this->Makefiles[i]->GetTargets();
+    for (cmTargets::iterator l = targets.begin(); l != targets.end(); l++) {
+      if (l->second.GetType() == cmState::INTERFACE_LIBRARY) {
         continue;
-        }
+      }
       const cmTarget::LinkLibraryVectorType& libs =
         l->second.GetOriginalLinkLibraries();
-      for(cmTarget::LinkLibraryVectorType::const_iterator lib = libs.begin();
-          lib != libs.end(); ++lib)
-        {
-        if(lib->first.size() > 9 &&
-           cmSystemTools::IsNOTFOUND(lib->first.c_str()))
-          {
-          std::string varName = lib->first.substr(0, lib->first.size()-9);
-          if(state->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
-            {
+      for (cmTarget::LinkLibraryVectorType::const_iterator lib = libs.begin();
+           lib != libs.end(); ++lib) {
+        if (lib->first.size() > 9 &&
+            cmSystemTools::IsNOTFOUND(lib->first.c_str())) {
+          std::string varName = lib->first.substr(0, lib->first.size() - 9);
+          if (state->GetCacheEntryPropertyAsBool(varName, "ADVANCED")) {
             varName += " (ADVANCED)";
-            }
+          }
           std::string text = notFoundMap[varName];
           text += "\n    linked by target \"";
           text += l->second.GetName();
           text += "\" in directory ";
-          text+=this->Makefiles[i]->GetCurrentSourceDirectory();
+          text += this->Makefiles[i]->GetCurrentSourceDirectory();
           notFoundMap[varName] = text;
-          }
         }
+      }
       std::vector<std::string> incs;
-      const char *incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES");
-      if (!incDirProp)
-        {
+      const char* incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES");
+      if (!incDirProp) {
         continue;
-        }
+      }
 
-      std::string incDirs = cmGeneratorExpression::Preprocess(incDirProp,
-                        cmGeneratorExpression::StripAllGeneratorExpressions);
+      std::string incDirs = cmGeneratorExpression::Preprocess(
+        incDirProp, cmGeneratorExpression::StripAllGeneratorExpressions);
 
       cmSystemTools::ExpandListArgument(incDirs, incs);
 
-      for( std::vector<std::string>::const_iterator incDir = incs.begin();
-            incDir != incs.end(); ++incDir)
-        {
-        if(incDir->size() > 9 &&
-            cmSystemTools::IsNOTFOUND(incDir->c_str()))
-          {
-          std::string varName = incDir->substr(0, incDir->size()-9);
-          if(state->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
-            {
+      for (std::vector<std::string>::const_iterator incDir = incs.begin();
+           incDir != incs.end(); ++incDir) {
+        if (incDir->size() > 9 && cmSystemTools::IsNOTFOUND(incDir->c_str())) {
+          std::string varName = incDir->substr(0, incDir->size() - 9);
+          if (state->GetCacheEntryPropertyAsBool(varName, "ADVANCED")) {
             varName += " (ADVANCED)";
-            }
+          }
           std::string text = notFoundMap[varName];
           text += "\n   used as include directory in directory ";
           text += this->Makefiles[i]->GetCurrentSourceDirectory();
           notFoundMap[varName] = text;
-          }
         }
       }
-    this->CMakeInstance->UpdateProgress
-      ("Configuring", 0.9f+0.1f*(static_cast<float>(i)+1.0f)/
-        static_cast<float>(this->Makefiles.size()));
     }
+    this->CMakeInstance->UpdateProgress(
+      "Configuring", 0.9f +
+        0.1f * (static_cast<float>(i) + 1.0f) /
+          static_cast<float>(this->Makefiles.size()));
+  }
 
-  if(!notFoundMap.empty())
-    {
+  if (!notFoundMap.empty()) {
     std::string notFoundVars;
-    for(std::map<std::string, std::string>::const_iterator
-        ii = notFoundMap.begin();
-        ii != notFoundMap.end();
-        ++ii)
-      {
+    for (std::map<std::string, std::string>::const_iterator ii =
+           notFoundMap.begin();
+         ii != notFoundMap.end(); ++ii) {
       notFoundVars += ii->first;
       notFoundVars += ii->second;
       notFoundVars += "\n";
-      }
+    }
     cmSystemTools::Error("The following variables are used in this project, "
                          "but they are set to NOTFOUND.\n"
                          "Please set them or make sure they are set and "
                          "tested correctly in the CMake files:\n",
                          notFoundVars.c_str());
-    }
+  }
 }
 
 int cmGlobalGenerator::TryCompile(const std::string& srcdir,
                                   const std::string& bindir,
                                   const std::string& projectName,
                                   const std::string& target, bool fast,
-                                  std::string& output, cmMakefile *mf)
+                                  std::string& output, cmMakefile* mf)
 {
   // if this is not set, then this is a first time configure
   // and there is a good chance that the try compile stuff will
   // take the bulk of the time, so try and guess some progress
   // by getting closer and closer to 100 without actually getting there.
-  if (!this->CMakeInstance->GetState()->GetInitializedCacheValue
-      ("CMAKE_NUMBER_OF_MAKEFILES"))
-    {
+  if (!this->CMakeInstance->GetState()->GetInitializedCacheValue(
+        "CMAKE_NUMBER_OF_MAKEFILES")) {
     // If CMAKE_NUMBER_OF_MAKEFILES is not set
     // we are in the first time progress and we have no
     // idea how long it will be.  So, just move 1/10th of the way
     // there each time, and don't go over 95%
-    this->FirstTimeProgress += ((1.0f - this->FirstTimeProgress) /30.0f);
-    if(this->FirstTimeProgress > 0.95f)
-      {
+    this->FirstTimeProgress += ((1.0f - this->FirstTimeProgress) / 30.0f);
+    if (this->FirstTimeProgress > 0.95f) {
       this->FirstTimeProgress = 0.95f;
-      }
+    }
     this->CMakeInstance->UpdateProgress("Configuring",
                                         this->FirstTimeProgress);
-    }
+  }
 
   std::string newTarget;
-  if (!target.empty())
-    {
+  if (!target.empty()) {
     newTarget += target;
 #if 0
 #if defined(_WIN32) || defined(__CYGWIN__)
@@ -1829,35 +1617,30 @@ int cmGlobalGenerator::TryCompile(const std::string& srcdir,
       }
 #endif // WIN32
 #endif
-    }
+  }
   std::string config =
     mf->GetSafeDefinition("CMAKE_TRY_COMPILE_CONFIGURATION");
-  return this->Build(srcdir,bindir,projectName,
-                     newTarget,
-                     output,"",config,false,fast,false,
-                     this->TryCompileTimeout);
+  return this->Build(srcdir, bindir, projectName, newTarget, output, "",
+                     config, false, fast, false, this->TryCompileTimeout);
 }
 
 void cmGlobalGenerator::GenerateBuildCommand(
   std::vector<std::string>& makeCommand, const std::string&,
   const std::string&, const std::string&, const std::string&,
-  const std::string&, bool, bool,
-  std::vector<std::string> const&)
+  const std::string&, bool, bool, std::vector<std::string> const&)
 {
   makeCommand.push_back(
     "cmGlobalGenerator::GenerateBuildCommand not implemented");
 }
 
-int cmGlobalGenerator::Build(
-  const std::string&, const std::string& bindir,
-  const std::string& projectName, const std::string& target,
-  std::string& output,
-  const std::string& makeCommandCSTR,
-  const std::string& config,
-  bool clean, bool fast, bool verbose,
-  double timeout,
-  cmSystemTools::OutputOption outputflag,
-  std::vector<std::string> const& nativeOptions)
+int cmGlobalGenerator::Build(const std::string&, const std::string& bindir,
+                             const std::string& projectName,
+                             const std::string& target, std::string& output,
+                             const std::string& makeCommandCSTR,
+                             const std::string& config, bool clean, bool fast,
+                             bool verbose, double timeout,
+                             cmSystemTools::OutputOption outputflag,
+                             std::vector<std::string> const& nativeOptions)
 {
   /**
    * Run an executable command and put the stdout in output.
@@ -1875,21 +1658,19 @@ int cmGlobalGenerator::Build(
   std::string* outputPtr = &outputBuffer;
 
   std::vector<std::string> makeCommand;
-  this->GenerateBuildCommand(makeCommand, makeCommandCSTR, projectName,
-                             bindir, target, config, fast, verbose,
-                             nativeOptions);
+  this->GenerateBuildCommand(makeCommand, makeCommandCSTR, projectName, bindir,
+                             target, config, fast, verbose, nativeOptions);
 
   // Workaround to convince VCExpress.exe to produce output.
   if (outputflag == cmSystemTools::OUTPUT_PASSTHROUGH &&
-      !makeCommand.empty() && cmSystemTools::LowerCase(
-        cmSystemTools::GetFilenameName(makeCommand[0])) == "vcexpress.exe")
-    {
+      !makeCommand.empty() &&
+      cmSystemTools::LowerCase(
+        cmSystemTools::GetFilenameName(makeCommand[0])) == "vcexpress.exe") {
     outputflag = cmSystemTools::OUTPUT_FORWARD;
-    }
+  }
 
   // should we do a clean first?
-  if (clean)
-    {
+  if (clean) {
     std::vector<std::string> cleanCommand;
     this->GenerateBuildCommand(cleanCommand, makeCommandCSTR, projectName,
                                bindir, "clean", config, fast, verbose);
@@ -1898,8 +1679,7 @@ int cmGlobalGenerator::Build(
     output += "\n";
 
     if (!cmSystemTools::RunSingleCommand(cleanCommand, outputPtr, outputPtr,
-                                         &retVal, 0, outputflag, timeout))
-      {
+                                         &retVal, 0, outputflag, timeout)) {
       cmSystemTools::SetRunCommandHideConsole(hideconsole);
       cmSystemTools::Error("Generator: execution of make clean failed.");
       output += *outputPtr;
@@ -1908,9 +1688,9 @@ int cmGlobalGenerator::Build(
       // return to the original directory
       cmSystemTools::ChangeDirectory(cwd);
       return 1;
-      }
-    output += *outputPtr;
     }
+    output += *outputPtr;
+  }
 
   // now build
   std::string makeCommandStr = cmSystemTools::PrintSingleCommand(makeCommand);
@@ -1919,30 +1699,28 @@ int cmGlobalGenerator::Build(
   output += "\n";
 
   if (!cmSystemTools::RunSingleCommand(makeCommand, outputPtr, outputPtr,
-                                       &retVal, 0, outputflag, timeout))
-    {
+                                       &retVal, 0, outputflag, timeout)) {
     cmSystemTools::SetRunCommandHideConsole(hideconsole);
-    cmSystemTools::Error
-      ("Generator: execution of make failed. Make command was: ",
-       makeCommandStr.c_str());
+    cmSystemTools::Error(
+      "Generator: execution of make failed. Make command was: ",
+      makeCommandStr.c_str());
     output += *outputPtr;
-    output += "\nGenerator: execution of make failed. Make command was: "
-        + makeCommandStr + "\n";
+    output += "\nGenerator: execution of make failed. Make command was: " +
+      makeCommandStr + "\n";
 
     // return to the original directory
     cmSystemTools::ChangeDirectory(cwd);
     return 1;
-    }
+  }
   output += *outputPtr;
   cmSystemTools::SetRunCommandHideConsole(hideconsole);
 
   // The SGI MipsPro 7.3 compiler does not return an error code when
   // the source has a #error in it!  This is a work-around for such
   // compilers.
-  if((retVal == 0) && (output.find("#error") != std::string::npos))
-    {
+  if ((retVal == 0) && (output.find("#error") != std::string::npos)) {
     retVal = 1;
-    }
+  }
 
   cmSystemTools::ChangeDirectory(cwd);
   return retVal;
@@ -1950,85 +1728,75 @@ int cmGlobalGenerator::Build(
 
 std::string cmGlobalGenerator::GenerateCMakeBuildCommand(
   const std::string& target, const std::string& config,
-  const std::string& native,
-  bool ignoreErrors)
+  const std::string& native, bool ignoreErrors)
 {
   std::string makeCommand = cmSystemTools::GetCMakeCommand();
   makeCommand = cmSystemTools::ConvertToOutputPath(makeCommand.c_str());
   makeCommand += " --build .";
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     makeCommand += " --config \"";
     makeCommand += config;
     makeCommand += "\"";
-    }
-  if(!target.empty())
-    {
+  }
+  if (!target.empty()) {
     makeCommand += " --target \"";
     makeCommand += target;
     makeCommand += "\"";
-    }
+  }
   const char* sep = " -- ";
-  if(ignoreErrors)
-    {
+  if (ignoreErrors) {
     const char* iflag = this->GetBuildIgnoreErrorsFlag();
-    if(iflag && *iflag)
-      {
+    if (iflag && *iflag) {
       makeCommand += sep;
       makeCommand += iflag;
       sep = " ";
-      }
     }
-  if(!native.empty())
-    {
+  }
+  if (!native.empty()) {
     makeCommand += sep;
     makeCommand += native;
-    }
+  }
   return makeCommand;
 }
 
-void cmGlobalGenerator::AddMakefile(cmMakefile *mf)
+void cmGlobalGenerator::AddMakefile(cmMakefile* mf)
 {
   this->Makefiles.push_back(mf);
 
   // update progress
   // estimate how many lg there will be
-  const char *numGenC =
-    this->CMakeInstance->GetState()->GetInitializedCacheValue
-    ("CMAKE_NUMBER_OF_MAKEFILES");
+  const char* numGenC =
+    this->CMakeInstance->GetState()->GetInitializedCacheValue(
+      "CMAKE_NUMBER_OF_MAKEFILES");
 
-  if (!numGenC)
-    {
+  if (!numGenC) {
     // If CMAKE_NUMBER_OF_MAKEFILES is not set
     // we are in the first time progress and we have no
     // idea how long it will be.  So, just move half way
     // there each time, and don't go over 95%
-    this->FirstTimeProgress += ((1.0f - this->FirstTimeProgress) /30.0f);
-    if(this->FirstTimeProgress > 0.95f)
-      {
+    this->FirstTimeProgress += ((1.0f - this->FirstTimeProgress) / 30.0f);
+    if (this->FirstTimeProgress > 0.95f) {
       this->FirstTimeProgress = 0.95f;
-      }
+    }
     this->CMakeInstance->UpdateProgress("Configuring",
                                         this->FirstTimeProgress);
     return;
-    }
+  }
 
   int numGen = atoi(numGenC);
-  float prog = 0.9f*static_cast<float>(this->Makefiles.size())/
+  float prog = 0.9f * static_cast<float>(this->Makefiles.size()) /
     static_cast<float>(numGen);
-  if (prog > 0.9f)
-    {
+  if (prog > 0.9f) {
     prog = 0.9f;
-    }
+  }
   this->CMakeInstance->UpdateProgress("Configuring", prog);
 }
 
 void cmGlobalGenerator::AddInstallComponent(const char* component)
 {
-  if(component && *component)
-    {
+  if (component && *component) {
     this->InstallComponents.insert(component);
-    }
+  }
 }
 
 void cmGlobalGenerator::EnableInstallTarget()
@@ -2036,13 +1804,12 @@ void cmGlobalGenerator::EnableInstallTarget()
   this->InstallTargetEnabled = true;
 }
 
-cmLocalGenerator*
-cmGlobalGenerator::CreateLocalGenerator(cmMakefile* mf)
+cmLocalGenerator* cmGlobalGenerator::CreateLocalGenerator(cmMakefile* mf)
 {
   return new cmLocalGenerator(this, mf);
 }
 
-void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
+void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator* gen,
                                                      cmMakefile* mf)
 {
   this->SetConfiguredFilesPath(gen);
@@ -2050,12 +1817,10 @@ void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
   const char* make =
     gen->GetCMakeInstance()->GetCacheDefinition("CMAKE_MAKE_PROGRAM");
   this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", make,
-                                          "make program",
-                                          cmState::FILEPATH);
+                                          "make program", cmState::FILEPATH);
   // copy the enabled languages
   this->GetCMakeInstance()->GetState()->SetEnabledLanguages(
-    gen->GetCMakeInstance()->GetState()->GetEnabledLanguages()
-    );
+    gen->GetCMakeInstance()->GetState()->GetEnabledLanguages());
   this->LanguagesReady = gen->LanguagesReady;
   this->ExtensionToLanguage = gen->ExtensionToLanguage;
   this->IgnoreExtensions = gen->IgnoreExtensions;
@@ -2066,36 +1831,30 @@ void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
 
 void cmGlobalGenerator::SetConfiguredFilesPath(cmGlobalGenerator* gen)
 {
-  if(!gen->ConfiguredFilesPath.empty())
-    {
+  if (!gen->ConfiguredFilesPath.empty()) {
     this->ConfiguredFilesPath = gen->ConfiguredFilesPath;
-    }
-  else
-    {
+  } else {
     this->ConfiguredFilesPath = gen->CMakeInstance->GetHomeOutputDirectory();
     this->ConfiguredFilesPath += cmake::GetCMakeFilesDirectory();
-    }
+  }
 }
 
 bool cmGlobalGenerator::IsExcluded(cmState::Snapshot const& rootSnp,
-                       cmState::Snapshot const& snp_) const
+                                   cmState::Snapshot const& snp_) const
 {
   cmState::Snapshot snp = snp_;
-  while (snp.IsValid())
-    {
-    if(snp == rootSnp)
-      {
+  while (snp.IsValid()) {
+    if (snp == rootSnp) {
       // No directory excludes itself.
       return false;
-      }
+    }
 
-    if(snp.GetDirectory().GetPropertyAsBool("EXCLUDE_FROM_ALL"))
-      {
+    if (snp.GetDirectory().GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
       // This directory is excluded from its parent.
       return true;
-      }
-    snp = snp.GetBuildsystemDirectoryParent();
     }
+    snp = snp.GetBuildsystemDirectoryParent();
+  }
   return false;
 }
 
@@ -2113,19 +1872,18 @@ bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
 bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
                                    cmGeneratorTarget* target) const
 {
-  if(target->GetType() == cmState::INTERFACE_LIBRARY
-      || target->GetPropertyAsBool("EXCLUDE_FROM_ALL"))
-    {
+  if (target->GetType() == cmState::INTERFACE_LIBRARY ||
+      target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
     // This target is excluded from its directory.
     return true;
-    }
+  }
   // This target is included in its directory.  Check whether the
   // directory is excluded.
   return this->IsExcluded(root, target->GetLocalGenerator());
 }
 
-void
-cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang) const
+void cmGlobalGenerator::GetEnabledLanguages(
+  std::vector<std::string>& lang) const
 {
   lang = this->CMakeInstance->GetState()->GetEnabledLanguages();
 }
@@ -2133,11 +1891,10 @@ cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang) const
 int cmGlobalGenerator::GetLinkerPreference(const std::string& lang) const
 {
   std::map<std::string, int>::const_iterator it =
-                                   this->LanguageToLinkerPreference.find(lang);
-  if (it != this->LanguageToLinkerPreference.end())
-    {
+    this->LanguageToLinkerPreference.find(lang);
+  if (it != this->LanguageToLinkerPreference.end()) {
     return it->second;
-    }
+  }
   return 0;
 }
 
@@ -2145,53 +1902,45 @@ void cmGlobalGenerator::FillProjectMap()
 {
   this->ProjectMap.clear(); // make sure we start with a clean map
   unsigned int i;
-  for(i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
     // for each local generator add all projects
     cmState::Snapshot snp = this->LocalGenerators[i]->GetStateSnapshot();
     std::string name;
-    do
-      {
+    do {
       std::string snpProjName = snp.GetProjectName();
-      if (name != snpProjName)
-        {
+      if (name != snpProjName) {
         name = snpProjName;
         this->ProjectMap[name].push_back(this->LocalGenerators[i]);
-        }
-      snp = snp.GetBuildsystemDirectoryParent();
       }
-    while (snp.IsValid());
-    }
+      snp = snp.GetBuildsystemDirectoryParent();
+    } while (snp.IsValid());
+  }
 }
 
-cmMakefile*
-cmGlobalGenerator::FindMakefile(const std::string& start_dir) const
+cmMakefile* cmGlobalGenerator::FindMakefile(const std::string& start_dir) const
 {
-  for(std::vector<cmMakefile*>::const_iterator it =
-      this->Makefiles.begin(); it != this->Makefiles.end(); ++it)
-    {
+  for (std::vector<cmMakefile*>::const_iterator it = this->Makefiles.begin();
+       it != this->Makefiles.end(); ++it) {
     std::string sd = (*it)->GetCurrentSourceDirectory();
-    if (sd == start_dir)
-      {
+    if (sd == start_dir) {
       return *it;
-      }
     }
+  }
   return 0;
 }
 
 ///! Find a local generator by its startdirectory
-cmLocalGenerator*
-cmGlobalGenerator::FindLocalGenerator(const std::string& start_dir) const
+cmLocalGenerator* cmGlobalGenerator::FindLocalGenerator(
+  const std::string& start_dir) const
 {
-  for(std::vector<cmLocalGenerator*>::const_iterator it =
-      this->LocalGenerators.begin(); it != this->LocalGenerators.end(); ++it)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator it =
+         this->LocalGenerators.begin();
+       it != this->LocalGenerators.end(); ++it) {
     std::string sd = (*it)->GetCurrentSourceDirectory();
-    if (sd == start_dir)
-      {
+    if (sd == start_dir) {
       return *it;
-      }
     }
+  }
   return 0;
 }
 
@@ -2208,95 +1957,83 @@ bool cmGlobalGenerator::IsAlias(const std::string& name) const
 
 void cmGlobalGenerator::IndexTarget(cmTarget* t)
 {
-  if (!t->IsImported() || t->IsImportedGloballyVisible())
-    {
+  if (!t->IsImported() || t->IsImportedGloballyVisible()) {
     this->TargetSearchIndex[t->GetName()] = t;
-    }
+  }
 }
 
 void cmGlobalGenerator::IndexGeneratorTarget(cmGeneratorTarget* gt)
 {
-  if (!gt->IsImported() || gt->IsImportedGloballyVisible())
-    {
+  if (!gt->IsImported() || gt->IsImportedGloballyVisible()) {
     this->GeneratorTargetSearchIndex[gt->GetName()] = gt;
-    }
+  }
 }
 
 cmTarget* cmGlobalGenerator::FindTargetImpl(std::string const& name) const
 {
   TargetMap::const_iterator i = this->TargetSearchIndex.find(name);
-  if (i != this->TargetSearchIndex.end())
-    {
+  if (i != this->TargetSearchIndex.end()) {
     return i->second;
-    }
+  }
   return 0;
 }
 
-cmGeneratorTarget*
-cmGlobalGenerator::FindGeneratorTargetImpl(std::string const& name) const
+cmGeneratorTarget* cmGlobalGenerator::FindGeneratorTargetImpl(
+  std::string const& name) const
 {
   GeneratorTargetMap::const_iterator i =
     this->GeneratorTargetSearchIndex.find(name);
-  if (i != this->GeneratorTargetSearchIndex.end())
-    {
+  if (i != this->GeneratorTargetSearchIndex.end()) {
     return i->second;
-    }
+  }
   return 0;
 }
 
-cmTarget*
-cmGlobalGenerator::FindTarget(const std::string& name,
-                              bool excludeAliases) const
+cmTarget* cmGlobalGenerator::FindTarget(const std::string& name,
+                                        bool excludeAliases) const
 {
-  if (!excludeAliases)
-    {
+  if (!excludeAliases) {
     std::map<std::string, std::string>::const_iterator ai =
-        this->AliasTargets.find(name);
-    if (ai != this->AliasTargets.end())
-      {
+      this->AliasTargets.find(name);
+    if (ai != this->AliasTargets.end()) {
       return this->FindTargetImpl(ai->second);
-      }
     }
+  }
   return this->FindTargetImpl(name);
 }
 
-cmGeneratorTarget*
-cmGlobalGenerator::FindGeneratorTarget(const std::string& name) const
+cmGeneratorTarget* cmGlobalGenerator::FindGeneratorTarget(
+  const std::string& name) const
 {
   std::map<std::string, std::string>::const_iterator ai =
-      this->AliasTargets.find(name);
-  if (ai != this->AliasTargets.end())
-    {
+    this->AliasTargets.find(name);
+  if (ai != this->AliasTargets.end()) {
     return this->FindGeneratorTargetImpl(ai->second);
-    }
+  }
   return this->FindGeneratorTargetImpl(name);
 }
 
-bool
-cmGlobalGenerator::NameResolvesToFramework(const std::string& libname) const
+bool cmGlobalGenerator::NameResolvesToFramework(
+  const std::string& libname) const
 {
-  if(cmSystemTools::IsPathToFramework(libname.c_str()))
-    {
+  if (cmSystemTools::IsPathToFramework(libname.c_str())) {
     return true;
-    }
+  }
 
-  if(cmTarget* tgt = this->FindTarget(libname))
-    {
-    if(tgt->IsFrameworkOnApple())
-       {
-       return true;
-       }
+  if (cmTarget* tgt = this->FindTarget(libname)) {
+    if (tgt->IsFrameworkOnApple()) {
+      return true;
     }
+  }
 
   return false;
 }
 
 inline std::string removeQuotes(const std::string& s)
 {
-  if(s[0] == '\"' && s[s.size()-1] == '\"')
-    {
-    return s.substr(1, s.size()-2);
-    }
+  if (s[0] == '\"' && s[s.size() - 1] == '\"') {
+    return s.substr(1, s.size() - 2);
+  }
   return s;
 }
 
@@ -2306,98 +2043,86 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
   const char* cmakeCfgIntDir = this->GetCMakeCFGIntDir();
 
   // CPack
-  std::string workingDir =  mf->GetCurrentBinaryDirectory();
+  std::string workingDir = mf->GetCurrentBinaryDirectory();
   cmCustomCommandLines cpackCommandLines;
   std::vector<std::string> depends;
   cmCustomCommandLine singleLine;
   singleLine.push_back(cmSystemTools::GetCPackCommand());
-  if ( cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.' )
-    {
+  if (cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.') {
     singleLine.push_back("-C");
     singleLine.push_back(cmakeCfgIntDir);
-    }
+  }
   singleLine.push_back("--config");
-  std::string configFile = mf->GetCurrentBinaryDirectory();;
+  std::string configFile = mf->GetCurrentBinaryDirectory();
+  ;
   configFile += "/CPackConfig.cmake";
   std::string relConfigFile = "./CPackConfig.cmake";
   singleLine.push_back(relConfigFile);
   cpackCommandLines.push_back(singleLine);
-  if ( this->GetPreinstallTargetName() )
-    {
+  if (this->GetPreinstallTargetName()) {
     depends.push_back(this->GetPreinstallTargetName());
-    }
-  else
-    {
+  } else {
     const char* noPackageAll =
       mf->GetDefinition("CMAKE_SKIP_PACKAGE_ALL_DEPENDENCY");
-    if(!noPackageAll || cmSystemTools::IsOff(noPackageAll))
-      {
+    if (!noPackageAll || cmSystemTools::IsOff(noPackageAll)) {
       depends.push_back(this->GetAllTargetName());
-      }
-    }
-  if(cmSystemTools::FileExists(configFile.c_str()))
-    {
-    (*targets)[this->GetPackageTargetName()]
-      = this->CreateGlobalTarget(this->GetPackageTargetName(),
-                                 "Run CPack packaging tool...",
-                                 &cpackCommandLines, depends,
-                                 workingDir.c_str(), /*uses_terminal*/true);
     }
+  }
+  if (cmSystemTools::FileExists(configFile.c_str())) {
+    (*targets)[this->GetPackageTargetName()] = this->CreateGlobalTarget(
+      this->GetPackageTargetName(), "Run CPack packaging tool...",
+      &cpackCommandLines, depends, workingDir.c_str(), /*uses_terminal*/ true);
+  }
   // CPack source
   const char* packageSourceTargetName = this->GetPackageSourceTargetName();
-  if ( packageSourceTargetName )
-    {
+  if (packageSourceTargetName) {
     cpackCommandLines.erase(cpackCommandLines.begin(),
                             cpackCommandLines.end());
     singleLine.erase(singleLine.begin(), singleLine.end());
     depends.erase(depends.begin(), depends.end());
     singleLine.push_back(cmSystemTools::GetCPackCommand());
     singleLine.push_back("--config");
-    configFile = mf->GetCurrentBinaryDirectory();;
+    configFile = mf->GetCurrentBinaryDirectory();
+    ;
     configFile += "/CPackSourceConfig.cmake";
     relConfigFile = "./CPackSourceConfig.cmake";
     singleLine.push_back(relConfigFile);
-    if(cmSystemTools::FileExists(configFile.c_str()))
-      {
+    if (cmSystemTools::FileExists(configFile.c_str())) {
       singleLine.push_back(configFile);
       cpackCommandLines.push_back(singleLine);
-      (*targets)[packageSourceTargetName]
-        = this->CreateGlobalTarget(packageSourceTargetName,
-                                   "Run CPack packaging tool for source...",
-                                   &cpackCommandLines, depends,
-                                   workingDir.c_str(), /*uses_terminal*/true);
-      }
+      (*targets)[packageSourceTargetName] = this->CreateGlobalTarget(
+        packageSourceTargetName, "Run CPack packaging tool for source...",
+        &cpackCommandLines, depends, workingDir.c_str(),
+        /*uses_terminal*/ true);
     }
+  }
 
   // Test
-  if(mf->IsOn("CMAKE_TESTING_ENABLED"))
-    {
+  if (mf->IsOn("CMAKE_TESTING_ENABLED")) {
     cpackCommandLines.erase(cpackCommandLines.begin(),
                             cpackCommandLines.end());
     singleLine.erase(singleLine.begin(), singleLine.end());
     depends.erase(depends.begin(), depends.end());
     singleLine.push_back(cmSystemTools::GetCTestCommand());
     singleLine.push_back("--force-new-ctest-process");
-    if(cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.')
-      {
+    if (cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.') {
       singleLine.push_back("-C");
       singleLine.push_back(cmakeCfgIntDir);
-      }
-    else // TODO: This is a hack. Should be something to do with the generator
-      {
+    } else // TODO: This is a hack. Should be something to do with the
+           // generator
+    {
       singleLine.push_back("$(ARGS)");
-      }
-    cpackCommandLines.push_back(singleLine);
-    (*targets)[this->GetTestTargetName()]
-      = this->CreateGlobalTarget(this->GetTestTargetName(),
-        "Running tests...", &cpackCommandLines, depends, 0,
-        /*uses_terminal*/true);
     }
+    cpackCommandLines.push_back(singleLine);
+    (*targets)[this->GetTestTargetName()] =
+      this->CreateGlobalTarget(this->GetTestTargetName(), "Running tests...",
+                               &cpackCommandLines, depends, 0,
+                               /*uses_terminal*/ true);
+  }
 
-  //Edit Cache
+  // Edit Cache
   const char* editCacheTargetName = this->GetEditCacheTargetName();
-  if ( editCacheTargetName )
-    {
+  if (editCacheTargetName) {
     cpackCommandLines.erase(cpackCommandLines.begin(),
                             cpackCommandLines.end());
     singleLine.erase(singleLine.begin(), singleLine.end());
@@ -2405,36 +2130,29 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
 
     // Use generator preference for the edit_cache rule if it is defined.
     std::string edit_cmd = this->GetEditCacheCommand();
-    if (!edit_cmd.empty())
-      {
+    if (!edit_cmd.empty()) {
       singleLine.push_back(edit_cmd);
       singleLine.push_back("-H$(CMAKE_SOURCE_DIR)");
       singleLine.push_back("-B$(CMAKE_BINARY_DIR)");
       cpackCommandLines.push_back(singleLine);
-      (*targets)[editCacheTargetName] =
-        this->CreateGlobalTarget(
-          editCacheTargetName, "Running CMake cache editor...",
-          &cpackCommandLines, depends, 0, /*uses_terminal*/true);
-      }
-    else
-      {
+      (*targets)[editCacheTargetName] = this->CreateGlobalTarget(
+        editCacheTargetName, "Running CMake cache editor...",
+        &cpackCommandLines, depends, 0, /*uses_terminal*/ true);
+    } else {
       singleLine.push_back(cmSystemTools::GetCMakeCommand());
       singleLine.push_back("-E");
       singleLine.push_back("echo");
       singleLine.push_back("No interactive CMake dialog available.");
       cpackCommandLines.push_back(singleLine);
-      (*targets)[editCacheTargetName] =
-        this->CreateGlobalTarget(
-          editCacheTargetName,
-          "No interactive CMake dialog available...",
-          &cpackCommandLines, depends, 0, /*uses_terminal*/false);
-      }
+      (*targets)[editCacheTargetName] = this->CreateGlobalTarget(
+        editCacheTargetName, "No interactive CMake dialog available...",
+        &cpackCommandLines, depends, 0, /*uses_terminal*/ false);
     }
+  }
 
-  //Rebuild Cache
+  // Rebuild Cache
   const char* rebuildCacheTargetName = this->GetRebuildCacheTargetName();
-  if ( rebuildCacheTargetName )
-    {
+  if (rebuildCacheTargetName) {
     cpackCommandLines.erase(cpackCommandLines.begin(),
                             cpackCommandLines.end());
     singleLine.erase(singleLine.begin(), singleLine.end());
@@ -2443,155 +2161,131 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
     singleLine.push_back("-H$(CMAKE_SOURCE_DIR)");
     singleLine.push_back("-B$(CMAKE_BINARY_DIR)");
     cpackCommandLines.push_back(singleLine);
-    (*targets)[rebuildCacheTargetName] =
-      this->CreateGlobalTarget(
-        rebuildCacheTargetName, "Running CMake to regenerate build system...",
-        &cpackCommandLines, depends, 0, /*uses_terminal*/true);
-    }
+    (*targets)[rebuildCacheTargetName] = this->CreateGlobalTarget(
+      rebuildCacheTargetName, "Running CMake to regenerate build system...",
+      &cpackCommandLines, depends, 0, /*uses_terminal*/ true);
+  }
 
-  //Install
+  // Install
   bool skipInstallRules = mf->IsOn("CMAKE_SKIP_INSTALL_RULES");
-  if(this->InstallTargetEnabled && skipInstallRules)
-    {
+  if (this->InstallTargetEnabled && skipInstallRules) {
     mf->IssueMessage(cmake::WARNING,
-      "CMAKE_SKIP_INSTALL_RULES was enabled even though "
-      "installation rules have been specified");
-    }
-  else if(this->InstallTargetEnabled && !skipInstallRules)
-    {
-    if(!cmakeCfgIntDir || !*cmakeCfgIntDir || cmakeCfgIntDir[0] == '.')
-      {
+                     "CMAKE_SKIP_INSTALL_RULES was enabled even though "
+                     "installation rules have been specified");
+  } else if (this->InstallTargetEnabled && !skipInstallRules) {
+    if (!cmakeCfgIntDir || !*cmakeCfgIntDir || cmakeCfgIntDir[0] == '.') {
       std::set<std::string>* componentsSet = &this->InstallComponents;
       cpackCommandLines.erase(cpackCommandLines.begin(),
-        cpackCommandLines.end());
+                              cpackCommandLines.end());
       depends.erase(depends.begin(), depends.end());
       std::ostringstream ostr;
-      if (!componentsSet->empty())
-        {
+      if (!componentsSet->empty()) {
         ostr << "Available install components are: ";
         ostr << cmWrap('"', *componentsSet, '"', " ");
-        }
-      else
-        {
+      } else {
         ostr << "Only default component available";
-        }
-      singleLine.push_back(ostr.str());
-      (*targets)["list_install_components"]
-        = this->CreateGlobalTarget("list_install_components",
-          ostr.str().c_str(),
-          &cpackCommandLines, depends, 0, /*uses_terminal*/false);
       }
+      singleLine.push_back(ostr.str());
+      (*targets)["list_install_components"] = this->CreateGlobalTarget(
+        "list_install_components", ostr.str().c_str(), &cpackCommandLines,
+        depends, 0, /*uses_terminal*/ false);
+    }
     std::string cmd = cmSystemTools::GetCMakeCommand();
     cpackCommandLines.erase(cpackCommandLines.begin(),
-      cpackCommandLines.end());
+                            cpackCommandLines.end());
     singleLine.erase(singleLine.begin(), singleLine.end());
     depends.erase(depends.begin(), depends.end());
-    if ( this->GetPreinstallTargetName() )
-      {
+    if (this->GetPreinstallTargetName()) {
       depends.push_back(this->GetPreinstallTargetName());
-      }
-    else
-      {
+    } else {
       const char* noall =
         mf->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
-      if(!noall || cmSystemTools::IsOff(noall))
-        {
+      if (!noall || cmSystemTools::IsOff(noall)) {
         depends.push_back(this->GetAllTargetName());
-        }
       }
-    if(mf->GetDefinition("CMake_BINARY_DIR") &&
-       !mf->IsOn("CMAKE_CROSSCOMPILING"))
-      {
+    }
+    if (mf->GetDefinition("CMake_BINARY_DIR") &&
+        !mf->IsOn("CMAKE_CROSSCOMPILING")) {
       // We are building CMake itself.  We cannot use the original
       // executable to install over itself.  The generator will
       // automatically convert this name to the build-time location.
       cmd = "cmake";
-      }
+    }
     singleLine.push_back(cmd);
-    if ( cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.' )
-      {
+    if (cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.') {
       std::string cfgArg = "-DBUILD_TYPE=";
       bool iosPlatform = mf->PlatformIsAppleIos();
-      if(iosPlatform)
-        {
+      if (iosPlatform) {
         cfgArg += "$(CONFIGURATION)";
         singleLine.push_back(cfgArg);
         cfgArg = "-DEFFECTIVE_PLATFORM_NAME=$(EFFECTIVE_PLATFORM_NAME)";
-        }
-      else
-        {
+      } else {
         cfgArg += mf->GetDefinition("CMAKE_CFG_INTDIR");
-        }
-      singleLine.push_back(cfgArg);
       }
+      singleLine.push_back(cfgArg);
+    }
     singleLine.push_back("-P");
     singleLine.push_back("cmake_install.cmake");
     cpackCommandLines.push_back(singleLine);
-    (*targets)[this->GetInstallTargetName()] =
-      this->CreateGlobalTarget(
-        this->GetInstallTargetName(), "Install the project...",
-        &cpackCommandLines, depends, 0, /*uses_terminal*/true);
+    (*targets)[this->GetInstallTargetName()] = this->CreateGlobalTarget(
+      this->GetInstallTargetName(), "Install the project...",
+      &cpackCommandLines, depends, 0, /*uses_terminal*/ true);
 
     // install_local
-    if(const char* install_local = this->GetInstallLocalTargetName())
-      {
+    if (const char* install_local = this->GetInstallLocalTargetName()) {
       cmCustomCommandLine localCmdLine = singleLine;
 
-      localCmdLine.insert(localCmdLine.begin()+1,
-                                               "-DCMAKE_INSTALL_LOCAL_ONLY=1");
+      localCmdLine.insert(localCmdLine.begin() + 1,
+                          "-DCMAKE_INSTALL_LOCAL_ONLY=1");
       cpackCommandLines.erase(cpackCommandLines.begin(),
-                                                      cpackCommandLines.end());
+                              cpackCommandLines.end());
       cpackCommandLines.push_back(localCmdLine);
 
-      (*targets)[install_local] =
-        this->CreateGlobalTarget(
-          install_local, "Installing only the local directory...",
-          &cpackCommandLines, depends, 0, /*uses_terminal*/true);
-      }
+      (*targets)[install_local] = this->CreateGlobalTarget(
+        install_local, "Installing only the local directory...",
+        &cpackCommandLines, depends, 0, /*uses_terminal*/ true);
+    }
 
     // install_strip
     const char* install_strip = this->GetInstallStripTargetName();
-    if((install_strip !=0) && (mf->IsSet("CMAKE_STRIP")))
-      {
+    if ((install_strip != 0) && (mf->IsSet("CMAKE_STRIP"))) {
       cmCustomCommandLine stripCmdLine = singleLine;
 
-      stripCmdLine.insert(stripCmdLine.begin()+1,"-DCMAKE_INSTALL_DO_STRIP=1");
+      stripCmdLine.insert(stripCmdLine.begin() + 1,
+                          "-DCMAKE_INSTALL_DO_STRIP=1");
       cpackCommandLines.erase(cpackCommandLines.begin(),
-        cpackCommandLines.end());
+                              cpackCommandLines.end());
       cpackCommandLines.push_back(stripCmdLine);
 
-      (*targets)[install_strip] =
-        this->CreateGlobalTarget(
-          install_strip, "Installing the project stripped...",
-          &cpackCommandLines, depends, 0, /*uses_terminal*/true);
-      }
+      (*targets)[install_strip] = this->CreateGlobalTarget(
+        install_strip, "Installing the project stripped...",
+        &cpackCommandLines, depends, 0, /*uses_terminal*/ true);
     }
+  }
 }
 
 const char* cmGlobalGenerator::GetPredefinedTargetsFolder()
 {
-  const char* prop = this->GetCMakeInstance()->GetState()
-                         ->GetGlobalProperty("PREDEFINED_TARGETS_FOLDER");
+  const char* prop = this->GetCMakeInstance()->GetState()->GetGlobalProperty(
+    "PREDEFINED_TARGETS_FOLDER");
 
-  if (prop)
-    {
+  if (prop) {
     return prop;
-    }
+  }
 
   return "CMakePredefinedTargets";
 }
 
 bool cmGlobalGenerator::UseFolderProperty()
 {
-  const char* prop = this->GetCMakeInstance()->GetState()
-                         ->GetGlobalProperty("USE_FOLDERS");
+  const char* prop =
+    this->GetCMakeInstance()->GetState()->GetGlobalProperty("USE_FOLDERS");
 
   // If this property is defined, let the setter turn this on or off...
   //
-  if (prop)
-    {
+  if (prop) {
     return cmSystemTools::IsOn(prop);
-    }
+  }
 
   // By default, this feature is OFF, since it is not supported in the
   // Visual Studio Express editions until VS11:
@@ -2601,64 +2295,58 @@ bool cmGlobalGenerator::UseFolderProperty()
 
 cmTarget cmGlobalGenerator::CreateGlobalTarget(
   const std::string& name, const char* message,
-  const cmCustomCommandLines* commandLines,
-  std::vector<std::string> depends,
-  const char* workingDirectory,
-  bool uses_terminal)
+  const cmCustomCommandLines* commandLines, std::vector<std::string> depends,
+  const char* workingDirectory, bool uses_terminal)
 {
   // Package
   cmTarget target;
   target.SetType(cmState::GLOBAL_TARGET, name);
-  target.SetProperty("EXCLUDE_FROM_ALL","TRUE");
+  target.SetProperty("EXCLUDE_FROM_ALL", "TRUE");
 
   std::vector<std::string> no_outputs;
   std::vector<std::string> no_byproducts;
   std::vector<std::string> no_depends;
   // Store the custom command in the target.
-  cmCustomCommand cc(0, no_outputs, no_byproducts, no_depends,
-                     *commandLines, 0, workingDirectory);
+  cmCustomCommand cc(0, no_outputs, no_byproducts, no_depends, *commandLines,
+                     0, workingDirectory);
   cc.SetUsesTerminal(uses_terminal);
   target.AddPostBuildCommand(cc);
   target.SetProperty("EchoString", message);
   std::vector<std::string>::iterator dit;
-  for ( dit = depends.begin(); dit != depends.end(); ++ dit )
-    {
+  for (dit = depends.begin(); dit != depends.end(); ++dit) {
     target.AddUtility(*dit);
-    }
+  }
 
   // Organize in the "predefined targets" folder:
   //
-  if (this->UseFolderProperty())
-    {
+  if (this->UseFolderProperty()) {
     target.SetProperty("FOLDER", this->GetPredefinedTargetsFolder());
-    }
+  }
 
   return target;
 }
 
-std::string
-cmGlobalGenerator::GenerateRuleFile(std::string const& output) const
+std::string cmGlobalGenerator::GenerateRuleFile(
+  std::string const& output) const
 {
   std::string ruleFile = output;
   ruleFile += ".rule";
   const char* dir = this->GetCMakeCFGIntDir();
-  if(dir && dir[0] == '$')
-    {
+  if (dir && dir[0] == '$') {
     cmSystemTools::ReplaceString(ruleFile, dir,
                                  cmake::GetCMakeFilesDirectory());
-    }
+  }
   return ruleFile;
 }
 
 std::string cmGlobalGenerator::GetSharedLibFlagsForLanguage(
-                                                  std::string const& l) const
+  std::string const& l) const
 {
   std::map<std::string, std::string>::const_iterator it =
-                              this->LanguageToOriginalSharedLibFlags.find(l);
-  if(it != this->LanguageToOriginalSharedLibFlags.end())
-    {
+    this->LanguageToOriginalSharedLibFlags.find(l);
+  if (it != this->LanguageToOriginalSharedLibFlags.end()) {
     return it->second;
-    }
+  }
   return "";
 }
 
@@ -2684,39 +2372,29 @@ bool cmGlobalGenerator::IsReservedTarget(std::string const& name)
   // by one or more of the cmake generators.
 
   // Adding additional targets to this list will require a policy!
-  const char* reservedTargets[] =
-  {
-    "all", "ALL_BUILD",
-    "help",
-    "install", "INSTALL",
-    "preinstall",
-    "clean",
-    "edit_cache",
-    "rebuild_cache",
-    "test", "RUN_TESTS",
-    "package", "PACKAGE",
-    "package_source",
-    "ZERO_CHECK"
+  const char* reservedTargets[] = {
+    "all",        "ALL_BUILD", "help",       "install",        "INSTALL",
+    "preinstall", "clean",     "edit_cache", "rebuild_cache",  "test",
+    "RUN_TESTS",  "package",   "PACKAGE",    "package_source", "ZERO_CHECK"
   };
 
-  return std::find(cmArrayBegin(reservedTargets),
-                   cmArrayEnd(reservedTargets), name)
-      != cmArrayEnd(reservedTargets);
+  return std::find(cmArrayBegin(reservedTargets), cmArrayEnd(reservedTargets),
+                   name) != cmArrayEnd(reservedTargets);
 }
 
 void cmGlobalGenerator::SetExternalMakefileProjectGenerator(
-                            cmExternalMakefileProjectGenerator *extraGenerator)
+  cmExternalMakefileProjectGenerator* extraGenerator)
 {
   this->ExtraGenerator = extraGenerator;
-  if (this->ExtraGenerator!=0)
-    {
+  if (this->ExtraGenerator != 0) {
     this->ExtraGenerator->SetGlobalGenerator(this);
-    }
+  }
 }
 
 std::string cmGlobalGenerator::GetExtraGeneratorName() const
 {
-  return this->ExtraGenerator? this->ExtraGenerator->GetName() : std::string();
+  return this->ExtraGenerator ? this->ExtraGenerator->GetName()
+                              : std::string();
 }
 
 void cmGlobalGenerator::FileReplacedDuringGenerate(const std::string& filename)
@@ -2724,15 +2402,13 @@ void cmGlobalGenerator::FileReplacedDuringGenerate(const std::string& filename)
   this->FilesReplacedDuringGenerate.push_back(filename);
 }
 
-void
-cmGlobalGenerator
-::GetFilesReplacedDuringGenerate(std::vector<std::string>& filenames)
+void cmGlobalGenerator::GetFilesReplacedDuringGenerate(
+  std::vector<std::string>& filenames)
 {
   filenames.clear();
-  std::copy(
-    this->FilesReplacedDuringGenerate.begin(),
-    this->FilesReplacedDuringGenerate.end(),
-    std::back_inserter(filenames));
+  std::copy(this->FilesReplacedDuringGenerate.begin(),
+            this->FilesReplacedDuringGenerate.end(),
+            std::back_inserter(filenames));
 }
 
 void cmGlobalGenerator::GetTargetSets(TargetDependSet& projectTargets,
@@ -2741,32 +2417,28 @@ void cmGlobalGenerator::GetTargetSets(TargetDependSet& projectTargets,
                                       GeneratorVector const& generators)
 {
   // loop over all local generators
-  for(std::vector<cmLocalGenerator*>::const_iterator i = generators.begin();
-      i != generators.end(); ++i)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator i = generators.begin();
+       i != generators.end(); ++i) {
     // check to make sure generator is not excluded
-    if(this->IsExcluded(root, *i))
-      {
+    if (this->IsExcluded(root, *i)) {
       continue;
-      }
+    }
     // Get the targets in the makefile
     std::vector<cmGeneratorTarget*> tgts = (*i)->GetGeneratorTargets();
     // loop over all the targets
     for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-         l != tgts.end(); ++l)
-      {
+         l != tgts.end(); ++l) {
       cmGeneratorTarget* target = *l;
-      if(this->IsRootOnlyTarget(target) &&
-         target->GetLocalGenerator() != root)
-        {
+      if (this->IsRootOnlyTarget(target) &&
+          target->GetLocalGenerator() != root) {
         continue;
-        }
+      }
       // put the target in the set of original targets
       originalTargets.insert(target);
       // Get the set of targets that depend on target
       this->AddTargetDepends(target, projectTargets);
-      }
     }
+  }
 }
 
 bool cmGlobalGenerator::IsRootOnlyTarget(cmGeneratorTarget* target) const
@@ -2779,19 +2451,16 @@ void cmGlobalGenerator::AddTargetDepends(cmGeneratorTarget const* target,
                                          TargetDependSet& projectTargets)
 {
   // add the target itself
-  if(projectTargets.insert(target).second)
-    {
+  if (projectTargets.insert(target).second) {
     // This is the first time we have encountered the target.
     // Recursively follow its dependencies.
     TargetDependSet const& ts = this->GetTargetDirectDepends(target);
-    for(TargetDependSet::const_iterator i = ts.begin(); i != ts.end(); ++i)
-      {
+    for (TargetDependSet::const_iterator i = ts.begin(); i != ts.end(); ++i) {
       this->AddTargetDepends(*i, projectTargets);
-      }
     }
+  }
 }
 
-
 void cmGlobalGenerator::AddToManifest(std::string const& f)
 {
   // Add to the content listing for the file's directory.
@@ -2802,66 +2471,59 @@ void cmGlobalGenerator::AddToManifest(std::string const& f)
   dc.All.insert(file);
 }
 
-std::set<std::string> const&
-cmGlobalGenerator::GetDirectoryContent(std::string const& dir, bool needDisk)
+std::set<std::string> const& cmGlobalGenerator::GetDirectoryContent(
+  std::string const& dir, bool needDisk)
 {
   DirectoryContent& dc = this->DirectoryContentMap[dir];
-  if(needDisk)
-    {
+  if (needDisk) {
     long mt = cmSystemTools::ModifiedTime(dir);
-    if (mt != dc.LastDiskTime)
-      {
+    if (mt != dc.LastDiskTime) {
       // Reset to non-loaded directory content.
       dc.All = dc.Generated;
 
       // Load the directory content from disk.
       cmsys::Directory d;
-      if(d.Load(dir))
-        {
+      if (d.Load(dir)) {
         unsigned long n = d.GetNumberOfFiles();
-        for(unsigned long i = 0; i < n; ++i)
-          {
+        for (unsigned long i = 0; i < n; ++i) {
           const char* f = d.GetFile(i);
-          if(strcmp(f, ".") != 0 && strcmp(f, "..") != 0)
-            {
+          if (strcmp(f, ".") != 0 && strcmp(f, "..") != 0) {
             dc.All.insert(f);
-            }
           }
         }
-      dc.LastDiskTime = mt;
       }
+      dc.LastDiskTime = mt;
     }
+  }
   return dc.All;
 }
 
-void
-cmGlobalGenerator::AddRuleHash(const std::vector<std::string>& outputs,
-                               std::string const& content)
+void cmGlobalGenerator::AddRuleHash(const std::vector<std::string>& outputs,
+                                    std::string const& content)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   // Ignore if there are no outputs.
-  if(outputs.empty())
-    {
+  if (outputs.empty()) {
     return;
-    }
+  }
 
   // Compute a hash of the rule.
   RuleHash hash;
   {
-  unsigned char const* data =
-    reinterpret_cast<unsigned char const*>(content.c_str());
-  int length = static_cast<int>(content.length());
-  cmsysMD5* sum = cmsysMD5_New();
-  cmsysMD5_Initialize(sum);
-  cmsysMD5_Append(sum, data, length);
-  cmsysMD5_FinalizeHex(sum, hash.Data);
-  cmsysMD5_Delete(sum);
+    unsigned char const* data =
+      reinterpret_cast<unsigned char const*>(content.c_str());
+    int length = static_cast<int>(content.length());
+    cmsysMD5* sum = cmsysMD5_New();
+    cmsysMD5_Initialize(sum);
+    cmsysMD5_Append(sum, data, length);
+    cmsysMD5_FinalizeHex(sum, hash.Data);
+    cmsysMD5_Delete(sum);
   }
 
   // Shorten the output name (in expected use case).
   cmOutputConverter converter(this->GetMakefiles()[0]->GetStateSnapshot());
-  std::string fname = converter.Convert(
-        outputs[0], cmLocalGenerator::HOME_OUTPUT);
+  std::string fname =
+    converter.Convert(outputs[0], cmLocalGenerator::HOME_OUTPUT);
 
   // Associate the hash with this output.
   this->RuleHashes[fname] = hash;
@@ -2891,22 +2553,19 @@ void cmGlobalGenerator::CheckRuleHashes(std::string const& pfile,
 #else
   cmsys::ifstream fin(pfile.c_str(), std::ios::in);
 #endif
-  if(!fin)
-    {
+  if (!fin) {
     return;
-    }
+  }
   std::string line;
   std::string fname;
-  while(cmSystemTools::GetLineFromStream(fin, line))
-    {
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
     // Line format is a 32-byte hex string followed by a space
     // followed by a file name (with no escaping).
 
     // Skip blank and comment lines.
-    if(line.size() < 34 || line[0] == '#')
-      {
+    if (line.size() < 34 || line[0] == '#') {
       continue;
-      }
+    }
 
     // Get the filename.
     fname = line.substr(33, line.npos);
@@ -2914,55 +2573,46 @@ void cmGlobalGenerator::CheckRuleHashes(std::string const& pfile,
     // Look for a hash for this file's rule.
     std::map<std::string, RuleHash>::const_iterator rhi =
       this->RuleHashes.find(fname);
-    if(rhi != this->RuleHashes.end())
-      {
+    if (rhi != this->RuleHashes.end()) {
       // Compare the rule hash in the file to that we were given.
-      if(strncmp(line.c_str(), rhi->second.Data, 32) != 0)
-        {
+      if (strncmp(line.c_str(), rhi->second.Data, 32) != 0) {
         // The rule has changed.  Delete the output so it will be
         // built again.
         fname = cmSystemTools::CollapseFullPath(fname, home.c_str());
         cmSystemTools::RemoveFile(fname);
-        }
       }
-    else
-      {
+    } else {
       // We have no hash for a rule previously listed.  This may be a
       // case where a user has turned off a build option and might
       // want to turn it back on later, so do not delete the file.
       // Instead, we keep the rule hash as long as the file exists so
       // that if the feature is turned back on and the rule has
       // changed the file is still rebuilt.
-      std::string fpath =
-        cmSystemTools::CollapseFullPath(fname, home.c_str());
-      if(cmSystemTools::FileExists(fpath.c_str()))
-        {
+      std::string fpath = cmSystemTools::CollapseFullPath(fname, home.c_str());
+      if (cmSystemTools::FileExists(fpath.c_str())) {
         RuleHash hash;
         strncpy(hash.Data, line.c_str(), 32);
         this->RuleHashes[fname] = hash;
-        }
       }
     }
+  }
 }
 
 void cmGlobalGenerator::WriteRuleHashes(std::string const& pfile)
 {
   // Now generate a new persistence file with the current hashes.
-  if(this->RuleHashes.empty())
-    {
+  if (this->RuleHashes.empty()) {
     cmSystemTools::RemoveFile(pfile);
-    }
-  else
-    {
+  } else {
     cmGeneratedFileStream fout(pfile.c_str());
     fout << "# Hashes of file build rules.\n";
-    for(std::map<std::string, RuleHash>::const_iterator
-          rhi = this->RuleHashes.begin(); rhi != this->RuleHashes.end(); ++rhi)
-      {
+    for (std::map<std::string, RuleHash>::const_iterator rhi =
+           this->RuleHashes.begin();
+         rhi != this->RuleHashes.end(); ++rhi) {
       fout.write(rhi->second.Data, 32);
       fout << " " << rhi->first << "\n";
-      }
     }
+  }
 }
 
 void cmGlobalGenerator::WriteSummary()
@@ -2973,21 +2623,18 @@ void cmGlobalGenerator::WriteSummary()
   fname += "/TargetDirectories.txt";
   cmGeneratedFileStream fout(fname.c_str());
 
-  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
     std::vector<cmGeneratorTarget*> tgts =
-        this->LocalGenerators[i]->GetGeneratorTargets();
+      this->LocalGenerators[i]->GetGeneratorTargets();
     for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin();
-         it != tgts.end(); ++it)
-      {
-      if ((*it)->GetType() == cmState::INTERFACE_LIBRARY)
-        {
+         it != tgts.end(); ++it) {
+      if ((*it)->GetType() == cmState::INTERFACE_LIBRARY) {
         continue;
-        }
+      }
       this->WriteSummary(*it);
       fout << (*it)->GetSupportDirectory() << "\n";
-      }
     }
+  }
 }
 
 void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target)
@@ -3000,16 +2647,12 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target)
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
   // Check whether labels are enabled for this target.
-  if(const char* value = target->GetProperty("LABELS"))
-    {
+  if (const char* value = target->GetProperty("LABELS")) {
     Json::Value lj_root(Json::objectValue);
-    Json::Value& lj_target =
-      lj_root["target"] = Json::objectValue;
+    Json::Value& lj_target = lj_root["target"] = Json::objectValue;
     lj_target["name"] = target->GetName();
-    Json::Value& lj_target_labels =
-      lj_target["labels"] = Json::arrayValue;
-    Json::Value& lj_sources =
-      lj_root["sources"] = Json::arrayValue;
+    Json::Value& lj_target_labels = lj_target["labels"] = Json::arrayValue;
+    Json::Value& lj_sources = lj_root["sources"] = Json::arrayValue;
 
     cmSystemTools::MakeDirectory(dir.c_str());
     cmGeneratedFileStream fout(file.c_str());
@@ -3018,68 +2661,60 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target)
     // these labels.
     std::vector<std::string> labels;
     cmSystemTools::ExpandListArgument(value, labels);
-    if(!labels.empty())
-      {
+    if (!labels.empty()) {
       fout << "# Target labels\n";
-      for(std::vector<std::string>::const_iterator li = labels.begin();
-          li != labels.end(); ++li)
-        {
+      for (std::vector<std::string>::const_iterator li = labels.begin();
+           li != labels.end(); ++li) {
         fout << " " << *li << "\n";
         lj_target_labels.append(*li);
-        }
       }
+    }
 
     // List the source files with any per-source labels.
     fout << "# Source files and their labels\n";
     std::vector<cmSourceFile*> sources;
     std::vector<std::string> configs;
     target->Target->GetMakefile()->GetConfigurations(configs);
-    if (configs.empty())
-      {
+    if (configs.empty()) {
       configs.push_back("");
-      }
-    for(std::vector<std::string>::const_iterator ci = configs.begin();
-        ci != configs.end(); ++ci)
-      {
+    }
+    for (std::vector<std::string>::const_iterator ci = configs.begin();
+         ci != configs.end(); ++ci) {
       target->GetSourceFiles(sources, *ci);
-      }
-    std::vector<cmSourceFile*>::const_iterator sourcesEnd
-        = cmRemoveDuplicates(sources);
-    for(std::vector<cmSourceFile*>::const_iterator si = sources.begin();
-        si != sourcesEnd; ++si)
-      {
+    }
+    std::vector<cmSourceFile*>::const_iterator sourcesEnd =
+      cmRemoveDuplicates(sources);
+    for (std::vector<cmSourceFile*>::const_iterator si = sources.begin();
+         si != sourcesEnd; ++si) {
       Json::Value& lj_source = lj_sources.append(Json::objectValue);
       cmSourceFile* sf = *si;
       std::string const& sfp = sf->GetFullPath();
       fout << sfp << "\n";
       lj_source["file"] = sfp;
-      if(const char* svalue = sf->GetProperty("LABELS"))
-        {
+      if (const char* svalue = sf->GetProperty("LABELS")) {
         labels.clear();
-        Json::Value& lj_source_labels =
-          lj_source["labels"] = Json::arrayValue;
+        Json::Value& lj_source_labels = lj_source["labels"] = Json::arrayValue;
         cmSystemTools::ExpandListArgument(svalue, labels);
-        for(std::vector<std::string>::const_iterator li = labels.begin();
-            li != labels.end(); ++li)
-          {
+        for (std::vector<std::string>::const_iterator li = labels.begin();
+             li != labels.end(); ++li) {
           fout << " " << *li << "\n";
           lj_source_labels.append(*li);
-          }
         }
       }
+    }
     cmGeneratedFileStream json_fout(json_file.c_str());
     json_fout << lj_root;
-    }
-  else
+  } else
 #endif
-    {
+  {
     cmSystemTools::RemoveFile(file);
     cmSystemTools::RemoveFile(json_file);
-    }
+  }
 }
 
 // static
-std::string cmGlobalGenerator::EscapeJSON(const std::string& s) {
+std::string cmGlobalGenerator::EscapeJSON(const std::string& s)
+{
   std::string result;
   for (std::string::size_type i = 0; i < s.size(); ++i) {
     if (s[i] == '"' || s[i] == '\\') {
@@ -3090,39 +2725,38 @@ std::string cmGlobalGenerator::EscapeJSON(const std::string& s) {
   return result;
 }
 
-void cmGlobalGenerator::SetFilenameTargetDepends(cmSourceFile* sf,
-                                     std::set<cmGeneratorTarget const*> tgts)
+void cmGlobalGenerator::SetFilenameTargetDepends(
+  cmSourceFile* sf, std::set<cmGeneratorTarget const*> tgts)
 {
   this->FilenameTargetDepends[sf] = tgts;
 }
 
 std::set<cmGeneratorTarget const*> const&
-cmGlobalGenerator::GetFilenameTargetDepends(cmSourceFile* sf) const {
+cmGlobalGenerator::GetFilenameTargetDepends(cmSourceFile* sf) const
+{
   return this->FilenameTargetDepends[sf];
 }
 
 void cmGlobalGenerator::CreateEvaluationSourceFiles(
-                                              std::string const& config) const
+  std::string const& config) const
 {
   unsigned int i;
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
     this->LocalGenerators[i]->CreateEvaluationFileOutputs(config);
-    }
+  }
 }
 
 void cmGlobalGenerator::ProcessEvaluationFiles()
 {
   std::vector<std::string> generatedFiles;
   unsigned int i;
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
     this->LocalGenerators[i]->ProcessEvaluationFiles(generatedFiles);
-    }
+  }
 }
 
-std::string cmGlobalGenerator::ExpandCFGIntDir(const std::string& str,
-                            const std::string& /*config*/) const
+std::string cmGlobalGenerator::ExpandCFGIntDir(
+  const std::string& str, const std::string& /*config*/) const
 {
   return str;
 }
@@ -3141,24 +2775,22 @@ bool cmGlobalGenerator::GenerateCPackPropertiesFile()
   std::string path = this->CMakeInstance->GetHomeOutputDirectory();
   path += "/CPackProperties.cmake";
 
-  if(!cmSystemTools::FileExists(path.c_str()) && installedFiles.empty())
-    {
-      return true;
-    }
+  if (!cmSystemTools::FileExists(path.c_str()) && installedFiles.empty()) {
+    return true;
+  }
 
   cmGeneratedFileStream file(path.c_str());
   file << "# CPack properties\n";
 
-  for(cmake::InstalledFilesMap::const_iterator i = installedFiles.begin();
-    i != installedFiles.end(); ++i)
-    {
+  for (cmake::InstalledFilesMap::const_iterator i = installedFiles.begin();
+       i != installedFiles.end(); ++i) {
     cmInstalledFile const& installedFile = i->second;
 
-    cmCPackPropertiesGenerator cpackPropertiesGenerator(
-      lg, installedFile, configs);
+    cmCPackPropertiesGenerator cpackPropertiesGenerator(lg, installedFile,
+                                                        configs);
 
     cpackPropertiesGenerator.Generate(file, config, configs);
-    }
+  }
 
   return true;
 }